@nocobase/server 0.7.7-alpha.1 → 0.8.0-alpha.4

package/lib/application.d.ts

@@ -1,19 +1,18 @@
 /// <reference types="node" />
 /// <reference types="koa-bodyparser" />
 import { ACL } from '@nocobase/acl';
+import { Cache, ICacheConfig } from '@nocobase/cache';
 import Database, { Collection, CollectionOptions, IDatabaseOptions } from '@nocobase/database';
 import Resourcer, { ResourceOptions } from '@nocobase/resourcer';
-import { AsyncEmitter } from '@nocobase/utils';
+import { AsyncEmitter, ToposortOptions } from '@nocobase/utils';
 import { Command, CommandOptions, ParseOptions } from 'commander';
 import { Server } from 'http';
 import { i18n, InitOptions } from 'i18next';
-import Koa from 'koa';
+import Koa, { DefaultContext as KoaDefaultContext, DefaultState as KoaDefaultState } from 'koa';
 import { AppManager } from './app-manager';
 import { Plugin } from './plugin';
 import { InstallOptions, PluginManager } from './plugin-manager';
-import { ICacheConfig, Cache } from '@nocobase/cache';
 export declare type PluginConfiguration = string | [string, any];
-export declare type PluginsConfigurations = Array<PluginConfiguration>;
 export interface ResourcerOptions {
     prefix?: string;
 }
@@ -26,25 +25,21 @@ export interface ApplicationOptions {
     dataWrapping?: boolean;
     registerActions?: boolean;
     i18n?: i18n | InitOptions;
-    plugins?: PluginsConfigurations;
+    plugins?: PluginConfiguration[];
+    acl?: boolean;
+    pmSock?: string;
 }
-export interface DefaultState {
+export interface DefaultState extends KoaDefaultState {
     currentUser?: any;
     [key: string]: any;
 }
-export interface DefaultContext {
+export interface DefaultContext extends KoaDefaultContext {
     db: Database;
     cache: Cache;
     resourcer: Resourcer;
+    i18n: any;
     [key: string]: any;
 }
-interface MiddlewareOptions {
-    name?: string;
-    resourceName?: string;
-    resourceNames?: string[];
-    insertBefore?: string;
-    insertAfter?: string;
-}
 interface ActionsOptions {
     resourceName?: string;
     resourceNames?: string[];
@@ -77,32 +72,44 @@ export declare class ApplicationVersion {
 }
 export declare class Application<StateT = DefaultState, ContextT = DefaultContext> extends Koa implements AsyncEmitter {
     options: ApplicationOptions;
-    readonly db: Database;
-    readonly cache: Cache;
-    readonly resourcer: Resourcer;
-    readonly cli: Command;
-    readonly i18n: i18n;
-    readonly pm: PluginManager;
-    readonly acl: ACL;
-    readonly appManager: AppManager;
-    readonly version: ApplicationVersion;
+    protected _db: Database;
+    protected _resourcer: Resourcer;
+    protected _cache: Cache;
+    protected _cli: Command;
+    protected _i18n: i18n;
+    protected _pm: PluginManager;
+    protected _acl: ACL;
+    protected _appManager: AppManager;
+    protected _version: ApplicationVersion;
     protected plugins: Map<string, Plugin<any>>;
     listenServer: Server;
+    middleware: any;
     constructor(options: ApplicationOptions);
+    get db(): Database;
+    get cache(): Cache;
+    get resourcer(): Resourcer;
+    get cli(): Command;
+    get acl(): ACL;
+    get i18n(): i18n;
+    get pm(): PluginManager;
+    get version(): ApplicationVersion;
+    get appManager(): AppManager;
+    protected init(): void;
     private createDatabase;
     getVersion(): any;
-    plugin<O = any>(pluginClass: any, options?: O): Plugin<O>;
-    loadPluginConfig(pluginsConfigurations: PluginsConfigurations): void;
-    use<NewStateT = {}, NewContextT = {}>(middleware: Koa.Middleware<StateT & NewStateT, ContextT & NewContextT>, options?: MiddlewareOptions): Koa<Koa.DefaultState & StateT & NewStateT, Koa.DefaultContext & ContextT & NewContextT>;
+    plugin<O = any>(pluginClass: any, options?: O): Plugin;
+    use<NewStateT = {}, NewContextT = {}>(middleware: Koa.Middleware<StateT & NewStateT, ContextT & NewContextT>, options?: ToposortOptions): this;
+    callback(): (req: any, res: any) => any;
     collection(options: CollectionOptions): Collection<any, any>;
     resource(options: ResourceOptions): import("@nocobase/resourcer").Resource;
     actions(handlers: any, options?: ActionsOptions): void;
     command(name: string, desc?: string, opts?: CommandOptions): Command;
     findCommand(name: string): Command;
-    load(): Promise<void>;
+    load(options?: any): Promise<void>;
+    reload(options?: any): Promise<void>;
     getPlugin<P extends Plugin>(name: string): P;
     parse(argv?: string[]): Promise<Command>;
-    runAsCLI(argv?: readonly string[], options?: ParseOptions): Promise<Command>;
+    runAsCLI(argv?: string[], options?: ParseOptions): Promise<Command>;
     start(options?: StartOptions): Promise<void>;
     listen(...args: any[]): Server;
     stop(options?: any): Promise<void>;

package/lib/application.js

@@ -15,6 +15,16 @@ function _actions() {
   return data;
 }
 
+function _cache() {
+  const data = require("@nocobase/cache");
+
+  _cache = function _cache() {
+    return data;
+  };
+
+  return data;
+}
+
 function _database() {
   const data = _interopRequireDefault(require("@nocobase/database"));
 
@@ -55,6 +65,16 @@ function _koa() {
   return data;
 }
 
+function _koaCompose() {
+  const data = _interopRequireDefault(require("koa-compose"));
+
+  _koaCompose = function _koaCompose() {
+    return data;
+  };
+
+  return data;
+}
+
 function _lodash() {
   const data = require("lodash");
 
@@ -75,6 +95,16 @@ function _semver() {
   return data;
 }
 
+function _util() {
+  const data = require("util");
+
+  _util = function _util() {
+    return data;
+  };
+
+  return data;
+}
+
 var _acl = require("./acl");
 
 var _appManager = require("./app-manager");
@@ -85,24 +115,8 @@ var _helper = require("./helper");
 
 var _pluginManager = require("./plugin-manager");
 
-function _cache() {
-  const data = require("@nocobase/cache");
-
-  _cache = function _cache() {
-    return data;
-  };
-
-  return data;
-}
-
 function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
 
-function _createForOfIteratorHelper(o, allowArrayLike) { var it = typeof Symbol !== "undefined" && o[Symbol.iterator] || o["@@iterator"]; if (!it) { if (Array.isArray(o) || (it = _unsupportedIterableToArray(o)) || allowArrayLike && o && typeof o.length === "number") { if (it) o = it; var i = 0; var F = function F() {}; return { s: F, n: function n() { if (i >= o.length) return { done: true }; return { done: false, value: o[i++] }; }, e: function e(_e) { throw _e; }, f: F }; } throw new TypeError("Invalid attempt to iterate non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); } var normalCompletion = true, didErr = false, err; return { s: function s() { it = it.call(o); }, n: function n() { var step = it.next(); normalCompletion = step.done; return step; }, e: function e(_e2) { didErr = true; err = _e2; }, f: function f() { try { if (!normalCompletion && it.return != null) it.return(); } finally { if (didErr) throw err; } } }; }
-
-function _unsupportedIterableToArray(o, minLen) { if (!o) return; if (typeof o === "string") return _arrayLikeToArray(o, minLen); var n = Object.prototype.toString.call(o).slice(8, -1); if (n === "Object" && o.constructor) n = o.constructor.name; if (n === "Map" || n === "Set") return Array.from(o); if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen); }
-
-function _arrayLikeToArray(arr, len) { if (len == null || len > arr.length) len = arr.length; for (var i = 0, arr2 = new Array(len); i < len; i++) arr2[i] = arr[i]; return arr2; }
-
 function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); enumerableOnly && (symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; })), keys.push.apply(keys, symbols); } return keys; }
 
 function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = null != arguments[i] ? arguments[i] : {}; i % 2 ? ownKeys(Object(source), !0).forEach(function (key) { _defineProperty(target, key, source[key]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)) : ownKeys(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } return target; }
@@ -191,51 +205,118 @@ class Application extends _koa().default {
   constructor(options) {
     super();
     this.options = void 0;
-    this.db = void 0;
-    this.cache = void 0;
-    this.resourcer = void 0;
-    this.cli = void 0;
-    this.i18n = void 0;
-    this.pm = void 0;
-    this.acl = void 0;
-    this.appManager = void 0;
-    this.version = void 0;
+    this._db = void 0;
+    this._resourcer = void 0;
+    this._cache = void 0;
+    this._cli = void 0;
+    this._i18n = void 0;
+    this._pm = void 0;
+    this._acl = void 0;
+    this._appManager = void 0;
+    this._version = void 0;
     this.plugins = new Map();
     this.listenServer = void 0;
     this.options = options;
-    this.acl = (0, _acl.createACL)();
-    this.db = this.createDatabase(options);
-    this.cache = (0, _cache().createCache)(options.cache);
-    this.resourcer = (0, _helper.createResourcer)(options);
-    this.cli = new (_commander().Command)('nocobase').usage('[command] [options]');
-    this.i18n = (0, _helper.createI18n)(options);
-    this.pm = new _pluginManager.PluginManager({
-      app: this
-    });
-    this.appManager = new _appManager.AppManager(this);
+    this.init();
+  }
+
+  get db() {
+    return this._db;
+  }
+
+  get cache() {
+    return this._cache;
+  }
+
+  get resourcer() {
+    return this._resourcer;
+  }
+
+  get cli() {
+    return this._cli;
+  }
+
+  get acl() {
+    return this._acl;
+  }
+
+  get i18n() {
+    return this._i18n;
+  }
+
+  get pm() {
+    return this._pm;
+  }
+
+  get version() {
+    return this._version;
+  }
+
+  get appManager() {
+    return this._appManager;
+  }
+
+  init() {
+    const options = this.options; // @ts-ignore
+
+    this._events = []; // @ts-ignore
+
+    this._eventsCount = [];
+    this.removeAllListeners();
+    this.middleware = new (_utils().Toposort)();
+    this.plugins = new Map();
+    this._acl = (0, _acl.createACL)();
+
+    if (this._db) {
+      // MaxListenersExceededWarning
+      this._db.removeAllListeners();
+    }
+
+    this._db = this.createDatabase(options);
+    this._resourcer = (0, _helper.createResourcer)(options);
+    this._cli = new (_commander().Command)('nocobase').usage('[command] [options]');
+    this._i18n = (0, _helper.createI18n)(options);
+    this._cache = (0, _cache().createCache)(options.cache);
+    this.context.db = this._db;
+    this.context.resourcer = this._resourcer;
+    this.context.cache = this._cache;
+
+    if (this._pm) {
+      this._pm = this._pm.clone();
+    } else {
+      this._pm = new _pluginManager.PluginManager({
+        app: this,
+        plugins: options.plugins
+      });
+    }
+
+    this._appManager = new _appManager.AppManager(this);
+
+    if (this.options.acl !== false) {
+      this._resourcer.use(this._acl.middleware(), {
+        tag: 'acl',
+        after: ['parseToken']
+      });
+    }
+
     (0, _helper.registerMiddlewares)(this, options);
 
     if (options.registerActions !== false) {
       (0, _actions().registerActions)(this);
     }
 
-    this.loadPluginConfig(options.plugins || []);
     (0, _commands.registerCli)(this);
-    this.version = new ApplicationVersion(this);
+    this._version = new ApplicationVersion(this);
   }
 
   createDatabase(options) {
-    if (options.database instanceof _database().default) {
-      return options.database;
-    } else {
-      return new (_database().default)(_objectSpread(_objectSpread({}, options.database), {}, {
-        migrator: {
-          context: {
-            app: this
-          }
+    return new (_database().default)(_objectSpread(_objectSpread({}, options.database instanceof _database().default ? options.database.options : options.database), {}, {
+      migrator: {
+        context: {
+          app: this
         }
-      }));
-    }
+      }
+    }));
   }
 
   getVersion() {
@@ -243,36 +324,26 @@ class Application extends _koa().default {
   }
 
   plugin(pluginClass, options) {
-    return this.pm.add(pluginClass, options);
-  }
+    return this.pm.addStatic(pluginClass, options);
+  } // @ts-ignore
 
-  loadPluginConfig(pluginsConfigurations) {
-    var _iterator = _createForOfIteratorHelper(pluginsConfigurations),
-        _step;
 
-    try {
-      for (_iterator.s(); !(_step = _iterator.n()).done;) {
-        let pluginConfiguration = _step.value;
+  use(middleware, options) {
+    this.middleware.add(middleware, options);
+    return this;
+  }
 
-        if (typeof pluginConfiguration == 'string') {
-          pluginConfiguration = [pluginConfiguration, {}];
-        }
+  callback() {
+    const fn = (0, _koaCompose().default)(this.middleware.nodes);
+    if (!this.listenerCount('error')) this.on('error', this.onerror);
 
-        const plugin = _pluginManager.PluginManager.resolvePlugin(pluginConfiguration[0]);
+    const handleRequest = (req, res) => {
+      const ctx = this.createContext(req, res); // @ts-ignore
 
-        const pluginOptions = pluginConfiguration[1];
-        this.plugin(plugin, pluginOptions);
-      }
-    } catch (err) {
-      _iterator.e(err);
-    } finally {
-      _iterator.f();
-    }
-  }
+      return this.handleRequest(ctx, fn);
+    };
 
-  use(middleware, options) {
-    // @ts-ignore
-    return super.use(middleware);
+    return handleRequest;
   }
 
   collection(options) {
@@ -295,11 +366,31 @@ class Application extends _koa().default {
     return this.cli._findCommand(name);
   }
 
-  load() {
+  load(options) {
     var _this4 = this;
 
     return _asyncToGenerator(function* () {
-      yield _this4.pm.load();
+      if (options === null || options === void 0 ? void 0 : options.reload) {
+        const oldDb = _this4._db;
+
+        _this4.init();
+
+        yield oldDb.close();
+      }
+
+      yield _this4.emitAsync('beforeLoad', _this4, options);
+      yield _this4.pm.load(options);
+      yield _this4.emitAsync('afterLoad', _this4, options);
+    })();
+  }
+
+  reload(options) {
+    var _this5 = this;
+
+    return _asyncToGenerator(function* () {
+      yield _this5.load(_objectSpread(_objectSpread({}, options), {}, {
+        reload: true
+      }));
     })();
   }
 
@@ -308,56 +399,63 @@ class Application extends _koa().default {
   }
 
   parse(argv = process.argv) {
-    var _this5 = this;
+    var _this6 = this;
 
     return _asyncToGenerator(function* () {
-      return _this5.runAsCLI(argv);
+      return _this6.runAsCLI(argv);
     })();
   }
 
-  runAsCLI(argv, options) {
-    var _this6 = this;
+  runAsCLI(argv = process.argv, options) {
+    var _this7 = this;
 
     return _asyncToGenerator(function* () {
-      yield _this6.load();
-      return _this6.cli.parseAsync(argv, options);
+      yield _this7.load({
+        method: argv === null || argv === void 0 ? void 0 : argv[2]
+      });
+      return _this7.cli.parseAsync(argv, options);
     })();
   }
 
   start(options = {}) {
-    var _this7 = this;
+    var _this8 = this;
 
     return _asyncToGenerator(function* () {
       var _options$listen;
 
       // reconnect database
-      if (_this7.db.closed()) {
-        yield _this7.db.reconnect();
+      if (_this8.db.closed()) {
+        yield _this8.db.reconnect();
       }
 
-      yield _this7.emitAsync('beforeStart', _this7, options);
+      yield _this8.emitAsync('beforeStart', _this8, options);
 
       if (options === null || options === void 0 ? void 0 : (_options$listen = options.listen) === null || _options$listen === void 0 ? void 0 : _options$listen.port) {
+        const pmServer = yield _this8.pm.listen();
+
         const listen = () => new Promise((resolve, reject) => {
-          const Server = _this7.listen(options === null || options === void 0 ? void 0 : options.listen, () => {
+          const Server = _this8.listen(options === null || options === void 0 ? void 0 : options.listen, () => {
             resolve(Server);
           });
 
           Server.on('error', err => {
             reject(err);
           });
+          Server.on('close', () => {
+            pmServer.close();
+          });
         });
 
         try {
           //@ts-ignore
-          _this7.listenServer = yield listen();
+          _this8.listenServer = yield listen();
         } catch (e) {
           console.error(e);
           process.exit(1);
         }
       }
 
-      yield _this7.emitAsync('afterStart', _this7, options);
+      yield _this8.emitAsync('afterStart', _this8, options);
     })();
   }
 
@@ -366,55 +464,46 @@ class Application extends _koa().default {
   }
 
   stop(options = {}) {
-    var _this8 = this;
+    var _this9 = this;
 
     return _asyncToGenerator(function* () {
-      yield _this8.emitAsync('beforeStop', _this8, options);
+      yield _this9.emitAsync('beforeStop', _this9, options);
 
       try {
         // close database connection
         // silent if database already closed
-        yield _this8.db.close();
+        if (!_this9.db.closed()) {
+          yield _this9.db.close();
+        }
       } catch (e) {
         console.log(e);
       } // close http server
 
 
-      if (_this8.listenServer) {
-        const closeServer = () => new Promise((resolve, reject) => {
-          _this8.listenServer.close(err => {
-            if (err) {
-              return reject(err);
-            }
-
-            _this8.listenServer = null;
-            resolve(true);
-          });
-        });
-
-        yield closeServer();
+      if (_this9.listenServer) {
+        yield (0, _util().promisify)(_this9.listenServer.close).call(_this9.listenServer);
+        _this9.listenServer = null;
       }
 
-      yield _this8.emitAsync('afterStop', _this8, options);
+      yield _this9.emitAsync('afterStop', _this9, options);
     })();
   }
 
   destroy(options = {}) {
-    var _this9 = this;
+    var _this10 = this;
 
     return _asyncToGenerator(function* () {
-      yield _this9.emitAsync('beforeDestroy', _this9, options);
-      yield _this9.stop(options);
-      yield _this9.emitAsync('afterDestroy', _this9, options);
+      yield _this10.emitAsync('beforeDestroy', _this10, options);
+      yield _this10.stop(options);
+      yield _this10.emitAsync('afterDestroy', _this10, options);
     })();
   }
 
   install(options = {}) {
-    var _this10 = this;
+    var _this11 = this;
 
     return _asyncToGenerator(function* () {
-      yield _this10.emitAsync('beforeInstall', _this10, options);
-      const r = yield _this10.db.version.satisfies({
+      const r = yield _this11.db.version.satisfies({
         mysql: '>=8.0.17',
         sqlite: '3.x',
         postgres: '>=10'
@@ -426,33 +515,37 @@ class Application extends _koa().default {
       }
 
       if (options === null || options === void 0 ? void 0 : options.clean) {
-        yield _this10.db.clean((0, _lodash().isBoolean)(options.clean) ? {
+        yield _this11.db.clean((0, _lodash().isBoolean)(options.clean) ? {
           drop: options.clean
         } : options.clean);
+        yield _this11.reload({
+          method: 'install'
+        });
       }
 
-      yield _this10.db.sync(options === null || options === void 0 ? void 0 : options.sync);
-      yield _this10.pm.install(options);
-      yield _this10.version.update();
-      yield _this10.emitAsync('afterInstall', _this10, options);
+      yield _this11.emitAsync('beforeInstall', _this11, options);
+      yield _this11.db.sync(options === null || options === void 0 ? void 0 : options.sync);
+      yield _this11.pm.install(options);
+      yield _this11.version.update();
+      yield _this11.emitAsync('afterInstall', _this11, options);
     })();
   }
 
   upgrade(options = {}) {
-    var _this11 = this;
+    var _this12 = this;
 
     return _asyncToGenerator(function* () {
-      yield _this11.emitAsync('beforeUpgrade', _this11, options);
+      yield _this12.emitAsync('beforeUpgrade', _this12, options);
       const force = false;
-      yield _this11.db.migrator.up();
-      yield _this11.db.sync({
+      yield _this12.db.migrator.up();
+      yield _this12.db.sync({
         force,
         alter: {
           drop: force
         }
       });
-      yield _this11.version.update();
-      yield _this11.emitAsync('afterUpgrade', _this11, options);
+      yield _this12.version.update();
+      yield _this12.emitAsync('afterUpgrade', _this12, options);
     })();
   }
 

package/lib/commands/index.js

@@ -20,7 +20,9 @@ function registerCli(app) {
 
   require('./start').default(app);
 
-  require('./upgrade').default(app); // development only with @nocobase/cli
+  require('./upgrade').default(app);
+
+  require('./pm').default(app); // development only with @nocobase/cli
 
 
   app.command('build').argument('[packages...]');

package/lib/commands/pm.d.ts

@@ -0,0 +1,3 @@
+import Application from '../application';
+declare const _default: (app: Application) => void;
+export default _default;

package/lib/commands/pm.js

@@ -0,0 +1,27 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+
+function asyncGeneratorStep(gen, resolve, reject, _next, _throw, key, arg) { try { var info = gen[key](arg); var value = info.value; } catch (error) { reject(error); return; } if (info.done) { resolve(value); } else { Promise.resolve(value).then(_next, _throw); } }
+
+function _asyncToGenerator(fn) { return function () { var self = this, args = arguments; return new Promise(function (resolve, reject) { var gen = fn.apply(self, args); function _next(value) { asyncGeneratorStep(gen, resolve, reject, _next, _throw, "next", value); } function _throw(err) { asyncGeneratorStep(gen, resolve, reject, _next, _throw, "throw", err); } _next(undefined); }); }; }
+
+var _default = app => {
+  app.command('pm').argument('<method>').arguments('<plugins...>').action( /*#__PURE__*/function () {
+    var _ref = _asyncToGenerator(function* (method, plugins, options, ...args) {
+      app.pm.clientWrite({
+        method,
+        plugins
+      });
+    });
+
+    return function (_x, _x2, _x3) {
+      return _ref.apply(this, arguments);
+    };
+  }());
+};
+
+exports.default = _default;