@nocobase/plugin-ui-schema-storage 0.15.0-alpha.3 → 0.15.0-alpha.5

package/dist/externalVersion.js

@@ -1,11 +1,11 @@
 module.exports = {
-  "@nocobase/client": "0.15.0-alpha.3",
-  "@nocobase/database": "0.15.0-alpha.3",
-  "@nocobase/cache": "0.15.0-alpha.3",
-  "@nocobase/utils": "0.15.0-alpha.3",
+  "@nocobase/client": "0.15.0-alpha.5",
+  "@nocobase/database": "0.15.0-alpha.5",
+  "@nocobase/cache": "0.15.0-alpha.5",
+  "@nocobase/utils": "0.15.0-alpha.5",
   "lodash": "4.17.21",
-  "@nocobase/server": "0.15.0-alpha.3",
-  "@nocobase/actions": "0.15.0-alpha.3",
-  "@nocobase/resourcer": "0.15.0-alpha.3",
+  "@nocobase/server": "0.15.0-alpha.5",
+  "@nocobase/actions": "0.15.0-alpha.5",
+  "@nocobase/resourcer": "0.15.0-alpha.5",
   "@formily/json-schema": "2.2.27"
 };

package/dist/server/repository.d.ts

@@ -22,6 +22,9 @@ interface InsertAdjacentOptions extends removeParentOptions {
 }
 export declare class UiSchemaRepository extends Repository {
     cache: Cache;
+    get uiSchemasTableName(): any;
+    get uiSchemaTreePathTableName(): any;
+    static schemaToSingleNodes(schema: any, carry?: SchemaNode[], childOptions?: ChildOptions): SchemaNode[];
     setCache(cache: Cache): void;
     /**
      * clear cache with xUid which in uiSchemaTreePath's Path
@@ -31,18 +34,12 @@ export declare class UiSchemaRepository extends Repository {
      */
     clearXUidPathCache(xUid: string, transaction: Transaction): Promise<void>;
     tableNameAdapter(tableName: any): any;
-    get uiSchemasTableName(): any;
-    get uiSchemaTreePathTableName(): any;
     sqlAdapter(sql: string): string;
-    static schemaToSingleNodes(schema: any, carry?: SchemaNode[], childOptions?: ChildOptions): SchemaNode[];
     getProperties(uid: string, options?: GetPropertiesOptions): Promise<Partial<{
         "x-uid": any;
         "x-async": boolean;
     }>>;
-    private doGetProperties;
-    private doGetJsonSchema;
     getJsonSchema(uid: string, options?: GetJsonSchemaOptions): Promise<any>;
-    private ignoreSchemaProperties;
     nodesToSchema(nodes: any, rootUid: any): {
         "x-uid": any;
         "x-async": boolean;
@@ -50,42 +47,45 @@ export declare class UiSchemaRepository extends Repository {
     clearAncestor(uid: string, options?: Transactionable): Promise<void>;
     patch(newSchema: any, options?: any): Promise<void>;
     batchPatch(schemas: any[], options?: any): Promise<void>;
-    protected updateNode(uid: string, schema: any, transaction?: Transaction): Promise<void>;
-    protected childrenCount(uid: any, transaction: any): Promise<number>;
-    protected isLeafNode(uid: any, transaction: any): Promise<boolean>;
-    protected findParentUid(uid: any, transaction?: any): Promise<string>;
-    protected findNodeSchemaWithParent(uid: any, transaction: any): Promise<{
-        parentUid: string;
-        schema: any;
-    }>;
-    protected isSingleChild(uid: any, transaction: any): Promise<any>;
     removeEmptyParents(options: Transactionable & {
         uid: string;
         breakRemoveOn?: BreakRemoveOnType;
     }): Promise<void>;
-    private breakOnMatched;
     recursivelyRemoveIfNoChildren(options: Transactionable & {
         uid: string;
         breakRemoveOn?: BreakRemoveOnType;
     }): Promise<void>;
     remove(uid: string, options?: Transactionable & removeParentOptions): Promise<void>;
+    insertAdjacent(position: 'beforeBegin' | 'afterBegin' | 'beforeEnd' | 'afterEnd', target: string, schema: any, options?: InsertAdjacentOptions): Promise<any>;
+    duplicate(uid: string, options?: Transactionable): Promise<any>;
+    insert(schema: any, options?: Transactionable): Promise<any>;
+    insertNewSchema(schema: any, options?: Transactionable & {
+        returnNode?: boolean;
+    }): Promise<any>;
+    insertSingleNode(schema: SchemaNode, options: Transactionable & removeParentOptions): Promise<any>;
+    protected updateNode(uid: string, schema: any, transaction?: Transaction): Promise<void>;
+    protected childrenCount(uid: any, transaction: any): Promise<number>;
+    protected isLeafNode(uid: any, transaction: any): Promise<boolean>;
+    protected findParentUid(uid: any, transaction?: any): Promise<string>;
+    protected findNodeSchemaWithParent(uid: any, transaction: any): Promise<{
+        parentUid: string;
+        schema: any;
+    }>;
+    protected isSingleChild(uid: any, transaction: any): Promise<any>;
     protected insertBeside(targetUid: string, schema: any, side: 'before' | 'after', options?: InsertAdjacentOptions): Promise<any>;
     protected insertInner(targetUid: string, schema: any, position: 'first' | 'last', options?: InsertAdjacentOptions): Promise<any>;
-    private schemaExists;
-    insertAdjacent(position: 'beforeBegin' | 'afterBegin' | 'beforeEnd' | 'afterEnd', target: string, schema: any, options?: InsertAdjacentOptions): Promise<any>;
     protected insertAfterBegin(targetUid: string, schema: any, options?: InsertAdjacentOptions): Promise<any>;
     protected insertBeforeEnd(targetUid: string, schema: any, options?: InsertAdjacentOptions): Promise<any>;
     protected insertBeforeBegin(targetUid: string, schema: any, options?: InsertAdjacentOptions): Promise<any>;
     protected insertAfterEnd(targetUid: string, schema: any, options?: InsertAdjacentOptions): Promise<any>;
     protected insertNodes(nodes: SchemaNode[], options?: Transactionable): Promise<any[]>;
+    private doGetProperties;
+    private doGetJsonSchema;
+    private ignoreSchemaProperties;
+    private breakOnMatched;
+    private schemaExists;
     private regenerateUid;
-    duplicate(uid: string, options?: Transactionable): Promise<any>;
-    insert(schema: any, options?: Transactionable): Promise<any>;
-    insertNewSchema(schema: any, options?: Transactionable & {
-        returnNode?: boolean;
-    }): Promise<any>;
     private insertSchemaRecord;
     private prepareSingleNodeForInsert;
-    insertSingleNode(schema: SchemaNode, options: Transactionable & removeParentOptions): Promise<any>;
 }
 export default UiSchemaRepository;

package/dist/server/repository.js

@@ -79,37 +79,6 @@ function transaction(transactionAbleArgPosition) {
 }
 const _UiSchemaRepository = class _UiSchemaRepository extends import_database.Repository {
   cache;
-  // if you need to handle cache in repo method, so you must set cache first
-  setCache(cache) {
-    this.cache = cache;
-  }
-  /**
-   * clear cache with xUid which in uiSchemaTreePath's Path
-   * @param {string} xUid
-   * @param {Transaction} transaction
-   * @returns {Promise<void>}
-   */
-  async clearXUidPathCache(xUid, transaction2) {
-    if (!this.cache || !xUid) {
-      return;
-    }
-    const uiSchemaNodes = await this.database.getRepository("uiSchemaTreePath").find({
-      filter: {
-        descendant: xUid
-      },
-      transaction: transaction2
-    });
-    for (const uiSchemaNode of uiSchemaNodes) {
-      await this.cache.del(`p_${uiSchemaNode["ancestor"]}`);
-      await this.cache.del(`s_${uiSchemaNode["ancestor"]}`);
-    }
-  }
-  tableNameAdapter(tableName) {
-    if (this.database.sequelize.getDialect() === "postgres") {
-      return `"${this.database.options.schema || "public"}"."${tableName}"`;
-    }
-    return tableName;
-  }
   get uiSchemasTableName() {
     return this.tableNameAdapter(this.model.tableName);
   }
@@ -117,12 +86,6 @@ const _UiSchemaRepository = class _UiSchemaRepository extends import_database.Re
     const model = this.database.getCollection("uiSchemaTreePath").model;
     return this.tableNameAdapter(model.tableName);
   }
-  sqlAdapter(sql) {
-    if (this.database.sequelize.getDialect() === "mysql") {
-      return import_lodash.default.replace(sql, /"/g, "`");
-    }
-    return sql;
-  }
   static schemaToSingleNodes(schema, carry = [], childOptions = null) {
     const node = import_lodash.default.cloneDeep(
       import_lodash.default.isString(schema) ? {
@@ -165,61 +128,50 @@ const _UiSchemaRepository = class _UiSchemaRepository extends import_database.Re
     }
     return carry;
   }
-  async getProperties(uid2, options = {}) {
-    if ((options == null ? void 0 : options.readFromCache) && this.cache) {
-      return this.cache.wrap(`p_${uid2}`, () => {
-        return this.doGetProperties(uid2, options);
-      });
-    }
-    return this.doGetProperties(uid2, options);
+  // if you need to handle cache in repo method, so you must set cache first
+  setCache(cache) {
+    this.cache = cache;
   }
-  async doGetProperties(uid2, options = {}) {
-    const { transaction: transaction2 } = options;
-    const db = this.database;
-    const rawSql = `
-        SELECT "SchemaTable"."x-uid" as "x-uid", "SchemaTable"."name" as "name", "SchemaTable"."schema" as "schema",
-               TreePath.depth as depth,
-               NodeInfo.type as type, NodeInfo.async as async,  ParentPath.ancestor as parent, ParentPath.sort as sort
-        FROM ${this.uiSchemaTreePathTableName} as TreePath
-                 LEFT JOIN ${this.uiSchemasTableName} as "SchemaTable" ON "SchemaTable"."x-uid" =  TreePath.descendant
-                 LEFT JOIN ${this.uiSchemaTreePathTableName} as NodeInfo ON NodeInfo.descendant = "SchemaTable"."x-uid" and NodeInfo.descendant = NodeInfo.ancestor and NodeInfo.depth = 0
-                 LEFT JOIN ${this.uiSchemaTreePathTableName} as ParentPath ON (ParentPath.descendant = "SchemaTable"."x-uid" AND ParentPath.depth = 1)
-        WHERE TreePath.ancestor = :ancestor  AND (NodeInfo.async  = false or TreePath.depth = 1)`;
-    const nodes = await db.sequelize.query(this.sqlAdapter(rawSql), {
-      replacements: {
-        ancestor: uid2
+  /**
+   * clear cache with xUid which in uiSchemaTreePath's Path
+   * @param {string} xUid
+   * @param {Transaction} transaction
+   * @returns {Promise<void>}
+   */
+  async clearXUidPathCache(xUid, transaction2) {
+    if (!this.cache || !xUid) {
+      return;
+    }
+    const uiSchemaNodes = await this.database.getRepository("uiSchemaTreePath").find({
+      filter: {
+        descendant: xUid
       },
       transaction: transaction2
     });
-    if (nodes[0].length == 0) {
-      return {};
+    for (const uiSchemaNode of uiSchemaNodes) {
+      await this.cache.del(`p_${uiSchemaNode["ancestor"]}`);
+      await this.cache.del(`s_${uiSchemaNode["ancestor"]}`);
     }
-    const schema = this.nodesToSchema(nodes[0], uid2);
-    return import_lodash.default.pick(schema, ["type", "properties"]);
   }
-  async doGetJsonSchema(uid2, options) {
-    const db = this.database;
-    const treeTable = this.uiSchemaTreePathTableName;
-    const rawSql = `
-        SELECT "SchemaTable"."x-uid" as "x-uid", "SchemaTable"."name" as name, "SchemaTable"."schema" as "schema" ,
-               TreePath.depth as depth,
-               NodeInfo.type as type, NodeInfo.async as async,  ParentPath.ancestor as parent, ParentPath.sort as sort
-        FROM ${treeTable} as TreePath
-                 LEFT JOIN ${this.uiSchemasTableName} as "SchemaTable" ON "SchemaTable"."x-uid" =  TreePath.descendant
-                 LEFT JOIN ${treeTable} as NodeInfo ON NodeInfo.descendant = "SchemaTable"."x-uid" and NodeInfo.descendant = NodeInfo.ancestor and NodeInfo.depth = 0
-                 LEFT JOIN ${treeTable} as ParentPath ON (ParentPath.descendant = "SchemaTable"."x-uid" AND ParentPath.depth = 1)
-        WHERE TreePath.ancestor = :ancestor  ${(options == null ? void 0 : options.includeAsyncNode) ? "" : "AND (NodeInfo.async != true )"}
-    `;
-    const nodes = await db.sequelize.query(this.sqlAdapter(rawSql), {
-      replacements: {
-        ancestor: uid2
-      },
-      transaction: options == null ? void 0 : options.transaction
-    });
-    if (nodes[0].length == 0) {
-      return {};
+  tableNameAdapter(tableName) {
+    if (this.database.sequelize.getDialect() === "postgres") {
+      return `"${this.database.options.schema || "public"}"."${tableName}"`;
     }
-    return this.nodesToSchema(nodes[0], uid2);
+    return tableName;
+  }
+  sqlAdapter(sql) {
+    if (this.database.isMySQLCompatibleDialect()) {
+      return import_lodash.default.replace(sql, /"/g, "`");
+    }
+    return sql;
+  }
+  async getProperties(uid2, options = {}) {
+    if ((options == null ? void 0 : options.readFromCache) && this.cache) {
+      return this.cache.wrap(`p_${uid2}`, () => {
+        return this.doGetProperties(uid2, options);
+      });
+    }
+    return this.doGetProperties(uid2, options);
   }
   async getJsonSchema(uid2, options) {
     if ((options == null ? void 0 : options.readFromCache) && this.cache) {
@@ -229,9 +181,6 @@ const _UiSchemaRepository = class _UiSchemaRepository extends import_database.Re
     }
     return this.doGetJsonSchema(uid2, options);
   }
-  ignoreSchemaProperties(schemaProperties) {
-    return import_lodash.default.omit(schemaProperties, nodeKeys);
-  }
   nodesToSchema(nodes, rootUid) {
     const nodeAttributeSanitize = (node) => {
       const schema = {
@@ -317,86 +266,6 @@ const _UiSchemaRepository = class _UiSchemaRepository extends import_database.Re
       await this.patch(schema, { ...options, transaction: transaction2 });
     }
   }
-  async updateNode(uid2, schema, transaction2) {
-    const nodeModel = await this.findOne({
-      filter: {
-        "x-uid": uid2
-      }
-    });
-    await nodeModel.update(
-      {
-        schema: {
-          ...nodeModel.get("schema"),
-          ...import_lodash.default.omit(schema, ["x-async", "name", "x-uid", "properties"])
-        }
-      },
-      {
-        hooks: false,
-        transaction: transaction2
-      }
-    );
-    if (schema["x-server-hooks"]) {
-      await this.database.emitAsync(`${this.collection.name}.afterSave`, nodeModel, { transaction: transaction2 });
-    }
-  }
-  async childrenCount(uid2, transaction2) {
-    const db = this.database;
-    const countResult = await db.sequelize.query(
-      `SELECT COUNT(*) as count FROM ${this.uiSchemaTreePathTableName} where ancestor = :ancestor and depth  = 1`,
-      {
-        replacements: {
-          ancestor: uid2
-        },
-        type: "SELECT",
-        transaction: transaction2
-      }
-    );
-    return parseInt(countResult[0]["count"]);
-  }
-  async isLeafNode(uid2, transaction2) {
-    const childrenCount = await this.childrenCount(uid2, transaction2);
-    return childrenCount === 0;
-  }
-  async findParentUid(uid2, transaction2) {
-    const parent = await this.database.getRepository("uiSchemaTreePath").findOne({
-      filter: {
-        descendant: uid2,
-        depth: 1
-      },
-      transaction: transaction2
-    });
-    return parent ? parent.get("ancestor") : null;
-  }
-  async findNodeSchemaWithParent(uid2, transaction2) {
-    const schema = await this.database.getRepository("uiSchemas").findOne({
-      filter: {
-        "x-uid": uid2
-      },
-      transaction: transaction2
-    });
-    return {
-      parentUid: await this.findParentUid(uid2, transaction2),
-      schema
-    };
-  }
-  async isSingleChild(uid2, transaction2) {
-    const db = this.database;
-    const parent = await this.findParentUid(uid2, transaction2);
-    if (!parent) {
-      return null;
-    }
-    const parentChildrenCount = await this.childrenCount(parent, transaction2);
-    if (parentChildrenCount == 1) {
-      const schema = await db.getRepository("uiSchemas").findOne({
-        filter: {
-          "x-uid": parent
-        },
-        transaction: transaction2
-      });
-      return schema;
-    }
-    return null;
-  }
   async removeEmptyParents(options) {
     const { transaction: transaction2, uid: uid2, breakRemoveOn } = options;
     await this.clearXUidPathCache(uid2, transaction2);
@@ -410,19 +279,6 @@ const _UiSchemaRepository = class _UiSchemaRepository extends import_database.Re
     };
     await removeParent(uid2);
   }
-  breakOnMatched(schemaInstance, breakRemoveOn) {
-    if (!breakRemoveOn) {
-      return false;
-    }
-    for (const key of Object.keys(breakRemoveOn)) {
-      const instanceValue = schemaInstance.get(key);
-      const breakRemoveOnValue = breakRemoveOn[key];
-      if (instanceValue !== breakRemoveOnValue) {
-        return false;
-      }
-    }
-    return true;
-  }
   async recursivelyRemoveIfNoChildren(options) {
     const { uid: uid2, transaction: transaction2, breakRemoveOn } = options;
     await this.clearXUidPathCache(uid2, transaction2);
@@ -475,123 +331,34 @@ const _UiSchemaRepository = class _UiSchemaRepository extends import_database.Re
       }
     );
   }
-  async insertBeside(targetUid, schema, side, options) {
+  async insertAdjacent(position, target, schema, options) {
     const { transaction: transaction2 } = options;
-    const targetParent = await this.findParentUid(targetUid, transaction2);
-    const db = this.database;
-    const treeTable = this.uiSchemaTreePathTableName;
-    const typeQuery = await db.sequelize.query(`SELECT type from ${treeTable} WHERE ancestor = :uid AND depth = 0;`, {
-      type: "SELECT",
-      replacements: {
-        uid: targetUid
-      },
-      transaction: transaction2
-    });
-    const nodes = _UiSchemaRepository.schemaToSingleNodes(schema);
-    const rootNode = nodes[0];
-    rootNode.childOptions = {
-      parentUid: targetParent,
-      type: typeQuery[0]["type"],
-      position: {
-        type: side,
-        target: targetUid
-      }
-    };
-    const insertedNodes = await this.insertNodes(nodes, options);
-    return await this.getJsonSchema(insertedNodes[0].get("x-uid"), {
-      transaction: transaction2
-    });
-  }
-  async insertInner(targetUid, schema, position, options) {
-    const { transaction: transaction2 } = options;
-    const nodes = _UiSchemaRepository.schemaToSingleNodes(schema);
-    const rootNode = nodes[0];
-    rootNode.childOptions = {
-      parentUid: targetUid,
-      type: import_lodash.default.get(schema, "x-node-type", "properties"),
-      position
-    };
-    const insertedNodes = await this.insertNodes(nodes, options);
-    return await this.getJsonSchema(insertedNodes[0].get("x-uid"), {
-      transaction: transaction2
-    });
-  }
-  async schemaExists(schema, options) {
-    if (import_lodash.default.isObject(schema) && !schema["x-uid"]) {
-      return false;
-    }
-    const { transaction: transaction2 } = options;
-    const result = await this.database.sequelize.query(
-      this.sqlAdapter(`select "x-uid" from ${this.uiSchemasTableName} where "x-uid" = :uid`),
-      {
-        type: "SELECT",
-        replacements: {
-          uid: import_lodash.default.isString(schema) ? schema : schema["x-uid"]
-        },
-        transaction: transaction2
-      }
-    );
-    return result.length > 0;
-  }
-  async insertAdjacent(position, target, schema, options) {
-    const { transaction: transaction2 } = options;
-    await this.clearXUidPathCache(schema["x-uid"], transaction2);
-    if (options.wrap) {
-      const wrapSchemaNodes = await this.insertNewSchema(options.wrap, {
-        transaction: transaction2,
-        returnNode: true
-      });
-      const lastWrapNode = wrapSchemaNodes[wrapSchemaNodes.length - 1];
-      await this.insertAdjacent("afterBegin", lastWrapNode["x-uid"], schema, import_lodash.default.omit(options, "wrap"));
-      schema = wrapSchemaNodes[0]["x-uid"];
-      options.removeParentsIfNoChildren = false;
-    } else {
-      const schemaExists = await this.schemaExists(schema, { transaction: transaction2 });
-      if (schemaExists) {
-        schema = import_lodash.default.isString(schema) ? schema : schema["x-uid"];
-      } else {
-        const insertedSchema = await this.insertNewSchema(schema, {
-          transaction: transaction2,
-          returnNode: true
-        });
-        schema = insertedSchema[0]["x-uid"];
+    await this.clearXUidPathCache(schema["x-uid"], transaction2);
+    if (options.wrap) {
+      const wrapSchemaNodes = await this.insertNewSchema(options.wrap, {
+        transaction: transaction2,
+        returnNode: true
+      });
+      const lastWrapNode = wrapSchemaNodes[wrapSchemaNodes.length - 1];
+      await this.insertAdjacent("afterBegin", lastWrapNode["x-uid"], schema, import_lodash.default.omit(options, "wrap"));
+      schema = wrapSchemaNodes[0]["x-uid"];
+      options.removeParentsIfNoChildren = false;
+    } else {
+      const schemaExists = await this.schemaExists(schema, { transaction: transaction2 });
+      if (schemaExists) {
+        schema = import_lodash.default.isString(schema) ? schema : schema["x-uid"];
+      } else {
+        const insertedSchema = await this.insertNewSchema(schema, {
+          transaction: transaction2,
+          returnNode: true
+        });
+        schema = insertedSchema[0]["x-uid"];
       }
     }
     const result = await this[`insert${import_lodash.default.upperFirst(position)}`](target, schema, options);
     await this.clearXUidPathCache(result["x-uid"], transaction2);
     return result;
   }
-  async insertAfterBegin(targetUid, schema, options) {
-    return await this.insertInner(targetUid, schema, "first", options);
-  }
-  async insertBeforeEnd(targetUid, schema, options) {
-    return await this.insertInner(targetUid, schema, "last", options);
-  }
-  async insertBeforeBegin(targetUid, schema, options) {
-    return await this.insertBeside(targetUid, schema, "before", options);
-  }
-  async insertAfterEnd(targetUid, schema, options) {
-    return await this.insertBeside(targetUid, schema, "after", options);
-  }
-  async insertNodes(nodes, options) {
-    const { transaction: transaction2 } = options;
-    const insertedNodes = [];
-    for (const node of nodes) {
-      insertedNodes.push(
-        await this.insertSingleNode(node, {
-          ...options,
-          transaction: transaction2
-        })
-      );
-    }
-    return insertedNodes;
-  }
-  regenerateUid(s) {
-    s["x-uid"] = (0, import_utils.uid)();
-    Object.keys(s.properties || {}).forEach((key) => {
-      this.regenerateUid(s.properties[key]);
-    });
-  }
   async duplicate(uid2, options) {
     const s = await this.getJsonSchema(uid2, { ...options, includeAsyncNode: true });
     this.regenerateUid(s);
@@ -659,33 +426,6 @@ const _UiSchemaRepository = class _UiSchemaRepository extends import_database.Re
     await this.clearXUidPathCache(result["x-uid"], transaction2);
     return result;
   }
-  async insertSchemaRecord(name, uid2, schema, transaction2) {
-    const serverHooks = schema["x-server-hooks"] || [];
-    const node = await this.create({
-      values: {
-        name,
-        ["x-uid"]: uid2,
-        schema,
-        serverHooks
-      },
-      transaction: transaction2,
-      context: {
-        disableInsertHook: true
-      }
-    });
-    return node;
-  }
-  prepareSingleNodeForInsert(schema) {
-    const uid2 = schema["x-uid"];
-    const name = schema["name"];
-    const async = import_lodash.default.get(schema, "x-async", false);
-    const childOptions = schema["childOptions"];
-    delete schema["x-uid"];
-    delete schema["x-async"];
-    delete schema["name"];
-    delete schema["childOptions"];
-    return { uid: uid2, name, async, childOptions };
-  }
   async insertSingleNode(schema, options) {
     const { transaction: transaction2 } = options;
     const db = this.database;
@@ -784,7 +524,7 @@ const _UiSchemaRepository = class _UiSchemaRepository extends import_database.Re
                 FROM ${treeTable} as NodeInfo
                 WHERE NodeInfo.descendant = TreeTable.descendant and NodeInfo.depth = 0
                 AND TreeTable.depth = 1 AND TreeTable.ancestor = :ancestor and NodeInfo.type = :type`;
-        if (this.database.sequelize.getDialect() === "mysql") {
+        if (this.database.isMySQLCompatibleDialect()) {
           updateSql2 = `UPDATE ${treeTable} as TreeTable
           JOIN ${treeTable} as NodeInfo ON (NodeInfo.descendant = TreeTable.descendant and NodeInfo.depth = 0)
           SET TreeTable.sort = TreeTable.sort + 1
@@ -845,7 +585,7 @@ const _UiSchemaRepository = class _UiSchemaRepository extends import_database.Re
                            AND TreeTable.ancestor = :ancestor
                            and TreeTable.sort >= :sort
                            and NodeInfo.type = :type`;
-        if (this.database.sequelize.getDialect() === "mysql") {
+        if (this.database.isMySQLCompatibleDialect()) {
           updateSql2 = `UPDATE  ${treeTable} as TreeTable
 JOIN ${treeTable} as NodeInfo ON (NodeInfo.descendant = TreeTable.descendant and NodeInfo.depth = 0)
 SET TreeTable.sort = TreeTable.sort + 1
@@ -900,6 +640,266 @@ WHERE TreeTable.depth = 1 AND  TreeTable.ancestor = :ancestor and TreeTable.sort
     await this.clearXUidPathCache(uid2, transaction2);
     return savedNode;
   }
+  async updateNode(uid2, schema, transaction2) {
+    const nodeModel = await this.findOne({
+      filter: {
+        "x-uid": uid2
+      }
+    });
+    await nodeModel.update(
+      {
+        schema: {
+          ...nodeModel.get("schema"),
+          ...import_lodash.default.omit(schema, ["x-async", "name", "x-uid", "properties"])
+        }
+      },
+      {
+        hooks: false,
+        transaction: transaction2
+      }
+    );
+    if (schema["x-server-hooks"]) {
+      await this.database.emitAsync(`${this.collection.name}.afterSave`, nodeModel, { transaction: transaction2 });
+    }
+  }
+  async childrenCount(uid2, transaction2) {
+    const db = this.database;
+    const countResult = await db.sequelize.query(
+      `SELECT COUNT(*) as count FROM ${this.uiSchemaTreePathTableName} where ancestor = :ancestor and depth  = 1`,
+      {
+        replacements: {
+          ancestor: uid2
+        },
+        type: "SELECT",
+        transaction: transaction2
+      }
+    );
+    return parseInt(countResult[0]["count"]);
+  }
+  async isLeafNode(uid2, transaction2) {
+    const childrenCount = await this.childrenCount(uid2, transaction2);
+    return childrenCount === 0;
+  }
+  async findParentUid(uid2, transaction2) {
+    const parent = await this.database.getRepository("uiSchemaTreePath").findOne({
+      filter: {
+        descendant: uid2,
+        depth: 1
+      },
+      transaction: transaction2
+    });
+    return parent ? parent.get("ancestor") : null;
+  }
+  async findNodeSchemaWithParent(uid2, transaction2) {
+    const schema = await this.database.getRepository("uiSchemas").findOne({
+      filter: {
+        "x-uid": uid2
+      },
+      transaction: transaction2
+    });
+    return {
+      parentUid: await this.findParentUid(uid2, transaction2),
+      schema
+    };
+  }
+  async isSingleChild(uid2, transaction2) {
+    const db = this.database;
+    const parent = await this.findParentUid(uid2, transaction2);
+    if (!parent) {
+      return null;
+    }
+    const parentChildrenCount = await this.childrenCount(parent, transaction2);
+    if (parentChildrenCount == 1) {
+      const schema = await db.getRepository("uiSchemas").findOne({
+        filter: {
+          "x-uid": parent
+        },
+        transaction: transaction2
+      });
+      return schema;
+    }
+    return null;
+  }
+  async insertBeside(targetUid, schema, side, options) {
+    const { transaction: transaction2 } = options;
+    const targetParent = await this.findParentUid(targetUid, transaction2);
+    const db = this.database;
+    const treeTable = this.uiSchemaTreePathTableName;
+    const typeQuery = await db.sequelize.query(`SELECT type from ${treeTable} WHERE ancestor = :uid AND depth = 0;`, {
+      type: "SELECT",
+      replacements: {
+        uid: targetUid
+      },
+      transaction: transaction2
+    });
+    const nodes = _UiSchemaRepository.schemaToSingleNodes(schema);
+    const rootNode = nodes[0];
+    rootNode.childOptions = {
+      parentUid: targetParent,
+      type: typeQuery[0]["type"],
+      position: {
+        type: side,
+        target: targetUid
+      }
+    };
+    const insertedNodes = await this.insertNodes(nodes, options);
+    return await this.getJsonSchema(insertedNodes[0].get("x-uid"), {
+      transaction: transaction2
+    });
+  }
+  async insertInner(targetUid, schema, position, options) {
+    const { transaction: transaction2 } = options;
+    const nodes = _UiSchemaRepository.schemaToSingleNodes(schema);
+    const rootNode = nodes[0];
+    rootNode.childOptions = {
+      parentUid: targetUid,
+      type: import_lodash.default.get(schema, "x-node-type", "properties"),
+      position
+    };
+    const insertedNodes = await this.insertNodes(nodes, options);
+    return await this.getJsonSchema(insertedNodes[0].get("x-uid"), {
+      transaction: transaction2
+    });
+  }
+  async insertAfterBegin(targetUid, schema, options) {
+    return await this.insertInner(targetUid, schema, "first", options);
+  }
+  async insertBeforeEnd(targetUid, schema, options) {
+    return await this.insertInner(targetUid, schema, "last", options);
+  }
+  async insertBeforeBegin(targetUid, schema, options) {
+    return await this.insertBeside(targetUid, schema, "before", options);
+  }
+  async insertAfterEnd(targetUid, schema, options) {
+    return await this.insertBeside(targetUid, schema, "after", options);
+  }
+  async insertNodes(nodes, options) {
+    const { transaction: transaction2 } = options;
+    const insertedNodes = [];
+    for (const node of nodes) {
+      insertedNodes.push(
+        await this.insertSingleNode(node, {
+          ...options,
+          transaction: transaction2
+        })
+      );
+    }
+    return insertedNodes;
+  }
+  async doGetProperties(uid2, options = {}) {
+    const { transaction: transaction2 } = options;
+    const db = this.database;
+    const rawSql = `
+        SELECT "SchemaTable"."x-uid" as "x-uid", "SchemaTable"."name" as "name", "SchemaTable"."schema" as "schema",
+               TreePath.depth as depth,
+               NodeInfo.type as type, NodeInfo.async as async,  ParentPath.ancestor as parent, ParentPath.sort as sort
+        FROM ${this.uiSchemaTreePathTableName} as TreePath
+                 LEFT JOIN ${this.uiSchemasTableName} as "SchemaTable" ON "SchemaTable"."x-uid" =  TreePath.descendant
+                 LEFT JOIN ${this.uiSchemaTreePathTableName} as NodeInfo ON NodeInfo.descendant = "SchemaTable"."x-uid" and NodeInfo.descendant = NodeInfo.ancestor and NodeInfo.depth = 0
+                 LEFT JOIN ${this.uiSchemaTreePathTableName} as ParentPath ON (ParentPath.descendant = "SchemaTable"."x-uid" AND ParentPath.depth = 1)
+        WHERE TreePath.ancestor = :ancestor  AND (NodeInfo.async  = false or TreePath.depth = 1)`;
+    const nodes = await db.sequelize.query(this.sqlAdapter(rawSql), {
+      replacements: {
+        ancestor: uid2
+      },
+      transaction: transaction2
+    });
+    if (nodes[0].length == 0) {
+      return {};
+    }
+    const schema = this.nodesToSchema(nodes[0], uid2);
+    return import_lodash.default.pick(schema, ["type", "properties"]);
+  }
+  async doGetJsonSchema(uid2, options) {
+    const db = this.database;
+    const treeTable = this.uiSchemaTreePathTableName;
+    const rawSql = `
+        SELECT "SchemaTable"."x-uid" as "x-uid", "SchemaTable"."name" as name, "SchemaTable"."schema" as "schema" ,
+               TreePath.depth as depth,
+               NodeInfo.type as type, NodeInfo.async as async,  ParentPath.ancestor as parent, ParentPath.sort as sort
+        FROM ${treeTable} as TreePath
+                 LEFT JOIN ${this.uiSchemasTableName} as "SchemaTable" ON "SchemaTable"."x-uid" =  TreePath.descendant
+                 LEFT JOIN ${treeTable} as NodeInfo ON NodeInfo.descendant = "SchemaTable"."x-uid" and NodeInfo.descendant = NodeInfo.ancestor and NodeInfo.depth = 0
+                 LEFT JOIN ${treeTable} as ParentPath ON (ParentPath.descendant = "SchemaTable"."x-uid" AND ParentPath.depth = 1)
+        WHERE TreePath.ancestor = :ancestor  ${(options == null ? void 0 : options.includeAsyncNode) ? "" : "AND (NodeInfo.async != true )"}
+    `;
+    const nodes = await db.sequelize.query(this.sqlAdapter(rawSql), {
+      replacements: {
+        ancestor: uid2
+      },
+      transaction: options == null ? void 0 : options.transaction
+    });
+    if (nodes[0].length == 0) {
+      return {};
+    }
+    return this.nodesToSchema(nodes[0], uid2);
+  }
+  ignoreSchemaProperties(schemaProperties) {
+    return import_lodash.default.omit(schemaProperties, nodeKeys);
+  }
+  breakOnMatched(schemaInstance, breakRemoveOn) {
+    if (!breakRemoveOn) {
+      return false;
+    }
+    for (const key of Object.keys(breakRemoveOn)) {
+      const instanceValue = schemaInstance.get(key);
+      const breakRemoveOnValue = breakRemoveOn[key];
+      if (instanceValue !== breakRemoveOnValue) {
+        return false;
+      }
+    }
+    return true;
+  }
+  async schemaExists(schema, options) {
+    if (import_lodash.default.isObject(schema) && !schema["x-uid"]) {
+      return false;
+    }
+    const { transaction: transaction2 } = options;
+    const result = await this.database.sequelize.query(
+      this.sqlAdapter(`select "x-uid" from ${this.uiSchemasTableName} where "x-uid" = :uid`),
+      {
+        type: "SELECT",
+        replacements: {
+          uid: import_lodash.default.isString(schema) ? schema : schema["x-uid"]
+        },
+        transaction: transaction2
+      }
+    );
+    return result.length > 0;
+  }
+  regenerateUid(s) {
+    s["x-uid"] = (0, import_utils.uid)();
+    Object.keys(s.properties || {}).forEach((key) => {
+      this.regenerateUid(s.properties[key]);
+    });
+  }
+  async insertSchemaRecord(name, uid2, schema, transaction2) {
+    const serverHooks = schema["x-server-hooks"] || [];
+    const node = await this.create({
+      values: {
+        name,
+        ["x-uid"]: uid2,
+        schema,
+        serverHooks
+      },
+      transaction: transaction2,
+      context: {
+        disableInsertHook: true
+      }
+    });
+    return node;
+  }
+  prepareSingleNodeForInsert(schema) {
+    const uid2 = schema["x-uid"];
+    const name = schema["name"];
+    const async = import_lodash.default.get(schema, "x-async", false);
+    const childOptions = schema["childOptions"];
+    delete schema["x-uid"];
+    delete schema["x-async"];
+    delete schema["name"];
+    delete schema["childOptions"];
+    return { uid: uid2, name, async, childOptions };
+  }
 };
 __decorateClass([
   transaction()
@@ -915,37 +915,37 @@ __decorateClass([
 ], _UiSchemaRepository.prototype, "remove", 1);
 __decorateClass([
   transaction()
-], _UiSchemaRepository.prototype, "insertBeside", 1);
+], _UiSchemaRepository.prototype, "insertAdjacent", 1);
 __decorateClass([
   transaction()
-], _UiSchemaRepository.prototype, "insertInner", 1);
+], _UiSchemaRepository.prototype, "duplicate", 1);
 __decorateClass([
   transaction()
-], _UiSchemaRepository.prototype, "insertAdjacent", 1);
+], _UiSchemaRepository.prototype, "insert", 1);
 __decorateClass([
   transaction()
-], _UiSchemaRepository.prototype, "insertAfterBegin", 1);
+], _UiSchemaRepository.prototype, "insertNewSchema", 1);
 __decorateClass([
   transaction()
-], _UiSchemaRepository.prototype, "insertBeforeEnd", 1);
+], _UiSchemaRepository.prototype, "insertBeside", 1);
 __decorateClass([
   transaction()
-], _UiSchemaRepository.prototype, "insertBeforeBegin", 1);
+], _UiSchemaRepository.prototype, "insertInner", 1);
 __decorateClass([
   transaction()
-], _UiSchemaRepository.prototype, "insertAfterEnd", 1);
+], _UiSchemaRepository.prototype, "insertAfterBegin", 1);
 __decorateClass([
   transaction()
-], _UiSchemaRepository.prototype, "insertNodes", 1);
+], _UiSchemaRepository.prototype, "insertBeforeEnd", 1);
 __decorateClass([
   transaction()
-], _UiSchemaRepository.prototype, "duplicate", 1);
+], _UiSchemaRepository.prototype, "insertBeforeBegin", 1);
 __decorateClass([
   transaction()
-], _UiSchemaRepository.prototype, "insert", 1);
+], _UiSchemaRepository.prototype, "insertAfterEnd", 1);
 __decorateClass([
   transaction()
-], _UiSchemaRepository.prototype, "insertNewSchema", 1);
+], _UiSchemaRepository.prototype, "insertNodes", 1);
 let UiSchemaRepository = _UiSchemaRepository;
 var repository_default = UiSchemaRepository;
 // Annotate the CommonJS export names for ESM import in node:

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": "0.15.0-alpha.3",
+  "version": "0.15.0-alpha.5",
   "license": "AGPL-3.0",
   "main": "./dist/server/index.js",
   "devDependencies": {
@@ -22,5 +22,5 @@
     "@nocobase/test": "0.x",
     "@nocobase/utils": "0.x"
   },
-  "gitHead": "8f39868bd613a465efb20123094ebbc2390c1eef"
+  "gitHead": "4713b1a887dad4dadf27b65e3b3e2a46c6986cbf"
 }