@nocobase/plugin-client 2.1.0-beta.8 → 2.1.0

package/dist/server/server.js

@@ -82,7 +82,7 @@ class PluginClientServer extends import_server.Plugin {
     this.app.acl.allow("app", "getInfo");
     this.app.acl.registerSnippet({
       name: "app",
-      actions: ["app:restart", "app:refresh", "app:clearCache"]
+      actions: ["app:restart", "app:refresh", "app:clearCache", "app:publishEvent"]
     });
     const dialect = this.app.db.sequelize.getDialect();
     this.app.resourceManager.define({
@@ -139,10 +139,36 @@ class PluginClientServer extends import_server.Plugin {
         async refresh(ctx, next) {
           ctx.app.runCommand("refresh");
           await next();
+        },
+        async publishEvent(ctx, next) {
+          var _a, _b, _c;
+          const { plugin, command, payload } = ((_b = (_a = ctx.action) == null ? void 0 : _a.params) == null ? void 0 : _b.values) ?? {};
+          if (!plugin || typeof plugin !== "string") {
+            ctx.throw(400, "Plugin is required");
+            return;
+          }
+          if (!command || typeof command !== "string") {
+            ctx.throw(400, "Command is required");
+            return;
+          }
+          const { id, username } = ((_c = ctx.auth) == null ? void 0 : _c.user) ?? {};
+          const user = id ? { id, username } : void 0;
+          const eventName = `${command}@${plugin}`;
+          try {
+            await ctx.app.eventQueue.publish(eventName, {
+              plugin,
+              command,
+              user,
+              payload: payload ?? {}
+            });
+          } catch (err) {
+            ctx.app.logger.warn(`fail to publish event to [${eventName}]: ${err.message}`, payload);
+          }
+          await next();
         }
       }
     });
-    this.app.auditManager.registerActions(["app:restart", "app:refresh", "app:clearCache"]);
+    this.app.auditManager.registerActions(["app:restart", "app:refresh", "app:clearCache", "app:publishEvent"]);
     this.registerActionHandlers();
     this.bindNewMenuToRoles();
     this.setACL();
@@ -189,15 +215,48 @@ class PluginClientServer extends import_server.Plugin {
         instance.allowNewMenu === void 0 ? ["admin", "member"].includes(instance.name) : !!instance.allowNewMenu
       );
     });
-    this.db.on("desktopRoutes.afterDestroy", async (instance, { transaction }) => {
-      const r = this.db.getRepository("flowModels");
-      if (r) {
-        await r.destroy({
+    const collectDesktopRouteSchemaUids = async (instance, transaction) => {
+      const routeRepo = this.db.getRepository("desktopRoutes");
+      const schemaUids = /* @__PURE__ */ new Set();
+      const pendingIds = [];
+      const rootId = instance.get("id");
+      const rootSchemaUid = instance.get("schemaUid");
+      if (rootSchemaUid) {
+        schemaUids.add(rootSchemaUid);
+      }
+      if (rootId) {
+        pendingIds.push(rootId);
+      }
+      while (pendingIds.length) {
+        const routes = await routeRepo.find({
+          fields: ["id", "schemaUid"],
           filter: {
-            uid: instance.get("schemaUid")
+            parentId: {
+              $in: pendingIds.splice(0, pendingIds.length)
+            }
           },
           transaction
         });
+        for (const route of routes) {
+          const schemaUid = route.get("schemaUid");
+          const id = route.get("id");
+          if (schemaUid) {
+            schemaUids.add(schemaUid);
+          }
+          if (id) {
+            pendingIds.push(id);
+          }
+        }
+      }
+      return Array.from(schemaUids);
+    };
+    this.db.on("desktopRoutes.beforeDestroy", async (instance, { transaction }) => {
+      const r = this.db.getRepository("flowModels");
+      if (r == null ? void 0 : r.remove) {
+        const schemaUids = await collectDesktopRouteSchemaUids(instance, transaction);
+        for (const schemaUid of schemaUids) {
+          await r.remove(schemaUid, { transaction });
+        }
       }
     });
     this.db.on("desktopRoutes.afterCreate", async (instance, { transaction }) => {
@@ -346,11 +405,7 @@ class PluginClientServer extends import_server.Plugin {
     });
   }
   registerLocalizationSource() {
-    const localizationPlugin = this.app.pm.get("localization");
-    if (!localizationPlugin) {
-      return;
-    }
-    localizationPlugin.sourceManager.registerSource("desktop-routes", {
+    this.app.localeManager.registerSource("desktop-routes", {
       title: (0, import_utils.tval)("Desktop routes"),
       sync: async (ctx) => {
         const desktopRoutes = await ctx.db.getRepository("desktopRoutes").find({

package/dist/swagger/index.d.ts

@@ -0,0 +1,248 @@
+/**
+ * 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: {
+    openapi: string;
+    info: {
+        title: string;
+        version: string;
+    };
+    paths: {
+        '/roles/{roleName}/desktopRoutes:add': {
+            post: {
+                tags: string[];
+                summary: string;
+                parameters: {
+                    $ref: string;
+                }[];
+                requestBody: {
+                    required: boolean;
+                    content: {
+                        'application/json': {
+                            schema: {
+                                $ref: string;
+                            };
+                        };
+                    };
+                };
+                responses: {
+                    200: {
+                        description: string;
+                    };
+                };
+            };
+        };
+        '/roles/{roleName}/desktopRoutes:remove': {
+            post: {
+                tags: string[];
+                summary: string;
+                parameters: {
+                    $ref: string;
+                }[];
+                requestBody: {
+                    required: boolean;
+                    content: {
+                        'application/json': {
+                            schema: {
+                                $ref: string;
+                            };
+                        };
+                    };
+                };
+                responses: {
+                    200: {
+                        description: string;
+                    };
+                };
+            };
+        };
+        '/roles/{roleName}/desktopRoutes:set': {
+            post: {
+                tags: string[];
+                summary: string;
+                parameters: {
+                    $ref: string;
+                }[];
+                requestBody: {
+                    required: boolean;
+                    content: {
+                        'application/json': {
+                            schema: {
+                                $ref: string;
+                            };
+                        };
+                    };
+                };
+                responses: {
+                    200: {
+                        description: string;
+                    };
+                };
+            };
+        };
+        '/roles/{roleName}/desktopRoutes:list': {
+            get: {
+                tags: string[];
+                summary: string;
+                parameters: {
+                    $ref: string;
+                }[];
+                responses: {
+                    200: {
+                        description: string;
+                        content: {
+                            'application/json': {
+                                schema: {
+                                    type: string;
+                                    properties: {
+                                        data: {
+                                            type: string;
+                                            items: {
+                                                $ref: string;
+                                            };
+                                        };
+                                        meta: {
+                                            type: string;
+                                            additionalProperties: boolean;
+                                        };
+                                    };
+                                };
+                            };
+                        };
+                    };
+                };
+            };
+        };
+        '/desktopRoutes:listAccessible': {
+            get: {
+                tags: string[];
+                summary: string;
+                parameters: {
+                    $ref: string;
+                }[];
+                responses: {
+                    200: {
+                        description: string;
+                        content: {
+                            'application/json': {
+                                schema: {
+                                    type: string;
+                                    properties: {
+                                        data: {
+                                            type: string;
+                                            items: {
+                                                $ref: string;
+                                            };
+                                        };
+                                        meta: {
+                                            type: string;
+                                            additionalProperties: boolean;
+                                        };
+                                    };
+                                };
+                            };
+                        };
+                    };
+                };
+            };
+        };
+    };
+    components: {
+        parameters: {
+            RoleNamePath: {
+                name: string;
+                in: string;
+                description: string;
+                required: boolean;
+                schema: {
+                    type: string;
+                };
+            };
+            PaginateQuery: {
+                name: string;
+                in: string;
+                description: string;
+                required: boolean;
+                schema: {
+                    type: string;
+                };
+            };
+            TreeQuery: {
+                name: string;
+                in: string;
+                description: string;
+                required: boolean;
+                schema: {
+                    type: string;
+                };
+            };
+            SortScalarQuery: {
+                name: string;
+                in: string;
+                description: string;
+                required: boolean;
+                schema: {
+                    type: string;
+                };
+            };
+            FilterQuery: {
+                name: string;
+                in: string;
+                description: string;
+                required: boolean;
+                schema: {
+                    type: string;
+                    additionalProperties: boolean;
+                };
+            };
+        };
+        schemas: {
+            RouteIdList: {
+                type: string;
+                description: string;
+                items: {
+                    type: string;
+                };
+            };
+            DesktopRoute: {
+                type: string;
+                properties: {
+                    id: {
+                        type: string;
+                    };
+                    title: {
+                        type: string;
+                    };
+                    type: {
+                        type: string;
+                    };
+                    path: {
+                        type: string;
+                        nullable: boolean;
+                    };
+                    parentId: {
+                        type: string;
+                        nullable: boolean;
+                    };
+                    hidden: {
+                        type: string;
+                        nullable: boolean;
+                    };
+                    children: {
+                        type: string;
+                        items: {
+                            $ref: string;
+                        };
+                    };
+                };
+                additionalProperties: boolean;
+            };
+        };
+    };
+};
+export default _default;

package/dist/swagger/index.js

@@ -0,0 +1,222 @@
+/**
+ * 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 swagger_exports = {};
+__export(swagger_exports, {
+  default: () => swagger_default
+});
+module.exports = __toCommonJS(swagger_exports);
+var swagger_default = {
+  openapi: "3.0.2",
+  info: {
+    title: "NocoBase API - Client plugin",
+    version: "1.0.0"
+  },
+  paths: {
+    "/roles/{roleName}/desktopRoutes:add": {
+      post: {
+        tags: ["roles.desktopRoutes"],
+        summary: "Add desktop route permissions to a role",
+        parameters: [{ $ref: "#/components/parameters/RoleNamePath" }],
+        requestBody: {
+          required: true,
+          content: {
+            "application/json": {
+              schema: { $ref: "#/components/schemas/RouteIdList" }
+            }
+          }
+        },
+        responses: {
+          200: { description: "OK" }
+        }
+      }
+    },
+    "/roles/{roleName}/desktopRoutes:remove": {
+      post: {
+        tags: ["roles.desktopRoutes"],
+        summary: "Remove desktop route permissions from a role",
+        parameters: [{ $ref: "#/components/parameters/RoleNamePath" }],
+        requestBody: {
+          required: true,
+          content: {
+            "application/json": {
+              schema: { $ref: "#/components/schemas/RouteIdList" }
+            }
+          }
+        },
+        responses: {
+          200: { description: "OK" }
+        }
+      }
+    },
+    "/roles/{roleName}/desktopRoutes:set": {
+      post: {
+        tags: ["roles.desktopRoutes"],
+        summary: "Set desktop route permissions for a role",
+        parameters: [{ $ref: "#/components/parameters/RoleNamePath" }],
+        requestBody: {
+          required: true,
+          content: {
+            "application/json": {
+              schema: { $ref: "#/components/schemas/RouteIdList" }
+            }
+          }
+        },
+        responses: {
+          200: { description: "OK" }
+        }
+      }
+    },
+    "/roles/{roleName}/desktopRoutes:list": {
+      get: {
+        tags: ["roles.desktopRoutes"],
+        summary: "List desktop routes granted to a role",
+        parameters: [
+          { $ref: "#/components/parameters/RoleNamePath" },
+          { $ref: "#/components/parameters/PaginateQuery" },
+          { $ref: "#/components/parameters/FilterQuery" }
+        ],
+        responses: {
+          200: {
+            description: "OK",
+            content: {
+              "application/json": {
+                schema: {
+                  type: "object",
+                  properties: {
+                    data: {
+                      type: "array",
+                      items: { $ref: "#/components/schemas/DesktopRoute" }
+                    },
+                    meta: {
+                      type: "object",
+                      additionalProperties: true
+                    }
+                  }
+                }
+              }
+            }
+          }
+        }
+      }
+    },
+    "/desktopRoutes:listAccessible": {
+      get: {
+        tags: ["desktopRoutes"],
+        summary: "List desktop routes accessible to the current user",
+        parameters: [
+          { $ref: "#/components/parameters/TreeQuery" },
+          { $ref: "#/components/parameters/SortScalarQuery" },
+          { $ref: "#/components/parameters/FilterQuery" }
+        ],
+        responses: {
+          200: {
+            description: "OK",
+            content: {
+              "application/json": {
+                schema: {
+                  type: "object",
+                  properties: {
+                    data: {
+                      type: "array",
+                      items: { $ref: "#/components/schemas/DesktopRoute" }
+                    },
+                    meta: {
+                      type: "object",
+                      additionalProperties: true
+                    }
+                  }
+                }
+              }
+            }
+          }
+        }
+      }
+    }
+  },
+  components: {
+    parameters: {
+      RoleNamePath: {
+        name: "roleName",
+        in: "path",
+        description: "Role name.",
+        required: true,
+        schema: { type: "string" }
+      },
+      PaginateQuery: {
+        name: "paginate",
+        in: "query",
+        description: "Whether to return paginated result format.",
+        required: false,
+        schema: { type: "boolean" }
+      },
+      TreeQuery: {
+        name: "tree",
+        in: "query",
+        description: "Whether to return routes as a tree.",
+        required: false,
+        schema: { type: "boolean" }
+      },
+      SortScalarQuery: {
+        name: "sort",
+        in: "query",
+        description: "Sort field, for example `sort`.",
+        required: false,
+        schema: { type: "string" }
+      },
+      FilterQuery: {
+        name: "filter",
+        in: "query",
+        description: "JSON filter object.",
+        required: false,
+        schema: { type: "object", additionalProperties: true }
+      }
+    },
+    schemas: {
+      RouteIdList: {
+        type: "array",
+        description: "Desktop route id list.",
+        items: { type: "integer" }
+      },
+      DesktopRoute: {
+        type: "object",
+        properties: {
+          id: { type: "integer" },
+          title: { type: "string" },
+          type: { type: "string" },
+          path: { type: "string", nullable: true },
+          parentId: { type: "integer", nullable: true },
+          hidden: { type: "boolean", nullable: true },
+          children: {
+            type: "array",
+            items: { $ref: "#/components/schemas/DesktopRoute" }
+          }
+        },
+        additionalProperties: true
+      }
+    }
+  }
+};

package/package.json

@@ -6,7 +6,7 @@
   "description": "Provides a client interface for the NocoBase server",
   "description.ru-RU": "Предоставляет клиентский интерфейс для сервера NocoBase",
   "description.zh-CN": "为 NocoBase 服务端提供客户端界面",
-  "version": "2.1.0-beta.8",
+  "version": "2.1.0",
   "main": "./dist/server/index.js",
   "license": "Apache-2.0",
   "devDependencies": {
@@ -17,11 +17,11 @@
   },
   "peerDependencies": {
     "@nocobase/client": "2.x",
+    "@nocobase/client-v2": "2.x",
     "@nocobase/database": "2.x",
-    "@nocobase/plugin-localization": "2.x",
     "@nocobase/server": "2.x",
     "@nocobase/test": "2.x",
     "@nocobase/utils": "2.x"
   },
-  "gitHead": "5099d561c5467292414c1e77ad6bad3730d97344"
+  "gitHead": "9373212dd0f22cd985be1e23674d6b454944b9ee"
 }

package/dist/swagger/index.json

@@ -1,7 +0,0 @@
-{
-  "openapi": "3.0.2",
-  "info": {
-    "title": "NocoBase API - Client plugin"
-  },
-  "paths": {}
-}