@tachybase/module-multi-app 0.23.8

package/dist/server/migrations/20241126124904-add-createdBy.js

@@ -0,0 +1,41 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+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 add_createdBy_exports = {};
+__export(add_createdBy_exports, {
+  default: () => add_createdBy_default
+});
+module.exports = __toCommonJS(add_createdBy_exports);
+var import_server = require("@tachybase/server");
+class add_createdBy_default extends import_server.Migration {
+  on = "afterLoad";
+  // 'beforeLoad' or 'afterLoad'
+  appVersion = "<0.22.47";
+  async up() {
+    const userRepo = this.context.db.getRepository("users");
+    const appRepo = this.context.db.getRepository("applications");
+    const rootUser = await userRepo.findOne({ filter: { specialRole: "root" }, raw: true });
+    const { id } = rootUser;
+    const result = await appRepo.update({
+      filter: {
+        createdById: null
+      },
+      values: { createdById: id, updateById: id }
+    });
+    console.log("[applications] add createdBy", result.length, "rows");
+  }
+}

package/dist/server/models/application.d.ts

@@ -0,0 +1,10 @@
+import { Model, Transactionable } from '@tachybase/database';
+import { Application } from '@tachybase/server';
+import { AppOptionsFactory } from '../server';
+export interface registerAppOptions extends Transactionable {
+    skipInstall?: boolean;
+    appOptionsFactory: AppOptionsFactory;
+}
+export declare class ApplicationModel extends Model {
+    registerToSupervisor(mainApp: Application, options: registerAppOptions): Application<import("@tachybase/server").DefaultState, import("@tachybase/server").DefaultContext>;
+}

package/dist/server/models/application.js

@@ -0,0 +1,57 @@
+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 __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 application_exports = {};
+__export(application_exports, {
+  ApplicationModel: () => ApplicationModel
+});
+module.exports = __toCommonJS(application_exports);
+var import_database = require("@tachybase/database");
+var import_server = require("@tachybase/server");
+var import_utils = require("@tachybase/utils");
+var import_app_start_env = __toESM(require("../app-start-env"));
+class ApplicationModel extends import_database.Model {
+  registerToSupervisor(mainApp, options) {
+    const appName = this.get("name");
+    const preset = this.get("preset");
+    const tmpl = this.get("tmpl");
+    const appModelOptions = this.get("options") || {};
+    const startEnvs = appModelOptions.startEnvs || {};
+    let appOptions = options.appOptionsFactory(appName, mainApp, preset);
+    appOptions = (0, import_app_start_env.default)(appName, mainApp, appOptions, startEnvs);
+    const subAppOptions = {
+      ...(0, import_utils.merge)(appOptions, appModelOptions),
+      name: appName,
+      tmpl
+    };
+    return new import_server.Application(subAppOptions);
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  ApplicationModel
+});

package/dist/server/server.d.ts

@@ -0,0 +1,19 @@
+import { IDatabaseOptions, Transactionable } from '@tachybase/database';
+import Application, { Plugin } from '@tachybase/server';
+import { AppOptionsFactory } from './app-lifecycle';
+export type AppDbCreator = (app: Application, options?: Transactionable & {
+    context?: any;
+}) => Promise<void>;
+export type { AppOptionsFactory };
+export type SubAppUpgradeHandler = (mainApp: Application) => Promise<void>;
+export declare class PluginMultiAppManager extends Plugin {
+    appDbCreator: AppDbCreator;
+    appOptionsFactory: AppOptionsFactory;
+    subAppUpgradeHandler: SubAppUpgradeHandler;
+    static getDatabaseConfig(app: Application): IDatabaseOptions;
+    setSubAppUpgradeHandler(handler: SubAppUpgradeHandler): void;
+    setAppOptionsFactory(factory: AppOptionsFactory): void;
+    setAppDbCreator(appDbCreator: AppDbCreator): void;
+    beforeLoad(): void;
+    load(): Promise<void>;
+}

package/dist/server/server.js

@@ -0,0 +1,246 @@
+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 __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 server_exports = {};
+__export(server_exports, {
+  PluginMultiAppManager: () => PluginMultiAppManager
+});
+module.exports = __toCommonJS(server_exports);
+var import_path = __toESM(require("path"));
+var import_database = require("@tachybase/database");
+var import_server = require("@tachybase/server");
+var import_lodash = __toESM(require("lodash"));
+var import_server2 = require("../server");
+var actions = __toESM(require("./actions/apps"));
+var import_app_lifecycle = require("./app-lifecycle");
+var import_middlewares = require("./middlewares");
+const defaultSubAppUpgradeHandle = async (mainApp) => {
+  const repository = mainApp.db.getRepository("applications");
+  const findOptions = {};
+  const appSupervisor = import_server.AppSupervisor.getInstance();
+  if (appSupervisor.runningMode === "single") {
+    findOptions["filter"] = {
+      name: appSupervisor.singleAppName
+    };
+  }
+  const instances = await repository.find(findOptions);
+  for (const instance of instances) {
+    const instanceOptions = instance.get("options");
+    if ((instanceOptions == null ? void 0 : instanceOptions.standaloneDeployment) && appSupervisor.runningMode !== "single") {
+      continue;
+    }
+    const beforeSubAppStatus = import_server.AppSupervisor.getInstance().getAppStatus(instance.name);
+    const subApp = await appSupervisor.getApp(instance.name, {
+      upgrading: true
+    });
+    console.log({ beforeSubAppStatus });
+    try {
+      mainApp.setMaintainingMessage(`upgrading sub app ${instance.name}...`);
+      console.log(`${instance.name}: upgrading...`);
+      await subApp.runAsCLI(["upgrade"], { from: "user" });
+      if (!beforeSubAppStatus && import_server.AppSupervisor.getInstance().getAppStatus(instance.name) === "initialized") {
+        await import_server.AppSupervisor.getInstance().removeApp(instance.name);
+      }
+    } catch (error) {
+      console.log(`${instance.name}: upgrade failed`);
+      mainApp.logger.error(error);
+      console.error(error);
+    }
+  }
+};
+const defaultDbCreator = async (app) => {
+  var _a;
+  const databaseOptions = app.options.database;
+  const { host, port, username, password, dialect, database } = databaseOptions;
+  const tmpl = (_a = app.options) == null ? void 0 : _a.tmpl;
+  if (dialect === "mysql") {
+    const mysql = require("mysql2/promise");
+    const connection = await mysql.createConnection({ host, port, user: username, password });
+    await connection.query(`CREATE DATABASE IF NOT EXISTS \`${database}\`;`);
+    await connection.close();
+  }
+  if (dialect === "mariadb") {
+    const mariadb = require("mariadb");
+    const connection = await mariadb.createConnection({ host, port, user: username, password });
+    await connection.query(`CREATE DATABASE IF NOT EXISTS \`${database}\`;`);
+    await connection.end();
+  }
+  if (dialect === "postgres") {
+    const { Client } = require("pg");
+    const client = new Client({
+      host,
+      port,
+      user: username,
+      password,
+      database: "postgres"
+    });
+    await client.connect();
+    try {
+      if (tmpl) {
+        app.logger.info(`create new app db ${database} with tmpl db ${tmpl}...`);
+        const tmplExists = await client.query(`SELECT 1 FROM pg_database WHERE datname='${tmpl}'`);
+        if (tmplExists.rows.length === 0) {
+          const errMsg = `template database ${tmpl} not exists.`;
+          app.logger.error(errMsg);
+          import_server.AppSupervisor.getInstance().setAppError(database, new Error(errMsg));
+        } else {
+          const result = await client.query(`SELECT datistemplate FROM pg_database WHERE datname='${tmpl}'`);
+          const tmplDbIsTmpl = result.rows.length > 0 && result.rows[0].datistemplate;
+          if (!tmplDbIsTmpl) await client.query(`ALTER DATABASE "${tmpl}" IS_TEMPLATE true`);
+          await client.query(`ALTER DATABASE "${tmpl}" ALLOW_CONNECTIONS false`);
+          let tmplDbInUse = true;
+          do {
+            const tmp = await client.query(
+              `SELECT pg_terminate_backend(pid) FROM pg_stat_activity WHERE datname='${tmpl}' AND pid<>pg_backend_pid()`
+            );
+            tmplDbInUse = tmp.rows.length > 0;
+          } while (tmplDbInUse);
+          await client.query(`CREATE DATABASE "${database}" WITH TEMPLATE "${tmpl}"`);
+          if (!tmplDbIsTmpl) await client.query(`ALTER DATABASE "${tmpl}" IS_TEMPLATE false`);
+          await client.query(`ALTER DATABASE "${tmpl}" ALLOW_CONNECTIONS true`);
+        }
+      } else {
+        await client.query(`CREATE DATABASE "${database}"`);
+      }
+    } catch (e) {
+      app.logger.error(JSON.stringify(e));
+      import_server.AppSupervisor.getInstance().setAppError(database, e);
+    }
+    await client.end();
+  }
+};
+const defaultAppOptionsFactory = (appName, mainApp, preset) => {
+  const rawDatabaseOptions = PluginMultiAppManager.getDatabaseConfig(mainApp);
+  if (rawDatabaseOptions.dialect === "sqlite") {
+    const mainAppStorage = rawDatabaseOptions.storage;
+    if (mainAppStorage !== ":memory:") {
+      const mainStorageDir = import_path.default.dirname(mainAppStorage);
+      rawDatabaseOptions.storage = import_path.default.join(mainStorageDir, `${appName}.sqlite`);
+    }
+  } else {
+    rawDatabaseOptions.database = appName;
+  }
+  return {
+    database: {
+      ...rawDatabaseOptions,
+      tablePrefix: ""
+    },
+    plugins: [preset],
+    resourcer: {
+      prefix: process.env.API_BASE_PATH
+    }
+  };
+};
+class PluginMultiAppManager extends import_server.Plugin {
+  appDbCreator = defaultDbCreator;
+  appOptionsFactory = defaultAppOptionsFactory;
+  subAppUpgradeHandler = defaultSubAppUpgradeHandle;
+  static getDatabaseConfig(app) {
+    let oldConfig = app.options.database instanceof import_database.Database ? app.options.database.options : app.options.database;
+    if (!oldConfig && app.db) {
+      oldConfig = app.db.options;
+    }
+    return import_lodash.default.cloneDeep(import_lodash.default.omit(oldConfig, ["migrator"]));
+  }
+  setSubAppUpgradeHandler(handler) {
+    this.subAppUpgradeHandler = handler;
+  }
+  setAppOptionsFactory(factory) {
+    this.appOptionsFactory = factory;
+  }
+  setAppDbCreator(appDbCreator) {
+    this.appDbCreator = appDbCreator;
+  }
+  beforeLoad() {
+    this.db.registerModels({
+      ApplicationModel: import_server2.ApplicationModel
+    });
+  }
+  async load() {
+    this.db.on(
+      "applications.afterCreateWithAssociations",
+      async (model, options) => {
+        var _a;
+        const { transaction } = options;
+        const subApp = model.registerToSupervisor(this.app, {
+          appOptionsFactory: this.appOptionsFactory
+        });
+        await this.appDbCreator(subApp, {
+          transaction,
+          context: options.context
+        });
+        if (options.values.options.autoStart) {
+          const startPromise = subApp.runCommand("start", "--quickstart");
+          if ((_a = options == null ? void 0 : options.context) == null ? void 0 : _a.waitSubAppInstall) {
+            await startPromise;
+          }
+        }
+      }
+    );
+    this.db.on("applications.afterDestroy", async (model) => {
+      await import_server.AppSupervisor.getInstance().removeApp(model.get("name"));
+    });
+    const self = this;
+    import_server.AppSupervisor.getInstance().setAppBootstrapper((0, import_app_lifecycle.LazyLoadApplication)(self));
+    import_server.Gateway.getInstance().addAppSelectorMiddleware((0, import_middlewares.appSelectorMiddleware)(this.app));
+    this.app.on("afterStart", (0, import_app_lifecycle.onAfterStart)(this.db));
+    this.app.on("afterUpgrade", async (app, options) => {
+      await this.subAppUpgradeHandler(app);
+    });
+    this.app.acl.allow("applications", "listPinned", "loggedIn");
+    this.app.acl.allow("applications", "list", "loggedIn");
+    this.app.acl.registerSnippet({
+      name: `pm.${this.name}.applications`,
+      actions: ["applications:*"]
+    });
+    this.app.acl.addFixedParams("applications", "destroy", () => {
+      return {
+        filter: {
+          isTemplate: false
+        }
+      };
+    });
+    const injectAppList = (0, import_middlewares.injectAppListMiddleware)();
+    this.app.use(
+      async (ctx, next) => {
+        try {
+          await injectAppList(ctx, next);
+        } catch (error) {
+          ctx.logger.error(error);
+        }
+      },
+      { tag: "error-handling" }
+    );
+    for (const [key, action] of Object.entries(actions)) {
+      this.app.resourcer.registerActionHandler(`applications:${key}`, action);
+    }
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  PluginMultiAppManager
+});

package/dist/swagger/index.d.ts

@@ -0,0 +1,197 @@
+declare const _default: {
+    info: {
+        title: string;
+    };
+    tags: any[];
+    paths: {
+        '/applications:list': {
+            get: {
+                tags: string[];
+                description: string;
+                responses: {
+                    200: {
+                        description: string;
+                        content: {
+                            'application/json': {
+                                schema: {
+                                    $ref: string;
+                                };
+                            };
+                        };
+                    };
+                };
+            };
+        };
+        '/applications:create': {
+            post: {
+                tags: string[];
+                description: string;
+                requestBody: {
+                    required: boolean;
+                    content: {
+                        'application/json': {
+                            schema: {
+                                $ref: string;
+                            };
+                        };
+                    };
+                };
+                responses: {
+                    200: {
+                        description: string;
+                        content: {
+                            'application/json': {
+                                schema: {
+                                    $ref: string;
+                                };
+                            };
+                        };
+                    };
+                };
+            };
+        };
+        '/applications:update': {
+            post: {
+                tags: string[];
+                description: string;
+                parameters: {
+                    name: string;
+                    in: string;
+                    description: string;
+                    required: boolean;
+                    schema: {
+                        type: string;
+                    };
+                }[];
+                requestBody: {
+                    required: boolean;
+                    content: {
+                        'application/json': {
+                            schema: {
+                                $ref: string;
+                            };
+                        };
+                    };
+                };
+                responses: {
+                    200: {
+                        description: string;
+                        content: {
+                            'application/json': {
+                                schema: {
+                                    $ref: string;
+                                };
+                            };
+                        };
+                    };
+                };
+            };
+        };
+        '/applications:destroy': {
+            post: {
+                tags: string[];
+                description: string;
+                parameters: {
+                    name: string;
+                    in: string;
+                    description: string;
+                    required: boolean;
+                    schema: {
+                        type: string;
+                    };
+                }[];
+                responses: {
+                    200: {
+                        description: string;
+                    };
+                };
+            };
+        };
+    };
+    components: {
+        schemas: {
+            applicationFrom: {
+                allOf: ({
+                    $ref: string;
+                    type?: undefined;
+                    properties?: undefined;
+                } | {
+                    type: string;
+                    properties: {
+                        createdAt: {
+                            readOnly: boolean;
+                        };
+                        updatedAt: {
+                            readOnly: boolean;
+                        };
+                        status: {
+                            readOnly: boolean;
+                        };
+                    };
+                    $ref?: undefined;
+                })[];
+            };
+            application: {
+                type: string;
+                properties: {
+                    name: {
+                        type: string;
+                        example: string;
+                        description: string;
+                    };
+                    displayName: {
+                        type: string;
+                        example: string;
+                        description: string;
+                    };
+                    pinned: {
+                        type: string;
+                        example: boolean;
+                        description: string;
+                    };
+                    cname: {
+                        type: string;
+                        example: string;
+                        description: string;
+                    };
+                    status: {
+                        type: string;
+                        example: string;
+                        description: string;
+                    };
+                    options: {
+                        type: string;
+                        properties: {
+                            autoStart: {
+                                type: string;
+                                example: boolean;
+                                description: string;
+                            };
+                            startEnvs: {
+                                type: string;
+                                example: string;
+                                description: string;
+                            };
+                        };
+                    };
+                    tmpl: {
+                        type: string;
+                        example: string;
+                        description: string;
+                    };
+                    createdAt: {
+                        type: string;
+                        format: string;
+                        description: string;
+                    };
+                    updatedAt: {
+                        type: string;
+                        format: string;
+                        description: string;
+                    };
+                };
+            };
+        };
+    };
+};
+export default _default;