@nocobase/plugin-ui-schema-storage 1.9.0-beta.9 → 2.0.0-alpha.11

package/dist/externalVersion.js

@@ -8,14 +8,14 @@
  */
 
 module.exports = {
-  "@nocobase/client": "1.9.0-beta.9",
-  "@nocobase/database": "1.9.0-beta.9",
-  "@nocobase/cache": "1.9.0-beta.9",
-  "@nocobase/utils": "1.9.0-beta.9",
+  "@nocobase/client": "2.0.0-alpha.11",
+  "@nocobase/database": "2.0.0-alpha.11",
+  "@nocobase/cache": "2.0.0-alpha.11",
+  "@nocobase/utils": "2.0.0-alpha.11",
   "lodash": "4.17.21",
-  "@nocobase/server": "1.9.0-beta.9",
-  "@nocobase/plugin-localization": "1.9.0-beta.9",
-  "@nocobase/actions": "1.9.0-beta.9",
-  "@nocobase/resourcer": "1.9.0-beta.9",
-  "@formily/json-schema": "2.3.0"
+  "@nocobase/plugin-localization": "2.0.0-alpha.11",
+  "@nocobase/server": "2.0.0-alpha.11",
+  "@nocobase/actions": "2.0.0-alpha.11",
+  "@nocobase/resourcer": "2.0.0-alpha.11",
+  "@formily/json-schema": "2.3.7"
 };

package/dist/server/repository.d.ts

@@ -28,6 +28,7 @@ export interface removeParentOptions extends Transactionable {
 interface InsertAdjacentOptions extends removeParentOptions {
     wrap?: any;
 }
+export declare function transaction(transactionAbleArgPosition?: number): (target: any, propertyKey: string, descriptor: PropertyDescriptor) => PropertyDescriptor;
 export declare class UiSchemaRepository extends Repository {
     cache: Cache;
     get uiSchemasTableName(): any;
@@ -92,6 +93,7 @@ export declare class UiSchemaRepository extends Repository {
     protected insertAfterEnd(targetUid: string, schema: any, options?: InsertAdjacentOptions): Promise<any>;
     protected insertNodes(nodes: SchemaNode[], options?: Transactionable): Promise<any[]>;
     private doGetProperties;
+    findNodesById(uid: string, options?: GetJsonSchemaOptions): Promise<unknown[]>;
     private doGetJsonSchema;
     private ignoreSchemaProperties;
     private breakOnMatched;
@@ -99,5 +101,16 @@ export declare class UiSchemaRepository extends Repository {
     private regenerateUid;
     private insertSchemaRecord;
     private prepareSingleNodeForInsert;
+    static modelToSingleNodes(model: any, parentChildOptions?: any): SchemaNode[];
+    static nodeToModel(node: any): any;
+    static nodesToModel(nodes: any[], rootUid: string): any;
+    insertModel(model: any, options?: Transactionable): Promise<any>;
+    updateSingleNode(node: SchemaNode, options?: Transactionable): Promise<boolean>;
+    upsertModel(model: any, options?: Transactionable): Promise<string>;
+    findModelById(uid: string, options?: GetJsonSchemaOptions): Promise<any>;
+    findModelByParentId(parentUid: string, options?: GetJsonSchemaOptions & {
+        subKey?: string;
+    }): Promise<any>;
+    move(options: any): Promise<any>;
 }
 export default UiSchemaRepository;

package/dist/server/repository.js

@@ -45,7 +45,8 @@ var __decorateClass = (decorators, target, key, kind) => {
 var repository_exports = {};
 __export(repository_exports, {
   UiSchemaRepository: () => UiSchemaRepository,
-  default: () => repository_default
+  default: () => repository_default,
+  transaction: () => transaction
 });
 module.exports = __toCommonJS(repository_exports);
 var import_database = require("@nocobase/database");
@@ -217,6 +218,9 @@ const _UiSchemaRepository = class _UiSchemaRepository extends import_database.Re
       return schema;
     };
     const buildTree = (rootNode) => {
+      if (!rootNode) {
+        return null;
+      }
       const children = nodes.filter((node) => node.parent == rootNode["x-uid"]);
       if (children.length > 0) {
         const childrenGroupByType = import_lodash.default.groupBy(children, "type");
@@ -879,7 +883,7 @@ WHERE TreeTable.depth = 1 AND  TreeTable.ancestor = :ancestor and TreeTable.sort
     const schema = this.nodesToSchema(nodes[0], uid2);
     return import_lodash.default.pick(schema, ["type", "properties"]);
   }
-  async doGetJsonSchema(uid2, options) {
+  async findNodesById(uid2, options) {
     const db = this.database;
     const treeTable = this.uiSchemaTreePathTableName;
     const rawSql = `
@@ -899,9 +903,13 @@ WHERE TreeTable.depth = 1 AND  TreeTable.ancestor = :ancestor and TreeTable.sort
       transaction: options == null ? void 0 : options.transaction
     });
     if (nodes[0].length == 0) {
-      return {};
+      return [];
     }
-    return this.nodesToSchema(nodes[0], uid2);
+    return nodes[0];
+  }
+  async doGetJsonSchema(uid2, options) {
+    const nodes = await this.findNodesById(uid2, options);
+    return this.nodesToSchema(nodes, uid2);
   }
   ignoreSchemaProperties(schemaProperties) {
     return import_lodash.default.omit(schemaProperties, nodeKeys);
@@ -969,6 +977,175 @@ WHERE TreeTable.depth = 1 AND  TreeTable.ancestor = :ancestor and TreeTable.sort
     delete schema["childOptions"];
     return { uid: uid2, name, async, childOptions };
   }
+  static modelToSingleNodes(model, parentChildOptions = null) {
+    const { uid: oldUid, async, subModels, ...rest } = import_lodash.default.cloneDeep(model);
+    const currentUid = oldUid || (0, import_utils.uid)();
+    const node = {
+      "x-uid": currentUid,
+      "x-async": async || false,
+      name: currentUid,
+      ...rest
+    };
+    if (parentChildOptions) {
+      node.childOptions = parentChildOptions;
+    }
+    const nodes = [node];
+    if (Object.keys(subModels || {}).length > 0) {
+      for (const [subKey, subItems] of Object.entries(subModels)) {
+        const items = import_lodash.default.castArray(subItems);
+        let sort = 0;
+        for (const item of items) {
+          item.subKey = subKey;
+          item.subType = Array.isArray(subItems) ? "array" : "object";
+          const childOptions = {
+            parentUid: currentUid,
+            parentPath: [currentUid, ...(parentChildOptions == null ? void 0 : parentChildOptions.parentPath) || []].filter(Boolean),
+            type: subKey,
+            // type: 'properties',
+            sort: ++sort
+          };
+          const children = this.modelToSingleNodes(item, childOptions);
+          nodes.push(...children);
+        }
+      }
+    }
+    return nodes;
+  }
+  static nodeToModel(node) {
+    const { "x-uid": uid2, name, schema } = node;
+    const model = {
+      uid: uid2,
+      ...schema
+    };
+    return model;
+  }
+  static nodesToModel(nodes, rootUid) {
+    const nodeMap = /* @__PURE__ */ new Map();
+    for (const node of nodes) {
+      nodeMap.set(node["x-uid"], node);
+    }
+    const rootNode = nodeMap.get(rootUid);
+    if (!rootNode) return null;
+    const children = nodes.filter((n) => n.parent === rootUid);
+    const subModels = {};
+    for (const child of children) {
+      const { subKey, subType } = child.schema;
+      if (!subKey) continue;
+      const model = _UiSchemaRepository.nodesToModel(nodes, child["x-uid"]) || {
+        uid: child["x-uid"],
+        ...child.schema,
+        sortIndex: child.sort
+      };
+      model.sortIndex = child.sort;
+      if (subType === "array") {
+        if (!subModels[subKey]) subModels[subKey] = [];
+        subModels[subKey].push(model);
+      } else {
+        subModels[subKey] = model;
+      }
+    }
+    for (const key in subModels) {
+      if (Array.isArray(subModels[key])) {
+        subModels[key].sort((a, b) => (a.sortIndex ?? 0) - (b.sortIndex ?? 0));
+      }
+    }
+    const filteredSubModels = {};
+    for (const key in subModels) {
+      const value = subModels[key];
+      if (Array.isArray(value) && value.length === 0) continue;
+      if (!Array.isArray(value) && typeof value === "object" && value !== null && Object.keys(value).length === 0)
+        continue;
+      filteredSubModels[key] = value;
+    }
+    return {
+      uid: rootNode["x-uid"],
+      ...rootNode.schema,
+      ...Object.keys(filteredSubModels).length > 0 ? { subModels: filteredSubModels } : {}
+    };
+  }
+  async insertModel(model, options) {
+    const nodes = _UiSchemaRepository.modelToSingleNodes(model);
+    const rootUid = nodes[0]["x-uid"];
+    await this.insertNodes(nodes, options);
+    return await this.findModelById(rootUid, options);
+  }
+  async updateSingleNode(node, options) {
+    const instance = await this.model.findByPk(node["x-uid"], {
+      transaction: options == null ? void 0 : options.transaction
+    });
+    if (instance) {
+      await instance.update(
+        {
+          schema: {
+            ...instance.get("schema"),
+            ...import_lodash.default.omit(node, ["x-async", "name", "x-uid", "childOptions"])
+          }
+        },
+        {
+          hooks: false,
+          transaction: options == null ? void 0 : options.transaction
+        }
+      );
+      return true;
+    }
+    return false;
+  }
+  async upsertModel(model, options) {
+    let childOptions = null;
+    if (model.parentId) {
+      childOptions = {
+        parentUid: model.parentId,
+        type: model.subKey,
+        // type: 'properties',
+        position: "last"
+      };
+    }
+    const nodes = _UiSchemaRepository.modelToSingleNodes(model, childOptions);
+    const rootUid = nodes[0]["x-uid"];
+    for (const node of nodes) {
+      const exists = await this.updateSingleNode(node, options);
+      if (!exists) {
+        await this.insertSingleNode(node, options);
+      }
+    }
+    return rootUid;
+  }
+  async findModelById(uid2, options) {
+    const nodes = await this.findNodesById(uid2, options);
+    return _UiSchemaRepository.nodesToModel(nodes, uid2);
+  }
+  async findModelByParentId(parentUid, options) {
+    const r = this.database.getRepository("uiSchemaTreePath");
+    const treePaths = await r.model.findAll({
+      where: {
+        ancestor: parentUid,
+        depth: 1
+      },
+      transaction: options == null ? void 0 : options.transaction
+    });
+    const ancestors = treePaths.map((treePath2) => treePath2["descendant"]);
+    const where = {
+      ancestor: ancestors,
+      depth: 0
+    };
+    if (options == null ? void 0 : options.subKey) {
+      where["type"] = options.subKey;
+    }
+    const treePath = await r.model.findOne({
+      where,
+      transaction: options == null ? void 0 : options.transaction
+    });
+    if (treePath == null ? void 0 : treePath["descendant"]) {
+      return this.findModelById(treePath["descendant"], options);
+    }
+    return null;
+  }
+  async move(options) {
+    const { sourceId, targetId, position } = options;
+    return await this.insertAdjacent(position === "after" ? "afterEnd" : "beforeBegin", targetId, {
+      ["x-uid"]: sourceId
+    });
+  }
 };
 __decorateClass([
   transaction()
@@ -1018,9 +1195,19 @@ __decorateClass([
 __decorateClass([
   transaction()
 ], _UiSchemaRepository.prototype, "insertNodes", 1);
+__decorateClass([
+  transaction()
+], _UiSchemaRepository.prototype, "insertModel", 1);
+__decorateClass([
+  transaction()
+], _UiSchemaRepository.prototype, "updateSingleNode", 1);
+__decorateClass([
+  transaction()
+], _UiSchemaRepository.prototype, "upsertModel", 1);
 let UiSchemaRepository = _UiSchemaRepository;
 var repository_default = UiSchemaRepository;
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
-  UiSchemaRepository
+  UiSchemaRepository,
+  transaction
 });

package/dist/server/server.js

@@ -44,7 +44,6 @@ module.exports = __toCommonJS(server_exports);
 var import_database = require("@nocobase/database");
 var import_server = require("@nocobase/server");
 var import_utils = require("@nocobase/utils");
-var import_utils2 = require("@nocobase/utils");
 var import_path = __toESM(require("path"));
 var import_ui_schema_action = require("./actions/ui-schema-action");
 var import_model = require("./model");
@@ -97,7 +96,7 @@ class PluginUISchemaStorageServer extends import_server.Plugin {
     });
     db.on("uiSchemas.beforeCreate", function setUid(model) {
       if (!model.get("name")) {
-        model.set("name", (0, import_utils2.uid)());
+        model.set("name", (0, import_utils.uid)());
       }
     });
     db.on("uiSchemas.afterSave", async function setUid(model, options) {
@@ -131,7 +130,7 @@ class PluginUISchemaStorageServer extends import_server.Plugin {
         transaction
       });
     });
-    this.app.resourcer.define({
+    this.app.resourceManager.define({
       name: "uiSchemas",
       actions: import_ui_schema_action.uiSchemaActions
     });

package/package.json

@@ -4,7 +4,7 @@
   "displayName.zh-CN": "UI schema 存储服务",
   "description": "Provides centralized UI schema storage service.",
   "description.zh-CN": "提供中心化的 UI schema 存储服务。",
-  "version": "1.9.0-beta.9",
+  "version": "2.0.0-alpha.11",
   "license": "AGPL-3.0",
   "main": "./dist/server/index.js",
   "homepage": "https://docs.nocobase.com/handbook/ui-schema-storage",
@@ -13,17 +13,17 @@
     "@formily/json-schema": "2.x"
   },
   "peerDependencies": {
-    "@nocobase/actions": "1.x",
-    "@nocobase/cache": "1.x",
-    "@nocobase/client": "1.x",
-    "@nocobase/database": "1.x",
-    "@nocobase/plugin-error-handler": "1.x",
-    "@nocobase/resourcer": "1.x",
-    "@nocobase/server": "1.x",
-    "@nocobase/test": "1.x",
-    "@nocobase/utils": "1.x"
+    "@nocobase/actions": "2.x",
+    "@nocobase/cache": "2.x",
+    "@nocobase/client": "2.x",
+    "@nocobase/database": "2.x",
+    "@nocobase/plugin-error-handler": "2.x",
+    "@nocobase/resourcer": "2.x",
+    "@nocobase/server": "2.x",
+    "@nocobase/test": "2.x",
+    "@nocobase/utils": "2.x"
   },
-  "gitHead": "b44464f1d1bbc96022d0f622e0a2f1d7e8d7142f",
+  "gitHead": "172b05411f66f7024d5294caf2852533569c3796",
   "keywords": [
     "System & security"
   ]