@tego/core 1.3.44

package/lib/commands/start.js

@@ -0,0 +1,74 @@
+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 start_exports = {};
+__export(start_exports, {
+  default: () => start_default
+});
+module.exports = __toCommonJS(start_exports);
+var import_node_fs = __toESM(require("node:fs"));
+var import_node_path = require("node:path");
+var import_node_perf_hooks = require("node:perf_hooks");
+var import_utils = require("@tachybase/utils");
+var import_application_not_install = require("../errors/application-not-install");
+var start_default = /* @__PURE__ */ __name((app) => {
+  app.command("start").auth().option("--db-sync").option("--quickstart").action(async (...cliArgs) => {
+    const [options] = cliArgs;
+    app.logger.debug("start options", options);
+    const file = (0, import_node_path.resolve)(process.cwd(), "storage/app-upgrading");
+    const upgrading = await (0, import_utils.fsExists)(file);
+    if (upgrading) {
+      await app.upgrade();
+      await import_node_fs.default.promises.rm(file);
+    } else if (options.quickstart) {
+      if (await app.isInstalled()) {
+        await app.upgrade();
+      } else {
+        await app.install();
+      }
+      app["_started"] = true;
+      await app.restart();
+      app.logger.info("app has been started");
+      return;
+    }
+    if (!await app.isInstalled()) {
+      app["_started"] = true;
+      throw new import_application_not_install.ApplicationNotInstall(
+        `Application ${app.name} is not installed, Please run 'pnpm tachybase install' command first`
+      );
+    }
+    await app.load();
+    await app.start({
+      dbSync: options == null ? void 0 : options.dbSync,
+      quickstart: options.quickstart,
+      cliArgs,
+      checkInstall: true
+    });
+    app.logger.info(`app has been started at ${import_node_perf_hooks.performance.now().toFixed(2)} ms`);
+  });
+}, "default");

package/lib/commands/stop.d.ts

@@ -0,0 +1,3 @@
+import Application from '../application';
+declare const _default: (app: Application) => void;
+export default _default;

package/lib/commands/stop.js

@@ -0,0 +1,34 @@
+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 stop_exports = {};
+__export(stop_exports, {
+  default: () => stop_default
+});
+module.exports = __toCommonJS(stop_exports);
+var stop_default = /* @__PURE__ */ __name((app) => {
+  app.command("stop").ipc().action(async (...cliArgs) => {
+    if (!await app.isStarted()) {
+      app.logger.info("app has not started");
+      return;
+    }
+    await app.stop({
+      cliArgs
+    });
+  });
+}, "default");

package/lib/commands/upgrade.d.ts

@@ -0,0 +1,3 @@
+import Application from '../application';
+declare const _default: (app: Application) => void;
+export default _default;

package/lib/commands/upgrade.js

@@ -0,0 +1,29 @@
+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 upgrade_exports = {};
+__export(upgrade_exports, {
+  default: () => upgrade_default
+});
+module.exports = __toCommonJS(upgrade_exports);
+var upgrade_default = /* @__PURE__ */ __name((app) => {
+  app.command("upgrade").ipc().auth().action(async (options) => {
+    await app.upgrade(options);
+    app.logger.info(`\u2728  TachyBase has been upgraded to v${await app.version.get()}`);
+  });
+}, "default");

package/lib/cron/cron-job-manager.d.ts

@@ -0,0 +1,25 @@
+import Application from '../application';
+export interface CronJobParameters {
+    cronTime: string;
+    onTick: () => void;
+    start?: boolean;
+    timeZone?: string;
+    context?: any;
+}
+export declare class CronJob {
+    constructor(params: CronJobParameters);
+    start(): void;
+    stop(): void;
+}
+export declare class CronJobManager {
+    private app;
+    private _jobs;
+    private _started;
+    constructor(app: Application);
+    get started(): boolean;
+    get jobs(): Set<CronJob>;
+    addJob(options: CronJobParameters): CronJob;
+    removeJob(job: CronJob): void;
+    start(): void;
+    stop(): void;
+}

package/lib/cron/cron-job-manager.js

@@ -0,0 +1,89 @@
+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 cron_job_manager_exports = {};
+__export(cron_job_manager_exports, {
+  CronJob: () => CronJob,
+  CronJobManager: () => CronJobManager
+});
+module.exports = __toCommonJS(cron_job_manager_exports);
+const _CronJob = class _CronJob {
+  constructor(params) {
+    if (params.start !== false) {
+      this.start();
+    }
+  }
+  start() {
+    console.log("Mock CronJob started");
+  }
+  stop() {
+    console.log("Mock CronJob stopped");
+  }
+};
+__name(_CronJob, "CronJob");
+let CronJob = _CronJob;
+const _CronJobManager = class _CronJobManager {
+  constructor(app) {
+    this.app = app;
+    this._jobs = /* @__PURE__ */ new Set();
+    this._started = false;
+    app.on("beforeStop", async () => {
+      this.stop();
+    });
+    app.on("afterStart", async () => {
+      this.start();
+    });
+    app.on("beforeReload", async () => {
+      this.stop();
+    });
+  }
+  get started() {
+    return this._started;
+  }
+  get jobs() {
+    return this._jobs;
+  }
+  addJob(options) {
+    const cronJob = new CronJob(options);
+    this._jobs.add(cronJob);
+    return cronJob;
+  }
+  removeJob(job) {
+    job.stop();
+    this._jobs.delete(job);
+  }
+  start() {
+    this._jobs.forEach((job) => {
+      job.start();
+    });
+    this._started = true;
+  }
+  stop() {
+    this._jobs.forEach((job) => {
+      job.stop();
+    });
+    this._started = false;
+  }
+};
+__name(_CronJobManager, "CronJobManager");
+let CronJobManager = _CronJobManager;
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  CronJob,
+  CronJobManager
+});

package/lib/environment.d.ts

@@ -0,0 +1,10 @@
+export declare class Environment {
+    private vars;
+    setVariable(key: string, value: string): void;
+    removeVariable(key: string): void;
+    getVariablesAndSecrets(): {};
+    getVariables(): {};
+    renderJsonTemplate(template: any, options?: {
+        omit?: string[];
+    }): any;
+}

package/lib/environment.js

@@ -0,0 +1,73 @@
+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 environment_exports = {};
+__export(environment_exports, {
+  Environment: () => Environment
+});
+module.exports = __toCommonJS(environment_exports);
+var import_utils = require("@tachybase/utils");
+var import_lodash = __toESM(require("lodash"));
+const _Environment = class _Environment {
+  constructor() {
+    this.vars = {};
+  }
+  setVariable(key, value) {
+    this.vars[key] = value;
+  }
+  removeVariable(key) {
+    delete this.vars[key];
+  }
+  getVariablesAndSecrets() {
+    return this.vars;
+  }
+  getVariables() {
+    return this.vars;
+  }
+  renderJsonTemplate(template, options) {
+    if (options == null ? void 0 : options.omit) {
+      const omitTemplate = import_lodash.default.omit(template, options.omit);
+      const parsed = (0, import_utils.parse)(omitTemplate)({
+        $env: this.vars
+      });
+      for (const key of options.omit) {
+        import_lodash.default.set(parsed, key, import_lodash.default.get(template, key));
+      }
+      return parsed;
+    }
+    return (0, import_utils.parse)(template)({
+      $env: this.vars
+    });
+  }
+};
+__name(_Environment, "Environment");
+let Environment = _Environment;
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  Environment
+});

package/lib/errors/application-not-install.d.ts

@@ -0,0 +1,4 @@
+export declare class ApplicationNotInstall extends Error {
+    code: string;
+    constructor(message: any);
+}

package/lib/errors/application-not-install.js

@@ -0,0 +1,35 @@
+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 application_not_install_exports = {};
+__export(application_not_install_exports, {
+  ApplicationNotInstall: () => ApplicationNotInstall
+});
+module.exports = __toCommonJS(application_not_install_exports);
+const _ApplicationNotInstall = class _ApplicationNotInstall extends Error {
+  constructor(message) {
+    super(message);
+    this.code = "APP_NOT_INSTALLED_ERROR";
+  }
+};
+__name(_ApplicationNotInstall, "ApplicationNotInstall");
+let ApplicationNotInstall = _ApplicationNotInstall;
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  ApplicationNotInstall
+});

package/lib/errors/handler.d.ts

@@ -0,0 +1,3 @@
+type ErrorLevel = 'fatal' | 'silly' | 'warn';
+export declare function getErrorLevel(e: Error): ErrorLevel;
+export {};

package/lib/errors/handler.js

@@ -0,0 +1,41 @@
+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 handler_exports = {};
+__export(handler_exports, {
+  getErrorLevel: () => getErrorLevel
+});
+module.exports = __toCommonJS(handler_exports);
+var import_plugin_command_error = require("./plugin-command-error");
+function getErrorLevel(e) {
+  if (e.code === "commander.unknownCommand") {
+    return "silly";
+  }
+  if (e instanceof import_plugin_command_error.PluginCommandError) {
+    return "warn";
+  }
+  if (e.name === "RestoreCheckError") {
+    return "warn";
+  }
+  return "fatal";
+}
+__name(getErrorLevel, "getErrorLevel");
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  getErrorLevel
+});

package/lib/errors/plugin-command-error.d.ts

@@ -0,0 +1,2 @@
+export declare class PluginCommandError extends Error {
+}

package/lib/errors/plugin-command-error.js

@@ -0,0 +1,31 @@
+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 plugin_command_error_exports = {};
+__export(plugin_command_error_exports, {
+  PluginCommandError: () => PluginCommandError
+});
+module.exports = __toCommonJS(plugin_command_error_exports);
+const _PluginCommandError = class _PluginCommandError extends Error {
+};
+__name(_PluginCommandError, "PluginCommandError");
+let PluginCommandError = _PluginCommandError;
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  PluginCommandError
+});

package/lib/errors/plugin-not-exist.d.ts

@@ -0,0 +1,2 @@
+export declare class PluginNotExist extends Error {
+}

package/lib/errors/plugin-not-exist.js

@@ -0,0 +1,31 @@
+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 plugin_not_exist_exports = {};
+__export(plugin_not_exist_exports, {
+  PluginNotExist: () => PluginNotExist
+});
+module.exports = __toCommonJS(plugin_not_exist_exports);
+const _PluginNotExist = class _PluginNotExist extends Error {
+};
+__name(_PluginNotExist, "PluginNotExist");
+let PluginNotExist = _PluginNotExist;
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  PluginNotExist
+});

package/lib/gateway/errors.d.ts

@@ -0,0 +1,22 @@
+interface AppError {
+    status: number;
+    message: any;
+    command?: any;
+    maintaining: boolean;
+    code: any;
+}
+interface AppErrors {
+    [key: string]: Omit<AppError, 'code'> & {
+        code?: any;
+    };
+}
+export declare const errors: AppErrors;
+export declare function getErrorWithCode(errorCode: string): AppError;
+export declare function applyErrorWithArgs(error: AppError, options: any): {
+    status: number;
+    message: any;
+    command?: any;
+    maintaining: boolean;
+    code: any;
+};
+export {};

package/lib/gateway/errors.js

@@ -0,0 +1,138 @@
+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 errors_exports = {};
+__export(errors_exports, {
+  applyErrorWithArgs: () => applyErrorWithArgs,
+  errors: () => errors,
+  getErrorWithCode: () => getErrorWithCode
+});
+module.exports = __toCommonJS(errors_exports);
+var import_lodash = __toESM(require("lodash"));
+var import_app_supervisor = require("../app-supervisor");
+const errors = {
+  APP_NOT_FOUND: {
+    status: 404,
+    message: /* @__PURE__ */ __name(({ appName }) => `application ${appName} not found`, "message"),
+    maintaining: true
+  },
+  APP_ERROR: {
+    status: 503,
+    message: /* @__PURE__ */ __name(({ app }) => {
+      var _a;
+      return (_a = import_app_supervisor.AppSupervisor.getInstance().appErrors[app.name]) == null ? void 0 : _a.message;
+    }, "message"),
+    code: /* @__PURE__ */ __name(({ app }) => {
+      const error = import_app_supervisor.AppSupervisor.getInstance().appErrors[app.name];
+      return error["code"] || "APP_ERROR";
+    }, "code"),
+    command: /* @__PURE__ */ __name(({ app }) => app.getMaintaining().command, "command"),
+    maintaining: true
+  },
+  APP_STARTING: {
+    status: 503,
+    message: /* @__PURE__ */ __name(({ app }) => app.maintainingMessage, "message"),
+    maintaining: true
+  },
+  APP_STOPPED: {
+    status: 503,
+    message: /* @__PURE__ */ __name(({ app }) => `application ${app.name} is stopped`, "message"),
+    maintaining: true
+  },
+  APP_INITIALIZED: {
+    status: 503,
+    message: /* @__PURE__ */ __name(({ app }) => `application ${app.name} is initialized, waiting for command`, "message"),
+    maintaining: true
+  },
+  APP_INITIALIZING: {
+    status: 503,
+    message: /* @__PURE__ */ __name(({ appName }) => `application ${appName} is initializing`, "message"),
+    maintaining: true
+  },
+  COMMAND_ERROR: {
+    status: 503,
+    maintaining: true,
+    message: /* @__PURE__ */ __name(({ app }) => app.getMaintaining().error.message, "message"),
+    command: /* @__PURE__ */ __name(({ app }) => app.getMaintaining().command, "command")
+  },
+  COMMAND_END: {
+    status: 503,
+    maintaining: true,
+    message: /* @__PURE__ */ __name(({ app }) => `${app.getMaintaining().command.name} running end`, "message"),
+    command: /* @__PURE__ */ __name(({ app }) => app.getMaintaining().command, "command")
+  },
+  APP_COMMANDING: {
+    status: 503,
+    maintaining: true,
+    message: /* @__PURE__ */ __name(({ app, message }) => message || app.maintainingMessage, "message"),
+    command: /* @__PURE__ */ __name(({ app, command }) => command || app.getMaintaining().command, "command")
+  },
+  APP_RUNNING: {
+    status: 200,
+    maintaining: false,
+    message: /* @__PURE__ */ __name(({ message, app }) => message || `application ${app.name} is running`, "message")
+  },
+  UNKNOWN_ERROR: {
+    status: 500,
+    message: "unknown error",
+    maintaining: true
+  }
+};
+function getErrorWithCode(errorCode) {
+  const rawCode = errorCode;
+  errorCode = import_lodash.default.snakeCase(errorCode).toUpperCase();
+  if (!errors[errorCode] && errors[`APP_${errorCode}`]) {
+    errorCode = `APP_${errorCode}`;
+  }
+  if (!errors[errorCode]) {
+    errorCode = "UNKNOWN_ERROR";
+  }
+  const error = import_lodash.default.cloneDeep(errors[errorCode]);
+  if (!error.code) {
+    error["code"] = errorCode === "UNKNOWN_ERROR" ? rawCode : errorCode;
+  }
+  return error;
+}
+__name(getErrorWithCode, "getErrorWithCode");
+function applyErrorWithArgs(error, options) {
+  const functionKeys = Object.keys(error).filter((key) => typeof error[key] === "function");
+  const functionResults = functionKeys.map((key) => {
+    return error[key](options);
+  });
+  return {
+    ...error,
+    ...import_lodash.default.zipObject(functionKeys, functionResults)
+  };
+}
+__name(applyErrorWithArgs, "applyErrorWithArgs");
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  applyErrorWithArgs,
+  errors,
+  getErrorWithCode
+});