@nocobase/server 1.5.0-beta.8 → 1.5.0

package/lib/application.d.ts

@@ -31,6 +31,7 @@ import { Plugin } from './plugin';
 import { InstallOptions, PluginManager } from './plugin-manager';
 import { PubSubManager, PubSubManagerOptions } from './pub-sub-manager';
 import { SyncMessageManager } from './sync-message-manager';
+import { ServiceContainer } from './service-container';
 import { AuditManager } from './audit-manager';
 export type PluginType = string | typeof Plugin;
 export type PluginConfiguration = PluginType | [PluginType, any];
@@ -169,6 +170,7 @@ export declare class Application<StateT = DefaultState, ContextT = DefaultContex
     private _maintainingCommandStatus;
     private _maintainingStatusBeforeCommand;
     private _actionCommand;
+    container: ServiceContainer;
     lockManager: LockManager;
     constructor(options: ApplicationOptions);
     private static staticCommands;

package/lib/application.js

@@ -76,6 +76,7 @@ var import_plugin_manager = require("./plugin-manager");
 var import_pub_sub_manager = require("./pub-sub-manager");
 var import_sync_message_manager = require("./sync-message-manager");
 var import_package = __toESM(require("../package.json"));
+var import_service_container = require("./service-container");
 var import_available_action = require("./acl/available-action");
 var import_audit_manager = require("./audit-manager");
 const _Application = class _Application extends import_koa.default {
@@ -126,6 +127,7 @@ const _Application = class _Application extends import_koa.default {
   _maintainingCommandStatus;
   _maintainingStatusBeforeCommand;
   _actionCommand;
+  container = new import_service_container.ServiceContainer();
   lockManager;
   static addCommand(callback) {
     this.staticCommands.push(callback);

package/lib/gateway/index.js

@@ -63,7 +63,17 @@ var import_errors = require("./errors");
 var import_ipc_socket_client = require("./ipc-socket-client");
 var import_ipc_socket_server = require("./ipc-socket-server");
 var import_ws_server = require("./ws-server");
+var import_node_worker_threads = require("node:worker_threads");
+var import_node_process = __toESM(require("node:process"));
 const compress = (0, import_node_util.promisify)((0, import_compression.default)());
+function getSocketPath() {
+  const { SOCKET_PATH } = import_node_process.default.env;
+  if ((0, import_path.isAbsolute)(SOCKET_PATH)) {
+    return SOCKET_PATH;
+  }
+  return (0, import_path.resolve)(import_node_process.default.cwd(), SOCKET_PATH);
+}
+__name(getSocketPath, "getSocketPath");
 const _Gateway = class _Gateway extends import_events.EventEmitter {
   /**
    * use main app as default app to handle request
@@ -72,16 +82,14 @@ const _Gateway = class _Gateway extends import_events.EventEmitter {
   server = null;
   ipcSocketServer = null;
   loggers = new import_utils.Registry();
-  port = process.env.APP_PORT ? parseInt(process.env.APP_PORT) : null;
+  port = import_node_process.default.env.APP_PORT ? parseInt(import_node_process.default.env.APP_PORT) : null;
   host = "0.0.0.0";
   wsServer;
-  socketPath = (0, import_path.resolve)(process.cwd(), "storage", "gateway.sock");
+  socketPath = (0, import_path.resolve)(import_node_process.default.cwd(), "storage", "gateway.sock");
   constructor() {
     super();
     this.reset();
-    if (process.env.SOCKET_PATH) {
-      this.socketPath = (0, import_path.resolve)(process.cwd(), process.env.SOCKET_PATH);
-    }
+    this.socketPath = getSocketPath();
   }
   static getInstance(options = {}) {
     if (!_Gateway.instance) {
@@ -90,7 +98,7 @@ const _Gateway = class _Gateway extends import_events.EventEmitter {
     return _Gateway.instance;
   }
   static async getIPCSocketClient() {
-    const socketPath = (0, import_path.resolve)(process.cwd(), process.env.SOCKET_PATH || "storage/gateway.sock");
+    const socketPath = getSocketPath();
     try {
       return await import_ipc_socket_client.IPCSocketClient.getConnection(socketPath);
     } catch (error) {
@@ -166,7 +174,7 @@ const _Gateway = class _Gateway extends import_events.EventEmitter {
   }
   async requestHandler(req, res) {
     const { pathname } = (0, import_url.parse)(req.url);
-    const { PLUGIN_STATICS_PATH, APP_PUBLIC_PATH } = process.env;
+    const { PLUGIN_STATICS_PATH, APP_PUBLIC_PATH } = import_node_process.default.env;
     if (pathname.endsWith("/__umi/api/bundle-status")) {
       res.statusCode = 200;
       res.end("ok");
@@ -176,7 +184,7 @@ const _Gateway = class _Gateway extends import_events.EventEmitter {
       req.url = req.url.substring(APP_PUBLIC_PATH.length - 1);
       await compress(req, res);
       return (0, import_serve_handler.default)(req, res, {
-        public: (0, import_path.resolve)(process.cwd()),
+        public: (0, import_path.resolve)(import_node_process.default.cwd()),
         directoryListing: false
       });
     }
@@ -195,15 +203,22 @@ const _Gateway = class _Gateway extends import_events.EventEmitter {
         ]
       });
     }
-    if (!pathname.startsWith(process.env.API_BASE_PATH)) {
+    if (!pathname.startsWith(import_node_process.default.env.API_BASE_PATH)) {
       req.url = req.url.substring(APP_PUBLIC_PATH.length - 1);
       await compress(req, res);
       return (0, import_serve_handler.default)(req, res, {
-        public: `${process.env.APP_PACKAGE_ROOT}/dist/client`,
+        public: `${import_node_process.default.env.APP_PACKAGE_ROOT}/dist/client`,
         rewrites: [{ source: "/**", destination: "/index.html" }]
       });
     }
-    const handleApp = await this.getRequestHandleAppName(req);
+    let handleApp = "main";
+    try {
+      handleApp = await this.getRequestHandleAppName(req);
+    } catch (error) {
+      console.log(error);
+      this.responseErrorWithCode("APP_INITIALIZING", res, { appName: handleApp });
+      return;
+    }
     const hasApp = import_app_supervisor.AppSupervisor.getInstance().hasApp(handleApp);
     if (!hasApp) {
       void import_app_supervisor.AppSupervisor.getInstance().bootStrapApp(handleApp);
@@ -257,10 +272,10 @@ const _Gateway = class _Gateway extends import_events.EventEmitter {
   }
   /* istanbul ignore next -- @preserve */
   async watch() {
-    if (!process.env.IS_DEV_CMD) {
+    if (!import_node_process.default.env.IS_DEV_CMD) {
       return;
     }
-    const file = process.env.WATCH_FILE;
+    const file = import_node_process.default.env.WATCH_FILE;
     if (!import_fs.default.existsSync(file)) {
       await import_fs.default.promises.writeFile(file, `export const watchId = '${(0, import_utils.uid)()}';`, "utf-8");
     }
@@ -273,8 +288,8 @@ const _Gateway = class _Gateway extends import_events.EventEmitter {
     if (isStart) {
       await this.watch();
       const startOptions = this.getStartOptions();
-      const port = startOptions.port || process.env.APP_PORT || 13e3;
-      const host = startOptions.host || process.env.APP_HOST || "0.0.0.0";
+      const port = startOptions.port || import_node_process.default.env.APP_PORT || 13e3;
+      const host = startOptions.host || import_node_process.default.env.APP_HOST || "0.0.0.0";
       this.start({
         port,
         host
@@ -282,7 +297,7 @@ const _Gateway = class _Gateway extends import_events.EventEmitter {
     } else if (!this.isHelp()) {
       ipcClient = await this.tryConnectToIPCServer();
       if (ipcClient) {
-        const response = await ipcClient.write({ type: "passCliArgv", payload: { argv: process.argv } });
+        const response = await ipcClient.write({ type: "passCliArgv", payload: { argv: import_node_process.default.argv } });
         ipcClient.close();
         if (!["error", "not_found"].includes(response.type)) {
           return;
@@ -293,15 +308,19 @@ const _Gateway = class _Gateway extends import_events.EventEmitter {
       await (0, import_plugin_symlink.createStoragePluginsSymlink)();
     }
     const mainApp = import_app_supervisor.AppSupervisor.getInstance().bootMainApp(options.mainAppOptions);
-    mainApp.runAsCLI(process.argv, {
-      throwError: true,
-      from: "node"
-    }).then(async () => {
+    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" }];
+    }
+    mainApp.runAsCLI(...runArgs).then(async () => {
       if (!isStart && !await mainApp.isStarted()) {
         await mainApp.stop({ logging: false });
       }
     }).catch(async (e) => {
       if (e.code !== "commander.helpDisplayed") {
+        if (!import_node_worker_threads.isMainThread) {
+          throw e;
+        }
         mainApp.log.error(e);
       }
       if (!isStart && !await mainApp.isStarted()) {
@@ -310,16 +329,16 @@ const _Gateway = class _Gateway extends import_events.EventEmitter {
     });
   }
   isStart() {
-    const argv = process.argv;
+    const argv = import_node_process.default.argv;
     return argv[2] === "start";
   }
   isHelp() {
-    const argv = process.argv;
+    const argv = import_node_process.default.argv;
     return argv[2] === "help";
   }
   getStartOptions() {
     const program = new import_commander.Command();
-    program.allowUnknownOption().option("-s, --silent").option("-p, --port [post]").option("-h, --host [host]").option("--db-sync").parse(process.argv);
+    program.allowUnknownOption().option("-s, --silent").option("-p, --port [post]").option("-h, --host [host]").option("--db-sync").parse(import_node_process.default.argv);
     return program.opts();
   }
   start(options) {
@@ -344,7 +363,7 @@ const _Gateway = class _Gateway extends import_events.EventEmitter {
     this.wsServer = new import_ws_server.WSServer();
     this.server.on("upgrade", (request, socket, head) => {
       const { pathname } = (0, import_url.parse)(request.url);
-      if (pathname === process.env.WS_PATH) {
+      if (pathname === import_node_process.default.env.WS_PATH) {
         this.wsServer.wss.handleUpgrade(request, socket, head, (ws) => {
           this.wsServer.wss.emit("connection", ws, request);
         });

package/lib/gateway/ws-server.d.ts

@@ -7,29 +7,45 @@
  * For more information, please refer to: https://www.nocobase.com/agreement.
  */
 /// <reference types="node" />
+/// <reference types="node" />
 import WebSocket from 'ws';
 import { IncomingMessage } from 'http';
 import { Logger } from '@nocobase/logger';
+import EventEmitter from 'events';
 declare class WebSocketWithId extends WebSocket {
     id: string;
 }
 interface WebSocketClient {
     ws: WebSocketWithId;
-    tags: string[];
+    tags: Set<string>;
     url: string;
     headers: any;
     app?: string;
+    id: string;
 }
-export declare class WSServer {
+export declare class WSServer extends EventEmitter {
     wss: WebSocket.Server;
     webSocketClients: Map<string, WebSocketClient>;
     logger: Logger;
     constructor();
+    bindAppWSEvents(app: any): void;
     addNewConnection(ws: WebSocketWithId, request: IncomingMessage): WebSocketClient;
+    setClientTag(clientId: string, tagKey: string, tagValue: string): void;
+    removeClientTag(clientId: string, tagKey: string): void;
     setClientApp(client: WebSocketClient): Promise<void>;
     removeConnection(id: string): void;
     sendMessageToConnection(client: WebSocketClient, sendMessage: object): void;
     sendToConnectionsByTag(tagName: string, tagValue: string, sendMessage: object): void;
+    /**
+     * Send message to clients that match all the given tag conditions
+     * @param tags Array of tag conditions, each condition is an object with tagName and tagValue
+     * @param sendMessage Message to be sent
+     */
+    sendToConnectionsByTags(tags: Array<{
+        tagName: string;
+        tagValue: string;
+    }>, sendMessage: object): void;
+    sendToClient(clientId: string, sendMessage: object): void;
     loopThroughConnections(callback: (client: WebSocketClient) => void): void;
     close(): void;
 }

package/lib/gateway/ws-server.js

@@ -46,16 +46,18 @@ var import_nanoid = require("nanoid");
 var import_app_supervisor = require("../app-supervisor");
 var import_errors = require("./errors");
 var import_lodash = __toESM(require("lodash"));
+var import_events = __toESM(require("events"));
 function getPayloadByErrorCode(code, options) {
   const error = (0, import_errors.getErrorWithCode)(code);
   return import_lodash.default.omit((0, import_errors.applyErrorWithArgs)(error, options), ["status", "maintaining"]);
 }
 __name(getPayloadByErrorCode, "getPayloadByErrorCode");
-const _WSServer = class _WSServer {
+const _WSServer = class _WSServer extends import_events.default {
   wss;
   webSocketClients = /* @__PURE__ */ new Map();
   logger;
   constructor() {
+    super();
     this.wss = new import_ws.WebSocketServer({ noServer: true });
     this.wss.on("connection", (ws, request) => {
       const client = this.addNewConnection(ws, request);
@@ -66,6 +68,15 @@ const _WSServer = class _WSServer {
       ws.on("close", () => {
         this.removeConnection(ws.id);
       });
+      ws.on("message", (message) => {
+        if (message.toString() === "ping") {
+          return;
+        }
+        this.emit("message", {
+          client,
+          message
+        });
+      });
     });
     import_gateway.Gateway.getInstance().on("appSelectorChanged", () => {
       this.loopThroughConnections(async (client) => {
@@ -73,8 +84,12 @@ const _WSServer = class _WSServer {
           url: client.url,
           headers: client.headers
         });
-        client.tags = client.tags.filter((tag) => !tag.startsWith("app#"));
-        client.tags.push(`app#${handleAppName}`);
+        for (const tag of client.tags) {
+          if (tag.startsWith("app#")) {
+            client.tags.delete(tag);
+          }
+        }
+        client.tags.add(`app#${handleAppName}`);
         import_app_supervisor.AppSupervisor.getInstance().bootStrapApp(handleAppName);
       });
     });
@@ -118,19 +133,87 @@ const _WSServer = class _WSServer {
         }
       });
     });
+    import_app_supervisor.AppSupervisor.getInstance().on("afterAppAdded", (app) => {
+      this.bindAppWSEvents(app);
+    });
+    this.on("message", async ({ client, message }) => {
+      const app = await import_app_supervisor.AppSupervisor.getInstance().getApp(client.app);
+      if (!app) {
+        return;
+      }
+      const parsedMessage = JSON.parse(message.toString());
+      if (!parsedMessage.type) {
+        return;
+      }
+      const eventName = `ws:message:${parsedMessage.type}`;
+      app.emit(eventName, {
+        clientId: client.id,
+        tags: [...client.tags],
+        payload: parsedMessage.payload
+      });
+    });
+  }
+  bindAppWSEvents(app) {
+    if (app.listenerCount("ws:setTag") > 0) {
+      return;
+    }
+    app.on("ws:setTag", ({ clientId, tagKey, tagValue }) => {
+      this.setClientTag(clientId, tagKey, tagValue);
+    });
+    app.on("ws:removeTag", ({ clientId, tagKey }) => {
+      this.removeClientTag(clientId, tagKey);
+    });
+    app.on("ws:sendToTag", ({ tagKey, tagValue, message }) => {
+      this.sendToConnectionsByTags(
+        [
+          { tagName: tagKey, tagValue },
+          { tagName: "app", tagValue: app.name }
+        ],
+        message
+      );
+    });
+    app.on("ws:sendToClient", ({ clientId, message }) => {
+      this.sendToClient(clientId, message);
+    });
+    app.on("ws:sendToCurrentApp", ({ message }) => {
+      this.sendToConnectionsByTag("app", app.name, message);
+    });
+    app.on("ws:sendToTags", ({ tags, message }) => {
+      this.sendToConnectionsByTags(tags, message);
+    });
+    app.on("ws:authorized", ({ clientId, userId }) => {
+      this.sendToClient(clientId, { type: "authorized" });
+    });
   }
   addNewConnection(ws, request) {
     const id = (0, import_nanoid.nanoid)();
     ws.id = id;
     this.webSocketClients.set(id, {
       ws,
-      tags: [],
+      tags: /* @__PURE__ */ new Set(),
       url: request.url,
-      headers: request.headers
+      headers: request.headers,
+      id
     });
     this.setClientApp(this.webSocketClients.get(id));
     return this.webSocketClients.get(id);
   }
+  setClientTag(clientId, tagKey, tagValue) {
+    const client = this.webSocketClients.get(clientId);
+    if (!client) {
+      return;
+    }
+    client.tags.add(`${tagKey}#${tagValue}`);
+    console.log(`client tags: ${Array.from(client.tags)}`);
+  }
+  removeClientTag(clientId, tagKey) {
+    const client = this.webSocketClients.get(clientId);
+    client.tags.forEach((tag) => {
+      if (tag.startsWith(tagKey)) {
+        client.tags.delete(tag);
+      }
+    });
+  }
   async setClientApp(client) {
     const req = {
       url: client.url,
@@ -139,31 +222,11 @@ const _WSServer = class _WSServer {
     const handleAppName = await import_gateway.Gateway.getInstance().getRequestHandleAppName(req);
     client.app = handleAppName;
     console.log(`client tags: app#${handleAppName}`);
-    client.tags.push(`app#${handleAppName}`);
+    client.tags.add(`app#${handleAppName}`);
     const hasApp = import_app_supervisor.AppSupervisor.getInstance().hasApp(handleAppName);
     if (!hasApp) {
       import_app_supervisor.AppSupervisor.getInstance().bootStrapApp(handleAppName);
     }
-    const appStatus = import_app_supervisor.AppSupervisor.getInstance().getAppStatus(handleAppName, "initializing");
-    if (appStatus === "not_found") {
-      this.sendMessageToConnection(client, {
-        type: "maintaining",
-        payload: getPayloadByErrorCode("APP_NOT_FOUND", { appName: handleAppName })
-      });
-      return;
-    }
-    if (appStatus === "initializing") {
-      this.sendMessageToConnection(client, {
-        type: "maintaining",
-        payload: getPayloadByErrorCode("APP_INITIALIZING", { appName: handleAppName })
-      });
-      return;
-    }
-    const app = await import_app_supervisor.AppSupervisor.getInstance().getApp(handleAppName);
-    this.sendMessageToConnection(client, {
-      type: "maintaining",
-      payload: getPayloadByErrorCode(appStatus, { app })
-    });
   }
   removeConnection(id) {
     console.log(`client disconnected ${id}`);
@@ -173,12 +236,27 @@ const _WSServer = class _WSServer {
     client.ws.send(JSON.stringify(sendMessage));
   }
   sendToConnectionsByTag(tagName, tagValue, sendMessage) {
+    this.sendToConnectionsByTags([{ tagName, tagValue }], sendMessage);
+  }
+  /**
+   * Send message to clients that match all the given tag conditions
+   * @param tags Array of tag conditions, each condition is an object with tagName and tagValue
+   * @param sendMessage Message to be sent
+   */
+  sendToConnectionsByTags(tags, sendMessage) {
     this.loopThroughConnections((client) => {
-      if (client.tags.includes(`${tagName}#${tagValue}`)) {
+      const allTagsMatch = tags.every(({ tagName, tagValue }) => client.tags.has(`${tagName}#${tagValue}`));
+      if (allTagsMatch) {
         this.sendMessageToConnection(client, sendMessage);
       }
     });
   }
+  sendToClient(clientId, sendMessage) {
+    const client = this.webSocketClients.get(clientId);
+    if (client) {
+      this.sendMessageToConnection(client, sendMessage);
+    }
+  }
   loopThroughConnections(callback) {
     this.webSocketClients.forEach((client) => {
       callback(client);

package/lib/middlewares/data-template.js

@@ -36,7 +36,7 @@ async function dataTemplate(ctx, next) {
   await next();
   if (isTemplate && actionName === "get") {
     ctx.body = traverseJSON(JSON.parse(JSON.stringify(ctx.body)), {
-      collection: ctx.db.getCollection(resourceName),
+      collection: ctx.getCurrentRepository().collection,
       include: [...fields || [], ...appends || []]
     });
   }
@@ -101,7 +101,7 @@ const traverseJSON = /* @__PURE__ */ __name((data, options) => {
       result[key] = data[key];
       continue;
     }
-    if (field.options.primaryKey && excludePk) {
+    if (field.options.primaryKey && excludePk && !collection.isMultiFilterTargetKey()) {
       continue;
     }
     if (field.options.isForeignKey) {

package/lib/plugin-manager/plugin-manager.d.ts

@@ -67,7 +67,7 @@ export declare class PluginManager {
     /**
      * @internal
      */
-    static getPackageName(name: string): Promise<string>;
+    static getPackageName(name: string): Promise<any>;
     /**
      * @internal
      */
@@ -75,7 +75,7 @@ export declare class PluginManager {
     /**
      * @internal
      */
-    static findPackage(name: string): Promise<string>;
+    static findPackage(name: string): Promise<any>;
     /**
      * @internal
      */
@@ -89,9 +89,9 @@ export declare class PluginManager {
     addPreset(plugin: string | typeof Plugin, options?: any): void;
     getPlugins(): Map<typeof Plugin, Plugin<any>>;
     getAliases(): IterableIterator<string>;
-    get(name: string | typeof Plugin): Plugin<any>;
+    get<T extends Plugin>(name: string | typeof Plugin | (new () => T)): T;
     has(name: string | typeof Plugin): boolean;
-    del(name: string | typeof Plugin): void;
+    del(name: any): void;
     create(pluginName: string, options?: {
         forceRecreate?: boolean;
     }): Promise<void>;

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

@@ -139,15 +139,12 @@ const _PluginManager = class _PluginManager {
    * @internal
    */
   static async getPackageName(name) {
-    const prefixes = this.getPluginPkgPrefix();
-    for (const prefix of prefixes) {
-      const pkg = (0, import_path.resolve)(process.env.NODE_MODULES_PATH, `${prefix}${name}`, "package.json");
-      const exists = await import_fs_extra.default.exists(pkg);
-      if (exists) {
-        return `${prefix}${name}`;
-      }
+    const { packageName } = await this.parseName(name);
+    const packageFile = (0, import_path.resolve)(process.env.NODE_MODULES_PATH, packageName, "package.json");
+    if (!await import_fs_extra.default.exists(packageFile)) {
+      return null;
     }
-    throw new Error(`${name} plugin does not exist`);
+    return packageName;
   }
   /**
    * @internal
@@ -312,7 +309,9 @@ const _PluginManager = class _PluginManager {
     try {
       if (typeof plugin === "string" && options.name && !options.packageName) {
         const packageName = await _PluginManager.getPackageName(options.name);
-        options["packageName"] = packageName;
+        if (packageName) {
+          options["packageName"] = packageName;
+        }
       }
       if (options.packageName) {
         const packageJson = await _PluginManager.getPackageJson(options.packageName);
@@ -320,12 +319,14 @@ const _PluginManager = class _PluginManager {
         options["version"] = packageJson.version;
       }
     } catch (error) {
+      this.app.log.error(error);
       console.error(error);
     }
-    this.app.log.trace(`add plugin [${options.name}]`, {
+    this.app.log.trace(`adding plugin [${options.name}]`, {
       method: "add",
       submodule: "plugin-manager",
-      name: options.name
+      name: options.name,
+      options
     });
     let P;
     try {
@@ -343,6 +344,12 @@ const _PluginManager = class _PluginManager {
       this.pluginAliases.set(options.packageName, instance);
     }
     await instance.afterAdd();
+    this.app.log.trace(`added plugin [${options.name}]`, {
+      method: "add",
+      submodule: "plugin-manager",
+      name: instance.name,
+      options: instance.options
+    });
   }
   /**
    * @internal
@@ -364,15 +371,20 @@ const _PluginManager = class _PluginManager {
     const packageNames = items.map((item) => item.packageName);
     const source = [];
     for (const packageName of packageNames) {
-      const dirname = await (0, import_utils2.getPluginBasePath)(packageName);
-      const directory = (0, import_path.join)(dirname, "server/commands/*." + ((0, import_path.basename)(dirname) === "src" ? "ts" : "js"));
-      source.push(directory.replaceAll(import_path.sep, "/"));
+      try {
+        const dirname = await (0, import_utils2.getPluginBasePath)(packageName);
+        const directory = (0, import_path.join)(dirname, "server/commands/*." + ((0, import_path.basename)(dirname) === "src" ? "{ts,js}" : "js"));
+        source.push(directory.replaceAll(import_path.sep, "/"));
+      } catch (error) {
+        this.app.log.error(error);
+        continue;
+      }
     }
     for (const plugin of this.options.plugins || []) {
       if (typeof plugin === "string") {
         const { packageName } = await _PluginManager.parseName(plugin);
         const dirname = await (0, import_utils2.getPluginBasePath)(packageName);
-        const directory = (0, import_path.join)(dirname, "server/commands/*." + ((0, import_path.basename)(dirname) === "src" ? "ts" : "js"));
+        const directory = (0, import_path.join)(dirname, "server/commands/*." + ((0, import_path.basename)(dirname) === "src" ? "{ts,js}" : "js"));
         source.push(directory.replaceAll(import_path.sep, "/"));
       }
     }

package/lib/service-container.d.ts

@@ -0,0 +1,5 @@
+export declare class ServiceContainer {
+    private services;
+    register<T>(name: string, service: T): void;
+    get<T>(name: string): T;
+}

package/lib/service-container.js

@@ -0,0 +1,50 @@
+/**
+ * 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 service_container_exports = {};
+__export(service_container_exports, {
+  ServiceContainer: () => ServiceContainer
+});
+module.exports = __toCommonJS(service_container_exports);
+const _ServiceContainer = class _ServiceContainer {
+  services = /* @__PURE__ */ new Map();
+  register(name, service) {
+    if (typeof service === "function") {
+      service = service();
+    }
+    this.services.set(name, service);
+  }
+  get(name) {
+    return this.services.get(name);
+  }
+};
+__name(_ServiceContainer, "ServiceContainer");
+let ServiceContainer = _ServiceContainer;
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  ServiceContainer
+});

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@nocobase/server",
-    "version": "1.5.0-beta.8",
+    "version": "1.5.0",
     "main": "lib/index.js",
     "types": "./lib/index.d.ts",
     "license": "AGPL-3.0",
@@ -10,19 +10,19 @@
         "@koa/cors": "^3.1.0",
         "@koa/multer": "^3.0.2",
         "@koa/router": "^9.4.0",
-        "@nocobase/acl": "1.5.0-beta.8",
-        "@nocobase/actions": "1.5.0-beta.8",
-        "@nocobase/auth": "1.5.0-beta.8",
-        "@nocobase/cache": "1.5.0-beta.8",
-        "@nocobase/data-source-manager": "1.5.0-beta.8",
-        "@nocobase/database": "1.5.0-beta.8",
-        "@nocobase/evaluators": "1.5.0-beta.8",
-        "@nocobase/lock-manager": "1.5.0-beta.8",
-        "@nocobase/logger": "1.5.0-beta.8",
-        "@nocobase/resourcer": "1.5.0-beta.8",
-        "@nocobase/sdk": "1.5.0-beta.8",
-        "@nocobase/telemetry": "1.5.0-beta.8",
-        "@nocobase/utils": "1.5.0-beta.8",
+        "@nocobase/acl": "1.5.0",
+        "@nocobase/actions": "1.5.0",
+        "@nocobase/auth": "1.5.0",
+        "@nocobase/cache": "1.5.0",
+        "@nocobase/data-source-manager": "1.5.0",
+        "@nocobase/database": "1.5.0",
+        "@nocobase/evaluators": "1.5.0",
+        "@nocobase/lock-manager": "1.5.0",
+        "@nocobase/logger": "1.5.0",
+        "@nocobase/resourcer": "1.5.0",
+        "@nocobase/sdk": "1.5.0",
+        "@nocobase/telemetry": "1.5.0",
+        "@nocobase/utils": "1.5.0",
         "@types/decompress": "4.2.7",
         "@types/ini": "^1.3.31",
         "@types/koa-send": "^4.1.3",
@@ -56,5 +56,5 @@
         "@types/serve-handler": "^6.1.1",
         "@types/ws": "^8.5.5"
     },
-    "gitHead": "eb7db7301ac5eed305e73540884611832bc761f6"
+    "gitHead": "1eae52e1fc837e9b1c6b63fc31bda7945b6101e9"
 }