@nocobase/server 2.1.0-alpha.15 → 2.1.0-alpha.17

package/lib/app-supervisor/app-options-factory.d.ts

@@ -16,6 +16,7 @@ export declare const appOptionsFactory: (appName: string, mainApp: Application,
         migrator?: any;
         usingBigIntForId?: boolean;
         underscored?: boolean;
+        rawTimezone?: string;
         logger?: import("@nocobase/logger/lib/logger").Logger | import("@nocobase/logger/lib/logger").LoggerOptions;
         customHooks?: any;
         instanceId?: string;

package/lib/commands/pm.js

@@ -32,35 +32,12 @@ __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");
+var import_utils = require("../plugin-manager/utils");
 /* 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
-        };
-      })
-    );
+    const items = await (0, import_utils.pmListSummary)(app);
     console.log("--- BEGIN_PLUGIN_LIST_JSON ---");
     console.log(JSON.stringify(items));
     console.log("--- END_PLUGIN_LIST_JSON ---");

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

@@ -24,7 +24,7 @@ declare const _default: {
         enable(ctx: any, next: any): Promise<void>;
         disable(ctx: any, next: any): Promise<void>;
         remove(ctx: any, next: any): Promise<void>;
-        list(ctx: any, next: any): Promise<void>;
+        list(ctx: any, next: any): Promise<any>;
         listEnabled(ctx: any, next: any): Promise<void>;
         listEnabledV2(ctx: any, next: any): Promise<void>;
         get(ctx: any, next: any): Promise<void>;

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

@@ -48,6 +48,7 @@ var import_fs = __toESM(require("fs"));
 var import_fs_extra = __toESM(require("fs-extra"));
 var import_path = __toESM(require("path"));
 var import_crypto = __toESM(require("crypto"));
+var import_utils2 = require("../utils");
 var import_package = __toESM(require("../../../package.json"));
 const PLUGIN_CLIENT_ENTRY_FILES = {
   client: "dist/client/index.js",
@@ -240,6 +241,11 @@ var resource_default = {
       await next();
     },
     async list(ctx, next) {
+      const { mode } = ctx.action.params;
+      if (mode === "summary") {
+        ctx.body = await (0, import_utils2.pmListSummary)(ctx.app);
+        return next();
+      }
       const locale = ctx.getCurrentLocale();
       const pm = ctx.app.pm;
       const plugin = pm.get("nocobase");

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

@@ -9,6 +9,7 @@
 import { AxiosRequestConfig } from 'axios';
 import { PluginManagerRepository } from './plugin-manager-repository';
 import { PluginData } from './types';
+import Application from '../application';
 /**
  * get temp dir
  *
@@ -112,4 +113,10 @@ export declare function checkAndGetCompatible(packageName: string): Promise<{
     depsCompatible: DepCompatible[];
 }>;
 export declare function getPluginBasePath(packageName: string): Promise<string>;
+export declare function pmListSummary(app: Application): Promise<{
+    displayName: any;
+    packageName: any;
+    enabled: boolean;
+    description: any;
+}[]>;
 export {};

package/lib/plugin-manager/utils.js

@@ -65,6 +65,7 @@ __export(utils_exports, {
   getTempDir: () => getTempDir,
   isNotBuiltinModule: () => isNotBuiltinModule,
   isValidPackageName: () => isValidPackageName,
+  pmListSummary: () => pmListSummary,
   readJSONFileContent: () => readJSONFileContent,
   removePluginPackage: () => removePluginPackage,
   removeRequireCache: () => removeRequireCache,
@@ -88,6 +89,8 @@ var import_semver = __toESM(require("semver"));
 var import_clientStaticUtils = require("./clientStaticUtils");
 var import_constants = require("./constants");
 var import_deps = __toESM(require("./deps"));
+var import_findPackageNames = require("./findPackageNames");
+var import_plugin_manager = __toESM(require("./plugin-manager"));
 /* istanbul ignore next -- @preserve */
 async function getTempDir() {
   const temporaryDirectory = await import_fs_extra.default.realpath(import_os.default.tmpdir());
@@ -525,6 +528,33 @@ async function getPluginBasePath(packageName) {
   return import_path.default.dirname(import_path.default.dirname(file));
 }
 __name(getPluginBasePath, "getPluginBasePath");
+async function pmListSummary(app) {
+  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.default.parseName(name);
+      const json = await import_plugin_manager.default.getPackageJson(item.packageName);
+      return {
+        displayName: json.displayName || name,
+        packageName: item.packageName,
+        enabled: enabledPlugins.includes(item.packageName),
+        description: json.description
+      };
+    })
+  );
+  return items;
+}
+__name(pmListSummary, "pmListSummary");
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   checkAndGetCompatible,
@@ -555,6 +585,7 @@ __name(getPluginBasePath, "getPluginBasePath");
   getTempDir,
   isNotBuiltinModule,
   isValidPackageName,
+  pmListSummary,
   readJSONFileContent,
   removePluginPackage,
   removeRequireCache,

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;