@nocobase/server 2.0.0-beta.9 → 2.0.0

package/lib/app-supervisor/app-options-factory.d.ts

@@ -0,0 +1,80 @@
+/**
+ * This file is part of the NocoBase (R) project.
+ * Copyright (c) 2020-2024 NocoBase Co., Ltd.
+ * Authors: NocoBase Team.
+ *
+ * This project is dual-licensed under AGPL-3.0 and NocoBase Commercial License.
+ * For more information, please refer to: https://www.nocobase.com/agreement.
+ */
+import { IDatabaseOptions } from '@nocobase/database';
+import Application from '../application';
+import { AppModelOptions } from './types';
+export declare const appOptionsFactory: (appName: string, mainApp: Application, options: AppModelOptions) => {
+    dbConnType: string;
+    database: {
+        tablePrefix: string;
+        migrator?: any;
+        usingBigIntForId?: boolean;
+        underscored?: boolean;
+        logger?: import("@nocobase/logger/lib/logger").Logger | import("@nocobase/logger/lib/logger").LoggerOptions;
+        customHooks?: any;
+        instanceId?: string;
+        addAllCollections?: boolean;
+        dialect?: import("sequelize").Dialect;
+        dialectModule?: object;
+        dialectModulePath?: string;
+        dialectOptions?: object;
+        storage?: string;
+        database?: string;
+        username?: string;
+        password?: string;
+        host?: string;
+        port?: number;
+        ssl?: boolean;
+        protocol?: string;
+        define?: import("sequelize").ModelOptions<import("sequelize").Model<any, any>>;
+        query?: import("sequelize").QueryOptions;
+        set?: import("sequelize").DefaultSetOptions;
+        sync?: import("@nocobase/database").SyncOptions;
+        timezone?: string;
+        omitNull?: boolean;
+        native?: boolean;
+        replication?: false | import("sequelize").ReplicationOptions;
+        pool?: import("sequelize").PoolOptions;
+        quoteIdentifiers?: boolean;
+        isolationLevel?: string;
+        transactionType?: import("@nocobase/database").Transaction.TYPES;
+        typeValidation?: boolean;
+        operatorsAliases?: import("sequelize").OperatorsAliases;
+        standardConformingStrings?: boolean;
+        clientMinMessages?: string | boolean;
+        hooks?: Partial<import("sequelize/types/hooks").SequelizeHooks<import("sequelize").Model<any, any>, any, any>>;
+        minifyAliases?: boolean;
+        logQueryParameters?: boolean;
+        retry?: import("retry-as-promised").Options;
+        schema?: string;
+        attributeBehavior?: "escape" | "throw" | "unsafe-legacy";
+        logging?: boolean | ((sql: string, timing?: number) => void);
+        benchmark?: boolean;
+    };
+    plugins: string[];
+    resourcer: {
+        prefix: string;
+    };
+    cacheManager: {
+        prefix: string;
+        defaultStore?: string;
+        stores?: {
+            [storeType: string]: {
+                [key: string]: any;
+                store?: "memory" | import("cache-manager").FactoryStore<import("cache-manager").Store, any>;
+                close?: (store: import("cache-manager").Store) => Promise<void>;
+            };
+        };
+    };
+    logger: import("../application").AppLoggerOptions;
+} & {
+    name: string;
+    dbConnType?: string;
+    database?: IDatabaseOptions;
+};

package/lib/app-supervisor/app-options-factory.js

@@ -0,0 +1,91 @@
+/**
+ * This file is part of the NocoBase (R) project.
+ * Copyright (c) 2020-2024 NocoBase Co., Ltd.
+ * Authors: NocoBase Team.
+ *
+ * This project is dual-licensed under AGPL-3.0 and NocoBase Commercial License.
+ * For more information, please refer to: https://www.nocobase.com/agreement.
+ */
+
+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_options_factory_exports = {};
+__export(app_options_factory_exports, {
+  appOptionsFactory: () => appOptionsFactory
+});
+module.exports = __toCommonJS(app_options_factory_exports);
+var import_database = require("@nocobase/database");
+var import_lodash = __toESM(require("lodash"));
+var import_path = __toESM(require("path"));
+var import_lodash2 = __toESM(require("lodash"));
+function 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"]));
+}
+__name(getDatabaseConfig, "getDatabaseConfig");
+const appOptionsFactory = /* @__PURE__ */ __name((appName, mainApp, options) => {
+  const rawDatabaseOptions = getDatabaseConfig(mainApp);
+  let dbConnType = "new_database";
+  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 if (process.env.USE_DB_SCHEMA_IN_SUBAPP === "true" && ["postgres", "kingbase"].includes(rawDatabaseOptions.dialect)) {
+    rawDatabaseOptions.schema = appName;
+    dbConnType = "new_schema";
+  } else if ((options == null ? void 0 : options.dbConnType) !== "new_schema") {
+    rawDatabaseOptions.database = appName;
+  }
+  const defaultOptions = {
+    dbConnType,
+    database: {
+      ...rawDatabaseOptions,
+      tablePrefix: ""
+    },
+    plugins: ["nocobase"],
+    resourcer: {
+      prefix: process.env.API_BASE_PATH
+    },
+    cacheManager: {
+      ...mainApp.options.cacheManager,
+      prefix: appName
+    },
+    logger: mainApp.options.logger
+  };
+  return import_lodash2.default.merge({}, defaultOptions, { ...options, name: appName });
+}, "appOptionsFactory");
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  appOptionsFactory
+});

package/lib/app-supervisor/condition-registry.d.ts

@@ -0,0 +1,18 @@
+/**
+ * This file is part of the NocoBase (R) project.
+ * Copyright (c) 2020-2024 NocoBase Co., Ltd.
+ * Authors: NocoBase Team.
+ *
+ * This project is dual-licensed under AGPL-3.0 and NocoBase Commercial License.
+ * For more information, please refer to: https://www.nocobase.com/agreement.
+ */
+export type Predicate<C> = (ctx: C) => boolean | Promise<boolean>;
+type Handler<C, R> = (ctx: C) => R | Promise<R>;
+export declare class ConditionalRegistry<C, R> {
+    private rules;
+    private defaultHandler?;
+    register(when: Predicate<C>, run: Handler<C, R>, priority?: number): void;
+    setDefault(run: Handler<C, R>): void;
+    run(ctx: C): Promise<R>;
+}
+export {};

package/lib/app-supervisor/condition-registry.js

@@ -0,0 +1,60 @@
+/**
+ * This file is part of the NocoBase (R) project.
+ * Copyright (c) 2020-2024 NocoBase Co., Ltd.
+ * Authors: NocoBase Team.
+ *
+ * This project is dual-licensed under AGPL-3.0 and NocoBase Commercial License.
+ * For more information, please refer to: https://www.nocobase.com/agreement.
+ */
+
+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 condition_registry_exports = {};
+__export(condition_registry_exports, {
+  ConditionalRegistry: () => ConditionalRegistry
+});
+module.exports = __toCommonJS(condition_registry_exports);
+const _ConditionalRegistry = class _ConditionalRegistry {
+  rules = [];
+  defaultHandler;
+  register(when, run, priority = 0) {
+    this.rules.push({ when, run, priority });
+    this.rules.sort((a, b) => (b.priority ?? 0) - (a.priority ?? 0));
+  }
+  setDefault(run) {
+    this.defaultHandler = run;
+  }
+  async run(ctx) {
+    for (const rule of this.rules) {
+      if (await rule.when(ctx)) {
+        return await rule.run(ctx);
+      }
+    }
+    if (this.defaultHandler) {
+      return await this.defaultHandler(ctx);
+    }
+    throw new Error("No handler matched and no default handler defined");
+  }
+};
+__name(_ConditionalRegistry, "ConditionalRegistry");
+let ConditionalRegistry = _ConditionalRegistry;
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  ConditionalRegistry
+});

package/lib/app-supervisor/db-creator.d.ts

@@ -0,0 +1,16 @@
+/**
+ * This file is part of the NocoBase (R) project.
+ * Copyright (c) 2020-2024 NocoBase Co., Ltd.
+ * Authors: NocoBase Team.
+ *
+ * This project is dual-licensed under AGPL-3.0 and NocoBase Commercial License.
+ * For more information, please refer to: https://www.nocobase.com/agreement.
+ */
+import { Predicate } from './condition-registry';
+import type { AppDbCreator, AppDbCreatorOptions } from './types';
+export declare const createDatabaseCondition: Predicate<AppDbCreatorOptions>;
+export declare const createConnectionCondition: Predicate<AppDbCreatorOptions>;
+export declare const createSchemaCondition: Predicate<AppDbCreatorOptions>;
+export declare const createDatabase: AppDbCreator;
+export declare const createConnection: AppDbCreator;
+export declare const createSchema: AppDbCreator;

package/lib/app-supervisor/db-creator.js

@@ -0,0 +1,163 @@
+/**
+ * This file is part of the NocoBase (R) project.
+ * Copyright (c) 2020-2024 NocoBase Co., Ltd.
+ * Authors: NocoBase Team.
+ *
+ * This project is dual-licensed under AGPL-3.0 and NocoBase Commercial License.
+ * For more information, please refer to: https://www.nocobase.com/agreement.
+ */
+
+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 db_creator_exports = {};
+__export(db_creator_exports, {
+  createConnection: () => createConnection,
+  createConnectionCondition: () => createConnectionCondition,
+  createDatabase: () => createDatabase,
+  createDatabaseCondition: () => createDatabaseCondition,
+  createSchema: () => createSchema,
+  createSchemaCondition: () => createSchemaCondition
+});
+module.exports = __toCommonJS(db_creator_exports);
+var import_db_drivers = require("./db-drivers");
+async function createMySQLDatabase({
+  host,
+  port,
+  username,
+  password,
+  database,
+  driver
+}) {
+  var _a;
+  const conn = await driver.createConnection({
+    host,
+    port,
+    user: username,
+    password
+  });
+  await conn.query(`CREATE DATABASE IF NOT EXISTS \`${database}\``);
+  await (((_a = conn.end) == null ? void 0 : _a.call(conn)) ?? conn.close());
+}
+__name(createMySQLDatabase, "createMySQLDatabase");
+async function withPgClient(options, fn) {
+  const { Client } = (0, import_db_drivers.loadPgModule)();
+  const client = new Client(options);
+  await client.connect();
+  try {
+    await fn(client);
+  } catch (e) {
+    console.log(e);
+  } finally {
+    await client.end();
+  }
+}
+__name(withPgClient, "withPgClient");
+const createDatabaseCondition = /* @__PURE__ */ __name(({ appOptions }) => !(appOptions == null ? void 0 : appOptions.dbConnType) || appOptions.dbConnType === "new_database", "createDatabaseCondition");
+const createConnectionCondition = /* @__PURE__ */ __name(({ appOptions }) => (appOptions == null ? void 0 : appOptions.dbConnType) === "new_connection", "createConnectionCondition");
+const createSchemaCondition = /* @__PURE__ */ __name(({ appOptions }) => appOptions.dbConnType === "new_schema", "createSchemaCondition");
+const createDatabase = /* @__PURE__ */ __name(async ({ app }) => {
+  const { host, port, username, password, dialect, database } = app.options.database;
+  if (dialect === "mysql") {
+    const mysql = (0, import_db_drivers.loadMysqlDriver)();
+    return createMySQLDatabase({
+      host,
+      port,
+      username,
+      password,
+      database,
+      driver: mysql
+    });
+  }
+  if (dialect === "mariadb") {
+    const mariadb = (0, import_db_drivers.loadMariadbDriver)();
+    return createMySQLDatabase({
+      host,
+      port,
+      username,
+      password,
+      database,
+      driver: mariadb
+    });
+  }
+  if (["postgres", "kingbase"].includes(dialect)) {
+    return withPgClient({ host, port, user: username, password, database: dialect }, async (client) => {
+      const exists = await client.query("SELECT 1 FROM pg_database WHERE datname = $1", [database]);
+      if (exists.rowCount === 0) {
+        await client.query(`CREATE DATABASE "${database}"`);
+      }
+    });
+  }
+}, "createDatabase");
+const createConnection = /* @__PURE__ */ __name(async ({ app }) => {
+  const { host, port, username, password, dialect, database, schema } = app.options.database;
+  if (dialect === "mysql") {
+    const mysql = (0, import_db_drivers.loadMysqlDriver)();
+    return createMySQLDatabase({
+      host,
+      port,
+      username,
+      password,
+      database,
+      driver: mysql
+    });
+  }
+  if (dialect === "mariadb") {
+    const mariadb = (0, import_db_drivers.loadMariadbDriver)();
+    return createMySQLDatabase({
+      host,
+      port,
+      username,
+      password,
+      database,
+      driver: mariadb
+    });
+  }
+  if (["postgres", "kingbase"].includes(dialect)) {
+    if (schema) {
+      return withPgClient(
+        { host, port, user: username, password, database },
+        (client) => client.query(`CREATE SCHEMA IF NOT EXISTS ${schema}`)
+      );
+    } else {
+      return withPgClient(
+        { host, port, user: username, password, database: dialect },
+        (client) => client.query(`CREATE DATABASE "${database}"`)
+      );
+    }
+  }
+}, "createConnection");
+const createSchema = /* @__PURE__ */ __name(async ({ app }) => {
+  const { host, port, username, password, dialect, schema, database } = app.options.database;
+  if (!["postgres", "kingbase"].includes(dialect)) {
+    throw new Error("Schema is only supported for postgres/kingbase");
+  }
+  return withPgClient(
+    { host, port, user: username, password, database },
+    (client) => client.query(`CREATE SCHEMA IF NOT EXISTS ${schema}`)
+  );
+}, "createSchema");
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  createConnection,
+  createConnectionCondition,
+  createDatabase,
+  createDatabaseCondition,
+  createSchema,
+  createSchemaCondition
+});

package/lib/app-supervisor/db-drivers.d.ts

@@ -0,0 +1,11 @@
+/**
+ * This file is part of the NocoBase (R) project.
+ * Copyright (c) 2020-2024 NocoBase Co., Ltd.
+ * Authors: NocoBase Team.
+ *
+ * This project is dual-licensed under AGPL-3.0 and NocoBase Commercial License.
+ * For more information, please refer to: https://www.nocobase.com/agreement.
+ */
+export declare function loadMysqlDriver(): any;
+export declare function loadMariadbDriver(): any;
+export declare function loadPgModule(): any;

package/lib/app-supervisor/db-drivers.js

@@ -0,0 +1,52 @@
+/**
+ * This file is part of the NocoBase (R) project.
+ * Copyright (c) 2020-2024 NocoBase Co., Ltd.
+ * Authors: NocoBase Team.
+ *
+ * This project is dual-licensed under AGPL-3.0 and NocoBase Commercial License.
+ * For more information, please refer to: https://www.nocobase.com/agreement.
+ */
+
+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 db_drivers_exports = {};
+__export(db_drivers_exports, {
+  loadMariadbDriver: () => loadMariadbDriver,
+  loadMysqlDriver: () => loadMysqlDriver,
+  loadPgModule: () => loadPgModule
+});
+module.exports = __toCommonJS(db_drivers_exports);
+function loadMysqlDriver() {
+  return require("mysql2/promise");
+}
+__name(loadMysqlDriver, "loadMysqlDriver");
+function loadMariadbDriver() {
+  return require("mariadb");
+}
+__name(loadMariadbDriver, "loadMariadbDriver");
+function loadPgModule() {
+  return require("pg");
+}
+__name(loadPgModule, "loadPgModule");
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  loadMariadbDriver,
+  loadMysqlDriver,
+  loadPgModule
+});

package/lib/app-supervisor/index.d.ts

@@ -0,0 +1,161 @@
+/**
+ * This file is part of the NocoBase (R) project.
+ * Copyright (c) 2020-2024 NocoBase Co., Ltd.
+ * Authors: NocoBase Team.
+ *
+ * This project is dual-licensed under AGPL-3.0 and NocoBase Commercial License.
+ * For more information, please refer to: https://www.nocobase.com/agreement.
+ */
+/// <reference types="node" />
+/// <reference types="node" />
+/// <reference types="node" />
+import { IncomingMessage, ServerResponse } from 'http';
+import { AsyncEmitter } from '@nocobase/utils';
+import { EventEmitter } from 'events';
+import Application, { ApplicationOptions } from '../application';
+import type { AppDiscoveryAdapter, AppProcessAdapter, AppStatus, EnvironmentInfo, GetAppOptions, ProcessCommand, AppDbCreator, AppOptionsFactory, AppDbCreatorOptions, AppCommandAdapter, AppModel, BootstrapLock } from './types';
+import { Predicate } from './condition-registry';
+import { PubSubManagerPublishOptions } from '../pub-sub-manager';
+import { Transaction, Transactionable } from '@nocobase/database';
+import { SystemLogger } from '@nocobase/logger';
+import AesEncryptor from '../aes-encryptor';
+export type AppDiscoveryAdapterFactory = (context: {
+    supervisor: AppSupervisor;
+}) => AppDiscoveryAdapter;
+export type AppProcessAdapterFactory = (context: {
+    supervisor: AppSupervisor;
+}) => AppProcessAdapter;
+export type AppCommandAdapterFactory = (context: {
+    supervisor: AppSupervisor;
+}) => AppCommandAdapter;
+export declare class AppSupervisor extends EventEmitter implements AsyncEmitter {
+    private static instance;
+    private static discoveryAdapterFactories;
+    private static processAdapterFactories;
+    private static commandAdapterFactories;
+    private static defaultDiscoveryAdapterName;
+    private static defaultProcessAdapterName;
+    private static defaultCommandAdapterName;
+    runningMode: 'single' | 'multiple';
+    singleAppName: string | null;
+    logger: SystemLogger;
+    aesEncryptor?: AesEncryptor;
+    emitAsync: (event: string | symbol, ...args: any[]) => Promise<boolean>;
+    private discoveryAdapter;
+    private processAdapter;
+    private commandAdapter;
+    private discoveryAdapterName;
+    private processAdapterName;
+    private commandAdapterName;
+    private appDbCreator;
+    appOptionsFactory: AppOptionsFactory;
+    private environmentHeartbeatInterval;
+    private environmentHeartbeatTimer;
+    private constructor();
+    private resolveDiscoveryAdapterName;
+    private resolveProcessAdapterName;
+    private resolveCommandAdapterName;
+    private createDiscoveryAdapter;
+    private isProcessCapableAdapter;
+    private createProcessAdapter;
+    private createCommandAdapter;
+    static registerDiscoveryAdapter(name: string, factory: AppDiscoveryAdapterFactory): void;
+    static registerProcessAdapter(name: string, factory: AppProcessAdapterFactory): void;
+    static registerCommandAdapter(name: string, factory: AppCommandAdapterFactory): void;
+    static setDefaultDiscoveryAdapter(name: string): void;
+    static setDefaultProcessAdapter(name: string): void;
+    static setDefaultCommandAdapter(name: string): void;
+    static getInstance(): AppSupervisor;
+    get apps(): Record<string, Application>;
+    get appStatus(): Record<string, AppStatus>;
+    get appErrors(): Record<string, Error>;
+    get lastSeenAt(): Map<string, number>;
+    get lastMaintainingMessage(): Record<string, string>;
+    get statusBeforeCommanding(): Record<string, AppStatus>;
+    get environmentName(): string;
+    get environmentUrl(): string;
+    get environmentProxyUrl(): string;
+    getProcessAdapter(): AppProcessAdapter;
+    getDiscoveryAdapter(): AppDiscoveryAdapter;
+    registerAppDbCreator(condition: Predicate<AppDbCreatorOptions>, creator: AppDbCreator, priority?: number): void;
+    createDatabase(options: AppDbCreatorOptions): Promise<void>;
+    setAppOptionsFactory(factory: AppOptionsFactory): void;
+    bootstrapApp(appName: string): Promise<void>;
+    initApp({ appName, options }: {
+        appName: string;
+        options?: {
+            upgrading?: boolean;
+        };
+    }): Promise<void>;
+    setAppError(appName: string, error: Error): void;
+    hasAppError(appName: string): boolean;
+    clearAppError(appName: string): void;
+    reset(): Promise<void>;
+    destroy(): Promise<void>;
+    getAppStatus(appName: string, defaultStatus?: AppStatus): Promise<AppStatus>;
+    setAppStatus(appName: string, status: AppStatus, options?: {}): Promise<void>;
+    clearAppStatus(appName: string): Promise<void>;
+    getAppsStatuses(appNames?: string[]): Promise<import("./types").AppStatusesResult>;
+    getBootstrapLock(appName: string): Promise<BootstrapLock | null>;
+    registerApp({ appModel, mainApp, hook }: {
+        appModel: AppModel;
+        mainApp?: Application;
+        hook?: boolean;
+    }): Application<import("../application").DefaultState, import("../application").DefaultContext>;
+    bootMainApp(options: ApplicationOptions): Application<import("../application").DefaultState, import("../application").DefaultContext>;
+    setAppLastSeenAt(appName: string): Promise<void>;
+    getAppLastSeenAt(appName: string): Promise<number>;
+    addAppModel(appModel: AppModel): Promise<void>;
+    getAppModel(appName: string): Promise<AppModel>;
+    removeAppModel(appName: string): Promise<void>;
+    getAppNameByCName(cname: string): Promise<string>;
+    addAutoStartApps(environmentName: string, appNames: string[]): Promise<void>;
+    getAutoStartApps(): Promise<string[]>;
+    removeAutoStartApps(environmentName: string, appNames: string[]): Promise<void>;
+    addApp(app: Application): Application<import("../application").DefaultState, import("../application").DefaultContext>;
+    getApp(appName: string, options?: GetAppOptions): Promise<Application<import("../application").DefaultState, import("../application").DefaultContext>>;
+    hasApp(appName: string): boolean;
+    createApp(options: {
+        appModel: AppModel;
+        mainApp?: Application;
+        transaction?: Transaction;
+    }, context?: {
+        requestId: string;
+    }): Promise<void>;
+    startApp(appName: string, context?: {
+        requestId: string;
+    }): Promise<void>;
+    stopApp(appName: string, context?: {
+        requestId: string;
+    }): Promise<void>;
+    removeApp(appName: string, context?: {
+        requestId: string;
+    }): Promise<void>;
+    upgradeApp(appName: string, context?: {
+        requestId: string;
+    }): Promise<void>;
+    /**
+     * @deprecated
+     * use {#getApps} instead
+     */
+    subApps(): Application<import("../application").DefaultState, import("../application").DefaultContext>[];
+    getApps(): Application<import("../application").DefaultState, import("../application").DefaultContext>[];
+    proxyWeb(appName: string, req: IncomingMessage, res: ServerResponse): Promise<boolean>;
+    proxyWs(req: IncomingMessage, socket: any, head: Buffer): Promise<boolean>;
+    registerEnvironment(mainApp: Application): Promise<void>;
+    unregisterEnvironment(): Promise<void>;
+    private normalizeEnvInfo;
+    listEnvironments(): Promise<EnvironmentInfo[]>;
+    getEnvironment(environmentName: string): Promise<EnvironmentInfo>;
+    heartbeatEnvironment(): Promise<void>;
+    dispatchCommand(command: ProcessCommand): Promise<void>;
+    registerCommandHandler(mainApp: Application): void;
+    sendSyncMessage(mainApp: Application, message: {
+        type: string;
+        appName: string;
+    }, options?: PubSubManagerPublishOptions & Transactionable): Promise<void>;
+    on(eventName: string | symbol, listener: (...args: any[]) => void): this;
+    private bindAppEvents;
+}
+export type { AppDiscoveryAdapter, AppProcessAdapter, AppCommandAdapter, AppStatus, ProcessCommand, EnvironmentInfo, GetAppOptions, AppDbCreator, AppOptionsFactory, AppModel, AppModelOptions, BootstrapLock, } from './types';
+export { MainOnlyAdapter } from './main-only-adapter';