@tachybase/module-multi-app 0.23.8

package/dist/server/actions/apps.d.ts

@@ -0,0 +1,5 @@
+import { Context, Next } from '@tachybase/actions';
+export declare function start(ctx: Context, next: Next): Promise<void>;
+export declare function stop(ctx: Context, next: Next): Promise<void>;
+export declare function listPinned(ctx: Context, next: Next): Promise<void>;
+export declare function create(ctx: Context, next: Next): Promise<void>;

package/dist/server/actions/apps.js

@@ -0,0 +1,117 @@
+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 apps_exports = {};
+__export(apps_exports, {
+  create: () => create,
+  listPinned: () => listPinned,
+  start: () => start,
+  stop: () => stop
+});
+module.exports = __toCommonJS(apps_exports);
+var import_server = require("@tachybase/server");
+var import_constants = require("../../constants");
+async function start(ctx, next) {
+  const targetAppId = String(ctx.request.url.split("filterByTk=")[1]);
+  const appSupervisor = import_server.AppSupervisor.getInstance();
+  if (!appSupervisor.hasApp(targetAppId)) {
+    appSupervisor.blockApps.delete(targetAppId);
+    await import_server.AppSupervisor.getInstance().getApp(targetAppId);
+    ctx.body = "ok";
+    await next();
+  } else {
+    ctx.throw(400, ctx.t("App already started", { ns: import_constants.NAMESPACE }));
+  }
+}
+async function stop(ctx, next) {
+  const targetAppId = String(ctx.request.url.split("filterByTk=")[1]);
+  const appSupervisor = import_server.AppSupervisor.getInstance();
+  if (appSupervisor.hasApp(targetAppId)) {
+    appSupervisor.blockApps.add(targetAppId);
+    await appSupervisor.removeApp(targetAppId);
+    ctx.body = "ok";
+    await next();
+  } else {
+    ctx.throw(400, ctx.t("App already stopped", { ns: import_constants.NAMESPACE }));
+  }
+}
+async function listPinned(ctx, next) {
+  const items = await ctx.db.getRepository("applications").find({
+    filter: {
+      pinned: true
+    }
+  });
+  ctx.body = items;
+  await next();
+}
+async function create(ctx, next) {
+  var _a, _b, _c;
+  const params = ctx.action.params;
+  const tmpl = (_a = params.values) == null ? void 0 : _a.tmpl;
+  if (tmpl) {
+    const startEnvs = (_c = (_b = params.values) == null ? void 0 : _b.options) == null ? void 0 : _c.startEnvs;
+    if (startEnvs) {
+      const dbDialect = startEnvs.split("\n").find((line) => line.startsWith("DB_DIALECT="));
+      if (dbDialect) {
+        const dbType2 = dbDialect.split("=")[1].trim();
+        if (dbType2 !== "postgres") {
+          ctx.throw(
+            400,
+            ctx.t("This database does not support to create application using template", { ns: import_constants.NAMESPACE })
+          );
+        }
+      }
+    }
+    const dbType = ctx.db.options.dialect;
+    if (dbType !== "postgres") {
+      ctx.throw(400, ctx.t("This database does not support to create application using template", { ns: import_constants.NAMESPACE }));
+    }
+    const matchedApp = await ctx.db.getRepository("applications").find({
+      filter: {
+        name: tmpl
+      }
+    });
+    if (matchedApp.length === 0) {
+      ctx.throw(400, ctx.t("Template not exists", { ns: import_constants.NAMESPACE }));
+    }
+    const appStatus = import_server.AppSupervisor.getInstance().getAppStatus(tmpl, "initialized");
+    if (appStatus !== "stopped" && appStatus !== "initialized") {
+      ctx.throw(400, ctx.t("Template is in use", { ns: import_constants.NAMESPACE }));
+    }
+  }
+  await ctx.db.getRepository("applications").create({
+    values: {
+      ...params.values,
+      createdBy: ctx.state.currentUser.id,
+      updatedBy: ctx.state.currentUser.id
+    }
+  });
+  const app = await ctx.db.getRepository("applications").find({
+    filter: {
+      name: ctx.request.body.name
+    }
+  });
+  ctx.body = app;
+  await next();
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  create,
+  listPinned,
+  start,
+  stop
+});

package/dist/server/app-lifecycle.d.ts

@@ -0,0 +1,8 @@
+import Application, { AppSupervisor } from '@tachybase/server';
+export type AppOptionsFactory = (appName: string, mainApp: Application, preset: string) => any;
+export declare function LazyLoadApplication(context: any): ({ appSupervisor, appName, options, }: {
+    appSupervisor: AppSupervisor;
+    appName: string;
+    options: any;
+}) => Promise<void>;
+export declare function onAfterStart(db: any): (app: Application) => Promise<void>;

package/dist/server/app-lifecycle.js

@@ -0,0 +1,99 @@
+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 app_lifecycle_exports = {};
+__export(app_lifecycle_exports, {
+  LazyLoadApplication: () => LazyLoadApplication,
+  onAfterStart: () => onAfterStart
+});
+module.exports = __toCommonJS(app_lifecycle_exports);
+var import_server = require("@tachybase/server");
+function LazyLoadApplication(context) {
+  return async ({
+    appSupervisor,
+    appName,
+    options
+  }) => {
+    const loadButNotStart = options == null ? void 0 : options.upgrading;
+    const name = appName;
+    if (appSupervisor.hasApp(name)) {
+      return;
+    }
+    const applicationRecord = await context.app.db.getRepository("applications").findOne({
+      filter: {
+        name
+      }
+    });
+    if (!applicationRecord) {
+      return;
+    }
+    const instanceOptions = applicationRecord.get("options");
+    if ((instanceOptions == null ? void 0 : instanceOptions.standaloneDeployment) && appSupervisor.runningMode !== "single") {
+      return;
+    }
+    if (!applicationRecord) {
+      return;
+    }
+    const subApp = applicationRecord.registerToSupervisor(context.app, {
+      appOptionsFactory: context.appOptionsFactory
+    });
+    if (!loadButNotStart) {
+      await subApp.runCommand("start", "--quickstart");
+    }
+  };
+}
+function onAfterStart(db) {
+  return async (app) => {
+    const repository = db.getRepository("applications");
+    const appSupervisor = import_server.AppSupervisor.getInstance();
+    app.setMaintainingMessage("starting sub applications...");
+    if (appSupervisor.runningMode == "single") {
+      import_server.Gateway.getInstance().addAppSelectorMiddleware((ctx) => ctx.resolvedAppName = appSupervisor.singleAppName);
+      try {
+        await import_server.AppSupervisor.getInstance().getApp(appSupervisor.singleAppName);
+      } catch (err) {
+        console.error("Auto register sub application in single mode failed: ", appSupervisor.singleAppName, err);
+      }
+      return;
+    }
+    try {
+      const subApps = await repository.find({
+        filter: {
+          "options.autoStart": true
+        }
+      });
+      const promises = [];
+      for (const subAppInstance of subApps) {
+        promises.push(
+          (async () => {
+            if (!appSupervisor.hasApp(subAppInstance.name)) {
+              await import_server.AppSupervisor.getInstance().getApp(subAppInstance.name);
+            }
+          })()
+        );
+      }
+      await Promise.all(promises);
+    } catch (err) {
+      console.error("Auto register sub applications failed: ", err);
+    }
+  };
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  LazyLoadApplication,
+  onAfterStart
+});

package/dist/server/app-start-env.d.ts

@@ -0,0 +1,2 @@
+import { Application } from '@tachybase/server';
+export default function mergeApplicationStartEnvs(appName: String, mainApp: Application, options: any, startEnvs: any): any;

package/dist/server/app-start-env.js

@@ -0,0 +1,105 @@
+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 app_start_env_exports = {};
+__export(app_start_env_exports, {
+  default: () => mergeApplicationStartEnvs
+});
+module.exports = __toCommonJS(app_start_env_exports);
+function mergeApplicationStartEnvs(appName, mainApp, options, startEnvs) {
+  if (typeof startEnvs === "string") {
+    const envs = startEnvs.trim().split("\n");
+    startEnvs = {};
+    for (const env of envs) {
+      const [key, value] = env.split("=");
+      startEnvs[key] = value;
+    }
+  }
+  if (startEnvs && Object.keys(startEnvs).length !== 0) {
+    if (startEnvs.APP_KEY) {
+      options = {
+        ...options,
+        authManager: {
+          jwt: {
+            secret: startEnvs.APP_KEY
+          }
+        }
+      };
+      delete startEnvs.APP_KEY;
+    }
+    if (startEnvs.API_BASE_PATH) {
+      options.resourcer.prefix = startEnvs.API_BASE_PATH;
+      delete startEnvs.API_BASE_PATH;
+    }
+    if (startEnvs.DB_DIALECT) {
+      options.database.dialect = startEnvs.DB_DIALECT;
+      delete startEnvs.DB_DIALECT;
+    }
+    if (startEnvs.DB_STORAGE) {
+      options.database.storage = startEnvs.DB_STORAGE;
+      delete startEnvs.DB_STORAGE;
+    }
+    if (startEnvs.DB_TABLE_PREFIX) {
+      options.database.tablePrefix = startEnvs.DB_TABLE_PREFIX;
+      delete startEnvs.DB_TABLE_PREFIX;
+    }
+    if (startEnvs.DB_HOST) {
+      options.database.host = startEnvs.DB_HOST;
+      delete startEnvs.DB_HOST;
+    }
+    if (startEnvs.DB_PORT) {
+      options.database.port = parseInt(startEnvs.DB_PORT);
+      delete startEnvs.DB_PORT;
+    }
+    if (startEnvs.DB_DATABASE) {
+      options.database.database = startEnvs.DB_DATABASE;
+      delete startEnvs.DB_DATABASE;
+    }
+    if (startEnvs.DB_USER) {
+      options.database.username = startEnvs.DB_USER;
+      delete startEnvs.DB_USER;
+    }
+    if (startEnvs.DB_PASSWORD) {
+      options.database.password = startEnvs.DB_PASSWORD;
+      delete startEnvs.DB_PASSWORD;
+    }
+    if (startEnvs.DB_UNDERSCORED) {
+      options.database.underscored = startEnvs.DB_UNDERSCORED === "true";
+      delete startEnvs.DB_UNDERSCORED;
+    }
+    if (startEnvs.DB_TIMEZONE) {
+      options.database.timezone = startEnvs.DB_TIMEZONE;
+      delete startEnvs.DB_TIMEZONE;
+    }
+    if (startEnvs.DB_SCHEMA) {
+      options.database.schema = startEnvs.DB_SCHEMA;
+      delete startEnvs.DB_SCHEMA;
+    }
+    if (startEnvs.CACHE_DEFAULT_STORE) {
+      options.cacheManager.defaultStore = startEnvs.CACHE_DEFAULT_STORE;
+      delete startEnvs.CACHE_DEFAULT_STORE;
+    }
+    if (startEnvs.CACHE_MEMORY_MAX) {
+      options.cacheManager.stores.memory.max = parseInt(startEnvs.CACHE_MEMORY_MAX);
+      delete startEnvs.CACHE_MEMORY_MAX;
+    }
+    if (Object.keys(startEnvs).length !== 0) {
+      mainApp.logger.warn(`Application ${appName} has unsupported startEnvs: ${JSON.stringify(startEnvs)}`);
+    }
+  }
+  return options;
+}

package/dist/server/collections/applications.d.ts

@@ -0,0 +1,2 @@
+declare const _default: import("@tachybase/database").CollectionOptions;
+export default _default;

package/dist/server/collections/applications.js

@@ -0,0 +1,82 @@
+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 applications_exports = {};
+__export(applications_exports, {
+  default: () => applications_default
+});
+module.exports = __toCommonJS(applications_exports);
+var import_database = require("@tachybase/database");
+var applications_default = (0, import_database.defineCollection)({
+  dumpRules: {
+    group: "third-party"
+  },
+  name: "applications",
+  model: "ApplicationModel",
+  autoGenId: false,
+  sortable: "sort",
+  filterTargetKey: "name",
+  createdBy: true,
+  updatedBy: true,
+  fields: [
+    {
+      type: "uid",
+      name: "name",
+      primaryKey: true
+    },
+    {
+      type: "string",
+      name: "displayName"
+    },
+    {
+      type: "string",
+      name: "cname",
+      unique: true
+    },
+    {
+      type: "string",
+      name: "preset",
+      defaultValue: "tachybase"
+    },
+    {
+      type: "string",
+      name: "tmpl"
+    },
+    {
+      type: "boolean",
+      name: "pinned"
+    },
+    {
+      type: "string",
+      name: "icon"
+    },
+    {
+      type: "string",
+      name: "status",
+      defaultValue: "pending"
+    },
+    {
+      type: "json",
+      name: "options"
+    },
+    {
+      type: "boolean",
+      name: "isTemplate",
+      defaultValue: false
+    }
+  ]
+});

package/dist/server/index.d.ts

@@ -0,0 +1,4 @@
+import { ApplicationModel, registerAppOptions } from './models/application';
+export { PluginMultiAppManager as default } from './server';
+export { ApplicationModel };
+export type { registerAppOptions };

package/dist/server/index.js

@@ -0,0 +1,29 @@
+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 server_exports = {};
+__export(server_exports, {
+  ApplicationModel: () => import_application.ApplicationModel,
+  default: () => import_server.PluginMultiAppManager
+});
+module.exports = __toCommonJS(server_exports);
+var import_application = require("./models/application");
+var import_server = require("./server");
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  ApplicationModel
+});

package/dist/server/middlewares/app-selector.d.ts

@@ -0,0 +1 @@
+export declare function appSelectorMiddleware(app: any): (ctx: any, next: any) => Promise<void>;

package/dist/server/middlewares/app-selector.js

@@ -0,0 +1,47 @@
+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 app_selector_exports = {};
+__export(app_selector_exports, {
+  appSelectorMiddleware: () => appSelectorMiddleware
+});
+module.exports = __toCommonJS(app_selector_exports);
+function appSelectorMiddleware(app) {
+  return async (ctx, next) => {
+    const { req } = ctx;
+    if (!ctx.resolvedAppName && req.headers["x-hostname"]) {
+      const repository = app.db.getRepository("applications");
+      if (!repository) {
+        await next();
+        return;
+      }
+      const appInstance = await repository.findOne({
+        filter: {
+          cname: req.headers["x-hostname"]
+        }
+      });
+      if (appInstance) {
+        ctx.resolvedAppName = appInstance.name;
+      }
+    }
+    await next();
+  };
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  appSelectorMiddleware
+});

package/dist/server/middlewares/index.d.ts

@@ -0,0 +1,2 @@
+export * from './app-selector';
+export * from './inject-app-list';

package/dist/server/middlewares/index.js

@@ -0,0 +1,23 @@
+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 __reExport = (target, mod, secondTarget) => (__copyProps(target, mod, "default"), secondTarget && __copyProps(secondTarget, mod, "default"));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var middlewares_exports = {};
+module.exports = __toCommonJS(middlewares_exports);
+__reExport(middlewares_exports, require("./app-selector"), module.exports);
+__reExport(middlewares_exports, require("./inject-app-list"), module.exports);
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  ...require("./app-selector"),
+  ...require("./inject-app-list")
+});

package/dist/server/middlewares/inject-app-list.d.ts

@@ -0,0 +1 @@
+export declare function injectAppListMiddleware(): (ctx: any, next: any) => Promise<void>;

package/dist/server/middlewares/inject-app-list.js

@@ -0,0 +1,48 @@
+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 inject_app_list_exports = {};
+__export(inject_app_list_exports, {
+  injectAppListMiddleware: () => injectAppListMiddleware
+});
+module.exports = __toCommonJS(inject_app_list_exports);
+var import_server = require("@tachybase/server");
+function injectAppListMiddleware() {
+  return async (ctx, next) => {
+    await next();
+    const { actionName, resourceName, params } = ctx.action;
+    if (actionName === "list" && resourceName === "applications") {
+      const applications = ctx.body.rows;
+      for (const application of applications) {
+        const appStatus = import_server.AppSupervisor.getInstance().getAppStatus(application.name, "stopped");
+        application.status = appStatus;
+        if (application.tmpl) {
+          const matchedApp = applications.find((app) => app.name === application.tmpl);
+          if (matchedApp) {
+            application.tmpl = `${matchedApp.displayName}(${application.tmpl})`;
+          } else {
+            application.tmpl = `Not Exists(${application.tmpl})`;
+          }
+        }
+      }
+    }
+  };
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  injectAppListMiddleware
+});

package/dist/server/migrations/20240820153000-add-apps-tmpl.d.ts

@@ -0,0 +1,6 @@
+import { Migration } from '@tachybase/server';
+export default class AddAppTmplMigration extends Migration {
+    appVersion: string;
+    up(): Promise<void>;
+    down(): Promise<void>;
+}

package/dist/server/migrations/20240820153000-add-apps-tmpl.js

@@ -0,0 +1,47 @@
+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_apps_tmpl_exports = {};
+__export(add_apps_tmpl_exports, {
+  default: () => AddAppTmplMigration
+});
+module.exports = __toCommonJS(add_apps_tmpl_exports);
+var import_server = require("@tachybase/server");
+class AddAppTmplMigration extends import_server.Migration {
+  appVersion = "<0.21.99";
+  async up() {
+    const Field = this.context.db.getRepository("fields");
+    const existed = await Field.count({
+      filter: {
+        name: "tmpl",
+        collectionName: "applications"
+      }
+    });
+    if (!existed) {
+      await Field.create({
+        values: {
+          name: "tmpl",
+          collectionName: "applications",
+          type: "string",
+          unique: true
+        }
+      });
+    }
+  }
+  async down() {
+  }
+}

package/dist/server/migrations/20241126124904-add-createdBy.d.ts

@@ -0,0 +1,6 @@
+import { Migration } from '@tachybase/server';
+export default class extends Migration {
+    on: string;
+    appVersion: string;
+    up(): Promise<void>;
+}