@nocobase/server 0.7.0-alpha.9 → 0.7.1-alpha.4

package/lib/acl/available-action.js

@@ -1,39 +1,41 @@
 "use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
 exports.availableActions = void 0;
 const availableActions = {
-    create: {
-        displayName: '{{t("Add new")}}',
-        type: 'new-data',
-        onNewRecord: true,
-        allowConfigureFields: true,
-    },
-    // import: {
-    //   displayName: '{{t("Import")}}',
-    //   type: 'new-data',
-    //   scope: false,
-    // },
-    export: {
-        displayName: '{{t("Export")}}',
-        type: 'old-data',
-        allowConfigureFields: true,
-    },
-    view: {
-        displayName: '{{t("View")}}',
-        type: 'old-data',
-        aliases: ['get', 'list'],
-        allowConfigureFields: true,
-    },
-    update: {
-        displayName: '{{t("Edit")}}',
-        type: 'old-data',
-        aliases: ['update', 'move'],
-        allowConfigureFields: true,
-    },
-    destroy: {
-        displayName: '{{t("Delete")}}',
-        type: 'old-data',
-    },
+  create: {
+    displayName: '{{t("Add new")}}',
+    type: 'new-data',
+    onNewRecord: true,
+    allowConfigureFields: true
+  },
+  // import: {
+  //   displayName: '{{t("Import")}}',
+  //   type: 'new-data',
+  //   scope: false,
+  // },
+  // export: {
+  //   displayName: '{{t("Export")}}',
+  //   type: 'old-data',
+  //   allowConfigureFields: true,
+  // },
+  view: {
+    displayName: '{{t("View")}}',
+    type: 'old-data',
+    aliases: ['get', 'list'],
+    allowConfigureFields: true
+  },
+  update: {
+    displayName: '{{t("Edit")}}',
+    type: 'old-data',
+    aliases: ['update', 'move'],
+    allowConfigureFields: true
+  },
+  destroy: {
+    displayName: '{{t("Delete")}}',
+    type: 'old-data'
+  }
 };
-exports.availableActions = availableActions;
-//# sourceMappingURL=available-action.js.map
+exports.availableActions = availableActions;

package/lib/acl/index.js

@@ -1,23 +1,47 @@
 "use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.createACL = void 0;
-const acl_1 = require("@nocobase/acl");
-const available_action_1 = require("./available-action");
-const configureResources = [
-    'roles',
-    'collections',
-    'roles.collections',
-    'roles.resources',
-    'rolesResourcesScopes',
-    'availableActions',
-];
-function createACL() {
-    const acl = new acl_1.ACL();
-    for (const [actionName, actionParams] of Object.entries(available_action_1.availableActions)) {
-        acl.setAvailableAction(actionName, actionParams);
-    }
-    acl.registerConfigResources(configureResources);
-    return acl;
-}
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
 exports.createACL = createACL;
-//# sourceMappingURL=index.js.map
+
+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 = arr == null ? null : typeof Symbol !== "undefined" && arr[Symbol.iterator] || arr["@@iterator"]; if (_i == null) return; var _arr = []; var _n = true; var _d = false; var _s, _e; try { for (_i = _i.call(arr); !(_n = (_s = _i.next()).done); _n = true) { _arr.push(_s.value); if (i && _arr.length === i) break; } } catch (err) { _d = true; _e = err; } finally { try { if (!_n && _i["return"] != null) _i["return"](); } finally { if (_d) throw _e; } } return _arr; }
+
+function _arrayWithHoles(arr) { if (Array.isArray(arr)) return arr; }
+
+const configureResources = ['roles', 'collections', '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];
+
+    acl.setAvailableAction(actionName, actionParams);
+  }
+
+  acl.registerConfigResources(configureResources);
+  return acl;
+}

package/lib/app-manager.d.ts

@@ -1,7 +1,7 @@
 /// <reference types="node" />
-import Application, { ApplicationOptions } from './application';
-import http, { IncomingMessage } from 'http';
 import EventEmitter from 'events';
+import http, { IncomingMessage, ServerResponse } from 'http';
+import Application, { ApplicationOptions } from './application';
 declare type AppSelector = (req: IncomingMessage) => Application | string | undefined | null;
 export declare class AppManager extends EventEmitter {
     private app;
@@ -13,7 +13,7 @@ export declare class AppManager extends EventEmitter {
     setAppSelector(selector: AppSelector): void;
     listen(...args: any[]): http.Server;
     getApplication(appName: string): Promise<null | Application>;
-    callback(): (req: any, res: any) => Promise<void>;
+    callback(): (req: IncomingMessage, res: ServerResponse) => Promise<void>;
     emitAsync: (event: string | symbol, ...args: any[]) => Promise<boolean>;
 }
 export {};

package/lib/app-manager.js

@@ -1,76 +1,155 @@
 "use strict";
-var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
-    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
-    return new (P || (P = Promise))(function (resolve, reject) {
-        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
-        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
-        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
-        step((generator = generator.apply(thisArg, _arguments || [])).next());
-    });
-};
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
 exports.AppManager = void 0;
-const application_1 = __importDefault(require("./application"));
-const http_1 = __importDefault(require("http"));
-const events_1 = __importDefault(require("events"));
-const utils_1 = require("@nocobase/utils");
-class AppManager extends events_1.default {
-    constructor(app) {
-        super();
-        this.app = app;
-        this.applications = new Map();
-        this.appSelector = (req) => this.app;
-        app.on('beforeStop', (mainApp, options) => __awaiter(this, void 0, void 0, function* () {
-            return yield Promise.all([...this.applications.values()].map((application) => application.stop(options)));
-        }));
-        app.on('afterDestroy', (mainApp, options) => __awaiter(this, void 0, void 0, function* () {
-            return yield Promise.all([...this.applications.values()].map((application) => application.destroy(options)));
-        }));
-    }
-    createApplication(name, options) {
-        const application = new application_1.default(options);
-        this.applications.set(name, application);
-        return application;
-    }
-    removeApplication(name) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const application = this.applications.get(name);
-            if (!application) {
-                return;
-            }
-            yield application.destroy();
-            this.applications.delete(name);
-        });
-    }
-    setAppSelector(selector) {
-        this.appSelector = selector;
-    }
-    listen(...args) {
-        const server = http_1.default.createServer(this.callback());
-        return server.listen(...args);
-    }
-    getApplication(appName) {
-        return __awaiter(this, void 0, void 0, function* () {
-            yield this.emitAsync('beforeGetApplication', {
-                appManager: this,
-                name: appName,
-            });
-            return this.applications.get(appName);
-        });
-    }
-    callback() {
-        return (req, res) => __awaiter(this, void 0, void 0, function* () {
-            let handleApp = this.appSelector(req) || this.app;
-            if (typeof handleApp === 'string') {
-                handleApp = (yield this.getApplication(handleApp)) || this.app;
-            }
-            handleApp.callback()(req, res);
-        });
-    }
+
+function _utils() {
+  const data = require("@nocobase/utils");
+
+  _utils = function _utils() {
+    return data;
+  };
+
+  return data;
 }
+
+function _events() {
+  const data = _interopRequireDefault(require("events"));
+
+  _events = function _events() {
+    return data;
+  };
+
+  return data;
+}
+
+function _http() {
+  const data = _interopRequireDefault(require("http"));
+
+  _http = function _http() {
+    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 AppManager extends _events().default {
+  constructor(app) {
+    var _this;
+
+    super();
+    _this = this;
+    this.app = void 0;
+    this.applications = new Map();
+
+    this.appSelector = req => this.app;
+
+    this.app = app;
+    app.on('beforeStop', /*#__PURE__*/function () {
+      var _ref = _asyncToGenerator(function* (mainApp, options) {
+        return yield Promise.all([..._this.applications.values()].map(application => application.stop(options)));
+      });
+
+      return function (_x, _x2) {
+        return _ref.apply(this, arguments);
+      };
+    }());
+    app.on('afterDestroy', /*#__PURE__*/function () {
+      var _ref2 = _asyncToGenerator(function* (mainApp, options) {
+        return yield Promise.all([..._this.applications.values()].map(application => application.destroy(options)));
+      });
+
+      return function (_x3, _x4) {
+        return _ref2.apply(this, arguments);
+      };
+    }());
+  }
+
+  createApplication(name, options) {
+    const application = new _application.default(options);
+    this.applications.set(name, application);
+    return application;
+  }
+
+  removeApplication(name) {
+    var _this2 = this;
+
+    return _asyncToGenerator(function* () {
+      const application = _this2.applications.get(name);
+
+      if (!application) {
+        return;
+      }
+
+      yield application.destroy();
+
+      _this2.applications.delete(name);
+    })();
+  }
+
+  setAppSelector(selector) {
+    this.appSelector = selector;
+  }
+
+  listen(...args) {
+    const server = _http().default.createServer(this.callback());
+
+    return server.listen(...args);
+  }
+
+  getApplication(appName) {
+    var _this3 = this;
+
+    return _asyncToGenerator(function* () {
+      yield _this3.emitAsync('beforeGetApplication', {
+        appManager: _this3,
+        name: appName
+      });
+      return _this3.applications.get(appName);
+    })();
+  }
+
+  callback() {
+    var _this4 = this;
+
+    return /*#__PURE__*/function () {
+      var _ref3 = _asyncToGenerator(function* (req, res) {
+        let handleApp = _this4.appSelector(req) || _this4.app;
+
+        if (typeof handleApp === 'string') {
+          handleApp = yield _this4.getApplication(handleApp);
+
+          if (!handleApp) {
+            res.statusCode = 404;
+            return res.end(JSON.stringify({
+              redirectTo: process.env.APP_NOT_FOUND_REDIRECT_TO,
+              errors: [{
+                message: 'Not Found'
+              }]
+            }));
+          }
+        }
+
+        handleApp.callback()(req, res);
+      });
+
+      return function (_x5, _x6) {
+        return _ref3.apply(this, arguments);
+      };
+    }();
+  }
+
+}
+
 exports.AppManager = AppManager;
-(0, utils_1.applyMixins)(AppManager, [utils_1.AsyncEmitter]);
-//# sourceMappingURL=app-manager.js.map
+(0, _utils().applyMixins)(AppManager, [_utils().AsyncEmitter]);

package/lib/application.d.ts

@@ -1,7 +1,7 @@
 /// <reference types="node" />
 /// <reference types="koa-bodyparser" />
 import { ACL } from '@nocobase/acl';
-import Database, { CollectionOptions, IDatabaseOptions } from '@nocobase/database';
+import Database, { Collection, CollectionOptions, IDatabaseOptions } from '@nocobase/database';
 import Resourcer, { ResourceOptions } from '@nocobase/resourcer';
 import { AsyncEmitter } from '@nocobase/utils';
 import { Command, CommandOptions } from 'commander';
@@ -26,11 +26,11 @@ export interface ApplicationOptions {
     i18n?: i18n | InitOptions;
     plugins?: PluginsConfigurations;
 }
-interface DefaultState {
+export interface DefaultState {
     currentUser?: any;
     [key: string]: any;
 }
-interface DefaultContext {
+export interface DefaultContext {
     db: Database;
     resourcer: Resourcer;
     [key: string]: any;
@@ -64,6 +64,14 @@ interface StartOptions {
     cliArgs?: any[];
     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>;
+}
 export declare class Application<StateT = DefaultState, ContextT = DefaultContext> extends Koa implements AsyncEmitter {
     options: ApplicationOptions;
     readonly db: Database;
@@ -73,13 +81,16 @@ export declare class Application<StateT = DefaultState, ContextT = DefaultContex
     readonly pm: PluginManager;
     readonly acl: ACL;
     readonly appManager: AppManager;
+    readonly version: ApplicationVersion;
     protected plugins: Map<string, Plugin<any>>;
     listenServer: Server;
     constructor(options: ApplicationOptions);
+    private createDatabase;
+    getVersion(): any;
     plugin<O = any>(pluginClass: any, options?: O): Plugin<O>;
     loadPluginConfig(pluginsConfigurations: PluginsConfigurations): void;
     use<NewStateT = {}, NewContextT = {}>(middleware: Koa.Middleware<StateT & NewStateT, ContextT & NewContextT>, options?: MiddlewareOptions): Koa<Koa.DefaultState & StateT & NewStateT, Koa.DefaultContext & ContextT & NewContextT>;
-    collection(options: CollectionOptions): import("@nocobase/database").Collection<any, any>;
+    collection(options: CollectionOptions): Collection<any, any>;
     resource(options: ResourceOptions): import("@nocobase/resourcer").Resource;
     actions(handlers: any, options?: ActionsOptions): void;
     command(name: string, desc?: string, opts?: CommandOptions): Command;
@@ -92,6 +103,7 @@ export declare class Application<StateT = DefaultState, ContextT = DefaultContex
     stop(options?: any): Promise<void>;
     destroy(options?: any): Promise<void>;
     install(options?: InstallOptions): Promise<void>;
+    upgrade(options?: any): Promise<void>;
     emitAsync: (event: string | symbol, ...args: any[]) => Promise<boolean>;
 }
 export default Application;