@nocobase/server 2.1.0-alpha.14 → 2.1.0-alpha.16

package/lib/commands/pm.js

@@ -32,9 +32,39 @@ __export(pm_exports, {
 module.exports = __toCommonJS(pm_exports);
 var import_app_supervisor = require("../app-supervisor");
 var import_plugin_command_error = require("../errors/plugin-command-error");
+var import_plugin_manager = require("../plugin-manager");
+var import_findPackageNames = require("../plugin-manager/findPackageNames");
 /* istanbul ignore file -- @preserve */
 var pm_default = /* @__PURE__ */ __name((app) => {
   const pm = app.command("pm");
+  pm.command("list").action(async () => {
+    const plugins1 = await (0, import_findPackageNames.findBuiltInPlugins)();
+    const plugins2 = await (0, import_findPackageNames.findLocalPlugins)();
+    let enabledPlugins = [];
+    try {
+      enabledPlugins = (await app.pm.repository.find({
+        filter: {
+          enabled: true
+        }
+      })).map((item) => item.packageName);
+    } catch (error) {
+    }
+    const items = await Promise.all(
+      [...plugins1, ...plugins2].map(async (name) => {
+        const item = await import_plugin_manager.PluginManager.parseName(name);
+        const json = await import_plugin_manager.PluginManager.getPackageJson(item.packageName);
+        return {
+          displayName: json.displayName || name,
+          packageName: item.packageName,
+          enabled: enabledPlugins.includes(item.packageName),
+          description: json.description
+        };
+      })
+    );
+    console.log("--- BEGIN_PLUGIN_LIST_JSON ---");
+    console.log(JSON.stringify(items));
+    console.log("--- END_PLUGIN_LIST_JSON ---");
+  });
   pm.command("create").argument("plugin").option("--force-recreate").action(async (plugin, options) => {
     await app.pm.create(plugin, options);
   });

package/lib/plugin-manager/plugin-manager.d.ts

@@ -13,7 +13,6 @@ import Application from '../application';
 import { Plugin } from '../plugin';
 import { PluginManagerRepository } from './plugin-manager-repository';
 import { PluginData } from './types';
-import { checkAndGetCompatible } from './utils';
 export declare const sleep: (timeout?: number) => Promise<unknown>;
 export interface PluginManagerOptions {
     app: Application;
@@ -29,7 +28,12 @@ export declare class AddPresetError extends Error {
 }
 export declare class PluginManager {
     options: PluginManagerOptions;
-    static checkAndGetCompatible: typeof checkAndGetCompatible;
+    private static compatibleCache;
+    private static compatiblePending;
+    static checkAndGetCompatible(packageName: string): Promise<{
+        isCompatible: boolean;
+        depsCompatible: import("./utils").DepCompatible[];
+    }>;
     /**
      * @internal
      */

package/lib/plugin-manager/plugin-manager.js

@@ -101,6 +101,23 @@ const _PluginManager = class _PluginManager {
     });
     this.app.resourceManager.use(import_middleware.uploadMiddleware, { tag: "upload", after: "acl" });
   }
+  static async checkAndGetCompatible(packageName) {
+    if (this.compatibleCache.has(packageName)) {
+      return this.compatibleCache.get(packageName);
+    }
+    const pending = this.compatiblePending.get(packageName);
+    if (pending) {
+      return pending;
+    }
+    const task = (0, import_utils2.checkAndGetCompatible)(packageName).then((compatible) => {
+      this.compatibleCache.set(packageName, compatible);
+      return compatible;
+    }).finally(() => {
+      this.compatiblePending.delete(packageName);
+    });
+    this.compatiblePending.set(packageName, task);
+    return task;
+  }
   /**
    * @internal
    */
@@ -1108,7 +1125,8 @@ const _PluginManager = class _PluginManager {
   }
 };
 __name(_PluginManager, "PluginManager");
-__publicField(_PluginManager, "checkAndGetCompatible", import_utils2.checkAndGetCompatible);
+__publicField(_PluginManager, "compatibleCache", /* @__PURE__ */ new Map());
+__publicField(_PluginManager, "compatiblePending", /* @__PURE__ */ new Map());
 __publicField(_PluginManager, "parsedNames", {});
 let PluginManager = _PluginManager;
 var plugin_manager_default = PluginManager;

package/lib/swagger/app.d.ts

@@ -0,0 +1,102 @@
+/**
+ * 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.
+ */
+declare const _default: {
+    readonly '/app:getLang': {
+        readonly get: {
+            readonly tags: readonly ["app"];
+            readonly summary: "Get the current application language";
+            readonly description: "Return the current locale used by the server.";
+            readonly parameters: readonly [];
+            readonly responses: {
+                readonly 200: {
+                    readonly description: "OK";
+                    readonly content: {
+                        readonly 'application/json': {
+                            readonly schema: {
+                                readonly type: "string";
+                            };
+                        };
+                    };
+                };
+            };
+        };
+    };
+    readonly '/app:getInfo': {
+        readonly get: {
+            readonly tags: readonly ["app"];
+            readonly summary: "Get application metadata";
+            readonly description: "Return basic application information, including version and environment-related metadata.";
+            readonly parameters: readonly [];
+            readonly responses: {
+                readonly 200: {
+                    readonly description: "OK";
+                    readonly content: {
+                        readonly 'application/json': {
+                            readonly schema: {
+                                readonly type: "object";
+                                readonly additionalProperties: true;
+                            };
+                        };
+                    };
+                };
+            };
+        };
+    };
+    readonly '/app:getPlugins': {
+        readonly get: {
+            readonly tags: readonly ["app"];
+            readonly summary: "List loaded plugins";
+            readonly description: "Return plugin metadata for the current application runtime.";
+            readonly parameters: readonly [];
+            readonly responses: {
+                readonly 200: {
+                    readonly description: "OK";
+                    readonly content: {
+                        readonly 'application/json': {
+                            readonly schema: {
+                                readonly type: "array";
+                                readonly items: {
+                                    readonly type: "object";
+                                    readonly additionalProperties: true;
+                                };
+                            };
+                        };
+                    };
+                };
+            };
+        };
+    };
+    readonly '/app:restart': {
+        readonly post: {
+            readonly tags: readonly ["app"];
+            readonly summary: "Restart the application";
+            readonly description: "Trigger an application restart asynchronously.";
+            readonly parameters: readonly [];
+            readonly responses: {
+                readonly 200: {
+                    readonly description: "OK";
+                };
+            };
+        };
+    };
+    readonly '/app:clearCache': {
+        readonly post: {
+            readonly tags: readonly ["app"];
+            readonly summary: "Clear application cache";
+            readonly description: "Clear server-side caches used by the current application instance.";
+            readonly parameters: readonly [];
+            readonly responses: {
+                readonly 200: {
+                    readonly description: "OK";
+                };
+            };
+        };
+    };
+};
+export default _default;

package/lib/swagger/app.js

@@ -0,0 +1,124 @@
+/**
+ * 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 __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 app_exports = {};
+__export(app_exports, {
+  default: () => app_default
+});
+module.exports = __toCommonJS(app_exports);
+var app_default = {
+  "/app:getLang": {
+    get: {
+      tags: ["app"],
+      summary: "Get the current application language",
+      description: "Return the current locale used by the server.",
+      parameters: [],
+      responses: {
+        200: {
+          description: "OK",
+          content: {
+            "application/json": {
+              schema: {
+                type: "string"
+              }
+            }
+          }
+        }
+      }
+    }
+  },
+  "/app:getInfo": {
+    get: {
+      tags: ["app"],
+      summary: "Get application metadata",
+      description: "Return basic application information, including version and environment-related metadata.",
+      parameters: [],
+      responses: {
+        200: {
+          description: "OK",
+          content: {
+            "application/json": {
+              schema: {
+                type: "object",
+                additionalProperties: true
+              }
+            }
+          }
+        }
+      }
+    }
+  },
+  "/app:getPlugins": {
+    get: {
+      tags: ["app"],
+      summary: "List loaded plugins",
+      description: "Return plugin metadata for the current application runtime.",
+      parameters: [],
+      responses: {
+        200: {
+          description: "OK",
+          content: {
+            "application/json": {
+              schema: {
+                type: "array",
+                items: {
+                  type: "object",
+                  additionalProperties: true
+                }
+              }
+            }
+          }
+        }
+      }
+    }
+  },
+  "/app:restart": {
+    post: {
+      tags: ["app"],
+      summary: "Restart the application",
+      description: "Trigger an application restart asynchronously.",
+      parameters: [],
+      responses: {
+        200: {
+          description: "OK"
+        }
+      }
+    }
+  },
+  "/app:clearCache": {
+    post: {
+      tags: ["app"],
+      summary: "Clear application cache",
+      description: "Clear server-side caches used by the current application instance.",
+      parameters: [],
+      responses: {
+        200: {
+          description: "OK"
+        }
+      }
+    }
+  }
+};

package/lib/swagger/base.d.ts

@@ -0,0 +1,244 @@
+/**
+ * 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.
+ */
+declare const _default: {
+    readonly openapi: "3.0.2";
+    readonly info: {
+        readonly title: "NocoBase API - Core";
+    };
+    readonly tags: readonly [{
+        readonly name: "$collection";
+        readonly description: "Data table";
+    }, {
+        readonly name: "$collection.$oneToOneAssociation";
+        readonly description: "One to one relationship";
+    }, {
+        readonly name: "$collection.$manyToOneAssociation";
+        readonly description: "Many to one relationship";
+    }, {
+        readonly name: "$collection.$oneToManyAssociation";
+        readonly description: "One to many relationship";
+    }, {
+        readonly name: "$collection.$manyToManyAssociation";
+        readonly description: "Many to many relationship";
+    }, {
+        readonly name: "app";
+        readonly description: "app";
+    }, {
+        readonly name: "pm";
+        readonly description: "pm";
+    }];
+    readonly components: {
+        readonly parameters: {
+            readonly collectionName: {
+                readonly required: true;
+                readonly name: "collectionName";
+                readonly in: "path";
+                readonly description: "Collection name";
+                readonly schema: {
+                    readonly type: "string";
+                };
+            };
+            readonly collectionIndex: {
+                readonly required: true;
+                readonly name: "collectionIndex";
+                readonly in: "path";
+                readonly description: "Collection index";
+                readonly schema: {
+                    readonly type: "integer";
+                    readonly format: "int64";
+                };
+            };
+            readonly oneToOneAssociation: {
+                readonly required: true;
+                readonly name: "oneToOneAssociation";
+                readonly in: "path";
+                readonly description: "Association name";
+                readonly schema: {
+                    readonly type: "string";
+                };
+            };
+            readonly manyToOneAssociation: {
+                readonly required: true;
+                readonly name: "manyToOneAssociation";
+                readonly in: "path";
+                readonly description: "Association name";
+                readonly schema: {
+                    readonly type: "string";
+                };
+            };
+            readonly oneToManyAssociation: {
+                readonly required: true;
+                readonly name: "oneToManyAssociation";
+                readonly in: "path";
+                readonly description: "Association name";
+                readonly schema: {
+                    readonly type: "string";
+                };
+            };
+            readonly manyToManyAssociation: {
+                readonly required: true;
+                readonly name: "manyToManyAssociation";
+                readonly in: "path";
+                readonly description: "Association name";
+                readonly schema: {
+                    readonly type: "string";
+                };
+            };
+            readonly page: {
+                readonly name: "page";
+                readonly in: "query";
+                readonly description: "page number";
+                readonly required: false;
+                readonly schema: {
+                    readonly type: "integer";
+                };
+            };
+            readonly pageSize: {
+                readonly name: "pageSize";
+                readonly in: "query";
+                readonly description: "page size";
+                readonly required: false;
+                readonly schema: {
+                    readonly type: "integer";
+                };
+            };
+            readonly filterByTk: {
+                readonly name: "filterByTk";
+                readonly in: "query";
+                readonly description: "filter by TK(default by ID)";
+                readonly schema: {
+                    readonly type: "string";
+                };
+            };
+            readonly filterByTks: {
+                readonly name: "filterByTks";
+                readonly in: "query";
+                readonly description: "filter by TKs(default by ID), example: `1,2,3`";
+                readonly schema: {
+                    readonly type: "string";
+                };
+            };
+            readonly filter: {
+                readonly name: "filter";
+                readonly in: "query";
+                readonly description: "filter items";
+                readonly content: {
+                    readonly 'application/json': {
+                        readonly schema: {
+                            readonly type: "object";
+                        };
+                    };
+                };
+            };
+            readonly sort: {
+                readonly name: "sort";
+                readonly in: "query";
+                readonly description: "sort items by fields, example: `-field1,-field2,field3`";
+                readonly schema: {
+                    readonly oneOf: readonly [{
+                        readonly type: "array";
+                        readonly items: {
+                            readonly type: "string";
+                        };
+                        readonly example: readonly ["-id", "createdAt"];
+                    }, {
+                        readonly type: "string";
+                        readonly example: "-id,createdAt";
+                    }];
+                };
+            };
+            readonly fields: {
+                readonly name: "fields";
+                readonly in: "query";
+                readonly description: "select fields, example: `field1,field2`";
+                readonly schema: {
+                    readonly oneOf: readonly [{
+                        readonly type: "array";
+                        readonly items: {
+                            readonly type: "string";
+                        };
+                        readonly example: readonly ["id", "createdAt"];
+                    }, {
+                        readonly type: "string";
+                        readonly example: "id,createdAt";
+                    }];
+                };
+            };
+            readonly except: {
+                readonly name: "except";
+                readonly in: "query";
+                readonly description: "except fields in results, example: `field1,field2`";
+                readonly schema: {
+                    readonly oneOf: readonly [{
+                        readonly type: "array";
+                        readonly items: {
+                            readonly type: "string";
+                        };
+                        readonly example: readonly ["id", "createdAt"];
+                    }, {
+                        readonly type: "string";
+                        readonly example: "id,createdAt";
+                    }];
+                };
+            };
+            readonly appends: {
+                readonly name: "appends";
+                readonly in: "query";
+                readonly description: "append associations in results, example: `assoc1,assoc2`";
+                readonly schema: {
+                    readonly oneOf: readonly [{
+                        readonly type: "array";
+                        readonly items: {
+                            readonly type: "string";
+                        };
+                        readonly example: readonly ["id", "createdAt"];
+                    }, {
+                        readonly type: "string";
+                        readonly example: "id,createdAt";
+                    }];
+                };
+            };
+            readonly whitelist: {
+                readonly name: "whitelist";
+                readonly in: "query";
+                readonly description: "whitelist for fields changes, example: `field1,field2`";
+                readonly schema: {
+                    readonly oneOf: readonly [{
+                        readonly type: "array";
+                        readonly items: {
+                            readonly type: "string";
+                        };
+                        readonly example: readonly ["id", "createdAt"];
+                    }, {
+                        readonly type: "string";
+                        readonly example: "id,createdAt";
+                    }];
+                };
+            };
+            readonly blacklist: {
+                readonly name: "blacklist";
+                readonly in: "query";
+                readonly description: "blacklist for fields changes, example: `field1,field2`";
+                readonly schema: {
+                    readonly oneOf: readonly [{
+                        readonly type: "array";
+                        readonly items: {
+                            readonly type: "string";
+                        };
+                        readonly example: readonly ["id", "createdAt"];
+                    }, {
+                        readonly type: "string";
+                        readonly example: "id,createdAt";
+                    }];
+                };
+            };
+        };
+    };
+};
+export default _default;