Public API

module.exports (default singleton)

import sails = require('./source/index');
// sails is an instance of Sails
sails.lift(config: object, cb: (err: Error | null) => void): void;
sails.load(config: object, cb: (err: Error | null) => void): void;
sails.lower(cb?: (err: Error | null) => void): void;

The default export is a pre-instantiated Sails app. Use sails.lift() to start the HTTP server and all hooks, sails.load() to initialize without binding a port, and sails.lower() to gracefully shut down.

Sails (constructor)

import { Sails } = require('./source/index');
// or:
const Sails = require('./source/index').Sails;

const app: SailsApp = new Sails();
app.lift({ appPath: __dirname, port: 3000 }, (err) => { ... });

Use the constructor when you need multiple isolated Sails instances in the same process — for example, in tests or multi-tenant scenarios. Each new Sails() carries its own config, hooks, and router.

SailsFactory (functional factory from app/index.js)

const SailsFactory = require('./source/app/index');
const app = SailsFactory(); // returns new Sails()

// Static helpers bound to an internal singleton:
SailsFactory.isLocalSailsValid(localSailsPath: string, appPath: string): boolean;
SailsFactory.isSailsAppSync(dirPath: string): boolean;

SailsFactory can be called as a function (no new) for convenience. isLocalSailsValid is useful when building CLI tooling that detects whether a project directory has a valid local Sails install. isSailsAppSync synchronously checks if a directory looks like a Sails project.

Working examples

Scenario - Lift a minimal Sails app programmatically

Embed a Sails server inside an existing Node.js process without the CLI. Useful for testing or embedding Sails inside a larger orchestration layer.

const { Sails } = require('./source/index');

const app = new Sails();

app.lift(
  {
    appPath: __dirname,
    port: 1337,
    environment: 'development',
    hooks: {
      grunt: false,  // disable asset pipeline
    },
    log: { level: 'warn' },
  },
  (err) => {
    if (err) {
      console.error('Failed to lift:', err);
      process.exit(1);
    }
    console.log(`Sails lifted on port ${app.config.port}`);
  }
);

Scenario - Load without HTTP (integration / unit testing)

Use sails.load() to initialize all hooks and the ORM without binding a TCP port. Ideal for running model-level tests or seeding a database.

const { Sails } = require('./source/index');

let app: any;

beforeAll((done) => {
  app = new Sails();
  app.load(
    {
      appPath: __dirname,
      environment: 'test',
      hooks: { grunt: false, views: false, blueprints: false },
      orm: { migrate: 'safe' },
    },
    done
  );
});

afterAll((done) => {
  app.lower(done);
});

test('User model exists', () => {
  expect(app.models.user).toBeDefined();
});

Scenario - Check if a directory is a valid Sails project

Use the static helpers exposed by SailsFactory to build tooling that validates project directories before attempting to lift.

const SailsFactory = require('./source/app/index');
const path = require('path');

const targetDir = path.resolve(process.argv[2] || '.');

if (!SailsFactory.isSailsAppSync(targetDir)) {
  console.error(`${targetDir} does not appear to be a Sails app.`);
  process.exit(1);
}

if (!SailsFactory.isLocalSailsValid(targetDir, targetDir)) {
  console.warn('Local Sails install may be outdated or missing.');
}

console.log('Project looks valid. Proceeding...');

File walkthrough

• index.js — Instantiates and exports a Sails singleton; also exports the Sails constructor as .Sails and .constructor.
• app/index.js — SailsFactory callable factory; exposes isLocalSailsValid and isSailsAppSync as static methods.
• app/Sails.js — The core Sails class with all instance methods attached.
• app/lift.js — Implements sails.lift(): loads hooks then starts the HTTP server.
• app/load.js — Implements sails.load(): runs configuration, loads hooks, skips HTTP bind.
• app/lower.js — Graceful shutdown: closes server, tears down hooks.
• app/configuration/ — Merges defaults, resolves hook paths, reads .sailsrc.
• app/configuration/default-hooks.js — Canonical list of built-in hooks by identity.
• app/private/ — Internal lifecycle helpers (bootstrap, global exposure, hook loading).
• hooks/index.js — Hook constructor; all built-in hooks are instances of this.
• hooks/blueprints/ — Generates implicit CRUD + association REST routes for models.
• hooks/http/ — Configures the Express app, middleware stack, and static file serving.
• hooks/session/ — Express-session integration with configurable store.
• hooks/security/ — CORS policy, CSRF token middleware, clickjacking headers.
• hooks/pubsub/ — Socket.io room helpers (subscribe, publish, unsubscribe).
• hooks/views/ — Template engine configuration (EJS by default).
• hooks/policies/ — Loads and applies policy middleware to routes.
• hooks/i18n/ — Locale detection and translation via i18n-2.
• router/ — Core route binding layer between string patterns and middleware.
• util/ — Shared internal utilities used across hooks and the app module.

Common pitfalls and fixes

• appPath missing causes a fatal error — always pass appPath: __dirname (or the project root) in config; the framework throws synchronously if it is absent.
• Multiple sails.lift() calls on the singleton — the default export is a shared singleton; use new Sails() for each isolated instance in tests or you will get port-conflict errors.
• NODE_ENV not set — without userconfig hook or explicit environment config, the framework defaults to 'development'; set it explicitly in production to avoid config leaks.
• Hook config or middleware properties reserved — defining a custom hook method named config or middleware throws E_INVALID_HOOK_CONFIG; rename your method.
• CJS/ESM interop — this source is fully CommonJS; use require() or createRequire from ESM; import sails from 'sails' will not resolve the named Sails export correctly without an interop shim.
• Blueprint routes require a Waterline ORM adapter — the blueprints hook silently skips models that have no configured datastore; install and configure sails-hook-orm plus an adapter (sails-disk, sails-mysql, etc.) before expecting CRUD routes.

Vibe-coding prompt template

I have the Sails.js framework source in `source/` (sails@1.5.17, lib/ directory)
and a usage guide in `USAGE.md`. I want you to integrate this into my existing
Node.js/TypeScript project step by step.

Context:
- Source root: source/   (index.js exports a Sails singleton and Sails constructor)
- Upstream package: user@example.com
- Guide: USAGE.md (read it first for real API signatures and import paths)

Tasks:
1. Install all dependencies listed in USAGE.md ## Required dependencies.
2. Create a `server.ts` (or `server.js`) that imports `Sails` from `./source/index`,
   constructs a new instance, and calls `.lift()` with appPath set to the project root,
   respecting the PORT environment variable.
3. Create a `test/sails.test.ts` that uses `sails.load()` (no HTTP) to test a model.
4. Wire the path alias in tsconfig.json if TypeScript is used.
5. Add a `start` and `test` script in package.json.
6. Show me every file you create or modify, with full content.
Do not invent any Sails APIs; use only the symbols documented in USAGE.md.

License and credit

Sails.js is released under the MIT License. See source/LICENSE if present, or the official repository at https://github.com/balderdashy/sails. Upstream npm package: sails. Website and documentation: https://sailsjs.com.

This product’s unique contribution is clean room implementation of valuable code block into AVCP compatible standard.

完整安装指南与集成提示词将在购买后解锁。

AdonisJS Full-Stack MVC Framework for Node.js

Automation, Utilities & Developer Tools

免费