@nocobase/plugin-multi-app-manager 0.12.0-alpha.4 → 0.13.0-alpha.1

package/dist/node_modules/qs/test/utils.js

@@ -0,0 +1,136 @@
+'use strict';
+
+var test = require('tape');
+var inspect = require('object-inspect');
+var SaferBuffer = require('safer-buffer').Buffer;
+var forEach = require('for-each');
+var utils = require('../lib/utils');
+
+test('merge()', function (t) {
+    t.deepEqual(utils.merge(null, true), [null, true], 'merges true into null');
+
+    t.deepEqual(utils.merge(null, [42]), [null, 42], 'merges null into an array');
+
+    t.deepEqual(utils.merge({ a: 'b' }, { a: 'c' }), { a: ['b', 'c'] }, 'merges two objects with the same key');
+
+    var oneMerged = utils.merge({ foo: 'bar' }, { foo: { first: '123' } });
+    t.deepEqual(oneMerged, { foo: ['bar', { first: '123' }] }, 'merges a standalone and an object into an array');
+
+    var twoMerged = utils.merge({ foo: ['bar', { first: '123' }] }, { foo: { second: '456' } });
+    t.deepEqual(twoMerged, { foo: { 0: 'bar', 1: { first: '123' }, second: '456' } }, 'merges a standalone and two objects into an array');
+
+    var sandwiched = utils.merge({ foo: ['bar', { first: '123', second: '456' }] }, { foo: 'baz' });
+    t.deepEqual(sandwiched, { foo: ['bar', { first: '123', second: '456' }, 'baz'] }, 'merges an object sandwiched by two standalones into an array');
+
+    var nestedArrays = utils.merge({ foo: ['baz'] }, { foo: ['bar', 'xyzzy'] });
+    t.deepEqual(nestedArrays, { foo: ['baz', 'bar', 'xyzzy'] });
+
+    var noOptionsNonObjectSource = utils.merge({ foo: 'baz' }, 'bar');
+    t.deepEqual(noOptionsNonObjectSource, { foo: 'baz', bar: true });
+
+    t.test(
+        'avoids invoking array setters unnecessarily',
+        { skip: typeof Object.defineProperty !== 'function' },
+        function (st) {
+            var setCount = 0;
+            var getCount = 0;
+            var observed = [];
+            Object.defineProperty(observed, 0, {
+                get: function () {
+                    getCount += 1;
+                    return { bar: 'baz' };
+                },
+                set: function () { setCount += 1; }
+            });
+            utils.merge(observed, [null]);
+            st.equal(setCount, 0);
+            st.equal(getCount, 1);
+            observed[0] = observed[0]; // eslint-disable-line no-self-assign
+            st.equal(setCount, 1);
+            st.equal(getCount, 2);
+            st.end();
+        }
+    );
+
+    t.end();
+});
+
+test('assign()', function (t) {
+    var target = { a: 1, b: 2 };
+    var source = { b: 3, c: 4 };
+    var result = utils.assign(target, source);
+
+    t.equal(result, target, 'returns the target');
+    t.deepEqual(target, { a: 1, b: 3, c: 4 }, 'target and source are merged');
+    t.deepEqual(source, { b: 3, c: 4 }, 'source is untouched');
+
+    t.end();
+});
+
+test('combine()', function (t) {
+    t.test('both arrays', function (st) {
+        var a = [1];
+        var b = [2];
+        var combined = utils.combine(a, b);
+
+        st.deepEqual(a, [1], 'a is not mutated');
+        st.deepEqual(b, [2], 'b is not mutated');
+        st.notEqual(a, combined, 'a !== combined');
+        st.notEqual(b, combined, 'b !== combined');
+        st.deepEqual(combined, [1, 2], 'combined is a + b');
+
+        st.end();
+    });
+
+    t.test('one array, one non-array', function (st) {
+        var aN = 1;
+        var a = [aN];
+        var bN = 2;
+        var b = [bN];
+
+        var combinedAnB = utils.combine(aN, b);
+        st.deepEqual(b, [bN], 'b is not mutated');
+        st.notEqual(aN, combinedAnB, 'aN + b !== aN');
+        st.notEqual(a, combinedAnB, 'aN + b !== a');
+        st.notEqual(bN, combinedAnB, 'aN + b !== bN');
+        st.notEqual(b, combinedAnB, 'aN + b !== b');
+        st.deepEqual([1, 2], combinedAnB, 'first argument is array-wrapped when not an array');
+
+        var combinedABn = utils.combine(a, bN);
+        st.deepEqual(a, [aN], 'a is not mutated');
+        st.notEqual(aN, combinedABn, 'a + bN !== aN');
+        st.notEqual(a, combinedABn, 'a + bN !== a');
+        st.notEqual(bN, combinedABn, 'a + bN !== bN');
+        st.notEqual(b, combinedABn, 'a + bN !== b');
+        st.deepEqual([1, 2], combinedABn, 'second argument is array-wrapped when not an array');
+
+        st.end();
+    });
+
+    t.test('neither is an array', function (st) {
+        var combined = utils.combine(1, 2);
+        st.notEqual(1, combined, '1 + 2 !== 1');
+        st.notEqual(2, combined, '1 + 2 !== 2');
+        st.deepEqual([1, 2], combined, 'both arguments are array-wrapped when not an array');
+
+        st.end();
+    });
+
+    t.end();
+});
+
+test('isBuffer()', function (t) {
+    forEach([null, undefined, true, false, '', 'abc', 42, 0, NaN, {}, [], function () {}, /a/g], function (x) {
+        t.equal(utils.isBuffer(x), false, inspect(x) + ' is not a buffer');
+    });
+
+    var fakeBuffer = { constructor: Buffer };
+    t.equal(utils.isBuffer(fakeBuffer), false, 'fake buffer is not a buffer');
+
+    var saferBuffer = SaferBuffer.from('abc');
+    t.equal(utils.isBuffer(saferBuffer), true, 'SaferBuffer instance is a buffer');
+
+    var buffer = Buffer.from && Buffer.alloc ? Buffer.from('abc') : new Buffer('abc');
+    t.equal(utils.isBuffer(buffer), true, 'real Buffer instance is a buffer');
+    t.end();
+});

package/dist/server/models/application.d.ts

@@ -6,5 +6,5 @@ export interface registerAppOptions extends Transactionable {
     appOptionsFactory: AppOptionsFactory;
 }
 export declare class ApplicationModel extends Model {
-    registerToMainApp(mainApp: Application, options: registerAppOptions): Application<import("@nocobase/server").DefaultState, import("@nocobase/server").DefaultContext>;
+    registerToSupervisor(mainApp: Application, options: registerAppOptions): Application<import("@nocobase/server").DefaultState, import("@nocobase/server").DefaultContext>;
 }

package/dist/server/models/application.js

@@ -4,7 +4,7 @@ var database = require('@nocobase/database');
 var server = require('@nocobase/server');
 
 class ApplicationModel extends database.Model {
-  registerToMainApp(mainApp, options) {
+  registerToSupervisor(mainApp, options) {
     const appName = this.get("name");
     const appOptions = this.get("options") || {};
     const subAppOptions = {
@@ -12,10 +12,7 @@ class ApplicationModel extends database.Model {
       ...appOptions,
       name: appName
     };
-    const subApp = new server.Application(subAppOptions);
-    mainApp.appManager.addSubApp(subApp);
-    console.log(`register application ${appName} to main app`);
-    return subApp;
+    return new server.Application(subAppOptions);
   }
 }
 

package/dist/server/server.d.ts

@@ -6,9 +6,9 @@ export declare class PluginMultiAppManager extends Plugin {
     appDbCreator: AppDbCreator;
     appOptionsFactory: AppOptionsFactory;
     private beforeGetApplicationMutex;
+    static getDatabaseConfig(app: Application): IDatabaseOptions;
     setAppOptionsFactory(factory: AppOptionsFactory): void;
     setAppDbCreator(appDbCreator: AppDbCreator): void;
-    static getDatabaseConfig(app: Application): IDatabaseOptions;
     beforeLoad(): void;
     load(): Promise<void>;
 }

package/dist/server/server.js

@@ -1,35 +1,19 @@
 'use strict';
 
-var Database = require('@nocobase/database');
+var database = require('@nocobase/database');
 var server = require('@nocobase/server');
+var asyncMutex = require('async-mutex');
 var lodash = require('lodash');
 var path = require('path');
-var application = require('./models/application');
-var asyncMutex = require('async-mutex');
+var qs = require('qs');
+var url = require('url');
+var server$1 = require('../server');
 
 function _interopDefault (e) { return e && e.__esModule ? e : { default: e }; }
 
-function _interopNamespace(e) {
-  if (e && e.__esModule) return e;
-  var n = Object.create(null);
-  if (e) {
-    Object.keys(e).forEach(function (k) {
-      if (k !== 'default') {
-        var d = Object.getOwnPropertyDescriptor(e, k);
-        Object.defineProperty(n, k, d.get ? d : {
-          enumerable: true,
-          get: function () { return e[k]; }
-        });
-      }
-    });
-  }
-  n.default = e;
-  return Object.freeze(n);
-}
-
-var Database__default = /*#__PURE__*/_interopDefault(Database);
 var lodash__default = /*#__PURE__*/_interopDefault(lodash);
-var path__namespace = /*#__PURE__*/_interopNamespace(path);
+var path__default = /*#__PURE__*/_interopDefault(path);
+var qs__default = /*#__PURE__*/_interopDefault(qs);
 
 const defaultDbCreator = async (app) => {
   const databaseOptions = app.options.database;
@@ -53,6 +37,7 @@ const defaultDbCreator = async (app) => {
     try {
       await client.query(`CREATE DATABASE "${database}"`);
     } catch (e) {
+      console.log(e);
     }
     await client.end();
   }
@@ -62,8 +47,8 @@ const defaultAppOptionsFactory = (appName, mainApp) => {
   if (rawDatabaseOptions.dialect === "sqlite") {
     const mainAppStorage = rawDatabaseOptions.storage;
     if (mainAppStorage !== ":memory:") {
-      const mainStorageDir = path__namespace.dirname(mainAppStorage);
-      rawDatabaseOptions.storage = path__namespace.join(mainStorageDir, `${appName}.sqlite`);
+      const mainStorageDir = path__default.default.dirname(mainAppStorage);
+      rawDatabaseOptions.storage = path__default.default.join(mainStorageDir, `${appName}.sqlite`);
     }
   } else {
     rawDatabaseOptions.database = appName;
@@ -83,23 +68,79 @@ class PluginMultiAppManager extends server.Plugin {
   appDbCreator = defaultDbCreator;
   appOptionsFactory = defaultAppOptionsFactory;
   beforeGetApplicationMutex = new asyncMutex.Mutex();
+  static getDatabaseConfig(app) {
+    const oldConfig = app.options.database instanceof database.Database ? app.options.database.options : app.options.database;
+    return lodash__default.default.cloneDeep(lodash__default.default.omit(oldConfig, ["migrator"]));
+  }
   setAppOptionsFactory(factory) {
     this.appOptionsFactory = factory;
   }
   setAppDbCreator(appDbCreator) {
     this.appDbCreator = appDbCreator;
   }
-  static getDatabaseConfig(app) {
-    const oldConfig = app.options.database instanceof Database__default.default ? app.options.database.options : app.options.database;
-    return lodash__default.default.cloneDeep(lodash__default.default.omit(oldConfig, ["migrator"]));
-  }
   beforeLoad() {
     this.db.registerModels({
-      ApplicationModel: application.ApplicationModel
+      ApplicationModel: server$1.ApplicationModel
     });
   }
   async load() {
-    this.app.appManager.setAppSelector(async (req) => {
+    await this.db.import({
+      directory: path.resolve(__dirname, "collections")
+    });
+    this.db.on("applications.afterCreateWithAssociations", async (model, options) => {
+      var _a;
+      const { transaction } = options;
+      const subApp = model.registerToSupervisor(this.app, {
+        appOptionsFactory: this.appOptionsFactory
+      });
+      await this.appDbCreator(subApp, transaction);
+      const startPromise = subApp.runAsCLI(["start", "--quickstart"], { from: "user" });
+      if ((_a = options == null ? void 0 : options.context) == null ? void 0 : _a.waitSubAppInstall) {
+        await startPromise;
+      }
+    });
+    this.db.on("applications.afterDestroy", async (model) => {
+      await server.AppSupervisor.getInstance().removeApp(model.get("name"));
+    });
+    const self = this;
+    async function LazyLoadApplication({
+      appSupervisor,
+      appName,
+      options
+    }) {
+      const name = appName;
+      if (appSupervisor.hasApp(name)) {
+        return;
+      }
+      const applicationRecord = await self.app.db.getRepository("applications").findOne({
+        filter: {
+          name
+        }
+      });
+      if (!applicationRecord) {
+        return;
+      }
+      const instanceOptions = applicationRecord.get("options");
+      if ((instanceOptions == null ? void 0 : instanceOptions.standaloneDeployment) && appSupervisor.runningMode !== "single") {
+        return;
+      }
+      if (!applicationRecord) {
+        return;
+      }
+      const subApp = applicationRecord.registerToSupervisor(self.app, {
+        appOptionsFactory: self.appOptionsFactory
+      });
+      if (!(options == null ? void 0 : options.upgrading)) {
+        await subApp.runCommand("start");
+      }
+    }
+    server.AppSupervisor.getInstance().setAppBootstrapper(LazyLoadApplication);
+    server.Gateway.getInstance().setAppSelector(async (req) => {
+      var _a;
+      const appName = (_a = qs__default.default.parse(url.parse(req.url).query)) == null ? void 0 : _a.__appName;
+      if (appName) {
+        return appName;
+      }
       if (req.headers["x-app"]) {
         return req.headers["x-app"];
       }
@@ -119,67 +160,16 @@ class PluginMultiAppManager extends server.Plugin {
       }
       return null;
     });
-    await this.db.import({
-      directory: path.resolve(__dirname, "collections")
-    });
-    this.db.on("applications.afterCreateWithAssociations", async (model, options) => {
-      const { transaction } = options;
-      const subApp = model.registerToMainApp(this.app, {
-        appOptionsFactory: this.appOptionsFactory
-      });
-      await this.appDbCreator(subApp, transaction);
-      await subApp.reload();
-      await subApp.db.sync();
-      await subApp.install();
-      await subApp.reload();
-    });
-    this.db.on("applications.afterDestroy", async (model) => {
-      await this.app.appManager.removeApplication(model.get("name"));
-    });
-    this.app.on(
-      "beforeGetApplication",
-      async ({ appManager, name, options }) => {
-        await this.beforeGetApplicationMutex.runExclusive(async () => {
-          if (appManager.applications.has(name)) {
-            return;
-          }
-          const applicationRecord = await this.app.db.getRepository("applications").findOne({
-            filter: {
-              name
-            }
-          });
-          const instanceOptions = applicationRecord.get("options");
-          if ((instanceOptions == null ? void 0 : instanceOptions.standaloneDeployment) && appManager.runningMode !== "single") {
-            return;
-          }
-          if (!applicationRecord) {
-            return;
-          }
-          const subApp = await applicationRecord.registerToMainApp(this.app, {
-            appOptionsFactory: this.appOptionsFactory
-          });
-          if (!(options == null ? void 0 : options.upgrading)) {
-            await subApp.load();
-          }
-        });
-      }
-    );
     this.app.on("afterStart", async (app) => {
       const repository = this.db.getRepository("applications");
-      const appManager = this.app.appManager;
-      if (appManager.runningMode == "single") {
+      const appSupervisor = server.AppSupervisor.getInstance();
+      this.app.setMaintainingMessage("starting sub applications...");
+      if (appSupervisor.runningMode == "single") {
+        server.Gateway.getInstance().setAppSelector(() => appSupervisor.singleAppName);
         try {
-          const subApp = await repository.findOne({
-            filter: {
-              name: appManager.singleAppName
-            }
-          });
-          const registeredApp = await subApp.registerToMainApp(this.app, {
-            appOptionsFactory: this.appOptionsFactory
-          });
-          await registeredApp.load();
+          await server.AppSupervisor.getInstance().getApp(appSupervisor.singleAppName);
         } catch (err) {
-          console.error("Auto register sub application in single mode failed: ", appManager.singleAppName, err);
+          console.error("Auto register sub application in single mode failed: ", appSupervisor.singleAppName, err);
         }
         return;
       }
@@ -189,43 +179,47 @@ class PluginMultiAppManager extends server.Plugin {
             "options.autoStart": true
           }
         });
-        for (const subApp of subApps) {
-          const registeredApp = await subApp.registerToMainApp(this.app, {
-            appOptionsFactory: this.appOptionsFactory
-          });
-          await registeredApp.load();
+        const promises = [];
+        for (const subAppInstance of subApps) {
+          promises.push(
+            (async () => {
+              await server.AppSupervisor.getInstance().getApp(subAppInstance.name);
+            })()
+          );
         }
+        await Promise.all(promises);
       } catch (err) {
         console.error("Auto register sub applications failed: ", err);
       }
     });
     this.app.on("afterUpgrade", async (app, options) => {
-      const cliArgs = options == null ? void 0 : options.cliArgs;
+      options == null ? void 0 : options.cliArgs;
       const repository = this.db.getRepository("applications");
       const findOptions = {};
-      const appManager = this.app.appManager;
-      if (appManager.runningMode == "single") {
+      const appSupervisor = server.AppSupervisor.getInstance();
+      if (appSupervisor.runningMode == "single") {
         findOptions["filter"] = {
-          name: appManager.singleAppName
+          name: appSupervisor.singleAppName
         };
       }
       const instances = await repository.find(findOptions);
       for (const instance of instances) {
         const instanceOptions = instance.get("options");
-        if ((instanceOptions == null ? void 0 : instanceOptions.standaloneDeployment) && appManager.runningMode !== "single") {
+        if ((instanceOptions == null ? void 0 : instanceOptions.standaloneDeployment) && appSupervisor.runningMode !== "single") {
           continue;
         }
-        const subApp = await appManager.getApplication(instance.name, {
+        const beforeSubAppStatus = server.AppSupervisor.getInstance().getAppStatus(instance.name);
+        const subApp = await appSupervisor.getApp(instance.name, {
           upgrading: true
         });
+        console.log({ beforeSubAppStatus });
         try {
+          this.app.setMaintainingMessage(`upgrading sub app ${instance.name}...`);
           console.log(`${instance.name}: upgrading...`);
-          await subApp.upgrade({
-            cliArgs
-          });
-          await subApp.stop({
-            cliArgs
-          });
+          await subApp.runAsCLI(["upgrade"], { from: "user" });
+          if (!beforeSubAppStatus && server.AppSupervisor.getInstance().getAppStatus(instance.name) === "initialized") {
+            await server.AppSupervisor.getInstance().removeApp(instance.name);
+          }
         } catch (error) {
           console.log(`${instance.name}: upgrade failed`);
           this.app.logger.error(error);
@@ -254,6 +248,17 @@ class PluginMultiAppManager extends server.Plugin {
         applications`,
       actions: ["applications:*"]
     });
+    this.app.resourcer.use(async (ctx, next) => {
+      await next();
+      const { actionName, resourceName, params } = ctx.action;
+      if (actionName === "list" && resourceName === "applications") {
+        const applications = ctx.body.rows;
+        for (const application of applications) {
+          const appStatus = server.AppSupervisor.getInstance().getAppStatus(application.name, "stopped");
+          application.status = appStatus;
+        }
+      }
+    });
   }
 }
 

package/dist/swagger/index.d.ts

@@ -0,0 +1,192 @@
+declare const _default: {
+    info: {
+        title: string;
+    };
+    tags: any[];
+    paths: {
+        '/applications:list': {
+            get: {
+                tags: string[];
+                description: string;
+                responses: {
+                    200: {
+                        description: string;
+                        content: {
+                            'application/json': {
+                                schema: {
+                                    $ref: string;
+                                };
+                            };
+                        };
+                    };
+                };
+            };
+        };
+        '/applications:create': {
+            post: {
+                tags: string[];
+                description: string;
+                requestBody: {
+                    required: boolean;
+                    content: {
+                        'application/json': {
+                            schema: {
+                                $ref: string;
+                            };
+                        };
+                    };
+                };
+                responses: {
+                    200: {
+                        description: string;
+                        content: {
+                            'application/json': {
+                                schema: {
+                                    $ref: string;
+                                };
+                            };
+                        };
+                    };
+                };
+            };
+        };
+        '/applications:update': {
+            post: {
+                tags: string[];
+                description: string;
+                parameters: {
+                    name: string;
+                    in: string;
+                    description: string;
+                    required: boolean;
+                    schema: {
+                        type: string;
+                    };
+                }[];
+                requestBody: {
+                    required: boolean;
+                    content: {
+                        'application/json': {
+                            schema: {
+                                $ref: string;
+                            };
+                        };
+                    };
+                };
+                responses: {
+                    200: {
+                        description: string;
+                        content: {
+                            'application/json': {
+                                schema: {
+                                    $ref: string;
+                                };
+                            };
+                        };
+                    };
+                };
+            };
+        };
+        '/applications:destroy': {
+            post: {
+                tags: string[];
+                description: string;
+                parameters: {
+                    name: string;
+                    in: string;
+                    description: string;
+                    required: boolean;
+                    schema: {
+                        type: string;
+                    };
+                }[];
+                responses: {
+                    200: {
+                        description: string;
+                    };
+                };
+            };
+        };
+    };
+    components: {
+        schemas: {
+            applicationFrom: {
+                allOf: ({
+                    $ref: string;
+                    type?: undefined;
+                    properties?: undefined;
+                } | {
+                    type: string;
+                    properties: {
+                        createdAt: {
+                            readOnly: boolean;
+                        };
+                        updatedAt: {
+                            readOnly: boolean;
+                        };
+                        status: {
+                            readOnly: boolean;
+                        };
+                    };
+                    $ref?: undefined;
+                })[];
+            };
+            application: {
+                type: string;
+                properties: {
+                    name: {
+                        type: string;
+                        example: string;
+                        description: string;
+                    };
+                    displayName: {
+                        type: string;
+                        example: string;
+                        description: string;
+                    };
+                    pinned: {
+                        type: string;
+                        example: boolean;
+                        description: string;
+                    };
+                    cname: {
+                        type: string;
+                        example: string;
+                        description: string;
+                    };
+                    status: {
+                        type: string;
+                        example: string;
+                        description: string;
+                    };
+                    options: {
+                        type: string;
+                        properties: {
+                            standaloneDeployment: {
+                                type: string;
+                                example: boolean;
+                                description: string;
+                            };
+                            autoStart: {
+                                type: string;
+                                example: boolean;
+                                description: string;
+                            };
+                        };
+                    };
+                    createdAt: {
+                        type: string;
+                        format: string;
+                        description: string;
+                    };
+                    updatedAt: {
+                        type: string;
+                        format: string;
+                        description: string;
+                    };
+                };
+            };
+        };
+    };
+};
+export default _default;