@tego/core 1.3.44

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

@@ -0,0 +1,140 @@
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var ipc_socket_server_exports = {};
+__export(ipc_socket_server_exports, {
+  IPCSocketServer: () => IPCSocketServer
+});
+module.exports = __toCommonJS(ipc_socket_server_exports);
+var import_node_crypto = require("node:crypto");
+var import_node_fs = __toESM(require("node:fs"));
+var import_node_net = __toESM(require("node:net"));
+var import_node_path = __toESM(require("node:path"));
+var import_xpipe = __toESM(require("xpipe"));
+var import_app_supervisor = require("../app-supervisor");
+var import_ipc_socket_client = require("./ipc-socket-client");
+const _IPCSocketServer = class _IPCSocketServer {
+  constructor(server) {
+    this.socketServer = server;
+  }
+  static buildServer(socketPath) {
+    if (import_node_fs.default.existsSync(socketPath)) {
+      import_node_fs.default.unlinkSync(socketPath);
+    }
+    const dir = import_node_path.default.dirname(socketPath);
+    if (!import_node_fs.default.existsSync(dir)) {
+      import_node_fs.default.mkdirSync(dir, { recursive: true });
+    }
+    const socketServer = import_node_net.default.createServer((c) => {
+      console.log("client connected");
+      c.on("end", () => {
+        console.log("client disconnected");
+      });
+      c.on("data", (data) => {
+        const dataAsString = data.toString();
+        const messages = dataAsString.split("\n");
+        for (const message of messages) {
+          if (message.length === 0) {
+            continue;
+          }
+          const reqId = (0, import_node_crypto.randomUUID)();
+          const dataObj = JSON.parse(message);
+          _IPCSocketServer.handleClientMessage({ reqId, ...dataObj }).then((result) => {
+            (0, import_ipc_socket_client.writeJSON)(c, {
+              reqId,
+              type: result === false ? "not_found" : "success"
+            });
+          }).catch((err) => {
+            (0, import_ipc_socket_client.writeJSON)(c, {
+              reqId,
+              type: "error",
+              payload: {
+                message: err.message,
+                stack: err.stack
+              }
+            });
+          });
+        }
+      });
+    });
+    socketServer.listen(import_xpipe.default.eq(socketPath), () => {
+      console.log(`Gateway IPC Server running at ${socketPath}`);
+    });
+    return new _IPCSocketServer(socketServer);
+  }
+  static async handleClientMessage({ reqId, type, payload }) {
+    if (type === "appReady") {
+      const status = await new Promise((resolve, reject) => {
+        let status2;
+        const max = 300;
+        let count = 0;
+        const timer = setInterval(async () => {
+          status2 = import_app_supervisor.AppSupervisor.getInstance().getAppStatus("main");
+          if (status2 === "running") {
+            clearInterval(timer);
+            resolve(status2);
+          }
+          if (count++ > max) {
+            reject("error");
+          }
+        }, 500);
+      });
+      console.log("status", status);
+      return status;
+    }
+    if (type === "passCliArgv") {
+      const argv = payload.argv;
+      const mainApp = await import_app_supervisor.AppSupervisor.getInstance().getApp("main");
+      if (!mainApp.cli.hasCommand(argv[2])) {
+        await mainApp.pm.loadCommands();
+      }
+      const cli = mainApp.cli;
+      if (!cli.parseHandleByIPCServer(argv, {
+        from: "node"
+      })) {
+        mainApp.logger.debug("Not handle by ipc server");
+        return false;
+      }
+      return mainApp.runAsCLI(argv, {
+        reqId,
+        from: "node",
+        throwError: true
+      });
+    }
+    throw new Error(`Unknown message type ${type}`);
+  }
+  close() {
+    this.socketServer.close();
+  }
+};
+__name(_IPCSocketServer, "IPCSocketServer");
+let IPCSocketServer = _IPCSocketServer;
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  IPCSocketServer
+});

package/lib/gateway/types.d.ts

@@ -0,0 +1,25 @@
+import http, { IncomingMessage, ServerResponse } from 'node:http';
+import { ApplicationOptions } from '../application';
+export interface Handler {
+    name: string;
+    prefix: string;
+    callback: (req: IncomingMessage, res: ServerResponse) => void;
+}
+export interface AppSelectorMiddlewareContext {
+    req: IncomingRequest;
+    resolvedAppName: string | null;
+}
+export interface RunOptions {
+    mainAppOptions: ApplicationOptions;
+}
+export interface StartHttpServerOptions {
+    port: number;
+    host: string;
+    callback?: (server: http.Server) => void;
+}
+export type AppSelectorMiddleware = (ctx: AppSelectorMiddlewareContext, next: () => Promise<void>) => void;
+export type AppSelector = (req: IncomingRequest) => string | Promise<string>;
+export interface IncomingRequest {
+    url: string;
+    headers: any;
+}

package/lib/gateway/types.js

@@ -0,0 +1,15 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+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 types_exports = {};
+module.exports = __toCommonJS(types_exports);

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

@@ -0,0 +1,63 @@
+import { IncomingMessage } from 'node:http';
+import { Logger } from '@tachybase/logger';
+import WebSocket from 'ws';
+declare class WebSocketWithId extends WebSocket {
+    id: string;
+}
+interface WebSocketClient {
+    ws: WebSocketWithId;
+    tags: Set<string>;
+    url: string;
+    headers: any;
+    app?: string;
+}
+type WSEventType = 'close' | 'error' | 'message' | 'connection';
+type WSEventHandler = (ws: WebSocketWithId, ...args: any[]) => Promise<void> | void;
+export declare class WSServer {
+    wss: WebSocket.Server;
+    webSocketClients: Map<string, WebSocketClient>;
+    static KEY_CORE_MESSAGE: string;
+    private currentId;
+    logger: Logger;
+    private appEventHandlers;
+    constructor();
+    /**
+     * 为指定应用注册 WebSocket 事件处理函数
+     * @param appName 应用名称
+     * @param eventType 事件类型
+     * @param handler 事件处理函数
+     */
+    registerAppEventHandler(appName: string, eventType: WSEventType, handler: WSEventHandler): this;
+    /**
+     * 移除指定应用的 WebSocket 事件处理函数
+     * @param appName 应用名称
+     * @param eventType 事件类型
+     * @param handler 事件处理函数
+     */
+    removeAppEventHandler(appName: string, eventType: WSEventType, handler: WSEventHandler): this;
+    /**
+     * 触发指定应用的事件处理函数
+     * 只有当客户端与应用名称匹配时，才会触发相应的事件处理函数
+     * @param appName 应用名称
+     * @param eventType 事件类型
+     * @param ws WebSocket 实例
+     * @param args 事件参数
+     */
+    private triggerAppEventHandlers;
+    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;
+    sendToConnectionsByTags(tags: Array<{
+        tagName: string;
+        tagValue: string;
+    }>, sendMessage: object): void;
+    sendToClient(clientId: string, sendMessage: object): void;
+    loopThroughConnections(callback: (client: WebSocketClient) => void): void;
+    close(): void;
+}
+export {};

package/lib/gateway/ws-server.js

@@ -0,0 +1,335 @@
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var ws_server_exports = {};
+__export(ws_server_exports, {
+  WSServer: () => WSServer
+});
+module.exports = __toCommonJS(ws_server_exports);
+var import_lodash = __toESM(require("lodash"));
+var import_nanoid = require("nanoid");
+var import_ws = require("ws");
+var import__ = require(".");
+var import_app_supervisor = require("../app-supervisor");
+var import_errors = require("./errors");
+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 {
+  constructor() {
+    this.webSocketClients = /* @__PURE__ */ new Map();
+    this.currentId = (0, import_nanoid.nanoid)();
+    // 存储每个应用注册的事件处理函数
+    this.appEventHandlers = {};
+    this.wss = new import_ws.WebSocketServer({ noServer: true });
+    this.wss.on("connection", (ws, request) => {
+      const client = this.addNewConnection(ws, request);
+      console.log(`new client connected ${ws.id}`);
+      ws.on("error", (error) => {
+        this.removeConnection(ws.id);
+        if (client && client.app) {
+          this.triggerAppEventHandlers(client.app, "error", ws, error);
+        }
+      });
+      ws.on("close", (code, reason) => {
+        if (client && client.app) {
+          this.triggerAppEventHandlers(client.app, "close", ws, code, reason);
+        }
+        this.removeConnection(ws.id);
+      });
+      ws.on("message", (data) => {
+        if (client && client.app) {
+          this.triggerAppEventHandlers(client.app, "message", ws, data);
+        }
+      });
+      if (client && client.app) {
+        this.triggerAppEventHandlers(client.app, "connection", ws, request);
+      }
+    });
+    import__.Gateway.getInstance().on("appSelectorChanged", () => {
+      this.loopThroughConnections(async (client) => {
+        const handleAppName = await import__.Gateway.getInstance().getRequestHandleAppName({
+          url: client.url,
+          headers: client.headers
+        });
+        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);
+      });
+    });
+    import_app_supervisor.AppSupervisor.getInstance().on("appError", async ({ appName, error }) => {
+      this.sendToConnectionsByTag("app", appName, {
+        type: "notification",
+        payload: {
+          message: error.message,
+          type: "error"
+        }
+      });
+    });
+    import_app_supervisor.AppSupervisor.getInstance().on("appMaintainingMessageChanged", async ({ appName, message, command, status }) => {
+      const app = await import_app_supervisor.AppSupervisor.getInstance().getApp(appName, {
+        withOutBootStrap: true
+      });
+      const payload = getPayloadByErrorCode(status, {
+        app,
+        message,
+        command
+      });
+      this.sendToConnectionsByTag("app", appName, {
+        type: "maintaining",
+        payload
+      });
+    });
+    import_app_supervisor.AppSupervisor.getInstance().on("appStatusChanged", async ({ appName, status, options }) => {
+      const app = await import_app_supervisor.AppSupervisor.getInstance().getApp(appName, {
+        withOutBootStrap: true
+      });
+      const payload = getPayloadByErrorCode(status, { app, appName });
+      this.sendToConnectionsByTag("app", appName, {
+        type: "maintaining",
+        payload: {
+          ...payload,
+          ...options
+        }
+      });
+    });
+    import_app_supervisor.AppSupervisor.getInstance().on("afterAppAdded", (app) => {
+      this.bindAppWSEvents(app);
+    });
+  }
+  /**
+   * 为指定应用注册 WebSocket 事件处理函数
+   * @param appName 应用名称
+   * @param eventType 事件类型
+   * @param handler 事件处理函数
+   */
+  registerAppEventHandler(appName, eventType, handler) {
+    if (!this.appEventHandlers[appName]) {
+      this.appEventHandlers[appName] = {};
+    }
+    if (!this.appEventHandlers[appName][eventType]) {
+      this.appEventHandlers[appName][eventType] = /* @__PURE__ */ new Set();
+    }
+    this.appEventHandlers[appName][eventType].add(handler);
+    console.log(`Registered ${eventType} handler for app ${appName}`);
+    return this;
+  }
+  /**
+   * 移除指定应用的 WebSocket 事件处理函数
+   * @param appName 应用名称
+   * @param eventType 事件类型
+   * @param handler 事件处理函数
+   */
+  removeAppEventHandler(appName, eventType, handler) {
+    if (this.appEventHandlers[appName] && this.appEventHandlers[appName][eventType]) {
+      this.appEventHandlers[appName][eventType].delete(handler);
+      console.log(`Removed ${eventType} handler for app ${appName}`);
+    }
+    return this;
+  }
+  /**
+   * 触发指定应用的事件处理函数
+   * 只有当客户端与应用名称匹配时，才会触发相应的事件处理函数
+   * @param appName 应用名称
+   * @param eventType 事件类型
+   * @param ws WebSocket 实例
+   * @param args 事件参数
+   */
+  triggerAppEventHandlers(appName, eventType, ws, ...args) {
+    if (!appName || !this.appEventHandlers[appName] || !this.appEventHandlers[appName][eventType]) {
+      return;
+    }
+    const client = this.webSocketClients.get(ws.id);
+    if (!client) {
+      return;
+    }
+    if (client.app !== appName) {
+      return;
+    }
+    for (const handler of this.appEventHandlers[appName][eventType]) {
+      try {
+        handler(ws, ...args);
+      } catch (error) {
+        console.error(`Error in ${appName} WebSocket ${eventType} handler:`, error);
+      }
+    }
+  }
+  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" });
+    });
+    app.on("ws:registerEventHandler", ({ eventType, handler }) => {
+      this.registerAppEventHandler(app.name, eventType, handler);
+    });
+    app.on("ws:removeEventHandler", ({ eventType, handler }) => {
+      this.removeAppEventHandler(app.name, eventType, handler);
+    });
+  }
+  addNewConnection(ws, request) {
+    const id = (0, import_nanoid.nanoid)();
+    ws.id = id;
+    this.webSocketClients.set(id, {
+      ws,
+      tags: /* @__PURE__ */ new Set(),
+      url: request.url,
+      headers: request.headers
+    });
+    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);
+    if (!client) {
+      return;
+    }
+    client.tags.forEach((tag) => {
+      if (tag.startsWith(`${tagKey}#`)) {
+        client.tags.delete(tag);
+      }
+    });
+  }
+  async setClientApp(client) {
+    const req = {
+      url: client.url,
+      headers: client.headers
+    };
+    const handleAppName = await import__.Gateway.getInstance().getRequestHandleAppName(req);
+    client.app = handleAppName;
+    console.log(`client tags: 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}`);
+    this.webSocketClients.delete(id);
+  }
+  sendMessageToConnection(client, sendMessage) {
+    client.ws.send(JSON.stringify(sendMessage));
+  }
+  sendToConnectionsByTag(tagName, tagValue, sendMessage) {
+    const tagString = `${tagName}#${tagValue}`;
+    this.webSocketClients.forEach((client) => {
+      if (client.tags.has(tagString)) {
+        this.sendMessageToConnection(client, sendMessage);
+      }
+    });
+  }
+  sendToConnectionsByTags(tags, sendMessage) {
+    const tagStrings = tags.map(({ tagName, tagValue }) => `${tagName}#${tagValue}`);
+    this.webSocketClients.forEach((client) => {
+      if (tagStrings.every((tagString) => client.tags.has(tagString))) {
+        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);
+    });
+  }
+  close() {
+    this.wss.close();
+  }
+};
+__name(_WSServer, "WSServer");
+_WSServer.KEY_CORE_MESSAGE = "KEY_CORE_MESSAGE";
+let WSServer = _WSServer;
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  WSServer
+});

package/lib/helper.d.ts

@@ -0,0 +1,11 @@
+import { Resourcer } from '@tachybase/resourcer';
+import { Command } from 'commander';
+import { type i18n as TypeI18n } from 'i18next';
+import Application, { ApplicationOptions } from './application';
+export declare function createI18n(options: ApplicationOptions): TypeI18n;
+export declare function createResourcer(options: ApplicationOptions): Resourcer;
+export declare function registerMiddlewares(app: Application, options: ApplicationOptions): void;
+export declare const createAppProxy: (app: Application) => Application<import("./application").DefaultState, import("./application").DefaultContext>;
+export declare const getCommandFullName: (command: Command) => string;
+export declare const tsxRerunning: () => Promise<void>;
+export declare const enablePerfHooks: (app: Application) => void;