@nocobase/server 0.12.0-alpha.5 → 0.13.0-alpha.2

package/lib/application.js

@@ -3,7 +3,7 @@
 Object.defineProperty(exports, "__esModule", {
   value: true
 });
-exports.default = exports.ApplicationVersion = exports.Application = void 0;
+exports.default = exports.Application = void 0;
 function _actions() {
   const data = require("@nocobase/actions");
   _actions = function _actions() {
@@ -74,27 +74,25 @@ function _koaCompose() {
   };
   return data;
 }
-function _semver() {
-  const data = _interopRequireDefault(require("semver"));
-  _semver = function _semver() {
-    return data;
-  };
-  return data;
-}
-function _util() {
-  const data = require("util");
-  _util = function _util() {
+function _lodash() {
+  const data = _interopRequireDefault(require("lodash"));
+  _lodash = function _lodash() {
     return data;
   };
   return data;
 }
 var _acl = require("./acl");
-var _appManager = require("./app-manager");
+var _appSupervisor = require("./app-supervisor");
 var _commands = require("./commands");
+var _applicationNotInstall = require("./errors/application-not-install");
 var _helper = require("./helper");
+var _applicationVersion = require("./helpers/application-version");
 var _locale = require("./locale");
 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) { key = _toPropertyKey(key); if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
@@ -103,72 +101,25 @@ function _toPrimitive(input, hint) { if (typeof input !== "object" || input ===
 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',
-        namespace: 'core.applicationVersion',
-        duplicator: 'required',
-        timestamps: false,
-        fields: [{
-          name: 'value',
-          type: 'string'
-        }]
-      });
-    }
-    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();
-        if (!model) {
-          return null;
-        }
-        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 === null || model === void 0 ? void 0 : model.value;
-        if (!version) {
-          return true;
-        }
-        return _semver().default.satisfies(version, range, {
-          includePrerelease: true
-        });
-      }
-      return true;
-    })();
-  }
-}
-exports.ApplicationVersion = ApplicationVersion;
 class Application extends _koa().default {
   constructor(options) {
     super();
     this.options = void 0;
+    this.listenServer = void 0;
+    this.stopped = false;
+    this.ready = false;
+    this.rawOptions = void 0;
+    this.activatedCommand = null;
+    this.running = false;
+    this.plugins = new Map();
+    this._appSupervisor = _appSupervisor.AppSupervisor.getInstance();
+    this._started = void 0;
+    this._authenticated = false;
+    this._maintaining = false;
+    this._maintainingCommandStatus = void 0;
+    this._maintainingStatusBeforeCommand = void 0;
+    this._loaded = void 0;
+    this._maintainingMessage = void 0;
     this._db = void 0;
     this._logger = void 0;
     this._resourcer = void 0;
@@ -177,140 +128,87 @@ class Application extends _koa().default {
     this._i18n = void 0;
     this._pm = void 0;
     this._acl = void 0;
-    this._appManager = void 0;
     this._authManager = void 0;
     this._locales = void 0;
     this._version = void 0;
-    this.plugins = new Map();
-    this.listenServer = void 0;
-    this.stopped = false;
     this.options = options;
+    this.rawOptions = this.name == 'main' ? _lodash().default.cloneDeep(options) : {};
     this.init();
+    this._appSupervisor.addApp(this);
+  }
+  get loaded() {
+    return this._loaded;
+  }
+  get maintainingMessage() {
+    return this._maintainingMessage;
   }
   get db() {
     return this._db;
   }
-  get cache() {
-    return this._cache;
+  get logger() {
+    return this._logger;
   }
   get resourcer() {
     return this._resourcer;
   }
+  get cache() {
+    return this._cache;
+  }
   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;
+  get acl() {
+    return this._acl;
   }
   get authManager() {
     return this._authManager;
   }
-  get logger() {
-    return this._logger;
+  get locales() {
+    return this._locales;
+  }
+  get version() {
+    return this._version;
   }
   get log() {
     return this._logger;
   }
-  get locales() {
-    return this._locales;
-  }
   get name() {
     return this.options.name || 'main';
   }
-  init() {
-    const options = this.options;
-    const logger = (0, _logger().createAppLogger)(options.logger);
-    this._logger = logger.instance;
-    // @ts-ignore
-    this._events = [];
-    // @ts-ignore
-    this._eventsCount = [];
-    this.removeAllListeners();
-    this.middleware = new (_utils().Toposort)();
-    this.plugins = new Map();
-    this._acl = (0, _acl.createACL)();
-    this.use(logger.middleware, {
-      tag: 'logger'
-    });
-    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.logger = this._logger;
-    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
-      });
-    }
-    if (this._appManager) {
-      this._appManager.bindMainApplication(this);
-    } else {
-      this._appManager = new _appManager.AppManager(this);
-    }
-    this._authManager = new (_auth().AuthManager)({
-      authKey: 'X-Authenticator',
-      default: 'basic'
-    });
-    this.resource({
-      name: 'auth',
-      actions: _auth().actions
-    });
-    this._resourcer.use(this._authManager.middleware(), {
-      tag: 'auth'
-    });
-    if (this.options.acl !== false) {
-      this._resourcer.use(this._acl.middleware(), {
-        tag: 'acl',
-        after: ['auth']
-      });
-    }
-    this._locales = new _locale.Locale(this);
-    (0, _helper.registerMiddlewares)(this, options);
-    if (options.registerActions !== false) {
-      (0, _actions().registerActions)(this);
+  isMaintaining() {
+    return this._maintaining;
+  }
+  getMaintaining() {
+    return this._maintainingCommandStatus;
+  }
+  setMaintaining(_maintainingCommandStatus) {
+    this._maintainingCommandStatus = _maintainingCommandStatus;
+    this.emit('maintaining', _maintainingCommandStatus);
+    if (_maintainingCommandStatus.status == 'command_end') {
+      this._maintaining = false;
+      return;
     }
-    (0, _commands.registerCli)(this);
-    this._version = new ApplicationVersion(this);
+    this._maintaining = true;
   }
-  createDatabase(options) {
-    const db = new (_database().default)(_objectSpread(_objectSpread({}, options.database instanceof _database().default ? options.database.options : options.database), {}, {
-      migrator: {
-        context: {
-          app: this
-        }
-      }
-    }));
-    db.setLogger(this._logger);
-    return db;
+  setMaintainingMessage(message) {
+    this._maintainingMessage = message;
+    this.emit('maintainingMessageChanged', {
+      message: this._maintainingMessage,
+      maintainingStatus: this._maintainingCommandStatus
+    });
   }
   getVersion() {
     return packageJson.version;
   }
   plugin(pluginClass, options) {
-    return this.pm.addStatic(pluginClass, options);
+    this.log.debug(`add plugin ${pluginClass.name}`);
+    this.pm.addPreset(pluginClass, options);
   }
   // @ts-ignore
   use(middleware, options) {
@@ -320,12 +218,11 @@ class Application extends _koa().default {
   callback() {
     const fn = (0, _koaCompose().default)(this.middleware.nodes);
     if (!this.listenerCount('error')) this.on('error', this.onerror);
-    const handleRequest = (req, res) => {
+    return (req, res) => {
       const ctx = this.createContext(req, res);
       // @ts-ignore
       return this.handleRequest(ctx, fn);
     };
-    return handleRequest;
   }
   collection(options) {
     return this.db.collection(options);
@@ -343,139 +240,227 @@ class Application extends _koa().default {
     return this.cli._findCommand(name);
   }
   load(options) {
-    var _this4 = this;
+    var _this = this;
     return _asyncToGenerator(function* () {
+      if (_this._loaded) {
+        return;
+      }
       if (options !== null && options !== void 0 && options.reload) {
-        console.log(`Reload the ${_this4.name} application configuration`);
-        const oldDb = _this4._db;
-        _this4.init();
+        _this.setMaintainingMessage('app reload');
+        _this.log.info(`app.reload()`);
+        const oldDb = _this._db;
+        _this.init();
         yield oldDb.close();
       }
-      yield _this4.emitAsync('beforeLoad', _this4, options);
-      yield _this4.pm.load(options);
-      yield _this4.emitAsync('afterLoad', _this4, options);
+      _this.setMaintainingMessage('init plugins');
+      yield _this.pm.initPlugins();
+      _this.setMaintainingMessage('start load');
+      _this.setMaintainingMessage('emit beforeLoad');
+      yield _this.emitAsync('beforeLoad', _this, options);
+      yield _this.pm.load(options);
+      _this.setMaintainingMessage('emit afterLoad');
+      yield _this.emitAsync('afterLoad', _this, options);
+      _this._loaded = true;
     })();
   }
   reload(options) {
-    var _this5 = this;
+    var _this2 = this;
     return _asyncToGenerator(function* () {
-      yield _this5.load(_objectSpread(_objectSpread({}, options), {}, {
+      _this2.log.debug(`start reload`);
+      _this2._loaded = false;
+      yield _this2.load(_objectSpread(_objectSpread({}, options), {}, {
         reload: true
       }));
-      yield _this5.emitAsync('afterReload', _this5, options);
+      _this2.log.debug('emit afterReload');
+      _this2.setMaintainingMessage('emit afterReload');
+      yield _this2.emitAsync('afterReload', _this2, options);
+      _this2.log.debug(`finish reload`);
     })();
   }
   getPlugin(name) {
     return this.pm.get(name);
   }
   parse(argv = process.argv) {
-    var _this6 = this;
+    var _this3 = this;
     return _asyncToGenerator(function* () {
-      return _this6.runAsCLI(argv);
+      return _this3.runAsCLI(argv);
     })();
   }
+  authenticate() {
+    var _this4 = this;
+    return _asyncToGenerator(function* () {
+      if (_this4._authenticated) {
+        return;
+      }
+      _this4._authenticated = true;
+      yield _this4.db.auth({
+        retry: 30
+      });
+      yield _this4.dbVersionCheck({
+        exit: true
+      });
+      yield _this4.db.prepare();
+    })();
+  }
+  runCommand(command, ...args) {
+    var _this5 = this;
+    return _asyncToGenerator(function* () {
+      return yield _this5.runAsCLI([command, ...args], {
+        from: 'user'
+      });
+    })();
+  }
+  createCli() {
+    var _this6 = this;
+    return new (_commander().Command)('nocobase').usage('[command] [options]').hook('preAction', /*#__PURE__*/function () {
+      var _ref = _asyncToGenerator(function* (_, actionCommand) {
+        _this6.activatedCommand = {
+          name: (0, _helper.getCommandFullName)(actionCommand)
+        };
+        _this6.setMaintaining({
+          status: 'command_begin',
+          command: _this6.activatedCommand
+        });
+        _this6.setMaintaining({
+          status: 'command_running',
+          command: _this6.activatedCommand
+        });
+        yield _this6.authenticate();
+        yield _this6.load();
+      });
+      return function (_x, _x2) {
+        return _ref.apply(this, arguments);
+      };
+    }()).hook('postAction', /*#__PURE__*/function () {
+      var _ref2 = _asyncToGenerator(function* (_, actionCommand) {
+        var _this6$_maintainingSt;
+        if ((_this6$_maintainingSt = _this6._maintainingStatusBeforeCommand) !== null && _this6$_maintainingSt !== void 0 && _this6$_maintainingSt.error && _this6._started) {
+          yield _this6.restart();
+        }
+      });
+      return function (_x3, _x4) {
+        return _ref2.apply(this, arguments);
+      };
+    }());
+  }
   runAsCLI(argv = process.argv, options) {
     var _this7 = this;
     return _asyncToGenerator(function* () {
+      if (_this7.activatedCommand) {
+        return;
+      }
+      _this7._maintainingStatusBeforeCommand = _this7._maintainingCommandStatus;
       try {
-        yield _this7.db.auth({
-          retry: 30
+        const command = yield _this7.cli.parseAsync(argv, options);
+        _this7.setMaintaining({
+          status: 'command_end',
+          command: _this7.activatedCommand
         });
+        return command;
       } catch (error) {
-        console.log(_chalk().default.red(error.message));
-        process.exit(1);
-      }
-      yield _this7.dbVersionCheck({
-        exit: true
-      });
-      yield _this7.db.prepare();
-      if ((argv === null || argv === void 0 ? void 0 : argv[2]) !== 'upgrade') {
-        yield _this7.load({
-          method: argv === null || argv === void 0 ? void 0 : argv[2]
+        console.log(`run command ${_this7.activatedCommand.name} error:`, error);
+        _this7.setMaintaining({
+          status: 'command_error',
+          command: _this7.activatedCommand,
+          error
         });
+      } finally {
+        _this7.activatedCommand = null;
       }
-      return _this7.cli.parseAsync(argv, options);
     })();
   }
   start(options = {}) {
     var _this8 = this;
     return _asyncToGenerator(function* () {
-      var _options$listen;
+      if (_this8._started) {
+        return;
+      }
+      _this8._started = true;
+      if (options.checkInstall && !(yield _this8.isInstalled())) {
+        throw new _applicationNotInstall.ApplicationNotInstall(`Application ${_this8.name} is not installed, Please run 'yarn nocobase install' command first`);
+      }
+      _this8.setMaintainingMessage('starting app...');
       if (_this8.db.closed()) {
         yield _this8.db.reconnect();
       }
-      if (options.dbSync) {
-        console.log('db sync...');
-        yield _this8.db.sync();
-      }
+      _this8.setMaintainingMessage('emit beforeStart');
       yield _this8.emitAsync('beforeStart', _this8, options);
-      if (options !== null && options !== void 0 && (_options$listen = options.listen) !== null && _options$listen !== void 0 && _options$listen.port) {
-        const pmServer = yield _this8.pm.listen();
-        const listen = () => new Promise((resolve, reject) => {
-          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
-          _this8.listenServer = yield listen();
-        } catch (e) {
-          console.error(e);
-          process.exit(1);
-        }
-      }
+      _this8.setMaintainingMessage('emit afterStart');
       yield _this8.emitAsync('afterStart', _this8, options);
+      yield _this8.emitAsync('__started', _this8, options);
       _this8.stopped = false;
     })();
   }
-  listen(...args) {
-    return this.appManager.listen(...args);
-  }
-  stop(options = {}) {
+  isStarted() {
     var _this9 = this;
     return _asyncToGenerator(function* () {
-      if (_this9.stopped) {
-        _this9.log.warn(`Application ${_this9.name} already stopped`);
+      return _this9._started;
+    })();
+  }
+  tryReloadOrRestart() {
+    var _this10 = this;
+    return _asyncToGenerator(function* () {
+      if (_this10._started) {
+        yield _this10.restart();
+      } else {
+        yield _this10.reload();
+      }
+    })();
+  }
+  restart(options = {}) {
+    var _this11 = this;
+    return _asyncToGenerator(function* () {
+      if (!_this11._started) {
         return;
       }
-      yield _this9.emitAsync('beforeStop', _this9, options);
-      // close http server
-      if (_this9.listenServer) {
-        yield (0, _util().promisify)(_this9.listenServer.close).call(_this9.listenServer);
-        _this9.listenServer = null;
+      _this11._started = false;
+      yield _this11.reload(options);
+      yield _this11.start(options);
+      _this11.emit('__restarted', _this11, options);
+    })();
+  }
+  stop(options = {}) {
+    var _this12 = this;
+    return _asyncToGenerator(function* () {
+      _this12.log.debug('stop app...');
+      _this12.setMaintainingMessage('stopping app...');
+      if (_this12.stopped) {
+        _this12.log.warn(`Application ${_this12.name} already stopped`);
+        return;
       }
+      yield _this12.emitAsync('beforeStop', _this12, options);
       try {
         // close database connection
         // silent if database already closed
-        if (!_this9.db.closed()) {
-          yield _this9.db.close();
+        if (!_this12.db.closed()) {
+          _this12.logger.info(`close db`);
+          yield _this12.db.close();
         }
       } catch (e) {
-        console.log(e);
+        _this12.log.error(e);
       }
-      yield _this9.emitAsync('afterStop', _this9, options);
-      _this9.stopped = true;
-      console.log(`${_this9.name} is stopped`);
+      yield _this12.emitAsync('afterStop', _this12, options);
+      _this12.stopped = true;
+      _this12.log.info(`${_this12.name} is stopped`);
+      _this12._started = false;
     })();
   }
   destroy(options = {}) {
-    var _this10 = this;
+    var _this13 = this;
     return _asyncToGenerator(function* () {
-      yield _this10.emitAsync('beforeDestroy', _this10, options);
-      yield _this10.stop(options);
-      yield _this10.emitAsync('afterDestroy', _this10, options);
+      _this13.logger.debug('start destroy app');
+      _this13.setMaintainingMessage('destroying app...');
+      yield _this13.emitAsync('beforeDestroy', _this13, options);
+      yield _this13.stop(options);
+      _this13.logger.debug('emit afterDestroy');
+      yield _this13.emitAsync('afterDestroy', _this13, options);
+      _this13.logger.debug('finish destroy app');
     })();
   }
   dbVersionCheck(options) {
-    var _this11 = this;
+    var _this14 = this;
     return _asyncToGenerator(function* () {
-      const r = yield _this11.db.version.satisfies({
+      const r = yield _this14.db.version.satisfies({
         mysql: '>=8.0.17',
         sqlite: '3.x',
         postgres: '>=10'
@@ -487,11 +472,11 @@ class Application extends _koa().default {
         }
         return false;
       }
-      if (_this11.db.inDialect('mysql')) {
-        const result = yield _this11.db.sequelize.query(`SHOW VARIABLES LIKE 'lower_case_table_names'`, {
+      if (_this14.db.inDialect('mysql')) {
+        const result = yield _this14.db.sequelize.query(`SHOW VARIABLES LIKE 'lower_case_table_names'`, {
           plain: true
         });
-        if ((result === null || result === void 0 ? void 0 : result.Value) === '1' && !_this11.db.options.underscored) {
+        if ((result === null || result === void 0 ? void 0 : result.Value) === '1' && !_this14.db.options.underscored) {
           console.log(`Your database lower_case_table_names=1, please add ${_chalk().default.yellow('DB_UNDERSCORED=true')} to the .env file`);
           if (options !== null && options !== void 0 && options.exit) {
             process.exit();
@@ -503,53 +488,168 @@ class Application extends _koa().default {
     })();
   }
   isInstalled() {
-    var _this12 = this;
+    var _this15 = this;
     return _asyncToGenerator(function* () {
-      return (yield _this12.db.collectionExistsInDb('applicationVersion')) || (yield _this12.db.collectionExistsInDb('collections'));
+      return (yield _this15.db.collectionExistsInDb('applicationVersion')) || (yield _this15.db.collectionExistsInDb('collections'));
     })();
   }
   install(options = {}) {
-    var _this13 = this;
+    var _this16 = this;
     return _asyncToGenerator(function* () {
-      var _options$sync;
-      console.log('Database dialect: ' + _this13.db.sequelize.getDialect());
+      var _options$sync, _this16$_maintainingS;
+      _this16.setMaintainingMessage('installing app...');
+      _this16.log.debug('Database dialect: ' + _this16.db.sequelize.getDialect());
       if (options !== null && options !== void 0 && options.clean || options !== null && options !== void 0 && (_options$sync = options.sync) !== null && _options$sync !== void 0 && _options$sync.force) {
-        console.log('Truncate database and reload app configuration');
-        yield _this13.db.clean({
+        _this16.log.debug('truncate database');
+        yield _this16.db.clean({
           drop: true
         });
-        yield _this13.reload({
-          method: 'install'
-        });
+        _this16.log.debug('app reloading');
+        yield _this16.reload();
+      } else if (yield _this16.isInstalled()) {
+        _this16.log.warn('app is installed');
+        return;
+      }
+      _this16.log.debug('emit beforeInstall');
+      _this16.setMaintainingMessage('call beforeInstall hook...');
+      yield _this16.emitAsync('beforeInstall', _this16, options);
+      _this16.log.debug('start install plugins');
+      yield _this16.pm.install(options);
+      _this16.log.debug('update version');
+      yield _this16.version.update();
+      _this16.log.debug('emit afterInstall');
+      _this16.setMaintainingMessage('call afterInstall hook...');
+      yield _this16.emitAsync('afterInstall', _this16, options);
+      if ((_this16$_maintainingS = _this16._maintainingStatusBeforeCommand) !== null && _this16$_maintainingS !== void 0 && _this16$_maintainingS.error) {
+        return;
+      }
+      if (_this16._started) {
+        yield _this16.restart();
       }
-      yield _this13.emitAsync('beforeInstall', _this13, options);
-      yield _this13.db.sync();
-      yield _this13.pm.install(options);
-      yield _this13.version.update();
-      yield _this13.emitAsync('afterInstall', _this13, options);
     })();
   }
   upgrade(options = {}) {
-    var _this14 = this;
+    var _this17 = this;
     return _asyncToGenerator(function* () {
-      yield _this14.emitAsync('beforeUpgrade', _this14, options);
+      yield _this17.emitAsync('beforeUpgrade', _this17, options);
       const force = false;
-      yield _this14.db.migrator.up();
-      yield _this14.db.sync({
+      yield _this17.db.migrator.up();
+      yield _this17.db.sync({
         force,
         alter: {
           drop: force
         }
       });
-      yield _this14.version.update();
-      yield _this14.emitAsync('afterUpgrade', _this14, options);
+      yield _this17.version.update();
+      yield _this17.emitAsync('afterUpgrade', _this17, options);
+      _this17.log.debug(_chalk().default.green(`✨  NocoBase has been upgraded to v${_this17.getVersion()}`));
+      if (_this17._started) {
+        yield _this17.restart();
+      }
     })();
   }
   toJSON() {
     return {
-      appName: this.name
+      appName: this.name,
+      name: this.name
     };
   }
+  reInitEvents() {
+    var _iterator = _createForOfIteratorHelper(this.eventNames()),
+      _step;
+    try {
+      for (_iterator.s(); !(_step = _iterator.n()).done;) {
+        const eventName = _step.value;
+        var _iterator2 = _createForOfIteratorHelper(this.listeners(eventName)),
+          _step2;
+        try {
+          for (_iterator2.s(); !(_step2 = _iterator2.n()).done;) {
+            const listener = _step2.value;
+            if (listener['_reinitializable']) {
+              this.removeListener(eventName, listener);
+            }
+          }
+        } catch (err) {
+          _iterator2.e(err);
+        } finally {
+          _iterator2.f();
+        }
+      }
+    } catch (err) {
+      _iterator.e(err);
+    } finally {
+      _iterator.f();
+    }
+  }
+  init() {
+    const options = this.options;
+    const logger = (0, _logger().createAppLogger)(_objectSpread(_objectSpread({}, options.logger), {}, {
+      defaultMeta: {
+        app: this.name
+      }
+    }));
+    this._logger = logger.instance;
+    this.reInitEvents();
+    this.middleware = new (_utils().Toposort)();
+    this.plugins = new Map();
+    this._acl = (0, _acl.createACL)();
+    this.use(logger.middleware, {
+      tag: 'logger'
+    });
+    if (this._db) {
+      // MaxListenersExceededWarning
+      this._db.removeAllListeners();
+    }
+    this._db = this.createDatabase(options);
+    this._resourcer = (0, _helper.createResourcer)(options);
+    this._cli = this.createCli();
+    this._i18n = (0, _helper.createI18n)(options);
+    this._cache = (0, _cache().createCache)(options.cache);
+    this.context.db = this._db;
+    this.context.logger = this._logger;
+    this.context.resourcer = this._resourcer;
+    this.context.cache = this._cache;
+    const plugins = this._pm ? this._pm.options.plugins : options.plugins;
+    this._pm = new _pluginManager.PluginManager({
+      app: this,
+      plugins: plugins || []
+    });
+    this._authManager = new (_auth().AuthManager)({
+      authKey: 'X-Authenticator',
+      default: 'basic'
+    });
+    this.resource({
+      name: 'auth',
+      actions: _auth().actions
+    });
+    this._resourcer.use(this._authManager.middleware(), {
+      tag: 'auth'
+    });
+    if (this.options.acl !== false) {
+      this._resourcer.use(this._acl.middleware(), {
+        tag: 'acl',
+        after: ['auth']
+      });
+    }
+    this._locales = new _locale.Locale((0, _helper.createAppProxy)(this));
+    (0, _helper.registerMiddlewares)(this, options);
+    if (options.registerActions !== false) {
+      (0, _actions().registerActions)(this);
+    }
+    (0, _commands.registerCli)(this);
+    this._version = new _applicationVersion.ApplicationVersion(this);
+  }
+  createDatabase(options) {
+    const db = new (_database().default)(_objectSpread(_objectSpread({}, options.database instanceof _database().default ? options.database.options : options.database), {}, {
+      migrator: {
+        context: {
+          app: this
+        }
+      }
+    }));
+    db.setLogger(this._logger);
+    return db;
+  }
 }
 exports.Application = Application;
 (0, _utils().applyMixins)(Application, [_utils().AsyncEmitter]);