@nocobase/server 2.0.0-alpha.5 → 2.0.0-alpha.51

package/lib/acl/available-action.js

@@ -56,7 +56,7 @@ const availableActions = {
   update: {
     displayName: '{{t("Edit")}}',
     type: "old-data",
-    aliases: ["update", "move", "add", "set", "remove", "toggle"],
+    aliases: ["update", "move"],
     allowConfigureFields: true
   },
   destroy: {

package/lib/aes-encryptor.js

@@ -109,6 +109,10 @@ const _AesEncryptor = class _AesEncryptor {
     return appKeyPath;
   }
   static async create(app) {
+    if (process.env.APP_AES_SECRET_KEY) {
+      const key2 = Buffer.from(process.env.APP_AES_SECRET_KEY, "hex");
+      return new _AesEncryptor(key2);
+    }
     const KEY_PATH = process.env.APP_AES_SECRET_KEY_PATH;
     const keyPath = KEY_PATH ? (0, import_path.resolve)(process.cwd(), KEY_PATH) : await this.getKeyPath(app.name);
     const key = await _AesEncryptor.getOrGenerateKey(keyPath);

package/lib/app-command.d.ts

@@ -14,6 +14,7 @@ export declare class AppCommand extends Command {
     auth(): this;
     preload(): this;
     hasCommand(name: string): boolean;
+    findCommand(name: string): any;
     isHandleByIPCServer(): boolean;
     createCommand(name?: string): AppCommand;
     parseHandleByIPCServer(argv: any, parseOptions?: any): Boolean;

package/lib/app-command.js

@@ -51,6 +51,9 @@ const _AppCommand = class _AppCommand extends import_commander.Command {
     const names = this.commands.map((c) => c.name());
     return names.includes(name);
   }
+  findCommand(name) {
+    return this._findCommand(name);
+  }
   isHandleByIPCServer() {
     return this._handleByIPCServer;
   }

package/lib/app-supervisor.d.ts

@@ -8,6 +8,7 @@
  */
 /// <reference types="node" />
 import { AsyncEmitter } from '@nocobase/utils';
+import { Mutex } from 'async-mutex';
 import { EventEmitter } from 'events';
 import Application, { ApplicationOptions } from './application';
 type BootOptions = {
@@ -16,9 +17,10 @@ type BootOptions = {
     appSupervisor: AppSupervisor;
 };
 type AppBootstrapper = (bootOptions: BootOptions) => Promise<void>;
-type AppStatus = 'initializing' | 'initialized' | 'running' | 'commanding' | 'stopped' | 'error' | 'not_found';
+export type AppStatus = 'preparing' | 'initializing' | 'initialized' | 'running' | 'commanding' | 'stopped' | 'error' | 'not_found';
 export declare class AppSupervisor extends EventEmitter implements AsyncEmitter {
     private static instance;
+    private bootstrapQueue;
     runningMode: 'single' | 'multiple';
     singleAppName: string | null;
     emitAsync: (event: string | symbol, ...args: any[]) => Promise<boolean>;
@@ -48,7 +50,8 @@ export declare class AppSupervisor extends EventEmitter implements AsyncEmitter
     reset(): Promise<void>;
     destroy(): Promise<void>;
     setAppStatus(appName: string, status: AppStatus, options?: {}): void;
-    getMutexOfApp(appName: string): any;
+    getMutexOfApp(appName: string): Mutex;
+    private _bootStrapApp;
     bootStrapApp(appName: string, options?: {}): Promise<void>;
     getApp(appName: string, options?: {
         withOutBootStrap?: boolean;
@@ -61,6 +64,8 @@ export declare class AppSupervisor extends EventEmitter implements AsyncEmitter
     touchApp(appName: string): void;
     addApp(app: Application): Application<import("./application").DefaultState, import("./application").DefaultContext>;
     getAppsNames(): Promise<string[]>;
+    startApp(appName: string): Promise<void>;
+    stopApp(appName: string): Promise<void>;
     removeApp(appName: string): Promise<void>;
     subApps(): Application<import("./application").DefaultState, import("./application").DefaultContext>[];
     on(eventName: string | symbol, listener: (...args: any[]) => void): this;

package/lib/app-supervisor.js

@@ -47,7 +47,9 @@ var import_async_mutex = require("async-mutex");
 var import_events = require("events");
 var import_application = __toESM(require("./application"));
 var import_handler = require("./errors/handler");
+var import_p_queue = __toESM(require("p-queue"));
 const _AppSupervisor = class _AppSupervisor extends import_events.EventEmitter {
+  bootstrapQueue;
   runningMode = "multiple";
   singleAppName = null;
   apps = {};
@@ -64,6 +66,12 @@ const _AppSupervisor = class _AppSupervisor extends import_events.EventEmitter {
       this.runningMode = "single";
       this.singleAppName = process.env.STARTUP_SUBAPP;
     }
+    this.bootstrapQueue = new import_p_queue.default({
+      concurrency: process.env.SUBAPP_BOOTSTRAP_CONCURRENCY ? parseInt(process.env.SUBAPP_BOOTSTRAP_CONCURRENCY) : Infinity,
+      intervalCap: process.env.SUBAPP_BOOTSTRAP_INTERVAL_CAP ? parseInt(process.env.SUBAPP_BOOTSTRAP_INTERVAL_CAP) : Infinity,
+      interval: process.env.SUBAPP_BOOTSTRAP_INTERVAL ? parseInt(process.env.SUBAPP_BOOTSTRAP_INTERVAL) : 0,
+      timeout: 1 * 60 * 1e3
+    });
   }
   static getInstance() {
     if (!_AppSupervisor.instance) {
@@ -113,24 +121,42 @@ const _AppSupervisor = class _AppSupervisor extends import_events.EventEmitter {
     }
     return this.appMutexes[appName];
   }
+  async _bootStrapApp(appName, options = {}) {
+    this.setAppStatus(appName, "initializing");
+    if (this.appBootstrapper) {
+      await this.appBootstrapper({
+        appSupervisor: this,
+        appName,
+        options
+      });
+    }
+    if (!this.hasApp(appName)) {
+      this.setAppStatus(appName, "not_found");
+    } else if (!this.getAppStatus(appName) || this.getAppStatus(appName) === "initializing") {
+      this.setAppStatus(appName, "initialized");
+    }
+  }
   async bootStrapApp(appName, options = {}) {
-    await this.getMutexOfApp(appName).runExclusive(async () => {
-      if (!this.hasApp(appName)) {
-        this.setAppStatus(appName, "initializing");
-        if (this.appBootstrapper) {
-          await this.appBootstrapper({
-            appSupervisor: this,
-            appName,
-            options
-          });
+    const mutex = this.getMutexOfApp(appName);
+    try {
+      await (0, import_async_mutex.tryAcquire)(mutex).runExclusive(async () => {
+        if (this.hasApp(appName) && this.getAppStatus(appName) !== "preparing") {
+          return;
         }
-        if (!this.hasApp(appName)) {
-          this.setAppStatus(appName, "not_found");
-        } else if (!this.getAppStatus(appName) || this.getAppStatus(appName) == "initializing") {
-          this.setAppStatus(appName, "initialized");
+        if (appName === "main") {
+          return this._bootStrapApp(appName, options);
         }
+        this.setAppStatus(appName, "preparing");
+        await this.bootstrapQueue.add(async () => {
+          await this._bootStrapApp(appName, options);
+        });
+      });
+    } catch (e) {
+      console.log(e);
+      if (e === import_async_mutex.E_ALREADY_LOCKED) {
+        return;
       }
-    });
+    }
   }
   async getApp(appName, options = {}) {
     if (!options.withOutBootStrap) {
@@ -170,7 +196,7 @@ const _AppSupervisor = class _AppSupervisor extends import_events.EventEmitter {
     this.apps[app.name] = app;
     this.emit("afterAppAdded", app);
     if (!this.getAppStatus(app.name) || this.getAppStatus(app.name) == "not_found") {
-      this.setAppStatus(app.name, "initialized");
+      this.setAppStatus(app.name, "preparing");
     }
     return app;
   }
@@ -179,12 +205,25 @@ const _AppSupervisor = class _AppSupervisor extends import_events.EventEmitter {
     const apps = Object.values(this.apps);
     return apps.map((app) => app.name);
   }
+  async startApp(appName) {
+    const appInstance = await _AppSupervisor.getInstance().getApp(appName);
+    await appInstance.runCommand("start", "--quickstart");
+  }
+  async stopApp(appName) {
+    if (!this.apps[appName]) {
+      console.log(`app ${appName} not exists`);
+      return;
+    }
+    await this.apps[appName].runCommand("stop");
+    this.apps[appName] = null;
+  }
   async removeApp(appName) {
     if (!this.apps[appName]) {
       console.log(`app ${appName} not exists`);
       return;
     }
     await this.apps[appName].runCommand("destroy");
+    this.apps[appName] = null;
   }
   subApps() {
     return Object.values(this.apps).filter((app) => app.name !== "main");

package/lib/application.d.ts

@@ -34,10 +34,9 @@ import { SyncMessageManager } from './sync-message-manager';
 import AesEncryptor from './aes-encryptor';
 import { AuditManager } from './audit-manager';
 import { Environment } from './environment';
-import { ServiceContainer } from './service-container';
 import { EventQueue, EventQueueOptions } from './event-queue';
-import { BackgroundJobManager, BackgroundJobManagerOptions } from './background-job-manager';
 import { RedisConfig, RedisConnectionManager } from './redis-connection-manager';
+import { ServiceContainer } from './service-container';
 import { WorkerIdAllocator } from './worker-id-allocator';
 export type PluginType = string | typeof Plugin;
 export type PluginConfiguration = PluginType | [PluginType, any];
@@ -89,7 +88,6 @@ export interface ApplicationOptions {
     auditManager?: AuditManager;
     lockManager?: LockManagerOptions;
     eventQueue?: EventQueueOptions;
-    backgroundJobManager?: BackgroundJobManagerOptions;
     /**
      * @internal
      */
@@ -190,9 +188,9 @@ export declare class Application<StateT = DefaultState, ContextT = DefaultContex
     container: ServiceContainer;
     lockManager: LockManager;
     eventQueue: EventQueue;
-    backgroundJobManager: BackgroundJobManager;
     constructor(options: ApplicationOptions);
     private static staticCommands;
+    static registerStaticCommand(callback: (app: Application) => void): void;
     static addCommand(callback: (app: Application) => void): void;
     private _sqlLogger;
     get instanceId(): number;
@@ -219,7 +217,7 @@ export declare class Application<StateT = DefaultState, ContextT = DefaultContex
     get environment(): Environment;
     protected _cronJobManager: CronJobManager;
     get cronJobManager(): CronJobManager;
-    get mainDataSource(): SequelizeDataSource;
+    get mainDataSource(): SequelizeDataSource<import("@nocobase/data-source-manager").DatabaseIntrospector>;
     get db(): Database;
     get resourceManager(): import("@nocobase/resourcer").ResourceManager;
     /**
@@ -283,7 +281,7 @@ export declare class Application<StateT = DefaultState, ContextT = DefaultContex
     setMaintainingMessage(message: string): void;
     /**
      * This method is deprecated and should not be used.
-     * Use {@link #this.version.get()} instead.
+     * Use {@link #this.getPackageVersion} instead.
      * @deprecated
      */
     getVersion(): string;

package/lib/application.js

@@ -50,8 +50,8 @@ var import_database = __toESM(require("@nocobase/database"));
 var import_logger = require("@nocobase/logger");
 var import_telemetry = require("@nocobase/telemetry");
 var import_lock_manager = require("@nocobase/lock-manager");
-var import_utils = require("@nocobase/utils");
 var import_snowflake_id = require("@nocobase/snowflake-id");
+var import_utils = require("@nocobase/utils");
 var import_crypto = require("crypto");
 var import_glob = __toESM(require("glob"));
 var import_koa = __toESM(require("koa"));
@@ -81,12 +81,11 @@ var import_available_action = require("./acl/available-action");
 var import_aes_encryptor = __toESM(require("./aes-encryptor"));
 var import_audit_manager = require("./audit-manager");
 var import_environment = require("./environment");
-var import_service_container = require("./service-container");
 var import_event_queue = require("./event-queue");
-var import_background_job_manager = require("./background-job-manager");
 var import_redis_connection_manager = require("./redis-connection-manager");
-var import_worker_id_allocator = require("./worker-id-allocator");
+var import_service_container = require("./service-container");
 var import_snowflake_id_field = require("./snowflake-id-field");
+var import_worker_id_allocator = require("./worker-id-allocator");
 const _Application = class _Application extends import_koa.default {
   constructor(options) {
     super();
@@ -142,7 +141,9 @@ const _Application = class _Application extends import_koa.default {
   container = new import_service_container.ServiceContainer();
   lockManager;
   eventQueue;
-  backgroundJobManager;
+  static registerStaticCommand(callback) {
+    this.staticCommands.push(callback);
+  }
   static addCommand(callback) {
     this.staticCommands.push(callback);
   }
@@ -336,7 +337,7 @@ const _Application = class _Application extends import_koa.default {
   }
   /**
    * This method is deprecated and should not be used.
-   * Use {@link #this.version.get()} instead.
+   * Use {@link #this.getPackageVersion} instead.
    * @deprecated
    */
   getVersion() {
@@ -777,6 +778,12 @@ const _Application = class _Application extends import_koa.default {
   }
   async upgrade(options = {}) {
     this.log.info("upgrading...");
+    const pkgVersion = this.getPackageVersion();
+    const appVersion = await this.version.get();
+    if (process.env.SKIP_SAME_VERSION_UPGRADE === "true" && pkgVersion === appVersion) {
+      this.log.info(`app is already the latest version (${appVersion})`);
+      return;
+    }
     await this.reInit();
     const migrator1 = await this.loadCoreMigrations();
     await migrator1.beforeLoad.up();
@@ -800,7 +807,9 @@ const _Application = class _Application extends import_koa.default {
     await migrator3.afterLoad.up();
     await this.pm.repository.updateVersions();
     await this.version.update();
-    await this.emitAsync("afterUpgrade", this, options);
+    if (!options.quickstart) {
+      await this.emitAsync("afterUpgrade", this, options);
+    }
     await this.restart();
   }
   toJSON() {
@@ -911,7 +920,6 @@ const _Application = class _Application extends import_koa.default {
     this.pubSubManager = (0, import_pub_sub_manager.createPubSubManager)(this, options.pubSubManager);
     this.syncMessageManager = new import_sync_message_manager.SyncMessageManager(this, options.syncMessageManager);
     this.eventQueue = new import_event_queue.EventQueue(this, options.eventQueue);
-    this.backgroundJobManager = new import_background_job_manager.BackgroundJobManager(this, options.backgroundJobManager);
     this.lockManager = new import_lock_manager.LockManager({
       defaultAdapter: process.env.LOCK_ADAPTER_DEFAULT,
       ...options.lockManager
@@ -927,8 +935,8 @@ const _Application = class _Application extends import_koa.default {
       plugins: plugins || []
     });
     this._telemetry = new import_telemetry.Telemetry({
-      serviceName: `nocobase-${this.name}`,
-      version: this.getVersion(),
+      appName: this.name,
+      version: this.getPackageVersion(),
       ...options.telemetry
     });
     this._authManager = new import_auth.AuthManager({
@@ -948,7 +956,7 @@ const _Application = class _Application extends import_koa.default {
         }
       }
     });
-    this._dataSourceManager.use(this._authManager.middleware(), { tag: "auth" });
+    this._dataSourceManager.use(this._authManager.middleware(), { tag: "auth", before: "default" });
     this._dataSourceManager.use(import_validate_filter_params.default, { tag: "validate-filter-params", before: ["auth"] });
     this._dataSourceManager.use(import_middlewares.parseVariables, {
       group: "parseVariables",

package/lib/commands/index.js

@@ -53,6 +53,7 @@ var import_start = __toESM(require("./start"));
 var import_stop = __toESM(require("./stop"));
 var import_upgrade = __toESM(require("./upgrade"));
 var import_console = __toESM(require("./console"));
+var import_repair = __toESM(require("./repair"));
 /* istanbul ignore file -- @preserve */
 function registerCli(app) {
   (0, import_console.default)(app);
@@ -68,6 +69,7 @@ function registerCli(app) {
   (0, import_destroy.default)(app);
   (0, import_start.default)(app);
   (0, import_refresh.default)(app);
+  (0, import_repair.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/pm.js

@@ -38,6 +38,17 @@ var pm_default = /* @__PURE__ */ __name((app) => {
   pm.command("create").argument("plugin").option("--force-recreate").action(async (plugin, options) => {
     await app.pm.create(plugin, options);
   });
+  pm.command("pull").arguments("<packageNames...>").option("--registry [registry]").option("--auth-token [authToken]").option("--version [version]").action(async (packageNames, options, cli) => {
+    try {
+      let name = packageNames;
+      if (Array.isArray(packageNames) && packageNames.length === 1) {
+        name = packageNames[0];
+      }
+      await app.pm.pull(name, { ...options });
+    } catch (error) {
+      throw new import_plugin_command_error.PluginCommandError(`Failed to pull plugin`, { cause: error });
+    }
+  });
   pm.command("add").ipc().preload().arguments("<packageNames...>").option("--registry [registry]").option("--auth-token [authToken]").option("--version [version]").action(async (packageNames, options, cli) => {
     try {
       let name = packageNames;

package/lib/commands/repair.d.ts

@@ -0,0 +1,11 @@
+/**
+ * This file is part of the NocoBase (R) project.
+ * Copyright (c) 2020-2024 NocoBase Co., Ltd.
+ * Authors: NocoBase Team.
+ *
+ * This project is dual-licensed under AGPL-3.0 and NocoBase Commercial License.
+ * For more information, please refer to: https://www.nocobase.com/agreement.
+ */
+import Application from '../application';
+declare const _default: (app: Application) => void;
+export default _default;

package/lib/commands/repair.js

@@ -0,0 +1,43 @@
+/**
+ * This file is part of the NocoBase (R) project.
+ * Copyright (c) 2020-2024 NocoBase Co., Ltd.
+ * Authors: NocoBase Team.
+ *
+ * This project is dual-licensed under AGPL-3.0 and NocoBase Commercial License.
+ * For more information, please refer to: https://www.nocobase.com/agreement.
+ */
+
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+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 __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var repair_exports = {};
+__export(repair_exports, {
+  default: () => repair_default
+});
+module.exports = __toCommonJS(repair_exports);
+var repair_default = /* @__PURE__ */ __name((app) => {
+  app.command("repair").auth().preload().action(async (options) => {
+    app.log.info("start repair data...");
+    const Collection = app.db.getCollection("collections");
+    if (Collection) {
+      await Collection.repository.setApp(app);
+      await Collection.repository.load();
+    }
+    await app.emitAsync("repair", options);
+  });
+}, "default");

package/lib/commands/start.js

@@ -61,7 +61,7 @@ var start_default = /* @__PURE__ */ __name((app) => {
       }
     } else if (options.quickstart) {
       if (await app.isInstalled()) {
-        await app.upgrade();
+        await app.upgrade({ quickstart: true });
       } else {
         await app.install();
       }

package/lib/event-queue.js

@@ -300,13 +300,13 @@ const _EventQueue = class _EventQueue {
     return this.adapter.isConnected();
   }
   async connect() {
-    if (!this.adapter) {
-      throw new Error("no adapter set, cannot connect");
-    }
     if (!this.app.serving()) {
       this.app.logger.warn("app is not serving, will not connect to event queue");
       return;
     }
+    if (!this.adapter) {
+      throw new Error("no adapter set, cannot connect");
+    }
     await this.adapter.connect();
     this.app.logger.debug(`connected to adapter, using memory? ${this.adapter instanceof MemoryEventQueueAdapter}`);
     for (const [channel, event] of this.events.entries()) {
@@ -342,6 +342,10 @@ const _EventQueue = class _EventQueue {
     }
   }
   async publish(channel, message, options = {}) {
+    if (!this.app.serving()) {
+      this.app.logger.warn("app is not serving, will not publish message to event queue");
+      return;
+    }
     if (!this.adapter) {
       throw new Error("no adapter set, cannot publish");
     }

package/lib/gateway/errors.js

@@ -53,7 +53,7 @@ const errors = {
   APP_ERROR: {
     status: 503,
     message: /* @__PURE__ */ __name(({ app }) => {
-      const error = import_app_supervisor.AppSupervisor.getInstance().appErrors[app.name];
+      const error = import_app_supervisor.AppSupervisor.getInstance().appErrors[app == null ? void 0 : app.name];
       if (!error) {
         return "";
       }
@@ -64,12 +64,17 @@ const errors = {
       return message;
     }, "message"),
     code: /* @__PURE__ */ __name(({ app }) => {
-      const error = import_app_supervisor.AppSupervisor.getInstance().appErrors[app.name];
+      const error = import_app_supervisor.AppSupervisor.getInstance().appErrors[app == null ? void 0 : app.name];
       return error["code"] || "APP_ERROR";
     }, "code"),
     command: /* @__PURE__ */ __name(({ app }) => app.getMaintaining().command, "command"),
     maintaining: true
   },
+  APP_PREPARING: {
+    status: 503,
+    message: /* @__PURE__ */ __name(({ appName }) => `application ${appName} is preparing, please wait patiently`, "message"),
+    maintaining: true
+  },
   APP_STARTING: {
     status: 503,
     message: /* @__PURE__ */ __name(({ app }) => app.maintainingMessage, "message"),
@@ -77,12 +82,12 @@ const errors = {
   },
   APP_STOPPED: {
     status: 503,
-    message: /* @__PURE__ */ __name(({ app }) => `application ${app.name} is stopped`, "message"),
+    message: /* @__PURE__ */ __name(({ app }) => `application ${app == null ? void 0 : app.name} is stopped`, "message"),
     maintaining: true
   },
   APP_INITIALIZED: {
     status: 503,
-    message: /* @__PURE__ */ __name(({ app }) => `application ${app.name} is initialized, waiting for command`, "message"),
+    message: /* @__PURE__ */ __name(({ app }) => `application ${app == null ? void 0 : app.name} is initialized, please refresh the page`, "message"),
     maintaining: true
   },
   APP_INITIALIZING: {
@@ -111,7 +116,7 @@ const errors = {
   APP_RUNNING: {
     status: 200,
     maintaining: false,
-    message: /* @__PURE__ */ __name(({ message, app }) => message || `application ${app.name} is running`, "message")
+    message: /* @__PURE__ */ __name(({ message, app }) => message || `application ${app == null ? void 0 : app.name} is running`, "message")
   },
   UNKNOWN_ERROR: {
     status: 500,

package/lib/gateway/index.d.ts

@@ -23,6 +23,12 @@ export interface IncomingRequest {
     url: string;
     headers: any;
 }
+export interface GatewayRequestContext {
+    req: IncomingMessage;
+    res: ServerResponse;
+    appName: string;
+}
+type GatewayMiddleware = (ctx: GatewayRequestContext, next: () => Promise<void>) => Promise<void> | void;
 export type AppSelector = (req: IncomingRequest) => string | Promise<string>;
 export type AppSelectorMiddleware = (ctx: AppSelectorMiddlewareContext, next: () => Promise<void>) => void;
 interface StartHttpServerOptions {
@@ -39,6 +45,7 @@ export interface AppSelectorMiddlewareContext {
 }
 export declare class Gateway extends EventEmitter {
     private static instance;
+    middlewares: Toposort<GatewayMiddleware>;
     /**
      * use main app as default app to handle request
      */
@@ -54,6 +61,7 @@ export declare class Gateway extends EventEmitter {
     private onTerminate;
     private constructor();
     static getInstance(options?: any): Gateway;
+    use(middleware: GatewayMiddleware, options?: ToposortOptions): void;
     static getIPCSocketClient(): Promise<false | IPCSocketClient>;
     destroy(): void;
     reset(): void;

package/lib/gateway/index.js

@@ -75,6 +75,7 @@ function getSocketPath() {
 }
 __name(getSocketPath, "getSocketPath");
 const _Gateway = class _Gateway extends import_events.EventEmitter {
+  middlewares;
   /**
    * use main app as default app to handle request
    */
@@ -124,6 +125,9 @@ const _Gateway = class _Gateway extends import_events.EventEmitter {
     }
     return _Gateway.instance;
   }
+  use(middleware, options) {
+    this.middlewares.add(middleware, options);
+  }
   static async getIPCSocketClient() {
     const socketPath = getSocketPath();
     try {
@@ -139,6 +143,7 @@ const _Gateway = class _Gateway extends import_events.EventEmitter {
     _Gateway.instance = null;
   }
   reset() {
+    this.middlewares = new import_utils.Toposort();
     this.selectorMiddlewares = new import_utils.Toposort();
     this.addAppSelectorMiddleware(
       async (ctx, next) => {
@@ -202,7 +207,15 @@ const _Gateway = class _Gateway extends import_events.EventEmitter {
     res.end(JSON.stringify({ error }));
   }
   responseErrorWithCode(code, res, options) {
+    const log = this.getLogger(options.appName, res);
     const error = (0, import_errors.applyErrorWithArgs)((0, import_errors.getErrorWithCode)(code), options);
+    log.error(error.message, {
+      method: "responseErrorWithCode",
+      code,
+      error,
+      statusCode: res.statusCode,
+      appName: options.appName
+    });
     this.responseError(res, error);
   }
   async requestHandler(req, res) {
@@ -256,11 +269,15 @@ const _Gateway = class _Gateway extends import_events.EventEmitter {
     if (!hasApp) {
       void import_app_supervisor.AppSupervisor.getInstance().bootStrapApp(handleApp);
     }
-    let appStatus = import_app_supervisor.AppSupervisor.getInstance().getAppStatus(handleApp, "initializing");
+    let appStatus = import_app_supervisor.AppSupervisor.getInstance().getAppStatus(handleApp, "preparing");
     if (appStatus === "not_found") {
       this.responseErrorWithCode("APP_NOT_FOUND", res, { appName: handleApp });
       return;
     }
+    if (appStatus === "preparing") {
+      this.responseErrorWithCode("APP_PREPARING", res, { appName: handleApp });
+      return;
+    }
     if (appStatus === "initializing") {
       this.responseErrorWithCode("APP_INITIALIZING", res, { appName: handleApp });
       return;
@@ -283,7 +300,14 @@ const _Gateway = class _Gateway extends import_events.EventEmitter {
     if (handleApp !== "main") {
       import_app_supervisor.AppSupervisor.getInstance().touchApp(handleApp);
     }
-    app.callback()(req, res);
+    const ctx = { req, res, appName: handleApp };
+    const fn = (0, import_koa_compose.default)([
+      ...this.middlewares.nodes,
+      async (_ctx) => {
+        await app.callback()(req, res);
+      }
+    ]);
+    await fn(ctx);
   }
   getAppSelectorMiddlewares() {
     return this.selectorMiddlewares;