@nocobase/server 2.0.0-alpha.7 → 2.0.0-alpha.71

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.d.ts

@@ -15,6 +15,7 @@ export type QueueCallbackOptions = {
     id?: string;
     retried?: number;
     signal?: AbortSignal;
+    queueOptions?: QueueMessageOptions;
 };
 export type QueueCallback = (message: any, options: QueueCallbackOptions) => Promise<void>;
 export type QueueEventOptions = {
@@ -23,6 +24,12 @@ export type QueueEventOptions = {
      */
     interval?: number;
     concurrency?: number;
+    /**
+     * Shared across multiple applications.
+     * Will not use app prefix for channel name.
+     * @experimental
+     */
+    shared?: boolean;
     idle(): boolean;
     process: QueueCallback;
 };
@@ -84,7 +91,7 @@ export declare class EventQueue {
     protected events: Map<string, QueueEventOptions>;
     get channelPrefix(): string;
     constructor(app: Application, options?: EventQueueOptions);
-    getFullChannel(channel: string): string;
+    getFullChannel(channel: string, shared?: boolean): string;
     setAdapter<A extends IEventQueueAdapter>(adapter: A): void;
     isConnected(): boolean;
     connect(): Promise<void>;

package/lib/event-queue.js

@@ -245,7 +245,8 @@ const _MemoryEventQueueAdapter = class _MemoryEventQueueAdapter {
     return (async () => event.process(content, {
       id,
       retried,
-      signal: AbortSignal.timeout(timeout)
+      signal: AbortSignal.timeout(timeout),
+      queueOptions: message.options
     }))().then(() => {
       logger.debug(`memory queue (${channel}) consumed message (${id})`);
     }).catch((ex) => {
@@ -270,16 +271,14 @@ const _EventQueue = class _EventQueue {
   constructor(app, options = {}) {
     this.app = app;
     this.options = options;
-    if (app.serving()) {
-      this.setAdapter(new MemoryEventQueueAdapter({ appName: this.app.name, logger: this.app.logger }));
-      app.on("afterStart", async () => {
-        await this.connect();
-      });
-      app.on("beforeStop", async () => {
-        app.logger.info("[queue] gracefully shutting down...");
-        await this.close();
-      });
-    }
+    this.setAdapter(new MemoryEventQueueAdapter({ appName: this.app.name, logger: this.app.logger }));
+    app.on("afterStart", async () => {
+      await this.connect();
+    });
+    app.on("afterStop", async () => {
+      app.logger.info("[queue] gracefully shutting down...");
+      await this.close();
+    });
   }
   adapter;
   events = /* @__PURE__ */ new Map();
@@ -287,7 +286,10 @@ const _EventQueue = class _EventQueue {
     var _a;
     return (_a = this.options) == null ? void 0 : _a.channelPrefix;
   }
-  getFullChannel(channel) {
+  getFullChannel(channel, shared = false) {
+    if (shared) {
+      return [this.channelPrefix, channel].filter(Boolean).join(".");
+    }
     return [this.app.name, this.channelPrefix, channel].filter(Boolean).join(".");
   }
   setAdapter(adapter) {
@@ -303,14 +305,10 @@ const _EventQueue = class _EventQueue {
     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;
-    }
     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()) {
-      this.adapter.subscribe(this.getFullChannel(channel), event);
+      this.adapter.subscribe(this.getFullChannel(channel, event.shared), event);
     }
   }
   async close() {
@@ -318,8 +316,8 @@ const _EventQueue = class _EventQueue {
       return;
     }
     await this.adapter.close();
-    for (const channel of this.events.keys()) {
-      this.adapter.unsubscribe(this.getFullChannel(channel));
+    for (const [channel, event] of this.events.entries()) {
+      this.adapter.unsubscribe(this.getFullChannel(channel, event.shared));
     }
   }
   subscribe(channel, options) {
@@ -329,16 +327,17 @@ const _EventQueue = class _EventQueue {
     }
     this.events.set(channel, options);
     if (this.isConnected()) {
-      this.adapter.subscribe(this.getFullChannel(channel), options);
+      this.adapter.subscribe(this.getFullChannel(channel, options.shared), this.events.get(channel));
     }
   }
   unsubscribe(channel) {
+    var _a;
     if (!this.events.has(channel)) {
       return;
     }
     this.events.delete(channel);
     if (this.isConnected()) {
-      this.adapter.unsubscribe(this.getFullChannel(channel));
+      this.adapter.unsubscribe(this.getFullChannel(channel, (_a = this.events.get(channel)) == null ? void 0 : _a.shared));
     }
   }
   async publish(channel, message, options = {}) {
@@ -348,7 +347,11 @@ const _EventQueue = class _EventQueue {
     if (!this.isConnected()) {
       throw new Error("event queue not connected, cannot publish");
     }
-    const c = this.getFullChannel(channel);
+    const event = this.events.get(channel);
+    if (!event) {
+      throw new Error(`event queue not subscribed on channel "${channel}", cannot publish`);
+    }
+    const c = this.getFullChannel(channel, event.shared);
     this.app.logger.debug(`event queue publishing to channel(${c})`, { message });
     await this.adapter.publish(c, message, {
       timeout: QUEUE_DEFAULT_ACK_TIMEOUT,

package/lib/gateway/errors.js

@@ -44,6 +44,15 @@ __export(errors_exports, {
 module.exports = __toCommonJS(errors_exports);
 var import_app_supervisor = require("../app-supervisor");
 var import_lodash = __toESM(require("lodash"));
+function getMaintaining(app) {
+  var _a;
+  return (_a = app == null ? void 0 : app.getMaintaining) == null ? void 0 : _a.call(app);
+}
+__name(getMaintaining, "getMaintaining");
+function getAppName(app) {
+  return (app == null ? void 0 : app.name) || "unknown";
+}
+__name(getAppName, "getAppName");
 const errors = {
   APP_NOT_FOUND: {
     status: 404,
@@ -53,6 +62,9 @@ const errors = {
   APP_ERROR: {
     status: 503,
     message: /* @__PURE__ */ __name(({ app }) => {
+      if (!(app == null ? void 0 : app.name)) {
+        return "";
+      }
       const error = import_app_supervisor.AppSupervisor.getInstance().appErrors[app.name];
       if (!error) {
         return "";
@@ -64,25 +76,36 @@ const errors = {
       return message;
     }, "message"),
     code: /* @__PURE__ */ __name(({ app }) => {
+      if (!(app == null ? void 0 : app.name)) {
+        return "APP_ERROR";
+      }
       const error = import_app_supervisor.AppSupervisor.getInstance().appErrors[app.name];
-      return error["code"] || "APP_ERROR";
+      return (error == null ? void 0 : error["code"]) || "APP_ERROR";
     }, "code"),
-    command: /* @__PURE__ */ __name(({ app }) => app.getMaintaining().command, "command"),
+    command: /* @__PURE__ */ __name(({ app }) => {
+      var _a;
+      return (_a = getMaintaining(app)) == null ? void 0 : _a.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"),
+    message: /* @__PURE__ */ __name(({ app }) => (app == null ? void 0 : app.maintainingMessage) || "", "message"),
     maintaining: true
   },
   APP_STOPPED: {
     status: 503,
-    message: /* @__PURE__ */ __name(({ app }) => `application ${app.name} is stopped`, "message"),
+    message: /* @__PURE__ */ __name(({ app, appName }) => `application ${appName || getAppName(app)} 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 ${getAppName(app)} is initialized, waiting for command`, "message"),
     maintaining: true
   },
   APP_INITIALIZING: {
@@ -93,25 +116,40 @@ const errors = {
   COMMAND_ERROR: {
     status: 503,
     maintaining: true,
-    message: /* @__PURE__ */ __name(({ app }) => app.getMaintaining().error.message, "message"),
-    command: /* @__PURE__ */ __name(({ app }) => app.getMaintaining().command, "command")
+    message: /* @__PURE__ */ __name(({ app }) => {
+      var _a, _b;
+      return ((_b = (_a = getMaintaining(app)) == null ? void 0 : _a.error) == null ? void 0 : _b.message) || "";
+    }, "message"),
+    command: /* @__PURE__ */ __name(({ app }) => {
+      var _a;
+      return (_a = getMaintaining(app)) == null ? void 0 : _a.command;
+    }, "command")
   },
   COMMAND_END: {
     status: 503,
     maintaining: true,
-    message: /* @__PURE__ */ __name(({ app }) => `${app.getMaintaining().command.name} running end`, "message"),
-    command: /* @__PURE__ */ __name(({ app }) => app.getMaintaining().command, "command")
+    message: /* @__PURE__ */ __name(({ app }) => {
+      var _a, _b;
+      return `${((_b = (_a = getMaintaining(app)) == null ? void 0 : _a.command) == null ? void 0 : _b.name) || "command"} running end`;
+    }, "message"),
+    command: /* @__PURE__ */ __name(({ app }) => {
+      var _a;
+      return (_a = getMaintaining(app)) == null ? void 0 : _a.command;
+    }, "command")
   },
   APP_COMMANDING: {
     status: 503,
     maintaining: true,
-    message: /* @__PURE__ */ __name(({ app, message }) => message || app.maintainingMessage, "message"),
-    command: /* @__PURE__ */ __name(({ app, command }) => command || app.getMaintaining().command, "command")
+    message: /* @__PURE__ */ __name(({ app, message }) => message || (app == null ? void 0 : app.maintainingMessage) || "", "message"),
+    command: /* @__PURE__ */ __name(({ app, command }) => {
+      var _a;
+      return command || ((_a = getMaintaining(app)) == null ? void 0 : _a.command);
+    }, "command")
   },
   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 ${getAppName(app)} 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
    */
@@ -98,6 +99,9 @@ const _Gateway = class _Gateway extends import_events.EventEmitter {
     try {
       for (const app of apps) {
         try {
+          if (!app) {
+            continue;
+          }
           await app.destroy({ signal });
         } catch (error) {
           const logger = (app == null ? void 0 : app.log) ?? console;
@@ -124,6 +128,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 +146,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 +210,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) {
@@ -213,7 +229,22 @@ const _Gateway = class _Gateway extends import_events.EventEmitter {
       res.end("ok");
       return;
     }
+    const supervisor = import_app_supervisor.AppSupervisor.getInstance();
+    let handleApp = "main";
+    try {
+      handleApp = await this.getRequestHandleAppName(req);
+    } catch (error) {
+      this.getLogger("main", res).error("Failed to get handle app name", { error });
+      this.responseErrorWithCode("APP_INITIALIZING", res, { appName: handleApp });
+      return;
+    }
     if (pathname.startsWith(APP_PUBLIC_PATH + "storage/uploads/")) {
+      if (handleApp !== "main") {
+        const isProxy = await supervisor.proxyWeb(handleApp, req, res);
+        if (isProxy) {
+          return;
+        }
+      }
       req.url = req.url.substring(APP_PUBLIC_PATH.length - 1);
       await compress(req, res);
       return (0, import_serve_handler.default)(req, res, {
@@ -222,6 +253,12 @@ const _Gateway = class _Gateway extends import_events.EventEmitter {
       });
     }
     if (pathname.startsWith(PLUGIN_STATICS_PATH) && !pathname.includes("/server/")) {
+      if (handleApp !== "main") {
+        const isProxy = await supervisor.proxyWeb(handleApp, req, res);
+        if (isProxy) {
+          return;
+        }
+      }
       await compress(req, res);
       const packageName = (0, import_plugin_manager.getPackageNameByExposeUrl)(pathname);
       const publicDir = (0, import_plugin_manager.getPackageDirByExposeUrl)(pathname);
@@ -237,6 +274,12 @@ const _Gateway = class _Gateway extends import_events.EventEmitter {
       });
     }
     if (!pathname.startsWith(import_node_process.default.env.API_BASE_PATH)) {
+      if (handleApp !== "main") {
+        const isProxy = await supervisor.proxyWeb(handleApp, req, res);
+        if (isProxy) {
+          return;
+        }
+      }
       req.url = req.url.substring(APP_PUBLIC_PATH.length - 1);
       await compress(req, res);
       return (0, import_serve_handler.default)(req, res, {
@@ -244,33 +287,43 @@ const _Gateway = class _Gateway extends import_events.EventEmitter {
         rewrites: [{ source: "/**", destination: "/index.html" }]
       });
     }
-    let handleApp = "main";
-    try {
-      handleApp = await this.getRequestHandleAppName(req);
-    } catch (error) {
-      console.log(error);
-      this.responseErrorWithCode("APP_INITIALIZING", res, { appName: handleApp });
-      return;
+    if (handleApp !== "main") {
+      const isProxy = await supervisor.proxyWeb(handleApp, req, res);
+      if (isProxy) {
+        return;
+      }
     }
-    const hasApp = import_app_supervisor.AppSupervisor.getInstance().hasApp(handleApp);
+    const hasApp = supervisor.hasApp(handleApp);
     if (!hasApp) {
-      void import_app_supervisor.AppSupervisor.getInstance().bootStrapApp(handleApp);
+      void supervisor.bootstrapApp(handleApp);
     }
-    let appStatus = import_app_supervisor.AppSupervisor.getInstance().getAppStatus(handleApp, "initializing");
+    let appStatus = await supervisor.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;
     }
     if (appStatus === "initialized") {
-      const appInstance = await import_app_supervisor.AppSupervisor.getInstance().getApp(handleApp);
-      appInstance.runCommand("start", "--quickstart");
-      appStatus = import_app_supervisor.AppSupervisor.getInstance().getAppStatus(handleApp);
+      const appInstance = await supervisor.getApp(handleApp);
+      if (!appInstance) {
+        this.responseErrorWithCode("APP_NOT_FOUND", res, { appName: handleApp });
+        return;
+      }
+      supervisor.startApp(handleApp);
+      appStatus = await supervisor.getAppStatus(handleApp);
+    }
+    const app = await supervisor.getApp(handleApp);
+    if (!app) {
+      this.responseErrorWithCode("APP_NOT_FOUND", res, { appName: handleApp });
+      return;
     }
-    const app = await import_app_supervisor.AppSupervisor.getInstance().getApp(handleApp);
     if (appStatus !== "running") {
       this.responseErrorWithCode(`${appStatus}`, res, { app, appName: handleApp });
       return;
@@ -281,9 +334,16 @@ const _Gateway = class _Gateway extends import_events.EventEmitter {
       return;
     }
     if (handleApp !== "main") {
-      import_app_supervisor.AppSupervisor.getInstance().touchApp(handleApp);
+      await supervisor.setAppLastSeenAt(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;
@@ -409,6 +469,10 @@ const _Gateway = class _Gateway extends import_events.EventEmitter {
     });
     this.wsServer = new import_ws_server.WSServer();
     this.server.on("upgrade", async (request, socket, head) => {
+      const isProxy = await import_app_supervisor.AppSupervisor.getInstance().proxyWs(request, socket, head);
+      if (isProxy) {
+        return;
+      }
       const appInstance = await import_app_supervisor.AppSupervisor.getInstance().getApp("main");
       for (const handle of _Gateway.wsServers) {
         const result = await handle(request, socket, head, appInstance);

package/lib/gateway/ipc-socket-server.js

@@ -104,7 +104,7 @@ const _IPCSocketServer = class _IPCSocketServer {
         const max = 300;
         let count = 0;
         const timer = setInterval(async () => {
-          status2 = import_app_supervisor.AppSupervisor.getInstance().getAppStatus("main");
+          status2 = await import_app_supervisor.AppSupervisor.getInstance().getAppStatus("main");
           if (status2 === "running") {
             clearInterval(timer);
             resolve(status2);

package/lib/gateway/ws-server.js

@@ -90,7 +90,7 @@ const _WSServer = class _WSServer extends import_events.default {
           }
         }
         client.tags.add(`app#${handleAppName}`);
-        import_app_supervisor.AppSupervisor.getInstance().bootStrapApp(handleAppName);
+        import_app_supervisor.AppSupervisor.getInstance().bootstrapApp(handleAppName);
       });
     });
     import_app_supervisor.AppSupervisor.getInstance().on("appError", async ({ appName, error }) => {
@@ -112,6 +112,7 @@ const _WSServer = class _WSServer extends import_events.default {
       });
       const payload = getPayloadByErrorCode(status, {
         app,
+        appName,
         message,
         command
       });
@@ -228,6 +229,9 @@ const _WSServer = class _WSServer extends import_events.default {
   }
   removeClientTag(clientId, tagKey) {
     const client = this.webSocketClients.get(clientId);
+    if (!client) {
+      return;
+    }
     client.tags.forEach((tag) => {
       if (tag.startsWith(`${tagKey}#`)) {
         client.tags.delete(tag);
@@ -245,7 +249,7 @@ const _WSServer = class _WSServer extends import_events.default {
     client.tags.add(`app#${handleAppName}`);
     const hasApp = import_app_supervisor.AppSupervisor.getInstance().hasApp(handleAppName);
     if (!hasApp) {
-      import_app_supervisor.AppSupervisor.getInstance().bootStrapApp(handleAppName);
+      import_app_supervisor.AppSupervisor.getInstance().bootstrapApp(handleAppName);
     }
   }
   removeConnection(id) {