@nocobase/server 0.18.0-alpha.9 → 0.19.0-alpha.10

package/lib/app-command.d.ts

@@ -1,7 +1,11 @@
 import { Command } from 'commander';
 export declare class AppCommand extends Command {
     private _handleByIPCServer;
+    _preload: boolean;
     ipc(): this;
+    auth(): this;
+    preload(): this;
+    hasCommand(name: string): boolean;
     isHandleByIPCServer(): boolean;
     createCommand(name?: string): AppCommand;
     parseHandleByIPCServer(argv: any, parseOptions?: any): Boolean;

package/lib/app-command.js

@@ -24,10 +24,24 @@ module.exports = __toCommonJS(app_command_exports);
 var import_commander = require("commander");
 const _AppCommand = class _AppCommand extends import_commander.Command {
   _handleByIPCServer = false;
+  _preload = false;
   ipc() {
     this._handleByIPCServer = true;
     return this;
   }
+  auth() {
+    this["_authenticate"] = true;
+    return this;
+  }
+  preload() {
+    this["_authenticate"] = true;
+    this._preload = true;
+    return this;
+  }
+  hasCommand(name) {
+    const names = this.commands.map((c) => c.name());
+    return names.includes(name);
+  }
   isHandleByIPCServer() {
     return this._handleByIPCServer;
   }

package/lib/app-supervisor.js

@@ -213,9 +213,17 @@ const _AppSupervisor = class _AppSupervisor extends import_events.EventEmitter {
     });
     app.on("__started", async (_app, options) => {
       const { maintainingStatus, options: startOptions } = options;
-      if (maintainingStatus && ["install", "upgrade", "pm.add", "pm.update", "pm.enable", "pm.disable", "pm.remove"].includes(
-        maintainingStatus.command.name
-      ) && !startOptions.recover) {
+      if (maintainingStatus && [
+        "install",
+        "upgrade",
+        "refresh",
+        "restore",
+        "pm.add",
+        "pm.update",
+        "pm.enable",
+        "pm.disable",
+        "pm.remove"
+      ].includes(maintainingStatus.command.name) && !startOptions.recover) {
         this.setAppStatus(app.name, "running", {
           refresh: true
         });

package/lib/application.d.ts

@@ -5,8 +5,9 @@ import { ACL } from '@nocobase/acl';
 import { AuthManager, AuthManagerOptions } from '@nocobase/auth';
 import { Cache, CacheManager, CacheManagerOptions } from '@nocobase/cache';
 import Database, { CollectionOptions, IDatabaseOptions } from '@nocobase/database';
-import { SystemLogger, RequestLoggerOptions, LoggerOptions, SystemLoggerOptions } from '@nocobase/logger';
+import { LoggerOptions, RequestLoggerOptions, SystemLogger, SystemLoggerOptions } from '@nocobase/logger';
 import { ResourceOptions, Resourcer } from '@nocobase/resourcer';
+import { Telemetry, TelemetryOptions } from '@nocobase/telemetry';
 import { AsyncEmitter, ToposortOptions } from '@nocobase/utils';
 import { Command, CommandOptions, ParseOptions } from 'commander';
 import { IncomingMessage, Server, ServerResponse } from 'http';
@@ -20,7 +21,6 @@ import { ApplicationVersion } from './helpers/application-version';
 import { Locale } from './locale';
 import { Plugin } from './plugin';
 import { InstallOptions, PluginManager } from './plugin-manager';
-import { TelemetryOptions, Telemetry } from '@nocobase/telemetry';
 export type PluginType = string | typeof Plugin;
 export type PluginConfiguration = PluginType | [PluginType, any];
 export interface ResourcerOptions {
@@ -70,6 +70,8 @@ interface StartOptions {
     cliArgs?: any[];
     dbSync?: boolean;
     checkInstall?: boolean;
+    quickstart?: boolean;
+    reload?: boolean;
     recover?: boolean;
 }
 type MaintainingStatus = 'command_begin' | 'command_end' | 'command_running' | 'command_error';
@@ -143,6 +145,9 @@ export declare class Application<StateT = DefaultState, ContextT = DefaultContex
     setMaintaining(_maintainingCommandStatus: MaintainingCommandStatus): void;
     setMaintainingMessage(message: string): void;
     getVersion(): string;
+    /**
+     * @deprecated
+     */
     plugin<O = any>(pluginClass: any, options?: O): void;
     use<NewStateT = {}, NewContextT = {}>(middleware: Koa.Middleware<StateT & NewStateT, ContextT & NewContextT>, options?: ToposortOptions): this;
     callback(): (req: IncomingMessage, res: ServerResponse) => any;
@@ -151,13 +156,35 @@ export declare class Application<StateT = DefaultState, ContextT = DefaultContex
     actions(handlers: any, options?: ActionsOptions): void;
     command(name: string, desc?: string, opts?: CommandOptions): AppCommand;
     findCommand(name: string): Command;
+    preload(): Promise<void>;
+    reInit(): Promise<void>;
     load(options?: any): Promise<void>;
     reload(options?: any): Promise<void>;
+    /**
+     * @deprecated
+     */
     getPlugin<P extends Plugin>(name: string | typeof Plugin): P;
     parse(argv?: string[]): Promise<AppCommand>;
     authenticate(): Promise<void>;
     runCommand(command: string, ...args: any[]): Promise<AppCommand>;
     createCli(): AppCommand;
+    loadMigrations(options: any): Promise<{
+        beforeLoad: any[];
+        afterSync: any[];
+        afterLoad: any[];
+    }>;
+    loadCoreMigrations(): Promise<{
+        beforeLoad: {
+            up: () => Promise<void>;
+        };
+        afterSync: {
+            up: () => Promise<void>;
+        };
+        afterLoad: {
+            up: () => Promise<void>;
+        };
+    }>;
+    loadPluginCommands(): Promise<void>;
     runAsCLI(argv?: string[], options?: ParseOptions & {
         throwError?: boolean;
         reqId?: string;

package/lib/application.js

@@ -36,12 +36,15 @@ var import_actions = require("@nocobase/actions");
 var import_auth = require("@nocobase/auth");
 var import_database = __toESM(require("@nocobase/database"));
 var import_logger = require("@nocobase/logger");
+var import_telemetry = require("@nocobase/telemetry");
 var import_utils = require("@nocobase/utils");
-var import_chalk = __toESM(require("chalk"));
 var import_crypto = require("crypto");
+var import_glob = __toESM(require("glob"));
 var import_koa = __toESM(require("koa"));
 var import_koa_compose = __toESM(require("koa-compose"));
 var import_lodash = __toESM(require("lodash"));
+var import_path = require("path");
+var import_semver = __toESM(require("semver"));
 var import_acl2 = require("./acl");
 var import_app_command = require("./app-command");
 var import_app_supervisor = require("./app-supervisor");
@@ -53,7 +56,6 @@ var import_helper = require("./helper");
 var import_application_version = require("./helpers/application-version");
 var import_locale = require("./locale");
 var import_plugin_manager = require("./plugin-manager");
-var import_telemetry = require("@nocobase/telemetry");
 var import_package = __toESM(require("../package.json"));
 const _Application = class _Application extends import_koa.default {
   constructor(options) {
@@ -180,6 +182,9 @@ const _Application = class _Application extends import_koa.default {
   getVersion() {
     return import_package.default.version;
   }
+  /**
+   * @deprecated
+   */
   plugin(pluginClass, options) {
     this.log.debug(`add plugin`, { method: "plugin", name: pluginClass.name });
     this.pm.addPreset(pluginClass, options);
@@ -213,6 +218,26 @@ const _Application = class _Application extends import_koa.default {
   findCommand(name) {
     return this.cli._findCommand(name);
   }
+  async preload() {
+  }
+  async reInit() {
+    if (!this._loaded) {
+      return;
+    }
+    this.log.info("app reinitializing");
+    if (this.cacheManager) {
+      await this.cacheManager.close();
+    }
+    if (this.telemetry.started) {
+      await this.telemetry.shutdown();
+    }
+    const oldDb = this._db;
+    this.init();
+    if (!oldDb.closed()) {
+      await oldDb.close();
+    }
+    this._loaded = false;
+  }
   async load(options) {
     var _a;
     if (this._loaded) {
@@ -238,14 +263,18 @@ const _Application = class _Application extends import_koa.default {
     await this.pm.initPlugins();
     this.setMaintainingMessage("start load");
     this.setMaintainingMessage("emit beforeLoad");
-    await this.emitAsync("beforeLoad", this, options);
+    if ((options == null ? void 0 : options.hooks) !== false) {
+      await this.emitAsync("beforeLoad", this, options);
+    }
     this.telemetry.init();
     if ((_a = this.options.telemetry) == null ? void 0 : _a.enabled) {
       this.telemetry.start();
     }
     await this.pm.load(options);
     this.setMaintainingMessage("emit afterLoad");
-    await this.emitAsync("afterLoad", this, options);
+    if ((options == null ? void 0 : options.hooks) !== false) {
+      await this.emitAsync("afterLoad", this, options);
+    }
     this._loaded = true;
   }
   async reload(options) {
@@ -261,6 +290,9 @@ const _Application = class _Application extends import_koa.default {
     await this.emitAsync("afterReload", this, options);
     this.log.debug(`finish reload`, { method: "reload" });
   }
+  /**
+   * @deprecated
+   */
   getPlugin(name) {
     return this.pm.get(name);
   }
@@ -293,8 +325,12 @@ const _Application = class _Application extends import_koa.default {
         status: "command_running",
         command: this.activatedCommand
       });
-      await this.authenticate();
-      await this.load();
+      if (actionCommand["_authenticate"]) {
+        await this.authenticate();
+      }
+      if (actionCommand["_preload"]) {
+        await this.load();
+      }
     }).hook("postAction", async (_, actionCommand) => {
       var _a;
       if (((_a = this._maintainingStatusBeforeCommand) == null ? void 0 : _a.error) && this._started) {
@@ -306,6 +342,64 @@ const _Application = class _Application extends import_koa.default {
     });
     return command;
   }
+  async loadMigrations(options) {
+    const { directory, context, namespace } = options;
+    const migrations = {
+      beforeLoad: [],
+      afterSync: [],
+      afterLoad: []
+    };
+    const extensions = ["js", "ts"];
+    const patten = `${directory}/*.{${extensions.join(",")}}`;
+    const files = import_glob.default.sync(patten, {
+      ignore: ["**/*.d.ts"]
+    });
+    const appVersion = await this.version.get();
+    for (const file of files) {
+      let filename = (0, import_path.basename)(file);
+      filename = filename.substring(0, filename.lastIndexOf(".")) || filename;
+      const Migration = await (0, import_utils.importModule)(file);
+      const m = new Migration({ app: this, db: this.db, ...context });
+      if (!m.appVersion || import_semver.default.satisfies(appVersion, m.appVersion, { includePrerelease: true })) {
+        m.name = `${filename}/${namespace}`;
+        migrations[m.on || "afterLoad"].push(m);
+      }
+    }
+    return migrations;
+  }
+  async loadCoreMigrations() {
+    const migrations = await this.loadMigrations({
+      directory: (0, import_path.resolve)(__dirname, "migrations"),
+      namespace: "@nocobase/server"
+    });
+    return {
+      beforeLoad: {
+        up: async () => {
+          this.log.debug("run core migrations(beforeLoad)");
+          const migrator = this.db.createMigrator({ migrations: migrations.beforeLoad });
+          await migrator.up();
+        }
+      },
+      afterSync: {
+        up: async () => {
+          this.log.debug("run core migrations(afterSync)");
+          const migrator = this.db.createMigrator({ migrations: migrations.afterSync });
+          await migrator.up();
+        }
+      },
+      afterLoad: {
+        up: async () => {
+          this.log.debug("run core migrations(afterLoad)");
+          const migrator = this.db.createMigrator({ migrations: migrations.afterLoad });
+          await migrator.up();
+        }
+      }
+    };
+  }
+  async loadPluginCommands() {
+    this.log.debug("load plugin commands");
+    await this.pm.loadCommands();
+  }
   async runAsCLI(argv = process.argv, options) {
     if (this.activatedCommand) {
       return;
@@ -316,6 +410,10 @@ const _Application = class _Application extends import_koa.default {
     }
     this._maintainingStatusBeforeCommand = this._maintainingCommandStatus;
     try {
+      const commandName = (options == null ? void 0 : options.from) === "user" ? argv[0] : argv[2];
+      if (!this.cli.hasCommand(commandName)) {
+        await this.pm.loadCommands();
+      }
       const command = await this.cli.parseAsync(argv, options);
       this.setMaintaining({
         status: "command_end",
@@ -323,7 +421,6 @@ const _Application = class _Application extends import_koa.default {
       });
       return command;
     } catch (error) {
-      console.log({ error });
       if (!this.activatedCommand) {
         this.activatedCommand = {
           name: "unknown"
@@ -393,6 +490,7 @@ const _Application = class _Application extends import_koa.default {
     if (!this._started) {
       return;
     }
+    this.log.info("restarting...");
     this._started = false;
     await this.emitAsync("beforeStop");
     await this.reload(options);
@@ -400,20 +498,30 @@ const _Application = class _Application extends import_koa.default {
     this.emit("__restarted", this, options);
   }
   async stop(options = {}) {
-    this.log.debug("stop app...", { method: "stop" });
+    const log = options.logging === false ? {
+      debug() {
+      },
+      warn() {
+      },
+      info() {
+      },
+      error() {
+      }
+    } : this.log;
+    log.debug("stop app...", { method: "stop" });
     this.setMaintainingMessage("stopping app...");
     if (this.stopped) {
-      this.log.warn(`Application ${this.name} already stopped`, { method: "stop" });
+      log.warn(`app is stopped`, { method: "stop" });
       return;
     }
     await this.emitAsync("beforeStop", this, options);
     try {
       if (!this.db.closed()) {
-        this.log.info(`close db`, { method: "stop" });
+        log.info(`close db`, { method: "stop" });
         await this.db.close();
       }
     } catch (e) {
-      this.log.error(e.message, { method: "stop", err: e.stack });
+      log.error(e.message, { method: "stop", err: e.stack });
     }
     if (this.cacheManager) {
       await this.cacheManager.close();
@@ -423,7 +531,7 @@ const _Application = class _Application extends import_koa.default {
     }
     await this.emitAsync("afterStop", this, options);
     this.stopped = true;
-    this.log.info(`${this.name} is stopped`, { method: "stop" });
+    log.info(`app has stopped`, { method: "stop" });
     this._started = false;
   }
   async destroy(options = {}) {
@@ -439,29 +547,27 @@ const _Application = class _Application extends import_koa.default {
     return await this.db.collectionExistsInDb("applicationVersion") || await this.db.collectionExistsInDb("collections");
   }
   async install(options = {}) {
-    var _a, _b;
-    this.setMaintainingMessage("installing app...");
-    this.log.debug("Database dialect: " + this.db.sequelize.getDialect(), { method: "install" });
-    if ((options == null ? void 0 : options.clean) || ((_a = options == null ? void 0 : options.sync) == null ? void 0 : _a.force)) {
-      this.log.debug("truncate database", { method: "install" });
+    var _a;
+    const reinstall = options.clean || options.force;
+    if (reinstall) {
       await this.db.clean({ drop: true });
-      this.log.debug("app reloading", { method: "install" });
-      await this.reload();
-    } else if (await this.isInstalled()) {
-      this.log.warn("app is installed", { method: "install" });
+    }
+    if (await this.isInstalled()) {
+      this.log.warn("app is installed");
       return;
     }
+    await this.reInit();
+    await this.db.sync();
+    await this.load({ hooks: false });
     this.log.debug("emit beforeInstall", { method: "install" });
     this.setMaintainingMessage("call beforeInstall hook...");
     await this.emitAsync("beforeInstall", this, options);
-    this.log.debug("start install plugins", { method: "install" });
-    await this.pm.install(options);
-    this.log.debug("update version", { method: "install" });
+    await this.pm.install();
     await this.version.update();
     this.log.debug("emit afterInstall", { method: "install" });
     this.setMaintainingMessage("call afterInstall hook...");
     await this.emitAsync("afterInstall", this, options);
-    if ((_b = this._maintainingStatusBeforeCommand) == null ? void 0 : _b.error) {
+    if ((_a = this._maintainingStatusBeforeCommand) == null ? void 0 : _a.error) {
       return;
     }
     if (this._started) {
@@ -469,27 +575,33 @@ const _Application = class _Application extends import_koa.default {
     }
   }
   async upgrade(options = {}) {
-    await this.emitAsync("beforeUpgrade", this, options);
-    const force = false;
-    await (0, import_utils.measureExecutionTime)(async () => {
-      await this.db.migrator.up();
-    }, "Migrator");
-    await (0, import_utils.measureExecutionTime)(async () => {
-      await this.db.sync({
-        force,
-        alter: {
-          drop: force
-        }
-      });
-    }, "Sync");
+    this.log.info("upgrading...");
+    await this.reInit();
+    const migrator1 = await this.loadCoreMigrations();
+    await migrator1.beforeLoad.up();
+    await this.db.sync();
+    await migrator1.afterSync.up();
+    await this.pm.initPresetPlugins();
+    const migrator2 = await this.pm.loadPresetMigrations();
+    await migrator2.beforeLoad.up();
+    await this.pm.load();
+    await this.db.sync();
+    await migrator2.afterSync.up();
+    await this.pm.upgrade();
+    await this.pm.initOtherPlugins();
+    const migrator3 = await this.pm.loadOtherMigrations();
+    await migrator3.beforeLoad.up();
+    await this.load();
+    await this.db.sync();
+    await migrator3.afterSync.up();
+    await this.pm.upgrade();
+    await migrator1.afterLoad.up();
+    await migrator2.afterLoad.up();
+    await migrator3.afterLoad.up();
+    await this.pm.repository.updateVersions();
     await this.version.update();
     await this.emitAsync("afterUpgrade", this, options);
-    this.log.debug(import_chalk.default.green(`\u2728  NocoBase has been upgraded to v${this.getVersion()}`));
-    if (this._started) {
-      await (0, import_utils.measureExecutionTime)(async () => {
-        await this.restart();
-      }, "Restart");
-    }
+    await this.restart();
   }
   toJSON() {
     return {

package/lib/commands/create-migration.d.ts

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

package/lib/commands/create-migration.js

@@ -0,0 +1,67 @@
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var create_migration_exports = {};
+__export(create_migration_exports, {
+  default: () => create_migration_default
+});
+module.exports = __toCommonJS(create_migration_exports);
+var import_dayjs = __toESM(require("dayjs"));
+var import_fs = __toESM(require("fs"));
+var import_path = require("path");
+var create_migration_default = /* @__PURE__ */ __name((app) => {
+  app.command("create-migration").argument("<name>").option("--pkg <pkg>").option("--on [on]").action(async (name, options) => {
+    const pkg = options.pkg;
+    const dir = await import_fs.default.promises.realpath((0, import_path.resolve)(process.env.NODE_MODULES_PATH, pkg));
+    const filename = (0, import_path.resolve)(
+      dir,
+      pkg === "@nocobase/server" ? "src" : "src/server",
+      "migrations",
+      `${(0, import_dayjs.default)().format("YYYYMMDDHHmmss")}-${name}.ts`
+    );
+    const version = app.getVersion();
+    const keys = version.split(".");
+    keys.push(1 * keys.pop() + 1);
+    const nextVersion = keys.join(".");
+    const from = pkg === "@nocobase/server" ? `../migration` : "@nocobase/server";
+    const data = `import { Migration } from '${from}';
+
+export default class extends Migration {
+  on = '${options.on || "afterLoad"}'; // 'beforeLoad' or 'afterLoad'
+  appVersion = '<${nextVersion}';
+
+  async up() {
+    // coding
+  }
+}
+`;
+    await import_fs.default.promises.mkdir((0, import_path.dirname)(filename), { recursive: true });
+    await import_fs.default.promises.writeFile(filename, data, "utf8");
+    app.log.info(`migration file in ${filename}`);
+  });
+}, "default");

package/lib/commands/db-clean.js

@@ -22,7 +22,7 @@ __export(db_clean_exports, {
 });
 module.exports = __toCommonJS(db_clean_exports);
 var db_clean_default = /* @__PURE__ */ __name((app) => {
-  app.command("db:clean").option("-y, --yes").action(async (opts) => {
+  app.command("db:clean").auth().option("-y, --yes").action(async (opts) => {
     console.log("Clearing database");
     await app.db.clean({
       drop: opts.yes

package/lib/commands/db-sync.js

@@ -22,7 +22,7 @@ __export(db_sync_exports, {
 });
 module.exports = __toCommonJS(db_sync_exports);
 var db_sync_default = /* @__PURE__ */ __name((app) => {
-  app.command("db:sync").action(async (...cliArgs) => {
+  app.command("db:sync").auth().action(async (...cliArgs) => {
     const [opts] = cliArgs;
     console.log("db sync...");
     const force = false;

package/lib/commands/destroy.js

@@ -22,7 +22,7 @@ __export(destroy_exports, {
 });
 module.exports = __toCommonJS(destroy_exports);
 var destroy_default = /* @__PURE__ */ __name((app) => {
-  app.command("destroy").action(async (...cliArgs) => {
+  app.command("destroy").preload().action(async (...cliArgs) => {
     await app.destroy({
       cliArgs
     });

package/lib/commands/index.js

@@ -31,31 +31,31 @@ __export(commands_exports, {
   registerCli: () => registerCli
 });
 module.exports = __toCommonJS(commands_exports);
-var import_console = __toESM(require("./console"));
+var import_create_migration = __toESM(require("./create-migration"));
 var import_db_auth = __toESM(require("./db-auth"));
 var import_db_clean = __toESM(require("./db-clean"));
 var import_db_sync = __toESM(require("./db-sync"));
 var import_destroy = __toESM(require("./destroy"));
 var import_install = __toESM(require("./install"));
-var import_migrator = __toESM(require("./migrator"));
 var import_pm = __toESM(require("./pm"));
+var import_refresh = __toESM(require("./refresh"));
 var import_restart = __toESM(require("./restart"));
 var import_start = __toESM(require("./start"));
 var import_stop = __toESM(require("./stop"));
 var import_upgrade = __toESM(require("./upgrade"));
 function registerCli(app) {
-  (0, import_console.default)(app);
   (0, import_db_auth.default)(app);
+  (0, import_create_migration.default)(app);
   (0, import_db_clean.default)(app);
   (0, import_db_sync.default)(app);
   (0, import_install.default)(app);
-  (0, import_migrator.default)(app);
-  (0, import_start.default)(app);
   (0, import_upgrade.default)(app);
   (0, import_pm.default)(app);
   (0, import_restart.default)(app);
   (0, import_stop.default)(app);
   (0, import_destroy.default)(app);
+  (0, import_start.default)(app);
+  (0, import_refresh.default)(app);
   app.command("build").argument("[packages...]");
   app.command("clean");
   app.command("dev").usage("[options]").option("-p, --port [port]").option("--client").option("--server");

package/lib/commands/install.js

@@ -22,14 +22,12 @@ __export(install_exports, {
 });
 module.exports = __toCommonJS(install_exports);
 var install_default = /* @__PURE__ */ __name((app) => {
-  app.command("install").ipc().option("-f, --force").option("-c, --clean").action(async (...cliArgs) => {
-    const [opts] = cliArgs;
-    await app.install({
-      cliArgs,
-      clean: opts.clean,
-      sync: {
-        force: opts.force
-      }
-    });
+  app.command("install").ipc().auth().option("-f, --force").option("-c, --clean").option("--lang <lang>").action(async (options) => {
+    if (options.lang) {
+      process.env.INIT_APP_LANG = options.lang;
+    }
+    await app.install(options);
+    const reinstall = options.clean || options.force;
+    app.log.info(`app ${reinstall ? "reinstalled" : "installed"} successfully [v${app.getVersion()}]`);
   });
 }, "default");

package/lib/commands/migrator.js

@@ -22,7 +22,7 @@ __export(migrator_exports, {
 });
 module.exports = __toCommonJS(migrator_exports);
 var migrator_default = /* @__PURE__ */ __name((app) => {
-  app.command("migrator").action(async (opts) => {
+  app.command("migrator").preload().action(async (opts) => {
     console.log("migrating...");
     await app.emitAsync("cli.beforeMigrator", opts);
     await app.db.migrator.runAsCLI(process.argv.slice(3));