@nocobase/server 2.0.0-beta.8 → 2.0.0

package/lib/gateway/index.js

@@ -44,6 +44,7 @@ __export(gateway_exports, {
 module.exports = __toCommonJS(gateway_exports);
 var import_logger = require("@nocobase/logger");
 var import_utils = require("@nocobase/utils");
+var import_utils2 = require("@nocobase/utils");
 var import_plugin_symlink = require("@nocobase/utils/plugin-symlink");
 var import_commander = require("commander");
 var import_compression = __toESM(require("compression"));
@@ -99,6 +100,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;
@@ -226,7 +230,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, {
@@ -235,6 +254,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);
@@ -250,6 +275,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, {
@@ -257,19 +288,17 @@ 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, "preparing");
+    let appStatus = await supervisor.getAppStatus(handleApp, "preparing");
     if (appStatus === "not_found") {
       this.responseErrorWithCode("APP_NOT_FOUND", res, { appName: handleApp });
       return;
@@ -283,11 +312,19 @@ const _Gateway = class _Gateway extends import_events.EventEmitter {
       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;
@@ -298,7 +335,7 @@ const _Gateway = class _Gateway extends import_events.EventEmitter {
       return;
     }
     if (handleApp !== "main") {
-      import_app_supervisor.AppSupervisor.getInstance().touchApp(handleApp);
+      await supervisor.setAppLastSeenAt(handleApp);
     }
     const ctx = { req, res, appName: handleApp };
     const fn = (0, import_koa_compose.default)([
@@ -366,6 +403,14 @@ const _Gateway = class _Gateway extends import_events.EventEmitter {
     }
     const mainApp = import_app_supervisor.AppSupervisor.getInstance().bootMainApp(options.mainAppOptions);
     mainApp.setMaxListeners(50);
+    mainApp.once("afterStart", () => {
+      (0, import_utils2.lockdownSes)({
+        consoleTaming: "unsafe",
+        errorTaming: "unsafe",
+        overrideTaming: "moderate",
+        stackFiltering: "verbose"
+      });
+    });
     let runArgs = [import_node_process.default.argv, { throwError: true, from: "node" }];
     if (!import_node_worker_threads.isMainThread) {
       runArgs = [import_node_worker_threads.workerData.argv, { throwError: true, from: "user" }];
@@ -433,6 +478,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
       });
@@ -248,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) {

package/lib/helper.js

@@ -76,6 +76,25 @@ function createResourcer(options) {
   return new import_resourcer.Resourcer({ ...options.resourcer });
 }
 __name(createResourcer, "createResourcer");
+function resolveCorsOrigin(ctx) {
+  const origin = ctx.get("origin");
+  const disallowNoOrigin = process.env.CORS_DISALLOW_NO_ORIGIN === "true";
+  const whitelistString = process.env.CORS_ORIGIN_WHITELIST;
+  if (!origin && disallowNoOrigin) {
+    return false;
+  }
+  if (!whitelistString) {
+    return origin;
+  }
+  const whitelist = new Set(
+    whitelistString.split(",").map((item) => item.trim()).filter(Boolean)
+  );
+  if (whitelist.has(origin)) {
+    return origin;
+  }
+  return false;
+}
+__name(resolveCorsOrigin, "resolveCorsOrigin");
 function registerMiddlewares(app, options) {
   var _a;
   app.use(
@@ -90,9 +109,7 @@ function registerMiddlewares(app, options) {
   app.use(
     (0, import_cors.default)({
       exposeHeaders: ["content-disposition"],
-      origin(ctx) {
-        return ctx.get("origin");
-      },
+      origin: resolveCorsOrigin,
       ...options.cors
     }),
     {

package/lib/plugin-manager/deps.js

@@ -41,7 +41,7 @@ const deps = {
   umzug: "3.x",
   "async-mutex": "0.5.x",
   "@formulajs/formulajs": "4.x",
-  mathjs: "10.x",
+  mathjs: "15.x",
   winston: "3.x",
   "winston-daily-rotate-file": "4.x",
   koa: "2.x",

package/lib/plugin-manager/plugin-manager.js

@@ -429,6 +429,7 @@ const _PluginManager = class _PluginManager {
       await this.app.emitAsync("beforeLoadPlugin", plugin, options);
       this.app.logger.trace(`load plugin [${name}] `, { submodule: "plugin-manager", method: "load", name });
       await plugin.loadCollections();
+      await plugin.loadAI();
       await plugin.load();
       plugin.state.loaded = true;
       await this.app.emitAsync("afterLoadPlugin", plugin, options);
@@ -557,6 +558,7 @@ const _PluginManager = class _PluginManager {
           continue;
         }
         await plugin.loadCollections();
+        await plugin.loadAI();
         await plugin.load();
       }
     } catch (error) {

package/lib/plugin.d.ts

@@ -45,6 +45,7 @@ export declare abstract class Plugin<O = any> implements PluginInterface {
     constructor(app: Application, options?: any);
     get log(): import("@nocobase/logger/lib/logger").Logger;
     get name(): string;
+    get ai(): import("@nocobase/ai").AIManager;
     get pm(): import("./plugin-manager").PluginManager;
     get db(): import("@nocobase/database").default;
     get enabled(): any;
@@ -88,6 +89,10 @@ export declare abstract class Plugin<O = any> implements PluginInterface {
      * @internal
      */
     loadCollections(): Promise<void>;
+    /**
+     * @internal
+     */
+    loadAI(): Promise<void>;
     /**
      * @deprecated
      */

package/lib/plugin.js

@@ -46,6 +46,7 @@ var import_fs = __toESM(require("fs"));
 var import_path = require("path");
 var import_plugin_manager = require("./plugin-manager");
 var import_utils2 = require("./plugin-manager/utils");
+var import_ai = require("@nocobase/ai");
 /* istanbul ignore file -- @preserve */
 const _Plugin = class _Plugin {
   options;
@@ -75,6 +76,9 @@ const _Plugin = class _Plugin {
   get name() {
     return this.options.name;
   }
+  get ai() {
+    return this.app.aiManager;
+  }
   get pm() {
     return this.app.pm;
   }
@@ -189,6 +193,27 @@ const _Plugin = class _Plugin {
       });
     }
   }
+  /**
+   * @internal
+   */
+  async loadAI() {
+    const pluginRoot = await this.getPluginBasePath();
+    if (!pluginRoot) {
+      return;
+    }
+    const basePath = (0, import_path.resolve)(pluginRoot, "ai");
+    if (!await (0, import_utils.fsExists)(basePath)) {
+      return;
+    }
+    const toolsLoader = new import_ai.ToolsLoader(this.ai, {
+      scan: {
+        basePath,
+        pattern: ["**/tools/**/*.ts", "**/tools/**/*.js", "!**/tools/**/*.d.ts", "**/tools/**/*/description.md"]
+      },
+      log: this.log
+    });
+    await toolsLoader.load();
+  }
   /**
    * @deprecated
    */

package/lib/redis-connection-manager.d.ts

@@ -6,23 +6,33 @@
  * 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 Redis from 'ioredis';
 import { Logger } from '@nocobase/logger';
-export { Redis };
-export interface RedisConfig {
-    connectionString: string;
+import { createClient } from 'redis';
+type RedisClientOptions = NonNullable<Parameters<typeof createClient>[0]>;
+export type Redis = ReturnType<typeof createClient>;
+export interface RedisConfig extends RedisClientOptions {
+    connectionString?: string;
 }
 export declare class RedisConnectionManager {
     private logger;
     private config;
     private connections;
+    private connectionConfigs;
+    private connecting;
     constructor(config: {
-        redisConfig: RedisConfig;
+        redisConfig?: RedisConfig;
         logger: Logger;
     });
     private bindEvents;
+    private mergeConfig;
+    private hasConnectionOptions;
+    private buildClientOptions;
+    private ensureConnected;
     private getClient;
     getConnection(key?: string, config?: RedisConfig): Redis | null;
+    private waitUntilReady;
     getConnectionSync(key?: string, config?: RedisConfig): Promise<Redis>;
+    private closeConnection;
     close(): Promise<void>;
 }
+export {};

package/lib/redis-connection-manager.js

@@ -37,76 +37,170 @@ var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__ge
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 var redis_connection_manager_exports = {};
 __export(redis_connection_manager_exports, {
-  Redis: () => import_ioredis.default,
   RedisConnectionManager: () => RedisConnectionManager
 });
 module.exports = __toCommonJS(redis_connection_manager_exports);
-var import_ioredis = __toESM(require("ioredis"));
+var import_merge = __toESM(require("lodash/merge"));
+var import_redis = require("redis");
 const _RedisConnectionManager = class _RedisConnectionManager {
   logger;
   config;
   connections = /* @__PURE__ */ new Map();
+  connectionConfigs = /* @__PURE__ */ new Map();
+  connecting = /* @__PURE__ */ new WeakMap();
   constructor(config) {
-    this.config = config.redisConfig;
+    this.config = config.redisConfig || {};
     this.logger = config.logger;
   }
   bindEvents(conn, key, config) {
     conn.on("connect", () => {
       this.logger.info(`Redis connected`, {
         method: "getConnection",
-        key,
-        config
+        key
+      });
+    });
+    conn.on("ready", () => {
+      this.logger.trace(`Redis ready`, {
+        method: "getConnection",
+        key
       });
     });
     conn.on("error", (err) => {
       this.logger.error(err.message, {
         err,
         method: "getConnection",
-        key,
-        config
+        key
       });
     });
-    conn.on("close", () => {
+    conn.on("end", () => {
       this.logger.trace(`Redis closed`, {
         method: "getConnection",
+        key
+      });
+    });
+  }
+  mergeConfig(config) {
+    return (0, import_merge.default)({}, this.config || {}, config || {});
+  }
+  hasConnectionOptions(config) {
+    if (!config) {
+      return false;
+    }
+    return Boolean(config.connectionString || config.url || config.socket);
+  }
+  buildClientOptions(config) {
+    const { connectionString, ...rest } = config;
+    const options = { ...rest };
+    if (connectionString && !options.url) {
+      options.url = connectionString;
+    }
+    return options;
+  }
+  ensureConnected(conn, key, config) {
+    if (conn.isOpen || this.connecting.has(conn)) {
+      return;
+    }
+    const promise = conn.connect().catch((err) => {
+      this.logger.error(err.message, {
+        err,
+        method: "connect",
         key,
         config
       });
+      this.connections.delete(key);
+      this.connectionConfigs.delete(key);
+      throw err;
+    }).finally(() => {
+      this.connecting.delete(conn);
     });
+    this.connecting.set(conn, promise);
   }
   getClient(key = "default", config) {
     let conn = this.connections.get(key);
     if (conn) {
+      this.ensureConnected(conn, key, this.connectionConfigs.get(key));
       return conn;
     }
-    const cfg = config || this.config;
-    if (!cfg.connectionString) {
+    const cfg = this.mergeConfig(config);
+    if (!this.hasConnectionOptions(cfg)) {
       return null;
     }
-    conn = new import_ioredis.default(cfg.connectionString);
+    conn = (0, import_redis.createClient)(this.buildClientOptions(cfg));
     this.connections.set(key, conn);
+    this.connectionConfigs.set(key, cfg);
     this.bindEvents(conn, key, cfg);
+    this.ensureConnected(conn, key, cfg);
     return conn;
   }
   getConnection(key = "default", config) {
     return this.getClient(key, config);
   }
-  async getConnectionSync(key = "default", config) {
-    return new Promise((resolve, reject) => {
-      const conn = this.getClient(key, config);
-      if (!conn) {
-        return reject(new Error("Redis connect string is missing"));
+  async waitUntilReady(conn) {
+    if (conn.isReady) {
+      return conn;
+    }
+    const pendingConnect = this.connecting.get(conn);
+    if (pendingConnect) {
+      await pendingConnect;
+      if (conn.isReady) {
+        return conn;
       }
-      conn.once("connect", () => resolve(conn));
-      conn.once("error", reject);
+    } else if (!conn.isOpen) {
+      await conn.connect();
+      if (conn.isReady) {
+        return conn;
+      }
+    }
+    return new Promise((resolve, reject) => {
+      const cleanup = /* @__PURE__ */ __name(() => {
+        conn.off("ready", handleReady);
+        conn.off("error", handleError);
+      }, "cleanup");
+      const handleReady = /* @__PURE__ */ __name(() => {
+        cleanup();
+        resolve(conn);
+      }, "handleReady");
+      const handleError = /* @__PURE__ */ __name((err) => {
+        cleanup();
+        reject(err);
+      }, "handleError");
+      conn.once("ready", handleReady);
+      conn.once("error", handleError);
     });
   }
-  async close() {
-    for (const conn of this.connections.values()) {
-      if (!(conn == null ? void 0 : conn.status) || conn.status === "close" || conn.status === "end") {
-        continue;
-      }
+  async getConnectionSync(key = "default", config) {
+    const conn = this.getClient(key, config);
+    if (!conn) {
+      throw new Error("Redis connection configuration is missing");
+    }
+    return this.waitUntilReady(conn);
+  }
+  async closeConnection(key, conn) {
+    if (!(conn == null ? void 0 : conn.isOpen)) {
+      return;
+    }
+    try {
       await conn.quit();
+    } catch (err) {
+      this.logger.warn(`Failed to quit redis connection`, {
+        err,
+        method: "closeConnection",
+        key
+      });
+      try {
+        conn.destroy();
+      } catch (disconnectErr) {
+        this.logger.warn(`Failed to disconnect redis connection`, {
+          err: disconnectErr,
+          method: "closeConnection",
+          key
+        });
+      }
+    }
+  }
+  async close() {
+    for (const [key, conn] of this.connections.entries()) {
+      await this.closeConnection(key, conn);
     }
   }
 };
@@ -114,6 +208,5 @@ __name(_RedisConnectionManager, "RedisConnectionManager");
 let RedisConnectionManager = _RedisConnectionManager;
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
-  Redis,
   RedisConnectionManager
 });

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@nocobase/server",
-  "version": "2.0.0-beta.8",
+  "version": "2.0.0",
   "main": "lib/index.js",
   "types": "./lib/index.d.ts",
   "license": "AGPL-3.0",
@@ -10,20 +10,21 @@
     "@koa/cors": "^5.0.0",
     "@koa/multer": "^3.1.0",
     "@koa/router": "^13.1.0",
-    "@nocobase/acl": "2.0.0-beta.8",
-    "@nocobase/actions": "2.0.0-beta.8",
-    "@nocobase/auth": "2.0.0-beta.8",
-    "@nocobase/cache": "2.0.0-beta.8",
-    "@nocobase/data-source-manager": "2.0.0-beta.8",
-    "@nocobase/database": "2.0.0-beta.8",
-    "@nocobase/evaluators": "2.0.0-beta.8",
-    "@nocobase/lock-manager": "2.0.0-beta.8",
-    "@nocobase/logger": "2.0.0-beta.8",
-    "@nocobase/resourcer": "2.0.0-beta.8",
-    "@nocobase/sdk": "2.0.0-beta.8",
-    "@nocobase/snowflake-id": "2.0.0-beta.8",
-    "@nocobase/telemetry": "2.0.0-beta.8",
-    "@nocobase/utils": "2.0.0-beta.8",
+    "@nocobase/acl": "2.0.0",
+    "@nocobase/actions": "2.0.0",
+    "@nocobase/ai": "2.0.0",
+    "@nocobase/auth": "2.0.0",
+    "@nocobase/cache": "2.0.0",
+    "@nocobase/data-source-manager": "2.0.0",
+    "@nocobase/database": "2.0.0",
+    "@nocobase/evaluators": "2.0.0",
+    "@nocobase/lock-manager": "2.0.0",
+    "@nocobase/logger": "2.0.0",
+    "@nocobase/resourcer": "2.0.0",
+    "@nocobase/sdk": "2.0.0",
+    "@nocobase/snowflake-id": "2.0.0",
+    "@nocobase/telemetry": "2.0.0",
+    "@nocobase/utils": "2.0.0",
     "@types/decompress": "4.2.7",
     "@types/ini": "^1.3.31",
     "@types/koa-send": "^4.1.3",
@@ -41,7 +42,6 @@
     "fs-extra": "^11.1.1",
     "i18next": "^22.4.9",
     "ini": "^4.1.1",
-    "ioredis": "^5.7.0",
     "koa": "^2.15.4",
     "koa-bodyparser": "^4.3.0",
     "koa-send": "^5.0.1",
@@ -50,6 +50,7 @@
     "multer": "^1.4.5-lts.2",
     "nanoid": "^3.3.11",
     "p-queue": "^6.6.2",
+    "redis": "^5.10.0",
     "semver": "^7.7.1",
     "serve-handler": "^6.1.6",
     "ws": "^8.13.0",
@@ -60,5 +61,5 @@
     "@types/serve-handler": "^6.1.1",
     "@types/ws": "^8.5.5"
   },
-  "gitHead": "6bd912b1028eb8bc09a823d35e4d37b3000861b1"
+  "gitHead": "3590c0087a56f0f285a5357f43a80bdc62b11bec"
 }