@nocobase/server 0.7.0-alpha.9 → 0.7.1-alpha.6

package/lib/application.js

@@ -1,163 +1,425 @@
 "use strict";
-var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
-    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
-    return new (P || (P = Promise))(function (resolve, reject) {
-        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
-        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
-        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
-        step((generator = generator.apply(thisArg, _arguments || [])).next());
-    });
-};
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.Application = void 0;
-const actions_1 = require("@nocobase/actions");
-const utils_1 = require("@nocobase/utils");
-const koa_1 = __importDefault(require("koa"));
-const lodash_1 = require("lodash");
-const acl_1 = require("./acl");
-const app_manager_1 = require("./app-manager");
-const commands_1 = require("./commands");
-const helper_1 = require("./helper");
-const plugin_manager_1 = require("./plugin-manager");
-class Application extends koa_1.default {
-    constructor(options) {
-        super();
-        this.options = options;
-        this.plugins = new Map();
-        this.acl = (0, acl_1.createACL)();
-        this.db = (0, helper_1.createDatabase)(options);
-        this.resourcer = (0, helper_1.createResourcer)(options);
-        this.cli = (0, commands_1.createCli)(this);
-        this.i18n = (0, helper_1.createI18n)(options);
-        this.pm = new plugin_manager_1.PluginManager({
-            app: this,
-        });
-        this.appManager = new app_manager_1.AppManager(this);
-        (0, helper_1.registerMiddlewares)(this, options);
-        if (options.registerActions !== false) {
-            (0, actions_1.registerActions)(this);
-        }
-        this.loadPluginConfig(options.plugins || []);
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = exports.ApplicationVersion = exports.Application = void 0;
+
+function _actions() {
+  const data = require("@nocobase/actions");
+
+  _actions = function _actions() {
+    return data;
+  };
+
+  return data;
+}
+
+function _database() {
+  const data = _interopRequireDefault(require("@nocobase/database"));
+
+  _database = function _database() {
+    return data;
+  };
+
+  return data;
+}
+
+function _utils() {
+  const data = require("@nocobase/utils");
+
+  _utils = function _utils() {
+    return data;
+  };
+
+  return data;
+}
+
+function _commander() {
+  const data = require("commander");
+
+  _commander = function _commander() {
+    return data;
+  };
+
+  return data;
+}
+
+function _koa() {
+  const data = _interopRequireDefault(require("koa"));
+
+  _koa = function _koa() {
+    return data;
+  };
+
+  return data;
+}
+
+function _lodash() {
+  const data = require("lodash");
+
+  _lodash = function _lodash() {
+    return data;
+  };
+
+  return data;
+}
+
+function _semver() {
+  const data = _interopRequireDefault(require("semver"));
+
+  _semver = function _semver() {
+    return data;
+  };
+
+  return data;
+}
+
+var _acl = require("./acl");
+
+var _appManager = require("./app-manager");
+
+var _commands = require("./commands");
+
+var _helper = require("./helper");
+
+var _pluginManager = require("./plugin-manager");
+
+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; }
+
+function _defineProperty(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
+
+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); }); }; }
+
+const packageJson = require('../package.json');
+
+class ApplicationVersion {
+  constructor(app) {
+    this.app = void 0;
+    this.collection = void 0;
+    this.app = app;
+
+    if (!app.db.hasCollection('applicationVersion')) {
+      app.db.collection({
+        name: 'applicationVersion',
+        timestamps: false,
+        fields: [{
+          name: 'value',
+          type: 'string'
+        }]
+      });
     }
-    plugin(pluginClass, options) {
-        return this.pm.add(pluginClass, options);
+
+    this.collection = this.app.db.getCollection('applicationVersion');
+  }
+
+  get() {
+    var _this = this;
+
+    return _asyncToGenerator(function* () {
+      if (yield _this.app.db.collectionExistsInDb('applicationVersion')) {
+        const model = yield _this.collection.model.findOne();
+        return model.get('value');
+      }
+
+      return null;
+    })();
+  }
+
+  update() {
+    var _this2 = this;
+
+    return _asyncToGenerator(function* () {
+      yield _this2.collection.sync();
+      yield _this2.collection.model.destroy({
+        truncate: true
+      });
+      yield _this2.collection.model.create({
+        value: _this2.app.getVersion()
+      });
+    })();
+  }
+
+  satisfies(range) {
+    var _this3 = this;
+
+    return _asyncToGenerator(function* () {
+      if (yield _this3.app.db.collectionExistsInDb('applicationVersion')) {
+        const model = yield _this3.collection.model.findOne();
+        const version = model.get('value');
+        return _semver().default.satisfies(version, range);
+      }
+
+      return true;
+    })();
+  }
+
+}
+
+exports.ApplicationVersion = ApplicationVersion;
+
+class Application extends _koa().default {
+  constructor(options) {
+    super();
+    this.options = void 0;
+    this.db = 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.plugins = new Map();
+    this.listenServer = void 0;
+    this.options = options;
+    this.acl = (0, _acl.createACL)();
+    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.pm = new _pluginManager.PluginManager({
+      app: this
+    });
+    this.appManager = new _appManager.AppManager(this);
+    (0, _helper.registerMiddlewares)(this, options);
+
+    if (options.registerActions !== false) {
+      (0, _actions().registerActions)(this);
     }
-    loadPluginConfig(pluginsConfigurations) {
-        for (let pluginConfiguration of pluginsConfigurations) {
-            if (typeof pluginConfiguration == 'string') {
-                pluginConfiguration = [pluginConfiguration, {}];
-            }
-            const plugin = plugin_manager_1.PluginManager.resolvePlugin(pluginConfiguration[0]);
-            const pluginOptions = pluginConfiguration[1];
-            this.plugin(plugin, pluginOptions);
+
+    this.loadPluginConfig(options.plugins || []);
+    (0, _commands.registerCli)(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
+          }
         }
+      }));
     }
-    use(middleware, options) {
-        // @ts-ignore
-        return super.use(middleware);
-    }
-    collection(options) {
-        return this.db.collection(options);
-    }
-    resource(options) {
-        return this.resourcer.define(options);
-    }
-    actions(handlers, options) {
-        return this.resourcer.registerActions(handlers);
-    }
-    command(name, desc, opts) {
-        return this.cli.command(name, desc, opts);
-    }
-    findCommand(name) {
-        return this.cli._findCommand(name);
-    }
-    load() {
-        return __awaiter(this, void 0, void 0, function* () {
-            yield this.pm.load();
-        });
-    }
-    getPlugin(name) {
-        return this.pm.get(name);
-    }
-    parse(argv = process.argv) {
-        return __awaiter(this, void 0, void 0, function* () {
-            yield this.load();
-            return this.cli.parseAsync(argv);
-        });
-    }
-    start(options) {
-        var _a;
-        return __awaiter(this, void 0, void 0, function* () {
-            // reconnect database
-            if (this.db.closed()) {
-                yield this.db.reconnect();
-            }
-            yield this.emitAsync('beforeStart', this, options);
-            if ((_a = options === null || options === void 0 ? void 0 : options.listen) === null || _a === void 0 ? void 0 : _a.port) {
-                const listen = () => new Promise((resolve) => {
-                    const Server = this.listen(options === null || options === void 0 ? void 0 : options.listen, () => {
-                        resolve(Server);
-                    });
-                });
-                // @ts-ignore
-                this.listenServer = yield listen();
-            }
-            yield this.emitAsync('afterStart', this, options);
-        });
-    }
-    listen(...args) {
-        return this.appManager.listen(...args);
-    }
-    stop(options) {
-        return __awaiter(this, void 0, void 0, function* () {
-            yield this.emitAsync('beforeStop', this, options);
-            try {
-                // close database connection
-                // silent if database already closed
-                yield this.db.close();
-            }
-            catch (e) {
-                console.log(e);
-            }
-            // close http server
-            if (this.listenServer) {
-                const closeServer = () => new Promise((resolve, reject) => {
-                    this.listenServer.close((err) => {
-                        if (err) {
-                            return reject(err);
-                        }
-                        this.listenServer = null;
-                        resolve(true);
-                    });
-                });
-                yield closeServer();
-            }
-            yield this.emitAsync('afterStop', this, options);
-        });
+  }
+
+  getVersion() {
+    return packageJson.version;
+  }
+
+  plugin(pluginClass, options) {
+    return this.pm.add(pluginClass, options);
+  }
+
+  loadPluginConfig(pluginsConfigurations) {
+    var _iterator = _createForOfIteratorHelper(pluginsConfigurations),
+        _step;
+
+    try {
+      for (_iterator.s(); !(_step = _iterator.n()).done;) {
+        let pluginConfiguration = _step.value;
+
+        if (typeof pluginConfiguration == 'string') {
+          pluginConfiguration = [pluginConfiguration, {}];
+        }
+
+        const plugin = _pluginManager.PluginManager.resolvePlugin(pluginConfiguration[0]);
+
+        const pluginOptions = pluginConfiguration[1];
+        this.plugin(plugin, pluginOptions);
+      }
+    } catch (err) {
+      _iterator.e(err);
+    } finally {
+      _iterator.f();
     }
-    destroy(options) {
-        return __awaiter(this, void 0, void 0, function* () {
-            yield this.emitAsync('beforeDestroy', this, options);
-            yield this.stop(options);
-            yield this.emitAsync('afterDestroy', this, options);
+  }
+
+  use(middleware, options) {
+    // @ts-ignore
+    return super.use(middleware);
+  }
+
+  collection(options) {
+    return this.db.collection(options);
+  }
+
+  resource(options) {
+    return this.resourcer.define(options);
+  }
+
+  actions(handlers, options) {
+    return this.resourcer.registerActions(handlers);
+  }
+
+  command(name, desc, opts) {
+    return this.cli.command(name, desc, opts).allowUnknownOption();
+  }
+
+  findCommand(name) {
+    return this.cli._findCommand(name);
+  }
+
+  load() {
+    var _this4 = this;
+
+    return _asyncToGenerator(function* () {
+      yield _this4.pm.load();
+    })();
+  }
+
+  getPlugin(name) {
+    return this.pm.get(name);
+  }
+
+  parse(argv = process.argv) {
+    var _this5 = this;
+
+    return _asyncToGenerator(function* () {
+      yield _this5.load();
+      return _this5.cli.parseAsync(argv);
+    })();
+  }
+
+  start(options = {}) {
+    var _this6 = this;
+
+    return _asyncToGenerator(function* () {
+      var _options$listen;
+
+      // reconnect database
+      if (_this6.db.closed()) {
+        yield _this6.db.reconnect();
+      }
+
+      yield _this6.emitAsync('beforeStart', _this6, options);
+
+      if (options === null || options === void 0 ? void 0 : (_options$listen = options.listen) === null || _options$listen === void 0 ? void 0 : _options$listen.port) {
+        const listen = () => new Promise((resolve, reject) => {
+          const Server = _this6.listen(options === null || options === void 0 ? void 0 : options.listen, () => {
+            resolve(Server);
+          });
+
+          Server.on('error', err => {
+            reject(err);
+          });
         });
-    }
-    install(options) {
-        return __awaiter(this, void 0, void 0, function* () {
-            yield this.emitAsync('beforeInstall', this, options);
-            if (options === null || options === void 0 ? void 0 : options.clean) {
-                yield this.db.clean((0, lodash_1.isBoolean)(options.clean) ? { drop: options.clean } : options.clean);
+
+        try {
+          //@ts-ignore
+          _this6.listenServer = yield listen();
+        } catch (e) {
+          console.error(e);
+          process.exit(1);
+        }
+      }
+
+      yield _this6.emitAsync('afterStart', _this6, options);
+    })();
+  }
+
+  listen(...args) {
+    return this.appManager.listen(...args);
+  }
+
+  stop(options = {}) {
+    var _this7 = this;
+
+    return _asyncToGenerator(function* () {
+      yield _this7.emitAsync('beforeStop', _this7, options);
+
+      try {
+        // close database connection
+        // silent if database already closed
+        yield _this7.db.close();
+      } catch (e) {
+        console.log(e);
+      } // close http server
+
+
+      if (_this7.listenServer) {
+        const closeServer = () => new Promise((resolve, reject) => {
+          _this7.listenServer.close(err => {
+            if (err) {
+              return reject(err);
             }
-            yield this.db.sync(options === null || options === void 0 ? void 0 : options.sync);
-            yield this.pm.install(options);
-            yield this.emitAsync('afterInstall', this, options);
+
+            _this7.listenServer = null;
+            resolve(true);
+          });
         });
-    }
+
+        yield closeServer();
+      }
+
+      yield _this7.emitAsync('afterStop', _this7, options);
+    })();
+  }
+
+  destroy(options = {}) {
+    var _this8 = this;
+
+    return _asyncToGenerator(function* () {
+      yield _this8.emitAsync('beforeDestroy', _this8, options);
+      yield _this8.stop(options);
+      yield _this8.emitAsync('afterDestroy', _this8, options);
+    })();
+  }
+
+  install(options = {}) {
+    var _this9 = this;
+
+    return _asyncToGenerator(function* () {
+      yield _this9.emitAsync('beforeInstall', _this9, options);
+
+      if (options === null || options === void 0 ? void 0 : options.clean) {
+        yield _this9.db.clean((0, _lodash().isBoolean)(options.clean) ? {
+          drop: options.clean
+        } : options.clean);
+      }
+
+      yield _this9.db.sync(options === null || options === void 0 ? void 0 : options.sync);
+      yield _this9.pm.install(options);
+      yield _this9.version.update();
+      yield _this9.emitAsync('afterInstall', _this9, options);
+    })();
+  }
+
+  upgrade(options = {}) {
+    var _this10 = this;
+
+    return _asyncToGenerator(function* () {
+      const force = false;
+      yield _this10.db.migrator.up();
+      yield _this10.db.sync({
+        force,
+        alter: {
+          drop: force
+        }
+      });
+      yield _this10.version.update();
+    })();
+  }
+
 }
+
 exports.Application = Application;
-(0, utils_1.applyMixins)(Application, [utils_1.AsyncEmitter]);
-exports.default = Application;
-//# sourceMappingURL=application.js.map
+(0, _utils().applyMixins)(Application, [_utils().AsyncEmitter]);
+var _default = Application;
+exports.default = _default;

package/lib/commands/console.d.ts

@@ -1,4 +1,3 @@
-declare const _default: ({ app }: {
-    app: any;
-}) => Promise<void>;
+import Application from '../application';
+declare const _default: (app: Application) => void;
 export default _default;

package/lib/commands/console.js

@@ -1,27 +1,36 @@
 "use strict";
-var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
-    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
-    return new (P || (P = Promise))(function (resolve, reject) {
-        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
-        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
-        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
-        step((generator = generator.apply(thisArg, _arguments || [])).next());
-    });
-};
-Object.defineProperty(exports, "__esModule", { value: true });
+
+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); }); }; }
+
 const REPL = require('repl');
-exports.default = ({ app }) => __awaiter(void 0, void 0, void 0, function* () {
+
+var _default = app => {
+  app.command('console').action( /*#__PURE__*/_asyncToGenerator(function* () {
     yield app.start();
-    const repl = (REPL.start('nocobase > ').context.app = app);
-    repl.on('exit', function (err) {
-        return __awaiter(this, void 0, void 0, function* () {
-            if (err) {
-                console.log(err);
-                process.exit(1);
-            }
-            yield app.stop();
-            process.exit(0);
-        });
-    });
-});
-//# sourceMappingURL=console.js.map
+    const repl = REPL.start('nocobase > ').context.app = app;
+    repl.on('exit', /*#__PURE__*/function () {
+      var _ref2 = _asyncToGenerator(function* (err) {
+        if (err) {
+          console.log(err);
+          process.exit(1);
+        }
+
+        yield app.stop();
+        process.exit(0);
+      });
+
+      return function (_x) {
+        return _ref2.apply(this, arguments);
+      };
+    }());
+  }));
+};
+
+exports.default = _default;

package/lib/commands/db-auth.d.ts

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

package/lib/commands/db-auth.js

@@ -0,0 +1,26 @@
+"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('db:auth').option('-r, --retry [retry]').action( /*#__PURE__*/function () {
+    var _ref = _asyncToGenerator(function* (opts) {
+      yield app.db.auth({
+        retry: opts.retry || 10
+      });
+    });
+
+    return function (_x) {
+      return _ref.apply(this, arguments);
+    };
+  }());
+};
+
+exports.default = _default;