@nocobase/server 0.13.0-alpha.4 → 0.13.0-alpha.6

package/lib/acl/available-action.js

@@ -1,13 +1,29 @@
-"use strict";
-
-Object.defineProperty(exports, "__esModule", {
-  value: true
+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 available_action_exports = {};
+__export(available_action_exports, {
+  availableActions: () => availableActions
 });
-exports.availableActions = void 0;
+module.exports = __toCommonJS(available_action_exports);
 const availableActions = {
   create: {
     displayName: '{{t("Add new")}}',
-    type: 'new-data',
+    type: "new-data",
     onNewRecord: true,
     allowConfigureFields: true
   },
@@ -23,19 +39,22 @@ const availableActions = {
   // },
   view: {
     displayName: '{{t("View")}}',
-    type: 'old-data',
-    aliases: ['get', 'list'],
+    type: "old-data",
+    aliases: ["get", "list"],
     allowConfigureFields: true
   },
   update: {
     displayName: '{{t("Edit")}}',
-    type: 'old-data',
-    aliases: ['update', 'move'],
+    type: "old-data",
+    aliases: ["update", "move"],
     allowConfigureFields: true
   },
   destroy: {
     displayName: '{{t("Delete")}}',
-    type: 'old-data'
+    type: "old-data"
   }
 };
-exports.availableActions = availableActions;
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  availableActions
+});

package/lib/acl/index.js

@@ -1,32 +1,49 @@
-"use strict";
-
-Object.defineProperty(exports, "__esModule", {
-  value: true
+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 acl_exports = {};
+__export(acl_exports, {
+  createACL: () => createACL
 });
-exports.createACL = createACL;
-function _acl() {
-  const data = require("@nocobase/acl");
-  _acl = function _acl() {
-    return data;
-  };
-  return data;
-}
-var _availableAction = require("./available-action");
-function _slicedToArray(arr, i) { return _arrayWithHoles(arr) || _iterableToArrayLimit(arr, i) || _unsupportedIterableToArray(arr, i) || _nonIterableRest(); }
-function _nonIterableRest() { throw new TypeError("Invalid attempt to destructure non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); }
-function _unsupportedIterableToArray(o, minLen) { if (!o) return; if (typeof o === "string") return _arrayLikeToArray(o, minLen); var n = Object.prototype.toString.call(o).slice(8, -1); if (n === "Object" && o.constructor) n = o.constructor.name; if (n === "Map" || n === "Set") return Array.from(o); if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen); }
-function _arrayLikeToArray(arr, len) { if (len == null || len > arr.length) len = arr.length; for (var i = 0, arr2 = new Array(len); i < len; i++) arr2[i] = arr[i]; return arr2; }
-function _iterableToArrayLimit(arr, i) { var _i = null == arr ? null : "undefined" != typeof Symbol && arr[Symbol.iterator] || arr["@@iterator"]; if (null != _i) { var _s, _e, _x, _r, _arr = [], _n = !0, _d = !1; try { if (_x = (_i = _i.call(arr)).next, 0 === i) { if (Object(_i) !== _i) return; _n = !1; } else for (; !(_n = (_s = _x.call(_i)).done) && (_arr.push(_s.value), _arr.length !== i); _n = !0); } catch (err) { _d = !0, _e = err; } finally { try { if (!_n && null != _i.return && (_r = _i.return(), Object(_r) !== _r)) return; } finally { if (_d) throw _e; } } return _arr; } }
-function _arrayWithHoles(arr) { if (Array.isArray(arr)) return arr; }
-const configureResources = ['roles', 'users', 'collections', 'fields', 'collections.fields', 'roles.collections', 'roles.resources', 'rolesResourcesScopes', 'availableActions'];
+module.exports = __toCommonJS(acl_exports);
+var import_acl = require("@nocobase/acl");
+var import_available_action = require("./available-action");
+const configureResources = [
+  "roles",
+  "users",
+  "collections",
+  "fields",
+  "collections.fields",
+  "roles.collections",
+  "roles.resources",
+  "rolesResourcesScopes",
+  "availableActions"
+];
 function createACL() {
-  const acl = new (_acl().ACL)();
-  for (var _i = 0, _Object$entries = Object.entries(_availableAction.availableActions); _i < _Object$entries.length; _i++) {
-    const _Object$entries$_i = _slicedToArray(_Object$entries[_i], 2),
-      actionName = _Object$entries$_i[0],
-      actionParams = _Object$entries$_i[1];
+  const acl = new import_acl.ACL();
+  for (const [actionName, actionParams] of Object.entries(import_available_action.availableActions)) {
     acl.setAvailableAction(actionName, actionParams);
   }
   acl.registerConfigResources(configureResources);
   return acl;
-}
+}
+__name(createACL, "createACL");
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  createACL
+});

package/lib/app-supervisor.d.ts

@@ -38,7 +38,7 @@ export declare class AppSupervisor extends EventEmitter implements AsyncEmitter
     clearAppError(appName: string): void;
     reset(): Promise<void>;
     destroy(): Promise<void>;
-    setAppStatus(appName: string, status: AppStatus): void;
+    setAppStatus(appName: string, status: AppStatus, options?: {}): void;
     getMutexOfApp(appName: string): any;
     bootStrapApp(appName: string, options?: {}): Promise<void>;
     getApp(appName: string, options?: {

package/lib/app-supervisor.js

@@ -1,61 +1,73 @@
-"use strict";
-
-Object.defineProperty(exports, "__esModule", {
-  value: true
+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 __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+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 __publicField = (obj, key, value) => {
+  __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
+  return value;
+};
+var app_supervisor_exports = {};
+__export(app_supervisor_exports, {
+  AppSupervisor: () => AppSupervisor
 });
-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 {
+module.exports = __toCommonJS(app_supervisor_exports);
+var import_utils = require("@nocobase/utils");
+var import_async_mutex = require("async-mutex");
+var import_events = require("events");
+var import_application = __toESM(require("./application"));
+var import_handler = require("./errors/handler");
+const _AppSupervisor = class _AppSupervisor extends import_events.EventEmitter {
+  runningMode = "multiple";
+  singleAppName = null;
+  apps = {};
+  appErrors = {};
+  appStatus = {};
+  lastMaintainingMessage = {};
+  statusBeforeCommanding = {};
+  appMutexes = {};
+  appBootstrapper = null;
   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.runningMode = "single";
       this.singleAppName = process.env.STARTUP_SUBAPP;
     }
   }
   static getInstance() {
-    if (!AppSupervisor.instance) {
-      AppSupervisor.instance = new AppSupervisor();
+    if (!_AppSupervisor.instance) {
+      _AppSupervisor.instance = new _AppSupervisor();
     }
-    return AppSupervisor.instance;
+    return _AppSupervisor.instance;
   }
   setAppError(appName, error) {
     this.appErrors[appName] = error;
-    this.emit('appError', {
-      appName: appName,
+    this.emit("appError", {
+      appName,
       error
     });
   }
@@ -65,130 +77,110 @@ class AppSupervisor extends _events().EventEmitter {
   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();
-    })();
+  async reset() {
+    const appNames = Object.keys(this.apps);
+    for (const appName of appNames) {
+      await this.removeApp(appName);
+    }
+    this.appBootstrapper = null;
+    this.removeAllListeners();
   }
-  destroy() {
-    var _this2 = this;
-    return _asyncToGenerator(function* () {
-      yield _this2.reset();
-      AppSupervisor.instance = null;
-    })();
+  async destroy() {
+    await this.reset();
+    _AppSupervisor.instance = null;
   }
-  setAppStatus(appName, status) {
+  setAppStatus(appName, status, options = {}) {
     if (this.appStatus[appName] === status) {
       return;
     }
     this.appStatus[appName] = status;
-    this.emit('appStatusChanged', {
+    this.emit("appStatusChanged", {
       appName,
-      status
+      status,
+      options
     });
   }
   getMutexOfApp(appName) {
     if (!this.appMutexes[appName]) {
-      this.appMutexes[appName] = new (_asyncMutex().Mutex)();
+      this.appMutexes[appName] = new import_async_mutex.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');
-          }
+  async bootStrapApp(appName, options = {}) {
+    await this.getMutexOfApp(appName).runExclusive(async () => {
+      if (!this.hasApp(appName)) {
+        this.setAppStatus(appName, "initializing");
+        if (this.appBootstrapper) {
+          await this.appBootstrapper({
+            appSupervisor: this,
+            appName,
+            options
+          });
+        }
+        if (!this.hasApp(appName)) {
+          this.setAppStatus(appName, "not_found");
+        } else if (!this.getAppStatus(appName) || this.getAppStatus(appName) == "initializing") {
+          this.setAppStatus(appName, "initialized");
         }
-      }));
-    })();
-  }
-  getApp(appName, options = {}) {
-    var _this4 = this;
-    return _asyncToGenerator(function* () {
-      if (!options.withOutBootStrap) {
-        yield _this4.bootStrapApp(appName, options);
       }
-      return _this4.apps[appName];
-    })();
+    });
+  }
+  async getApp(appName, options = {}) {
+    if (!options.withOutBootStrap) {
+      await this.bootStrapApp(appName, options);
+    }
+    return this.apps[appName];
   }
   setAppBootstrapper(appBootstrapper) {
     this.appBootstrapper = appBootstrapper;
   }
   getAppStatus(appName, defaultStatus) {
     const status = this.appStatus[appName];
-    if (status === undefined && defaultStatus !== undefined) {
+    if (status === void 0 && defaultStatus !== void 0) {
       return defaultStatus;
     }
     return status;
   }
   bootMainApp(options) {
-    return new _application.default(options);
+    return new import_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');
+    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);
-    })();
+  async getAppsNames() {
+    const apps = Object.values(this.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');
-    })();
+  async removeApp(appName) {
+    if (!this.apps[appName]) {
+      console.log(`app ${appName} not exists`);
+      return;
+    }
+    await this.apps[appName].runCommand("destroy");
   }
   subApps() {
-    return Object.values(this.apps).filter(app => app.name !== 'main');
+    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 (listenerName !== "") {
+      const exists = listeners.find((l) => l.name === listenerName);
       if (exists) {
         super.removeListener(eventName, exists);
       }
@@ -196,73 +188,88 @@ class AppSupervisor extends _events().EventEmitter {
     return super.on(eventName, listener);
   }
   bindAppEvents(app) {
-    var _this7 = this;
-    app.on('afterDestroy', () => {
+    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
-    }) => {
+    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') {
+      if (!maintainingStatus && appStatus !== "running") {
         return;
       }
-      this.emit('appMaintainingMessageChanged', {
+      this.emit("appMaintainingMessageChanged", {
         appName: app.name,
         message,
         status: appStatus,
-        command: appStatus == 'running' ? null : maintainingStatus.command
+        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;
+    app.on("__started", async (_app, options) => {
+      const { maintainingStatus } = options;
+      if (maintainingStatus && ["install", "upgrade", "pm.enable", "pm.disable"].includes(maintainingStatus.command.name)) {
+        this.setAppStatus(app.name, "running", {
+          refresh: true
+        });
+      } else {
+        this.setAppStatus(app.name, "running");
+      }
+    });
+    app.on("afterStop", async () => {
+      this.setAppStatus(app.name, "stopped");
+    });
+    app.on("maintaining", (maintainingStatus) => {
+      const { status, command } = maintainingStatus;
       switch (status) {
-        case 'command_begin':
+        case "command_begin":
           {
             this.statusBeforeCommanding[app.name] = this.getAppStatus(app.name);
-            this.setAppStatus(app.name, 'commanding');
+            this.setAppStatus(app.name, "commanding");
           }
           break;
-        case 'command_running':
-          // emit status changed
-          // this.emit('appMaintainingStatusChanged', maintainingStatus);
+        case "command_running":
           break;
-        case 'command_end':
+        case "command_end":
           {
             const appStatus = this.getAppStatus(app.name);
-            // emit status changed
-            this.emit('appMaintainingStatusChanged', maintainingStatus);
-            // not change
-            if (appStatus == 'commanding') {
+            this.emit("appMaintainingStatusChanged", maintainingStatus);
+            if (appStatus == "commanding") {
               this.setAppStatus(app.name, this.statusBeforeCommanding[app.name]);
             }
           }
           break;
-        case 'command_error':
+        case "command_error":
           {
-            this.setAppError(app.name, maintainingStatus.error);
-            this.setAppStatus(app.name, 'error');
+            const errorLevel = (0, import_handler.getErrorLevel)(maintainingStatus.error);
+            if (errorLevel === "fatal") {
+              this.setAppError(app.name, maintainingStatus.error);
+              this.setAppStatus(app.name, "error");
+              break;
+            }
+            if (errorLevel === "warn") {
+              this.emit("appError", {
+                appName: app.name,
+                error: maintainingStatus.error
+              });
+            }
+            this.setAppStatus(app.name, this.statusBeforeCommanding[app.name]);
           }
           break;
       }
     });
   }
-}
-exports.AppSupervisor = AppSupervisor;
-AppSupervisor.instance = void 0;
-(0, _utils().applyMixins)(AppSupervisor, [_utils().AsyncEmitter]);
+};
+__name(_AppSupervisor, "AppSupervisor");
+__publicField(_AppSupervisor, "instance");
+let AppSupervisor = _AppSupervisor;
+(0, import_utils.applyMixins)(AppSupervisor, [import_utils.AsyncEmitter]);
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  AppSupervisor
+});

package/lib/application.d.ts

@@ -5,7 +5,7 @@ import { AuthManager } from '@nocobase/auth';
 import { Cache, ICacheConfig } from '@nocobase/cache';
 import Database, { CollectionOptions, IDatabaseOptions } from '@nocobase/database';
 import { AppLoggerOptions, Logger } from '@nocobase/logger';
-import Resourcer, { ResourceOptions } from '@nocobase/resourcer';
+import { Resourcer, ResourceOptions } from '@nocobase/resourcer';
 import { AsyncEmitter, ToposortOptions } from '@nocobase/utils';
 import { Command, CommandOptions, ParseOptions } from 'commander';
 import { IncomingMessage, Server, ServerResponse } from 'http';
@@ -132,7 +132,9 @@ export declare class Application<StateT = DefaultState, ContextT = DefaultContex
     authenticate(): Promise<void>;
     runCommand(command: string, ...args: any[]): Promise<Command>;
     createCli(): Command;
-    runAsCLI(argv?: string[], options?: ParseOptions): Promise<Command>;
+    runAsCLI(argv?: string[], options?: ParseOptions & {
+        throwError?: boolean;
+    }): Promise<Command>;
     start(options?: StartOptions): Promise<void>;
     isStarted(): Promise<boolean>;
     tryReloadOrRestart(): Promise<void>;