@tego/core 1.3.44

package/lib/app-supervisor.js

@@ -0,0 +1,299 @@
+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 app_supervisor_exports = {};
+__export(app_supervisor_exports, {
+  AppSupervisor: () => AppSupervisor
+});
+module.exports = __toCommonJS(app_supervisor_exports);
+var import_node_events = require("node:events");
+var import_utils = require("@tachybase/utils");
+var import_async_mutex = require("async-mutex");
+var import_application = __toESM(require("./application"));
+var import_handler = require("./errors/handler");
+const _AppSupervisor = class _AppSupervisor extends import_node_events.EventEmitter {
+  constructor() {
+    super();
+    this.runningMode = "multiple";
+    this.singleAppName = null;
+    this.apps = {};
+    this.lastSeenAt = /* @__PURE__ */ new Map();
+    this.appErrors = {};
+    this.appStatus = {};
+    this.lastMaintainingMessage = {};
+    this.statusBeforeCommanding = {};
+    this.appMutexes = {};
+    this.appBootstrapper = null;
+    this.blockApps = /* @__PURE__ */ new Set();
+    if (process.env.STARTUP_SUBAPP) {
+      this.runningMode = "single";
+      this.singleAppName = process.env.STARTUP_SUBAPP;
+    }
+  }
+  static getInstance() {
+    if (!_AppSupervisor.instance) {
+      _AppSupervisor.instance = new _AppSupervisor();
+    }
+    return _AppSupervisor.instance;
+  }
+  setAppError(appName, error) {
+    this.appErrors[appName] = error;
+    this.emit("appError", {
+      appName,
+      error
+    });
+  }
+  hasAppError(appName) {
+    return !!this.appErrors[appName];
+  }
+  clearAppError(appName) {
+    delete this.appErrors[appName];
+  }
+  async reset() {
+    const appNames = Object.keys(this.apps);
+    for (const appName of appNames) {
+      await this.removeApp(appName);
+    }
+    this.appBootstrapper = null;
+    this.removeAllListeners();
+  }
+  async destroy() {
+    await this.reset();
+    _AppSupervisor.instance = null;
+  }
+  setAppStatus(appName, status, options = {}) {
+    if (this.appStatus[appName] === status) {
+      return;
+    }
+    this.appStatus[appName] = status;
+    this.emit("appStatusChanged", {
+      appName,
+      status,
+      options
+    });
+  }
+  touchApp(appName) {
+    if (!this.hasApp(appName)) {
+      return;
+    }
+    this.lastSeenAt.set(appName, Math.floor(Date.now() / 1e3));
+  }
+  getMutexOfApp(appName) {
+    if (!this.appMutexes[appName]) {
+      this.appMutexes[appName] = new import_async_mutex.Mutex();
+    }
+    return this.appMutexes[appName];
+  }
+  async bootStrapApp(appName, options = {}) {
+    await this.getMutexOfApp(appName).runExclusive(async () => {
+      if (!this.hasApp(appName)) {
+        if (!this.getAppStatus(appName)) {
+          this.setAppStatus(appName, "initializing");
+        }
+        if (this.appBootstrapper) {
+          await this.appBootstrapper({
+            appSupervisor: this,
+            appName,
+            options
+          });
+        }
+        if (!this.hasApp(appName)) {
+          this.setAppStatus(appName, "not_found", {
+            error: new Error(`app ${appName} not found`)
+          });
+        } else if (!this.getAppStatus(appName) || this.getAppStatus(appName) === "initializing") {
+          this.setAppStatus(appName, "initialized");
+        }
+      }
+    });
+  }
+  async getApp(appName, options = {}) {
+    if (!options.withOutBootStrap) {
+      if (!this.blockApps.has(appName)) {
+        await this.bootStrapApp(appName, options);
+      }
+    }
+    return this.apps[appName];
+  }
+  setAppBootstrapper(appBootstrapper) {
+    this.appBootstrapper = appBootstrapper;
+  }
+  getAppStatus(appName, defaultStatus) {
+    const status = this.appStatus[appName];
+    if (status === void 0 && defaultStatus !== void 0) {
+      return defaultStatus;
+    }
+    return status;
+  }
+  bootMainApp(options) {
+    return new import_application.default(options);
+  }
+  hasApp(appName) {
+    return !!this.apps[appName];
+  }
+  // add app into supervisor
+  addApp(app) {
+    if (this.blockApps.has(app.name)) {
+      return;
+    }
+    if (this.apps[app.name]) {
+      throw new Error(`app ${app.name} already exists`);
+    }
+    app.logger.info(`add app ${app.name} into supervisor`, { submodule: "supervisor", method: "addApp" });
+    this.bindAppEvents(app);
+    this.apps[app.name] = app;
+    this.emit("afterAppAdded", app);
+    if (!this.getAppStatus(app.name) || this.getAppStatus(app.name) === "not_found") {
+      this.setAppStatus(app.name, "initialized");
+    }
+    return app;
+  }
+  // get registered app names
+  async getAppsNames() {
+    const apps = Object.values(this.apps);
+    return apps.map((app) => app.name);
+  }
+  async removeApp(appName) {
+    if (!this.apps[appName]) {
+      console.log(`app ${appName} not exists`);
+      return;
+    }
+    await this.apps[appName].runCommand("destroy");
+  }
+  subApps() {
+    return Object.values(this.apps).filter((app) => app.name !== "main");
+  }
+  on(eventName, listener) {
+    const listeners = this.listeners(eventName);
+    const listenerName = listener.name;
+    if (listenerName !== "") {
+      const exists = listeners.find((l) => l.name === listenerName);
+      if (exists) {
+        super.removeListener(eventName, exists);
+      }
+    }
+    return super.on(eventName, listener);
+  }
+  bindAppEvents(app) {
+    app.on("afterDestroy", () => {
+      delete this.apps[app.name];
+      delete this.appStatus[app.name];
+      delete this.appErrors[app.name];
+      delete this.lastMaintainingMessage[app.name];
+      delete this.statusBeforeCommanding[app.name];
+      this.lastSeenAt.delete(app.name);
+    });
+    app.on("maintainingMessageChanged", ({ message, maintainingStatus }) => {
+      if (this.lastMaintainingMessage[app.name] === message) {
+        return;
+      }
+      this.lastMaintainingMessage[app.name] = message;
+      const appStatus = this.getAppStatus(app.name);
+      if (!maintainingStatus && appStatus !== "running") {
+        return;
+      }
+      this.emit("appMaintainingMessageChanged", {
+        appName: app.name,
+        message,
+        status: appStatus,
+        command: appStatus === "running" ? null : maintainingStatus.command
+      });
+    });
+    app.on("__started", async (_app, options) => {
+      const { maintainingStatus, options: startOptions } = options;
+      if (maintainingStatus && [
+        "install",
+        "upgrade",
+        "refresh",
+        "restore",
+        "pm.add",
+        "pm.update",
+        "pm.enable",
+        "pm.disable",
+        "pm.remove"
+      ].includes(maintainingStatus.command.name) && !startOptions.recover) {
+        this.setAppStatus(app.name, "running", {
+          refresh: true
+        });
+      } else {
+        this.setAppStatus(app.name, "running");
+      }
+    });
+    app.on("afterStop", async () => {
+      this.setAppStatus(app.name, "stopped");
+    });
+    app.on("maintaining", (maintainingStatus) => {
+      const { status, command } = maintainingStatus;
+      switch (status) {
+        case "command_begin":
+          {
+            this.statusBeforeCommanding[app.name] = this.getAppStatus(app.name);
+            this.setAppStatus(app.name, "commanding");
+          }
+          break;
+        case "command_running":
+          break;
+        case "command_end":
+          {
+            const appStatus = this.getAppStatus(app.name);
+            this.emit("appMaintainingStatusChanged", maintainingStatus);
+            if (appStatus === "commanding") {
+              this.setAppStatus(app.name, this.statusBeforeCommanding[app.name]);
+            }
+          }
+          break;
+        case "command_error":
+          {
+            const errorLevel = (0, import_handler.getErrorLevel)(maintainingStatus.error);
+            if (errorLevel === "fatal") {
+              this.setAppError(app.name, maintainingStatus.error);
+              this.setAppStatus(app.name, "error", {
+                error: maintainingStatus.error
+              });
+              break;
+            }
+            if (errorLevel === "warn") {
+              this.emit("appError", {
+                appName: app.name,
+                error: maintainingStatus.error
+              });
+            }
+            this.setAppStatus(app.name, this.statusBeforeCommanding[app.name]);
+          }
+          break;
+      }
+    });
+  }
+};
+__name(_AppSupervisor, "AppSupervisor");
+let AppSupervisor = _AppSupervisor;
+(0, import_utils.applyMixins)(AppSupervisor, [import_utils.AsyncEmitter]);
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  AppSupervisor
+});

package/lib/application.d.ts

@@ -0,0 +1,354 @@
+import { IncomingMessage, ServerResponse } from 'node:http';
+import { RecordableHistogram } from 'node:perf_hooks';
+import { AuthManager, AuthManagerOptions } from '@tachybase/auth';
+import { Cache, CacheManager, CacheManagerOptions } from '@tachybase/cache';
+import { DataSourceManager, SequelizeDataSource } from '@tachybase/data-source';
+import Database, { CollectionOptions, IDatabaseOptions } from '@tachybase/database';
+import { ContainerInstance } from '@tachybase/di';
+import { LoggerOptions, RequestLoggerOptions, SystemLogger, SystemLoggerOptions } from '@tachybase/logger';
+import { ResourceOptions, Resourcer } from '@tachybase/resourcer';
+import { AsyncEmitter, Constructable, ToposortOptions } from '@tachybase/utils';
+import { Command, CommandOptions, ParseOptions } from 'commander';
+import { i18n, InitOptions } from 'i18next';
+import Koa, { DefaultContext as KoaDefaultContext, DefaultState as KoaDefaultState } from 'koa';
+import WebSocket from 'ws';
+import AesEncryptor from './aes-encryptor';
+import { AppCommand } from './app-command';
+import { AppSupervisor } from './app-supervisor';
+import { CronJobManager } from './cron/cron-job-manager';
+import { Environment } from './environment';
+import { ApplicationVersion } from './helpers/application-version';
+import { Locale } from './locale';
+import { NoticeManager } from './notice';
+import { Plugin } from './plugin';
+import { InstallOptions, PluginManager } from './plugin-manager';
+import { PubSubManager, PubSubManagerOptions } from './pub-sub-manager';
+import { SyncMessageManager } from './sync-message-manager';
+type WSEventType = 'close' | 'error' | 'message' | 'connection';
+type WSEventHandler = (ws: WebSocket & {
+    id: string;
+}, ...args: any[]) => Promise<void> | void;
+export { Logger } from 'winston';
+export type PluginType = string | typeof Plugin;
+export type PluginConfiguration = PluginType | [PluginType, any];
+declare module '@tachybase/resourcer' {
+    interface ResourcerContext {
+        app?: Application;
+    }
+}
+export interface ResourcerOptions {
+    prefix?: string;
+}
+export interface AppLoggerOptions {
+    request: RequestLoggerOptions;
+    system: SystemLoggerOptions;
+}
+export interface ApplicationOptions {
+    database?: IDatabaseOptions | Database;
+    cacheManager?: CacheManagerOptions;
+    resourcer?: ResourcerOptions;
+    pubSubManager?: PubSubManagerOptions;
+    syncMessageManager?: any;
+    bodyParser?: any;
+    cors?: any;
+    dataWrapping?: boolean;
+    registerActions?: boolean;
+    i18n?: i18n | InitOptions;
+    plugins?: PluginConfiguration[];
+    acl?: boolean;
+    logger?: AppLoggerOptions;
+    pmSock?: string;
+    name?: string;
+    authManager?: AuthManagerOptions;
+    perfHooks?: boolean;
+    tmpl?: any;
+}
+export interface DefaultState extends KoaDefaultState {
+    currentUser?: any;
+    [key: string]: any;
+}
+export interface DefaultContext extends KoaDefaultContext {
+    db: Database;
+    cache: Cache;
+    resourcer: Resourcer;
+    i18n: any;
+    [key: string]: any;
+}
+interface ActionsOptions {
+    resourceName?: string;
+    resourceNames?: string[];
+}
+interface StartOptions {
+    cliArgs?: any[];
+    dbSync?: boolean;
+    checkInstall?: boolean;
+    quickstart?: boolean;
+    reload?: boolean;
+    recover?: boolean;
+}
+type MaintainingStatus = 'command_begin' | 'command_end' | 'command_running' | 'command_error';
+export type MaintainingCommandStatus = {
+    command: {
+        name: string;
+    };
+    status: MaintainingStatus;
+    error?: Error;
+};
+export declare class Application<StateT = DefaultState, ContextT = DefaultContext> extends Koa implements AsyncEmitter {
+    options: ApplicationOptions;
+    /**
+     * @internal
+     */
+    middleware: any;
+    /**
+     * @internal
+     */
+    stopped: boolean;
+    /**
+     * @internal
+     */
+    ready: boolean;
+    emitAsync: (event: string | symbol, ...args: any[]) => Promise<boolean>;
+    /**
+     * @internal
+     */
+    rawOptions: ApplicationOptions;
+    /**
+     * @internal
+     */
+    activatedCommand: {
+        name: string;
+    };
+    /**
+     * @internal
+     */
+    running: boolean;
+    /**
+     * @internal
+     */
+    perfHistograms: Map<string, RecordableHistogram>;
+    /**
+     * @internal
+     */
+    pubSubManager: PubSubManager;
+    syncMessageManager: SyncMessageManager;
+    protected plugins: Map<string, Plugin>;
+    protected _appSupervisor: AppSupervisor;
+    protected _started: boolean;
+    protected _logger: SystemLogger;
+    private _authenticated;
+    private _maintaining;
+    private _maintainingCommandStatus;
+    private _maintainingStatusBeforeCommand;
+    private _actionCommand;
+    private _noticeManager;
+    static KEY_CORE_APP_PREFIX: string;
+    private currentId;
+    container: ContainerInstance;
+    modules: Record<string, any>;
+    middlewareSourceMap: WeakMap<Function, string>;
+    private wsEventHandlers;
+    constructor(options: ApplicationOptions);
+    get noticeManager(): NoticeManager;
+    protected _loaded: boolean;
+    /**
+     * @internal
+     */
+    get loaded(): boolean;
+    private _maintainingMessage;
+    /**
+     * @internal
+     */
+    get maintainingMessage(): string;
+    private _env;
+    get environment(): Environment;
+    protected _aesEncryptor: AesEncryptor;
+    get aesEncryptor(): AesEncryptor;
+    protected _cronJobManager: CronJobManager;
+    get cronJobManager(): CronJobManager;
+    get mainDataSource(): SequelizeDataSource;
+    get db(): Database;
+    get logger(): SystemLogger;
+    get resourcer(): import("@tachybase/data-source").ResourceManager;
+    protected _cacheManager: CacheManager;
+    get cacheManager(): CacheManager;
+    protected _cache: Cache;
+    get cache(): Cache;
+    /**
+     * @internal
+     */
+    set cache(cache: Cache);
+    protected _cli: AppCommand;
+    get cli(): AppCommand;
+    protected _i18n: i18n;
+    get i18n(): i18n;
+    protected _pm: PluginManager;
+    get pm(): PluginManager;
+    get acl(): import("packages/acl/lib").ACL;
+    protected _authManager: AuthManager;
+    get authManager(): AuthManager;
+    protected _locales: Locale;
+    /**
+     * This method is deprecated and should not be used.
+     * Use {@link #localeManager} instead.
+     * @deprecated
+     */
+    get locales(): Locale;
+    get localeManager(): Locale;
+    protected _version: ApplicationVersion;
+    get version(): ApplicationVersion;
+    /**
+     * Use {@link logger}
+     * @deprecated
+     */
+    get log(): SystemLogger;
+    get name(): string;
+    protected _dataSourceManager: DataSourceManager;
+    get dataSourceManager(): DataSourceManager;
+    /**
+     * @internal
+     */
+    getMaintaining(): MaintainingCommandStatus;
+    /**
+     * @internal
+     */
+    setMaintaining(_maintainingCommandStatus: MaintainingCommandStatus): void;
+    /**
+     * @internal
+     */
+    setMaintainingMessage(message: string): void;
+    /**
+     * This method is deprecated and should not be used.
+     * Use {@link #this.version.get()} instead.
+     * @deprecated
+     */
+    getVersion(): string;
+    use<NewStateT = {}, NewContextT = {}>(middleware: Koa.Middleware<StateT & NewStateT, ContextT & NewContextT>, options?: ToposortOptions): this;
+    /**
+     * @internal
+     */
+    callback(): (req: IncomingMessage, res: ServerResponse) => any;
+    /**
+     * This method is deprecated and should not be used.
+     * Use {@link #this.db.collection()} instead.
+     * @deprecated
+     */
+    collection(options: CollectionOptions): import("@tachybase/database").Collection<any, any>;
+    /**
+     * This method is deprecated and should not be used.
+     * Use {@link #this.resourcer.define()} instead.
+     * @deprecated
+     */
+    resource(options: ResourceOptions): import("@tachybase/resourcer").Resource;
+    /**
+     * This method is deprecated and should not be used.
+     * Use {@link #this.resourcer.registerActions()} instead.
+     * @deprecated
+     */
+    actions(handlers: any, options?: ActionsOptions): void;
+    command(name: string, desc?: string, opts?: CommandOptions): AppCommand;
+    findCommand(name: string): Command;
+    /**
+     * @internal
+     */
+    reInit(): Promise<void>;
+    load(options?: any): Promise<void>;
+    reload(options?: any): Promise<void>;
+    /**
+     * This method is deprecated and should not be used.
+     * Use {@link this.pm.get()} instead.
+     * @deprecated
+     */
+    getPlugin<P extends Plugin>(name: string | Constructable<P>): P;
+    /**
+     * This method is deprecated and should not be used.
+     * Use {@link this.runAsCLI()} instead.
+     * @deprecated
+     */
+    parse(argv?: string[]): Promise<AppCommand>;
+    authenticate(): Promise<void>;
+    runCommand(command: string, ...args: any[]): Promise<AppCommand>;
+    runCommandThrowError(command: string, ...args: any[]): Promise<AppCommand>;
+    protected createCLI(): AppCommand;
+    /**
+     * @internal
+     */
+    loadMigrations(options: any): Promise<{
+        beforeLoad: any[];
+        afterSync: any[];
+        afterLoad: any[];
+    }>;
+    /**
+     * @internal
+     */
+    loadCoreMigrations(): Promise<{
+        beforeLoad: {
+            up: () => Promise<void>;
+        };
+        afterSync: {
+            up: () => Promise<void>;
+        };
+        afterLoad: {
+            up: () => Promise<void>;
+        };
+    }>;
+    /**
+     * @internal
+     */
+    loadPluginCommands(): Promise<void>;
+    /**
+     * @internal
+     */
+    runAsCLI(argv?: string[], options?: ParseOptions & {
+        throwError?: boolean;
+        reqId?: string;
+    }): Promise<AppCommand>;
+    start(options?: StartOptions): Promise<void>;
+    /**
+     * @internal
+     */
+    emitStartedEvent(options?: StartOptions): Promise<void>;
+    isStarted(): Promise<boolean>;
+    /**
+     * @internal
+     */
+    tryReloadOrRestart(options?: StartOptions): Promise<void>;
+    restart(options?: StartOptions): Promise<void>;
+    stop(options?: any): Promise<void>;
+    destroy(options?: any): Promise<void>;
+    isInstalled(): Promise<boolean>;
+    install(options?: InstallOptions): Promise<void>;
+    upgrade(options?: any): Promise<void>;
+    toJSON(): {
+        appName: string;
+        name: string;
+    };
+    /**
+     * @internal
+     */
+    reInitEvents(): void;
+    createLogger(options: LoggerOptions): import("winston").Logger;
+    protected init(): void;
+    protected createMainDataSource(options: ApplicationOptions): void;
+    protected createDatabase(options: ApplicationOptions): Database;
+    /**
+     * 初始化 WebSocket 事件处理
+     * 注册应用级别的事件，用于与 WSServer 通信
+     */
+    private initWSEventHandlers;
+    /**
+     * 为 WebSocket 事件注册处理函数
+     * 这是一个适配器方法，将事件处理函数注册到 Gateway 的 WSServer
+     * @param eventType 事件类型
+     * @param handler 事件处理函数
+     */
+    registerWSEventHandler(eventType: WSEventType, handler: WSEventHandler): this;
+    /**
+     * 移除 WebSocket 事件处理函数
+     * @param eventType 事件类型
+     * @param handler 事件处理函数
+     */
+    removeWSEventHandler(eventType: WSEventType, handler: WSEventHandler): this;
+    [key: string]: any;
+}
+export default Application;