@nocobase/server 0.12.0-alpha.5 → 0.13.0-alpha.2

package/lib/app-supervisor.d.ts

@@ -0,0 +1,59 @@
+/// <reference types="node" />
+import { AsyncEmitter } from '@nocobase/utils';
+import { EventEmitter } from 'events';
+import Application, { ApplicationOptions } from './application';
+type BootOptions = {
+    appName: string;
+    options: any;
+    appSupervisor: AppSupervisor;
+};
+type AppBootstrapper = (bootOptions: BootOptions) => Promise<void>;
+type AppStatus = 'initializing' | 'initialized' | 'running' | 'commanding' | 'stopped' | 'error' | 'not_found';
+export declare class AppSupervisor extends EventEmitter implements AsyncEmitter {
+    private static instance;
+    runningMode: 'single' | 'multiple';
+    singleAppName: string | null;
+    emitAsync: (event: string | symbol, ...args: any[]) => Promise<boolean>;
+    apps: {
+        [appName: string]: Application;
+    };
+    appErrors: {
+        [appName: string]: Error;
+    };
+    appStatus: {
+        [appName: string]: AppStatus;
+    };
+    lastMaintainingMessage: {
+        [appName: string]: string;
+    };
+    statusBeforeCommanding: {
+        [appName: string]: AppStatus;
+    };
+    private appMutexes;
+    private appBootstrapper;
+    private constructor();
+    static getInstance(): AppSupervisor;
+    setAppError(appName: string, error: Error): void;
+    hasAppError(appName: string): boolean;
+    clearAppError(appName: string): void;
+    reset(): Promise<void>;
+    destroy(): Promise<void>;
+    setAppStatus(appName: string, status: AppStatus): void;
+    getMutexOfApp(appName: string): any;
+    bootStrapApp(appName: string, options?: {}): Promise<void>;
+    getApp(appName: string, options?: {
+        withOutBootStrap?: boolean;
+        [key: string]: any;
+    }): Promise<Application<import("./application").DefaultState, import("./application").DefaultContext>>;
+    setAppBootstrapper(appBootstrapper: AppBootstrapper): void;
+    getAppStatus(appName: string, defaultStatus?: AppStatus): AppStatus | null;
+    bootMainApp(options: ApplicationOptions): Application<import("./application").DefaultState, import("./application").DefaultContext>;
+    hasApp(appName: string): boolean;
+    addApp(app: Application): Application<import("./application").DefaultState, import("./application").DefaultContext>;
+    getAppsNames(): Promise<string[]>;
+    removeApp(appName: string): Promise<void>;
+    subApps(): Application<import("./application").DefaultState, import("./application").DefaultContext>[];
+    on(eventName: string | symbol, listener: (...args: any[]) => void): this;
+    private bindAppEvents;
+}
+export {};

package/lib/app-supervisor.js

@@ -0,0 +1,268 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.AppSupervisor = void 0;
+function _utils() {
+  const data = require("@nocobase/utils");
+  _utils = function _utils() {
+    return data;
+  };
+  return data;
+}
+function _asyncMutex() {
+  const data = require("async-mutex");
+  _asyncMutex = function _asyncMutex() {
+    return data;
+  };
+  return data;
+}
+function _events() {
+  const data = require("events");
+  _events = function _events() {
+    return data;
+  };
+  return data;
+}
+var _application = _interopRequireDefault(require("./application"));
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+function asyncGeneratorStep(gen, resolve, reject, _next, _throw, key, arg) { try { var info = gen[key](arg); var value = info.value; } catch (error) { reject(error); return; } if (info.done) { resolve(value); } else { Promise.resolve(value).then(_next, _throw); } }
+function _asyncToGenerator(fn) { return function () { var self = this, args = arguments; return new Promise(function (resolve, reject) { var gen = fn.apply(self, args); function _next(value) { asyncGeneratorStep(gen, resolve, reject, _next, _throw, "next", value); } function _throw(err) { asyncGeneratorStep(gen, resolve, reject, _next, _throw, "throw", err); } _next(undefined); }); }; }
+class AppSupervisor extends _events().EventEmitter {
+  constructor() {
+    super();
+    this.runningMode = 'multiple';
+    this.singleAppName = null;
+    this.apps = {};
+    this.appErrors = {};
+    this.appStatus = {};
+    this.lastMaintainingMessage = {};
+    this.statusBeforeCommanding = {};
+    this.appMutexes = {};
+    this.appBootstrapper = null;
+    if (process.env.STARTUP_SUBAPP) {
+      this.runningMode = 'single';
+      this.singleAppName = process.env.STARTUP_SUBAPP;
+    }
+  }
+  static getInstance() {
+    if (!AppSupervisor.instance) {
+      AppSupervisor.instance = new AppSupervisor();
+    }
+    return AppSupervisor.instance;
+  }
+  setAppError(appName, error) {
+    this.appErrors[appName] = error;
+    this.emit('appError', {
+      appName: appName,
+      error
+    });
+  }
+  hasAppError(appName) {
+    return !!this.appErrors[appName];
+  }
+  clearAppError(appName) {
+    delete this.appErrors[appName];
+  }
+  reset() {
+    var _this = this;
+    return _asyncToGenerator(function* () {
+      const appNames = Object.keys(_this.apps);
+      for (var _i = 0, _appNames = appNames; _i < _appNames.length; _i++) {
+        const appName = _appNames[_i];
+        yield _this.removeApp(appName);
+      }
+      _this.appBootstrapper = null;
+      _this.removeAllListeners();
+    })();
+  }
+  destroy() {
+    var _this2 = this;
+    return _asyncToGenerator(function* () {
+      yield _this2.reset();
+      AppSupervisor.instance = null;
+    })();
+  }
+  setAppStatus(appName, status) {
+    if (this.appStatus[appName] === status) {
+      return;
+    }
+    this.appStatus[appName] = status;
+    this.emit('appStatusChanged', {
+      appName,
+      status
+    });
+  }
+  getMutexOfApp(appName) {
+    if (!this.appMutexes[appName]) {
+      this.appMutexes[appName] = new (_asyncMutex().Mutex)();
+    }
+    return this.appMutexes[appName];
+  }
+  bootStrapApp(appName, options = {}) {
+    var _this3 = this;
+    return _asyncToGenerator(function* () {
+      yield _this3.getMutexOfApp(appName).runExclusive( /*#__PURE__*/_asyncToGenerator(function* () {
+        if (!_this3.hasApp(appName)) {
+          _this3.setAppStatus(appName, 'initializing');
+          if (_this3.appBootstrapper) {
+            yield _this3.appBootstrapper({
+              appSupervisor: _this3,
+              appName,
+              options
+            });
+          }
+          if (!_this3.hasApp(appName)) {
+            _this3.setAppStatus(appName, 'not_found');
+          } else if (!_this3.getAppStatus(appName) || _this3.getAppStatus(appName) == 'initializing') {
+            _this3.setAppStatus(appName, 'initialized');
+          }
+        }
+      }));
+    })();
+  }
+  getApp(appName, options = {}) {
+    var _this4 = this;
+    return _asyncToGenerator(function* () {
+      if (!options.withOutBootStrap) {
+        yield _this4.bootStrapApp(appName, options);
+      }
+      return _this4.apps[appName];
+    })();
+  }
+  setAppBootstrapper(appBootstrapper) {
+    this.appBootstrapper = appBootstrapper;
+  }
+  getAppStatus(appName, defaultStatus) {
+    const status = this.appStatus[appName];
+    if (status === undefined && defaultStatus !== undefined) {
+      return defaultStatus;
+    }
+    return status;
+  }
+  bootMainApp(options) {
+    return new _application.default(options);
+  }
+  hasApp(appName) {
+    return !!this.apps[appName];
+  }
+  // add app into supervisor
+  addApp(app) {
+    // if there is already an app with the same name, throw error
+    if (this.apps[app.name]) {
+      throw new Error(`app ${app.name} already exists`);
+    }
+    console.log(`add app ${app.name} into supervisor`);
+    this.bindAppEvents(app);
+    this.apps[app.name] = app;
+    this.emit('afterAppAdded', app);
+    if (!this.getAppStatus(app.name) || this.getAppStatus(app.name) == 'not_found') {
+      this.setAppStatus(app.name, 'initialized');
+    }
+    return app;
+  }
+  // get registered app names
+  getAppsNames() {
+    var _this5 = this;
+    return _asyncToGenerator(function* () {
+      const apps = Object.values(_this5.apps);
+      return apps.map(app => app.name);
+    })();
+  }
+  removeApp(appName) {
+    var _this6 = this;
+    return _asyncToGenerator(function* () {
+      if (!_this6.apps[appName]) {
+        console.log(`app ${appName} not exists`);
+        return;
+      }
+      // call app.destroy
+      yield _this6.apps[appName].runCommand('destroy');
+    })();
+  }
+  subApps() {
+    return Object.values(this.apps).filter(app => app.name !== 'main');
+  }
+  on(eventName, listener) {
+    const listeners = this.listeners(eventName);
+    const listenerName = listener.name;
+    if (listenerName !== '') {
+      const exists = listeners.find(l => l.name === listenerName);
+      if (exists) {
+        super.removeListener(eventName, exists);
+      }
+    }
+    return super.on(eventName, listener);
+  }
+  bindAppEvents(app) {
+    var _this7 = this;
+    app.on('afterDestroy', () => {
+      delete this.apps[app.name];
+      delete this.appStatus[app.name];
+      delete this.appErrors[app.name];
+      delete this.lastMaintainingMessage[app.name];
+      delete this.statusBeforeCommanding[app.name];
+    });
+    app.on('maintainingMessageChanged', ({
+      message,
+      maintainingStatus
+    }) => {
+      if (this.lastMaintainingMessage[app.name] === message) {
+        return;
+      }
+      this.lastMaintainingMessage[app.name] = message;
+      const appStatus = this.getAppStatus(app.name);
+      if (!maintainingStatus && appStatus !== 'running') {
+        return;
+      }
+      this.emit('appMaintainingMessageChanged', {
+        appName: app.name,
+        message,
+        status: appStatus,
+        command: appStatus == 'running' ? null : maintainingStatus.command
+      });
+    });
+    app.on('__started', /*#__PURE__*/_asyncToGenerator(function* () {
+      _this7.setAppStatus(app.name, 'running');
+    }));
+    app.on('afterStop', /*#__PURE__*/_asyncToGenerator(function* () {
+      _this7.setAppStatus(app.name, 'stopped');
+    }));
+    app.on('maintaining', maintainingStatus => {
+      const status = maintainingStatus.status;
+      switch (status) {
+        case 'command_begin':
+          {
+            this.statusBeforeCommanding[app.name] = this.getAppStatus(app.name);
+            this.setAppStatus(app.name, 'commanding');
+          }
+          break;
+        case 'command_running':
+          // emit status changed
+          // this.emit('appMaintainingStatusChanged', maintainingStatus);
+          break;
+        case 'command_end':
+          {
+            const appStatus = this.getAppStatus(app.name);
+            // emit status changed
+            this.emit('appMaintainingStatusChanged', maintainingStatus);
+            // not change
+            if (appStatus == 'commanding') {
+              this.setAppStatus(app.name, this.statusBeforeCommanding[app.name]);
+            }
+          }
+          break;
+        case 'command_error':
+          {
+            this.setAppError(app.name, maintainingStatus.error);
+            this.setAppStatus(app.name, 'error');
+          }
+          break;
+      }
+    });
+  }
+}
+exports.AppSupervisor = AppSupervisor;
+AppSupervisor.instance = void 0;
+(0, _utils().applyMixins)(AppSupervisor, [_utils().AsyncEmitter]);

package/lib/application.d.ts

@@ -3,19 +3,21 @@
 import { ACL } from '@nocobase/acl';
 import { AuthManager } from '@nocobase/auth';
 import { Cache, ICacheConfig } from '@nocobase/cache';
-import Database, { Collection, CollectionOptions, IDatabaseOptions } from '@nocobase/database';
+import Database, { CollectionOptions, IDatabaseOptions } from '@nocobase/database';
 import { AppLoggerOptions, Logger } from '@nocobase/logger';
 import Resourcer, { ResourceOptions } from '@nocobase/resourcer';
 import { AsyncEmitter, ToposortOptions } from '@nocobase/utils';
 import { Command, CommandOptions, ParseOptions } from 'commander';
-import { Server } from 'http';
+import { IncomingMessage, Server, ServerResponse } from 'http';
 import { i18n, InitOptions } from 'i18next';
 import Koa, { DefaultContext as KoaDefaultContext, DefaultState as KoaDefaultState } from 'koa';
-import { AppManager } from './app-manager';
+import { AppSupervisor } from './app-supervisor';
+import { ApplicationVersion } from './helpers/application-version';
 import { Locale } from './locale';
 import { Plugin } from './plugin';
 import { InstallOptions, PluginManager } from './plugin-manager';
-export type PluginConfiguration = string | [string, any];
+export type PluginType = string | typeof Plugin;
+export type PluginConfiguration = PluginType | [PluginType, any];
 export interface ResourcerOptions {
     prefix?: string;
 }
@@ -49,84 +51,92 @@ interface ActionsOptions {
     resourceName?: string;
     resourceNames?: string[];
 }
-interface ListenOptions {
-    port?: number | undefined;
-    host?: string | undefined;
-    backlog?: number | undefined;
-    path?: string | undefined;
-    exclusive?: boolean | undefined;
-    readableAll?: boolean | undefined;
-    writableAll?: boolean | undefined;
-    /**
-     * @default false
-     */
-    ipv6Only?: boolean | undefined;
-    signal?: AbortSignal | undefined;
-}
 interface StartOptions {
     cliArgs?: any[];
     dbSync?: boolean;
-    listen?: ListenOptions;
-}
-export declare class ApplicationVersion {
-    protected app: Application;
-    protected collection: Collection;
-    constructor(app: Application);
-    get(): Promise<any>;
-    update(): Promise<void>;
-    satisfies(range: string): Promise<boolean>;
+    checkInstall?: boolean;
 }
+type MaintainingStatus = 'command_begin' | 'command_end' | 'command_running' | 'command_error';
+export type MaintainingCommandStatus = {
+    command: {
+        name: string;
+    };
+    status: MaintainingStatus;
+    error?: Error;
+};
 export declare class Application<StateT = DefaultState, ContextT = DefaultContext> extends Koa implements AsyncEmitter {
     options: ApplicationOptions;
+    listenServer: Server;
+    middleware: any;
+    stopped: boolean;
+    ready: boolean;
+    emitAsync: (event: string | symbol, ...args: any[]) => Promise<boolean>;
+    rawOptions: ApplicationOptions;
+    activatedCommand: {
+        name: string;
+    };
+    running: boolean;
+    protected plugins: Map<string, Plugin<any>>;
+    protected _appSupervisor: AppSupervisor;
+    protected _started: boolean;
+    private _authenticated;
+    private _maintaining;
+    private _maintainingCommandStatus;
+    private _maintainingStatusBeforeCommand;
+    constructor(options: ApplicationOptions);
+    protected _loaded: boolean;
+    get loaded(): boolean;
+    private _maintainingMessage;
+    get maintainingMessage(): string;
     protected _db: Database;
+    get db(): Database;
     protected _logger: Logger;
+    get logger(): Logger;
     protected _resourcer: Resourcer;
+    get resourcer(): Resourcer;
     protected _cache: Cache;
+    get cache(): Cache;
     protected _cli: Command;
+    get cli(): Command;
     protected _i18n: i18n;
+    get i18n(): i18n;
     protected _pm: PluginManager;
+    get pm(): PluginManager;
     protected _acl: ACL;
-    protected _appManager: AppManager;
+    get acl(): ACL;
     protected _authManager: AuthManager;
+    get authManager(): AuthManager;
     protected _locales: Locale;
+    get locales(): Locale;
     protected _version: ApplicationVersion;
-    protected plugins: Map<string, Plugin<any>>;
-    listenServer: Server;
-    middleware: any;
-    stopped: boolean;
-    constructor(options: ApplicationOptions);
-    get db(): Database;
-    get cache(): Cache;
-    get resourcer(): Resourcer;
-    get cli(): Command;
-    get acl(): ACL;
-    get i18n(): i18n;
-    get pm(): PluginManager;
     get version(): ApplicationVersion;
-    get appManager(): AppManager;
-    get authManager(): AuthManager;
-    get logger(): Logger;
     get log(): Logger;
-    get locales(): Locale;
     get name(): string;
-    protected init(): void;
-    private createDatabase;
+    isMaintaining(): boolean;
+    getMaintaining(): MaintainingCommandStatus;
+    setMaintaining(_maintainingCommandStatus: MaintainingCommandStatus): void;
+    setMaintainingMessage(message: string): void;
     getVersion(): any;
-    plugin<O = any>(pluginClass: any, options?: O): Plugin;
+    plugin<O = any>(pluginClass: any, options?: O): void;
     use<NewStateT = {}, NewContextT = {}>(middleware: Koa.Middleware<StateT & NewStateT, ContextT & NewContextT>, options?: ToposortOptions): this;
-    callback(): (req: any, res: any) => any;
-    collection(options: CollectionOptions): Collection<any, any>;
+    callback(): (req: IncomingMessage, res: ServerResponse) => any;
+    collection(options: CollectionOptions): import("@nocobase/database").Collection<any, any>;
     resource(options: ResourceOptions): import("@nocobase/resourcer").Resource;
     actions(handlers: any, options?: ActionsOptions): void;
     command(name: string, desc?: string, opts?: CommandOptions): Command;
     findCommand(name: string): Command;
     load(options?: any): Promise<void>;
     reload(options?: any): Promise<void>;
-    getPlugin<P extends Plugin>(name: string): P;
+    getPlugin<P extends Plugin>(name: string | typeof Plugin): P;
     parse(argv?: string[]): Promise<Command>;
+    authenticate(): Promise<void>;
+    runCommand(command: string, ...args: any[]): Promise<Command>;
+    createCli(): Command;
     runAsCLI(argv?: string[], options?: ParseOptions): Promise<Command>;
     start(options?: StartOptions): Promise<void>;
-    listen(...args: any[]): Server;
+    isStarted(): Promise<boolean>;
+    tryReloadOrRestart(): Promise<void>;
+    restart(options?: StartOptions): Promise<void>;
     stop(options?: any): Promise<void>;
     destroy(options?: any): Promise<void>;
     dbVersionCheck(options?: {
@@ -135,9 +145,12 @@ export declare class Application<StateT = DefaultState, ContextT = DefaultContex
     isInstalled(): Promise<boolean>;
     install(options?: InstallOptions): Promise<void>;
     upgrade(options?: any): Promise<void>;
-    emitAsync: (event: string | symbol, ...args: any[]) => Promise<boolean>;
     toJSON(): {
         appName: string;
+        name: string;
     };
+    reInitEvents(): void;
+    protected init(): void;
+    private createDatabase;
 }
 export default Application;