@nocobase/plugin-ui-schema-storage 0.7.5-alpha.1 → 0.7.6-alpha.1

package/lib/actions/ui-schema-action.js

@@ -28,7 +28,9 @@ function asyncGeneratorStep(gen, resolve, reject, _next, _throw, key, arg) { try
 function _asyncToGenerator(fn) { return function () { var self = this, args = arguments; return new Promise(function (resolve, reject) { var gen = fn.apply(self, args); function _next(value) { asyncGeneratorStep(gen, resolve, reject, _next, _throw, "next", value); } function _throw(err) { asyncGeneratorStep(gen, resolve, reject, _next, _throw, "throw", err); } _next(undefined); }); }; }
 
 const getRepositoryFromCtx = ctx => {
-  return ctx.db.getCollection('uiSchemas').repository;
+  const repo = ctx.db.getCollection('uiSchemas').repository;
+  repo.setCache(ctx.cache);
+  return repo;
 };
 
 const callRepositoryMethod = (method, paramsKey, optionsBuilder) => {
@@ -64,11 +66,15 @@ function parseInsertAdjacentValues(values) {
 
 const uiSchemaActions = {
   getJsonSchema: callRepositoryMethod('getJsonSchema', 'resourceIndex', params => {
+    const includeAsyncNode = params === null || params === void 0 ? void 0 : params.includeAsyncNode;
     return {
-      includeAsyncNode: params === null || params === void 0 ? void 0 : params.includeAsyncNode
+      readFromCache: !includeAsyncNode,
+      includeAsyncNode
     };
   }),
-  getProperties: callRepositoryMethod('getProperties', 'resourceIndex'),
+  getProperties: callRepositoryMethod('getProperties', 'resourceIndex', () => ({
+    readFromCache: true
+  })),
   insert: callRepositoryMethod('insert', 'values'),
   insertNewSchema: callRepositoryMethod('insertNewSchema', 'values'),
   remove: callRepositoryMethod('remove', 'resourceIndex'),
@@ -119,7 +125,7 @@ const uiSchemaActions = {
           }),
           transaction
         });
-        yield db.getRepository('uiSchemas').clearAncestor(filterByTk, {
+        yield getRepositoryFromCtx(ctx).clearAncestor(filterByTk, {
           transaction
         });
         ctx.body = {

package/lib/repository.d.ts

@@ -1,8 +1,14 @@
 import { Repository, Transactionable } from '@nocobase/database';
+import { Cache } from '@nocobase/cache';
 import { Transaction } from 'sequelize';
 import { ChildOptions, SchemaNode } from './dao/ui_schema_node_dao';
-interface GetJsonSchemaOptions {
+export interface GetJsonSchemaOptions {
     includeAsyncNode?: boolean;
+    readFromCache?: boolean;
+    transaction?: Transaction;
+}
+export interface GetPropertiesOptions {
+    readFromCache?: boolean;
     transaction?: Transaction;
 }
 declare type BreakRemoveOnType = {
@@ -16,15 +22,26 @@ interface InsertAdjacentOptions extends removeParentOptions {
     wrap?: any;
 }
 export declare class UiSchemaRepository extends Repository {
+    cache: Cache;
+    setCache(cache: Cache): void;
+    /**
+     * clear cache with xUid which in uiSchemaTreePath's Path
+     * @param {string} xUid
+     * @param {Transaction} transaction
+     * @returns {Promise<void>}
+     */
+    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?: Transactionable): Promise<Partial<{
+    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): {
@@ -34,10 +51,10 @@ 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>;
-    updateNode(uid: string, schema: any, transaction?: Transaction): 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>;
-    findParentUid(uid: any, transaction?: any): Promise<string>;
+    protected findParentUid(uid: any, transaction?: any): Promise<string>;
     protected findNodeSchemaWithParent(uid: any, transaction: any): Promise<{
         parentUid: string;
         schema: import("@nocobase/database").Model<any, any>;
@@ -53,15 +70,15 @@ export declare class UiSchemaRepository extends Repository {
         breakRemoveOn?: BreakRemoveOnType;
     }): Promise<void>;
     remove(uid: string, options?: Transactionable & removeParentOptions): Promise<void>;
-    insertBeside(targetUid: string, schema: any, side: 'before' | 'after', options?: InsertAdjacentOptions): Promise<any>;
-    insertInner(targetUid: string, schema: any, position: 'first' | 'last', options?: InsertAdjacentOptions): 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>;
-    insertNodes(nodes: SchemaNode[], options?: Transactionable): Promise<any[]>;
+    protected insertNodes(nodes: SchemaNode[], options?: Transactionable): Promise<any[]>;
     insert(schema: any, options?: Transactionable): Promise<any>;
     insertNewSchema(schema: any, options?: Transactionable & {
         returnNode?: boolean;

package/lib/repository.js

@@ -110,6 +110,56 @@ function transaction(transactionAbleArgPosition) {
 }
 
 class UiSchemaRepository extends _database().Repository {
+  constructor(...args) {
+    super(...args);
+    this.cache = void 0;
+  }
+
+  // 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>}
+   */
+
+
+  clearXUidPathCache(xUid, transaction) {
+    var _this = this;
+
+    return _asyncToGenerator(function* () {
+      if (!_this.cache || !xUid) {
+        return;
+      } // find all xUid node's parent nodes
+
+
+      const uiSchemaNodes = yield _this.database.getRepository('uiSchemaTreePath').find({
+        filter: {
+          descendant: xUid
+        },
+        transaction: transaction
+      });
+
+      var _iterator = _createForOfIteratorHelper(uiSchemaNodes),
+          _step;
+
+      try {
+        for (_iterator.s(); !(_step = _iterator.n()).done;) {
+          const uiSchemaNode = _step.value;
+          yield _this.cache.del(`p_${uiSchemaNode['ancestor']}`);
+          yield _this.cache.del(`s_${uiSchemaNode['ancestor']}`);
+        }
+      } catch (err) {
+        _iterator.e(err);
+      } finally {
+        _iterator.f();
+      }
+    })();
+  }
+
   tableNameAdapter(tableName) {
     if (this.database.sequelize.getDialect() === 'postgres') {
       return `"${tableName}"`;
@@ -154,12 +204,12 @@ class UiSchemaRepository extends _database().Repository {
 
     carry.push(node);
 
-    var _iterator = _createForOfIteratorHelper(nodeKeys),
-        _step;
+    var _iterator2 = _createForOfIteratorHelper(nodeKeys),
+        _step2;
 
     try {
-      for (_iterator.s(); !(_step = _iterator.n()).done;) {
-        const nodeKey = _step.value;
+      for (_iterator2.s(); !(_step2 = _iterator2.n()).done;) {
+        const nodeKey = _step2.value;
 
         const nodeProperty = _lodash().default.get(node, nodeKey);
 
@@ -172,37 +222,37 @@ class UiSchemaRepository extends _database().Repository {
         if (nodeKey === 'items' && nodeProperty) {
           const handleItems = _lodash().default.isArray(nodeProperty) ? nodeProperty : [nodeProperty];
 
-          var _iterator2 = _createForOfIteratorHelper(handleItems.entries()),
-              _step2;
+          var _iterator3 = _createForOfIteratorHelper(handleItems.entries()),
+              _step3;
 
           try {
-            for (_iterator2.s(); !(_step2 = _iterator2.n()).done;) {
-              const _step2$value = _slicedToArray(_step2.value, 2),
-                    i = _step2$value[0],
-                    item = _step2$value[1];
+            for (_iterator3.s(); !(_step3 = _iterator3.n()).done;) {
+              const _step3$value = _slicedToArray(_step3.value, 2),
+                    i = _step3$value[0],
+                    item = _step3$value[1];
 
               carry = this.schemaToSingleNodes(item, carry, _objectSpread(_objectSpread({}, childNodeChildOptions), {}, {
                 sort: i + 1
               }));
             }
           } catch (err) {
-            _iterator2.e(err);
+            _iterator3.e(err);
           } finally {
-            _iterator2.f();
+            _iterator3.f();
           }
         } else if (_lodash().default.isPlainObject(nodeProperty)) {
           const subNodeNames = _lodash().default.keys(_lodash().default.get(node, nodeKey));
 
           delete node[nodeKey];
 
-          var _iterator3 = _createForOfIteratorHelper(subNodeNames.entries()),
-              _step3;
+          var _iterator4 = _createForOfIteratorHelper(subNodeNames.entries()),
+              _step4;
 
           try {
-            for (_iterator3.s(); !(_step3 = _iterator3.n()).done;) {
-              const _step3$value = _slicedToArray(_step3.value, 2),
-                    i = _step3$value[0],
-                    subNodeName = _step3$value[1];
+            for (_iterator4.s(); !(_step4 = _iterator4.n()).done;) {
+              const _step4$value = _slicedToArray(_step4.value, 2),
+                    i = _step4$value[0],
+                    subNodeName = _step4$value[1];
 
               const subSchema = _objectSpread({
                 name: subNodeName
@@ -213,37 +263,51 @@ class UiSchemaRepository extends _database().Repository {
               }));
             }
           } catch (err) {
-            _iterator3.e(err);
+            _iterator4.e(err);
           } finally {
-            _iterator3.f();
+            _iterator4.f();
           }
         }
       }
     } catch (err) {
-      _iterator.e(err);
+      _iterator2.e(err);
     } finally {
-      _iterator.f();
+      _iterator2.f();
     }
 
     return carry;
   }
 
   getProperties(uid, options = {}) {
-    var _this = this;
+    var _this2 = this;
+
+    return _asyncToGenerator(function* () {
+      if ((options === null || options === void 0 ? void 0 : options.readFromCache) && _this2.cache) {
+        return _this2.cache.wrap(`p_${uid}`, () => {
+          return _this2.doGetProperties(uid, options);
+        });
+      }
+
+      return _this2.doGetProperties(uid, options);
+    })();
+  }
+
+  doGetProperties(uid, options = {}) {
+    var _this3 = this;
 
     return _asyncToGenerator(function* () {
       const transaction = options.transaction;
-      const db = _this.database;
+      const db = _this3.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)
+        FROM ${_this3.uiSchemaTreePathTableName} as TreePath
+                 LEFT JOIN ${_this3.uiSchemasTableName} as "SchemaTable" ON "SchemaTable"."x-uid" =  TreePath.descendant
+                 LEFT JOIN ${_this3.uiSchemaTreePathTableName} as NodeInfo ON NodeInfo.descendant = "SchemaTable"."x-uid" and NodeInfo.descendant = NodeInfo.ancestor and NodeInfo.depth = 0
+                 LEFT JOIN ${_this3.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 = yield db.sequelize.query(_this.sqlAdapter(rawSql), {
+      const nodes = yield db.sequelize.query(_this3.sqlAdapter(rawSql), {
         replacements: {
           ancestor: uid
         },
@@ -254,29 +318,29 @@ class UiSchemaRepository extends _database().Repository {
         return {};
       }
 
-      const schema = _this.nodesToSchema(nodes[0], uid);
+      const schema = _this3.nodesToSchema(nodes[0], uid);
 
       return _lodash().default.pick(schema, ['type', 'properties']);
     })();
   }
 
-  getJsonSchema(uid, options) {
-    var _this2 = this;
+  doGetJsonSchema(uid, options) {
+    var _this4 = this;
 
     return _asyncToGenerator(function* () {
-      const db = _this2.database;
-      const treeTable = _this2.uiSchemaTreePathTableName;
+      const db = _this4.database;
+      const treeTable = _this4.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 ${_this2.uiSchemasTableName} as "SchemaTable" ON "SchemaTable"."x-uid" =  TreePath.descendant
+                 LEFT JOIN ${_this4.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 || options === void 0 ? void 0 : options.includeAsyncNode) ? '' : 'AND (NodeInfo.async != true )'}
     `;
-      const nodes = yield db.sequelize.query(_this2.sqlAdapter(rawSql), {
+      const nodes = yield db.sequelize.query(_this4.sqlAdapter(rawSql), {
         replacements: {
           ancestor: uid
         },
@@ -287,9 +351,21 @@ class UiSchemaRepository extends _database().Repository {
         return {};
       }
 
-      const schema = _this2.nodesToSchema(nodes[0], uid);
+      return _this4.nodesToSchema(nodes[0], uid);
+    })();
+  }
 
-      return schema;
+  getJsonSchema(uid, options) {
+    var _this5 = this;
+
+    return _asyncToGenerator(function* () {
+      if ((options === null || options === void 0 ? void 0 : options.readFromCache) && _this5.cache) {
+        return _this5.cache.wrap(`s_${uid}`, () => {
+          return _this5.doGetJsonSchema(uid, options);
+        });
+      }
+
+      return _this5.doGetJsonSchema(uid, options);
     })();
   }
 
@@ -335,11 +411,12 @@ class UiSchemaRepository extends _database().Repository {
   }
 
   clearAncestor(uid, options) {
-    var _this3 = this;
+    var _this6 = this;
 
     return _asyncToGenerator(function* () {
-      const db = _this3.database;
-      const treeTable = _this3.uiSchemaTreePathTableName;
+      yield _this6.clearXUidPathCache(uid, options === null || options === void 0 ? void 0 : options.transaction);
+      const db = _this6.database;
+      const treeTable = _this6.uiSchemaTreePathTableName;
       yield db.sequelize.query(`DELETE
        FROM ${treeTable}
        WHERE descendant IN
@@ -357,19 +434,20 @@ class UiSchemaRepository extends _database().Repository {
   }
 
   patch(newSchema, options) {
-    var _this4 = this;
+    var _this7 = this;
 
     return _asyncToGenerator(function* () {
       const transaction = options.transaction;
       const rootUid = newSchema['x-uid'];
-      const oldTree = yield _this4.getJsonSchema(rootUid);
+      yield _this7.clearXUidPathCache(rootUid, transaction);
+      const oldTree = yield _this7.getJsonSchema(rootUid);
 
       const traverSchemaTree = /*#__PURE__*/function () {
         var _ref2 = _asyncToGenerator(function* (schema, path = []) {
           const node = schema;
           const oldNode = path.length == 0 ? oldTree : _lodash().default.get(oldTree, path);
           const oldNodeUid = oldNode['x-uid'];
-          yield _this4.updateNode(oldNodeUid, node, transaction);
+          yield _this7.updateNode(oldNodeUid, node, transaction);
           const properties = node.properties;
 
           if (_lodash().default.isPlainObject(properties)) {
@@ -390,34 +468,34 @@ class UiSchemaRepository extends _database().Repository {
   }
 
   batchPatch(schemas, options) {
-    var _this5 = this;
+    var _this8 = this;
 
     return _asyncToGenerator(function* () {
       const transaction = options.transaction;
 
-      var _iterator4 = _createForOfIteratorHelper(schemas),
-          _step4;
+      var _iterator5 = _createForOfIteratorHelper(schemas),
+          _step5;
 
       try {
-        for (_iterator4.s(); !(_step4 = _iterator4.n()).done;) {
-          const schema = _step4.value;
-          yield _this5.patch(schema, _objectSpread(_objectSpread({}, options), {}, {
+        for (_iterator5.s(); !(_step5 = _iterator5.n()).done;) {
+          const schema = _step5.value;
+          yield _this8.patch(schema, _objectSpread(_objectSpread({}, options), {}, {
             transaction
           }));
         }
       } catch (err) {
-        _iterator4.e(err);
+        _iterator5.e(err);
       } finally {
-        _iterator4.f();
+        _iterator5.f();
       }
     })();
   }
 
   updateNode(uid, schema, transaction) {
-    var _this6 = this;
+    var _this9 = this;
 
     return _asyncToGenerator(function* () {
-      const nodeModel = yield _this6.findOne({
+      const nodeModel = yield _this9.findOne({
         filter: {
           'x-uid': uid
         }
@@ -432,11 +510,11 @@ class UiSchemaRepository extends _database().Repository {
   }
 
   childrenCount(uid, transaction) {
-    var _this7 = this;
+    var _this10 = this;
 
     return _asyncToGenerator(function* () {
-      const db = _this7.database;
-      const countResult = yield db.sequelize.query(`SELECT COUNT(*) as count FROM ${_this7.uiSchemaTreePathTableName} where ancestor = :ancestor and depth  = 1`, {
+      const db = _this10.database;
+      const countResult = yield db.sequelize.query(`SELECT COUNT(*) as count FROM ${_this10.uiSchemaTreePathTableName} where ancestor = :ancestor and depth  = 1`, {
         replacements: {
           ancestor: uid
         },
@@ -448,19 +526,19 @@ class UiSchemaRepository extends _database().Repository {
   }
 
   isLeafNode(uid, transaction) {
-    var _this8 = this;
+    var _this11 = this;
 
     return _asyncToGenerator(function* () {
-      const childrenCount = yield _this8.childrenCount(uid, transaction);
+      const childrenCount = yield _this11.childrenCount(uid, transaction);
       return childrenCount === 0;
     })();
   }
 
   findParentUid(uid, transaction) {
-    var _this9 = this;
+    var _this12 = this;
 
     return _asyncToGenerator(function* () {
-      const parent = yield _this9.database.getRepository('uiSchemaTreePath').findOne({
+      const parent = yield _this12.database.getRepository('uiSchemaTreePath').findOne({
         filter: {
           descendant: uid,
           depth: 1
@@ -472,34 +550,34 @@ class UiSchemaRepository extends _database().Repository {
   }
 
   findNodeSchemaWithParent(uid, transaction) {
-    var _this10 = this;
+    var _this13 = this;
 
     return _asyncToGenerator(function* () {
-      const schema = yield _this10.database.getRepository('uiSchemas').findOne({
+      const schema = yield _this13.database.getRepository('uiSchemas').findOne({
         filter: {
           'x-uid': uid
         },
         transaction
       });
       return {
-        parentUid: yield _this10.findParentUid(uid, transaction),
+        parentUid: yield _this13.findParentUid(uid, transaction),
         schema
       };
     })();
   }
 
   isSingleChild(uid, transaction) {
-    var _this11 = this;
+    var _this14 = this;
 
     return _asyncToGenerator(function* () {
-      const db = _this11.database;
-      const parent = yield _this11.findParentUid(uid, transaction);
+      const db = _this14.database;
+      const parent = yield _this14.findParentUid(uid, transaction);
 
       if (!parent) {
         return null;
       }
 
-      const parentChildrenCount = yield _this11.childrenCount(parent, transaction);
+      const parentChildrenCount = yield _this14.childrenCount(parent, transaction);
 
       if (parentChildrenCount == 1) {
         const schema = yield db.getRepository('uiSchemas').findOne({
@@ -516,21 +594,22 @@ class UiSchemaRepository extends _database().Repository {
   }
 
   removeEmptyParents(options) {
-    var _this12 = this;
+    var _this15 = this;
 
     return _asyncToGenerator(function* () {
       const transaction = options.transaction,
             uid = options.uid,
             breakRemoveOn = options.breakRemoveOn;
+      yield _this15.clearXUidPathCache(uid, transaction);
 
       const removeParent = /*#__PURE__*/function () {
         var _ref3 = _asyncToGenerator(function* (nodeUid) {
-          const parent = yield _this12.isSingleChild(nodeUid, transaction);
+          const parent = yield _this15.isSingleChild(nodeUid, transaction);
 
-          if (parent && !_this12.breakOnMatched(parent, breakRemoveOn)) {
+          if (parent && !_this15.breakOnMatched(parent, breakRemoveOn)) {
             yield removeParent(parent.get('x-uid'));
           } else {
-            yield _this12.remove(nodeUid, {
+            yield _this15.remove(nodeUid, {
               transaction
             });
           }
@@ -564,28 +643,29 @@ class UiSchemaRepository extends _database().Repository {
   }
 
   recursivelyRemoveIfNoChildren(options) {
-    var _this13 = this;
+    var _this16 = this;
 
     return _asyncToGenerator(function* () {
       const uid = options.uid,
             transaction = options.transaction,
             breakRemoveOn = options.breakRemoveOn;
+      yield _this16.clearXUidPathCache(uid, transaction);
 
       const removeLeafNode = /*#__PURE__*/function () {
         var _ref4 = _asyncToGenerator(function* (nodeUid) {
-          const isLeafNode = yield _this13.isLeafNode(nodeUid, transaction);
+          const isLeafNode = yield _this16.isLeafNode(nodeUid, transaction);
 
           if (isLeafNode) {
-            const _yield$_this13$findNo = yield _this13.findNodeSchemaWithParent(nodeUid, transaction),
-                  parentUid = _yield$_this13$findNo.parentUid,
-                  schema = _yield$_this13$findNo.schema;
+            const _yield$_this16$findNo = yield _this16.findNodeSchemaWithParent(nodeUid, transaction),
+                  parentUid = _yield$_this16$findNo.parentUid,
+                  schema = _yield$_this16$findNo.schema;
 
-            if (_this13.breakOnMatched(schema, breakRemoveOn)) {
+            if (_this16.breakOnMatched(schema, breakRemoveOn)) {
               // break at here
               return;
             } else {
               // remove current node
-              yield _this13.remove(nodeUid, {
+              yield _this16.remove(nodeUid, {
                 transaction
               }); // continue remove
 
@@ -604,13 +684,14 @@ class UiSchemaRepository extends _database().Repository {
   }
 
   remove(uid, options) {
-    var _this14 = this;
+    var _this17 = this;
 
     return _asyncToGenerator(function* () {
       let transaction = options.transaction;
+      yield _this17.clearXUidPathCache(uid, transaction);
 
       if (options === null || options === void 0 ? void 0 : options.removeParentsIfNoChildren) {
-        yield _this14.removeEmptyParents({
+        yield _this17.removeEmptyParents({
           transaction,
           uid,
           breakRemoveOn: options.breakRemoveOn
@@ -618,19 +699,19 @@ class UiSchemaRepository extends _database().Repository {
         return;
       }
 
-      yield _this14.database.sequelize.query(_this14.sqlAdapter(`DELETE FROM ${_this14.uiSchemasTableName} WHERE "x-uid" IN (
-            SELECT descendant FROM ${_this14.uiSchemaTreePathTableName} WHERE ancestor = :uid
+      yield _this17.database.sequelize.query(_this17.sqlAdapter(`DELETE FROM ${_this17.uiSchemasTableName} WHERE "x-uid" IN (
+            SELECT descendant FROM ${_this17.uiSchemaTreePathTableName} WHERE ancestor = :uid
         )`), {
         replacements: {
           uid
         },
         transaction
       });
-      yield _this14.database.sequelize.query(` DELETE FROM ${_this14.uiSchemaTreePathTableName}
+      yield _this17.database.sequelize.query(` DELETE FROM ${_this17.uiSchemaTreePathTableName}
             WHERE descendant IN (
                 select descendant FROM
                     (SELECT descendant
-                     FROM ${_this14.uiSchemaTreePathTableName}
+                     FROM ${_this17.uiSchemaTreePathTableName}
                      WHERE ancestor = :uid)as descendantTable) `, {
         replacements: {
           uid
@@ -641,13 +722,13 @@ class UiSchemaRepository extends _database().Repository {
   }
 
   insertBeside(targetUid, schema, side, options) {
-    var _this15 = this;
+    var _this18 = this;
 
     return _asyncToGenerator(function* () {
       const transaction = options.transaction;
-      const targetParent = yield _this15.findParentUid(targetUid, transaction);
-      const db = _this15.database;
-      const treeTable = _this15.uiSchemaTreePathTableName;
+      const targetParent = yield _this18.findParentUid(targetUid, transaction);
+      const db = _this18.database;
+      const treeTable = _this18.uiSchemaTreePathTableName;
       const typeQuery = yield db.sequelize.query(`SELECT type from ${treeTable} WHERE ancestor = :uid AND depth = 0;`, {
         type: 'SELECT',
         replacements: {
@@ -665,15 +746,15 @@ class UiSchemaRepository extends _database().Repository {
           target: targetUid
         }
       };
-      const insertedNodes = yield _this15.insertNodes(nodes, options);
-      return yield _this15.getJsonSchema(insertedNodes[0].get('x-uid'), {
+      const insertedNodes = yield _this18.insertNodes(nodes, options);
+      return yield _this18.getJsonSchema(insertedNodes[0].get('x-uid'), {
         transaction
       });
     })();
   }
 
   insertInner(targetUid, schema, position, options) {
-    var _this16 = this;
+    var _this19 = this;
 
     return _asyncToGenerator(function* () {
       const transaction = options.transaction;
@@ -684,15 +765,15 @@ class UiSchemaRepository extends _database().Repository {
         type: _lodash().default.get(schema, 'x-node-type', 'properties'),
         position
       };
-      const insertedNodes = yield _this16.insertNodes(nodes, options);
-      return yield _this16.getJsonSchema(insertedNodes[0].get('x-uid'), {
+      const insertedNodes = yield _this19.insertNodes(nodes, options);
+      return yield _this19.getJsonSchema(insertedNodes[0].get('x-uid'), {
         transaction
       });
     })();
   }
 
   schemaExists(schema, options) {
-    var _this17 = this;
+    var _this20 = this;
 
     return _asyncToGenerator(function* () {
       if (_lodash().default.isObject(schema) && !schema['x-uid']) {
@@ -700,7 +781,7 @@ class UiSchemaRepository extends _database().Repository {
       }
 
       const transaction = options.transaction;
-      const result = yield _this17.database.sequelize.query(_this17.sqlAdapter(`select "x-uid" from ${_this17.uiSchemasTableName} where "x-uid" = :uid`), {
+      const result = yield _this20.database.sequelize.query(_this20.sqlAdapter(`select "x-uid" from ${_this20.uiSchemasTableName} where "x-uid" = :uid`), {
         type: 'SELECT',
         replacements: {
           uid: _lodash().default.isString(schema) ? schema : schema['x-uid']
@@ -712,31 +793,33 @@ class UiSchemaRepository extends _database().Repository {
   }
 
   insertAdjacent(position, target, schema, options) {
-    var _this18 = this;
+    var _this21 = this;
 
     return _asyncToGenerator(function* () {
-      const transaction = options.transaction;
+      const transaction = options.transaction; // if schema is existed then clear origin path schema cache
+
+      yield _this21.clearXUidPathCache(schema['x-uid'], transaction);
 
       if (options.wrap) {
         // insert wrap schema using insertNewSchema
-        const wrapSchemaNodes = yield _this18.insertNewSchema(options.wrap, {
+        const wrapSchemaNodes = yield _this21.insertNewSchema(options.wrap, {
           transaction,
           returnNode: true
         });
         const lastWrapNode = wrapSchemaNodes[wrapSchemaNodes.length - 1]; // insert schema into wrap schema
 
-        yield _this18.insertAdjacent('afterBegin', lastWrapNode['x-uid'], schema, _lodash().default.omit(options, 'wrap'));
+        yield _this21.insertAdjacent('afterBegin', lastWrapNode['x-uid'], schema, _lodash().default.omit(options, 'wrap'));
         schema = wrapSchemaNodes[0]['x-uid'];
         options.removeParentsIfNoChildren = false;
       } else {
-        const schemaExists = yield _this18.schemaExists(schema, {
+        const schemaExists = yield _this21.schemaExists(schema, {
           transaction
         });
 
         if (schemaExists) {
           schema = _lodash().default.isString(schema) ? schema : schema['x-uid'];
         } else {
-          const insertedSchema = yield _this18.insertNewSchema(schema, {
+          const insertedSchema = yield _this21.insertNewSchema(schema, {
             transaction,
             returnNode: true
           });
@@ -744,63 +827,66 @@ class UiSchemaRepository extends _database().Repository {
         }
       }
 
-      return yield _this18[`insert${_lodash().default.upperFirst(position)}`](target, schema, options);
+      const result = yield _this21[`insert${_lodash().default.upperFirst(position)}`](target, schema, options); // clear target schema path cache
+
+      yield _this21.clearXUidPathCache(result['x-uid'], transaction);
+      return result;
     })();
   }
 
   insertAfterBegin(targetUid, schema, options) {
-    var _this19 = this;
+    var _this22 = this;
 
     return _asyncToGenerator(function* () {
-      return yield _this19.insertInner(targetUid, schema, 'first', options);
+      return yield _this22.insertInner(targetUid, schema, 'first', options);
     })();
   }
 
   insertBeforeEnd(targetUid, schema, options) {
-    var _this20 = this;
+    var _this23 = this;
 
     return _asyncToGenerator(function* () {
-      return yield _this20.insertInner(targetUid, schema, 'last', options);
+      return yield _this23.insertInner(targetUid, schema, 'last', options);
     })();
   }
 
   insertBeforeBegin(targetUid, schema, options) {
-    var _this21 = this;
+    var _this24 = this;
 
     return _asyncToGenerator(function* () {
-      return yield _this21.insertBeside(targetUid, schema, 'before', options);
+      return yield _this24.insertBeside(targetUid, schema, 'before', options);
     })();
   }
 
   insertAfterEnd(targetUid, schema, options) {
-    var _this22 = this;
+    var _this25 = this;
 
     return _asyncToGenerator(function* () {
-      return yield _this22.insertBeside(targetUid, schema, 'after', options);
+      return yield _this25.insertBeside(targetUid, schema, 'after', options);
     })();
   }
 
   insertNodes(nodes, options) {
-    var _this23 = this;
+    var _this26 = this;
 
     return _asyncToGenerator(function* () {
       const transaction = options.transaction;
       const insertedNodes = [];
 
-      var _iterator5 = _createForOfIteratorHelper(nodes),
-          _step5;
+      var _iterator6 = _createForOfIteratorHelper(nodes),
+          _step6;
 
       try {
-        for (_iterator5.s(); !(_step5 = _iterator5.n()).done;) {
-          const node = _step5.value;
-          insertedNodes.push(yield _this23.insertSingleNode(node, _objectSpread(_objectSpread({}, options), {}, {
+        for (_iterator6.s(); !(_step6 = _iterator6.n()).done;) {
+          const node = _step6.value;
+          insertedNodes.push(yield _this26.insertSingleNode(node, _objectSpread(_objectSpread({}, options), {}, {
             transaction
           })));
         }
       } catch (err) {
-        _iterator5.e(err);
+        _iterator6.e(err);
       } finally {
-        _iterator5.f();
+        _iterator6.f();
       }
 
       return insertedNodes;
@@ -808,29 +894,31 @@ class UiSchemaRepository extends _database().Repository {
   }
 
   insert(schema, options) {
-    var _this24 = this;
+    var _this27 = this;
 
     return _asyncToGenerator(function* () {
       const nodes = UiSchemaRepository.schemaToSingleNodes(schema);
-      const insertedNodes = yield _this24.insertNodes(nodes, options);
-      return _this24.getJsonSchema(insertedNodes[0].get('x-uid'), {
+      const insertedNodes = yield _this27.insertNodes(nodes, options);
+      const result = yield _this27.getJsonSchema(insertedNodes[0].get('x-uid'), {
         transaction: options === null || options === void 0 ? void 0 : options.transaction
       });
+      yield _this27.clearXUidPathCache(result['x-uid'], options === null || options === void 0 ? void 0 : options.transaction);
+      return result;
     })();
   }
 
   insertNewSchema(schema, options) {
-    var _this25 = this;
+    var _this28 = this;
 
     return _asyncToGenerator(function* () {
       const transaction = options.transaction;
       const nodes = UiSchemaRepository.schemaToSingleNodes(schema); // insert schema fist
 
-      yield _this25.database.sequelize.query(_this25.sqlAdapter(`INSERT INTO ${_this25.uiSchemasTableName} ("x-uid", "name", "schema") VALUES ${nodes.map(n => '(?)').join(',')};`), {
+      yield _this28.database.sequelize.query(_this28.sqlAdapter(`INSERT INTO ${_this28.uiSchemasTableName} ("x-uid", "name", "schema") VALUES ${nodes.map(n => '(?)').join(',')};`), {
         replacements: _lodash().default.cloneDeep(nodes).map(node => {
-          const _this25$prepareSingle = _this25.prepareSingleNodeForInsert(node),
-                uid = _this25$prepareSingle.uid,
-                name = _this25$prepareSingle.name;
+          const _this28$prepareSingle = _this28.prepareSingleNodeForInsert(node),
+                uid = _this28$prepareSingle.uid,
+                name = _this28$prepareSingle.name;
 
           return [uid, name, JSON.stringify(node)];
         }),
@@ -839,10 +927,10 @@ class UiSchemaRepository extends _database().Repository {
       });
 
       const treePathData = _lodash().default.cloneDeep(nodes).reduce((carry, item) => {
-        const _this25$prepareSingle2 = _this25.prepareSingleNodeForInsert(item),
-              uid = _this25$prepareSingle2.uid,
-              childOptions = _this25$prepareSingle2.childOptions,
-              async = _this25$prepareSingle2.async;
+        const _this28$prepareSingle2 = _this28.prepareSingleNodeForInsert(item),
+              uid = _this28$prepareSingle2.uid,
+              childOptions = _this28$prepareSingle2.childOptions,
+              async = _this28$prepareSingle2.async;
 
         return [...carry, // self reference
         [uid, uid, 0, (childOptions === null || childOptions === void 0 ? void 0 : childOptions.type) || null, async, null], // parent references
@@ -852,7 +940,7 @@ class UiSchemaRepository extends _database().Repository {
       }, []); // insert tree path
 
 
-      yield _this25.database.sequelize.query(_this25.sqlAdapter(`INSERT INTO ${_this25.uiSchemaTreePathTableName} (ancestor, descendant, depth, type, async, sort) VALUES ${treePathData.map(item => '(?)').join(',')}`), {
+      yield _this28.database.sequelize.query(_this28.sqlAdapter(`INSERT INTO ${_this28.uiSchemaTreePathTableName} (ancestor, descendant, depth, type, async, sort) VALUES ${treePathData.map(item => '(?)').join(',')}`), {
         replacements: treePathData,
         type: 'insert',
         transaction
@@ -860,31 +948,33 @@ class UiSchemaRepository extends _database().Repository {
       const rootNode = nodes[0];
 
       if (rootNode['x-server-hooks']) {
-        const rootModel = yield _this25.findOne({
+        const rootModel = yield _this28.findOne({
           filter: {
             'x-uid': rootNode['x-uid']
           },
           transaction
         });
-        yield _this25.database.emitAsync(`${_this25.collection.name}.afterCreateWithAssociations`, rootModel, options);
+        yield _this28.database.emitAsync(`${_this28.collection.name}.afterCreateWithAssociations`, rootModel, options);
       }
 
       if (options === null || options === void 0 ? void 0 : options.returnNode) {
         return nodes;
       }
 
-      return _this25.getJsonSchema(nodes[0]['x-uid'], {
+      const result = yield _this28.getJsonSchema(nodes[0]['x-uid'], {
         transaction
       });
+      yield _this28.clearXUidPathCache(result['x-uid'], transaction);
+      return result;
     })();
   }
 
   insertSchemaRecord(name, uid, schema, transaction) {
-    var _this26 = this;
+    var _this29 = this;
 
     return _asyncToGenerator(function* () {
       const serverHooks = schema['x-server-hooks'] || [];
-      const node = yield _this26.create({
+      const node = yield _this29.create({
         values: {
           name,
           ['x-uid']: uid,
@@ -920,42 +1010,42 @@ class UiSchemaRepository extends _database().Repository {
   }
 
   insertSingleNode(schema, options) {
-    var _this27 = this;
+    var _this30 = this;
 
     return _asyncToGenerator(function* () {
       const transaction = options.transaction;
-      const db = _this27.database;
+      const db = _this30.database;
 
-      const _this27$prepareSingle = _this27.prepareSingleNodeForInsert(schema),
-            uid = _this27$prepareSingle.uid,
-            name = _this27$prepareSingle.name,
-            async = _this27$prepareSingle.async,
-            childOptions = _this27$prepareSingle.childOptions;
+      const _this30$prepareSingle = _this30.prepareSingleNodeForInsert(schema),
+            uid = _this30$prepareSingle.uid,
+            name = _this30$prepareSingle.name,
+            async = _this30$prepareSingle.async,
+            childOptions = _this30$prepareSingle.childOptions;
 
       let savedNode; // check node exists or not
 
-      const existsNode = yield _this27.findOne({
+      const existsNode = yield _this30.findOne({
         filter: {
           'x-uid': uid
         },
         transaction
       });
-      const treeTable = _this27.uiSchemaTreePathTableName;
+      const treeTable = _this30.uiSchemaTreePathTableName;
 
       if (existsNode) {
         savedNode = existsNode;
       } else {
-        savedNode = yield _this27.insertSchemaRecord(name, uid, schema, transaction);
+        savedNode = yield _this30.insertSchemaRecord(name, uid, schema, transaction);
       }
 
       if (childOptions) {
-        const oldParentUid = yield _this27.findParentUid(uid, transaction);
+        const oldParentUid = yield _this30.findParentUid(uid, transaction);
         const parentUid = childOptions.parentUid;
-        const childrenCount = yield _this27.childrenCount(uid, transaction);
+        const childrenCount = yield _this30.childrenCount(uid, transaction);
         const isTree = childrenCount > 0; // if node is a tree root move tree to new path
 
         if (isTree) {
-          yield _this27.clearAncestor(uid, {
+          yield _this30.clearAncestor(uid, {
             transaction
           }); // insert new tree path
 
@@ -1032,7 +1122,7 @@ class UiSchemaRepository extends _database().Repository {
                 WHERE NodeInfo.descendant = TreeTable.descendant and NodeInfo.depth = 0
                 AND TreeTable.depth = 1 AND TreeTable.ancestor = :ancestor and NodeInfo.type = :type`; // Compatible with mysql
 
-          if (_this27.database.sequelize.getDialect() === 'mysql') {
+          if (_this30.database.sequelize.getDialect() === 'mysql') {
             updateSql = `UPDATE ${treeTable} as TreeTable
           JOIN ${treeTable} as NodeInfo ON (NodeInfo.descendant = TreeTable.descendant and NodeInfo.depth = 0)
           SET TreeTable.sort = TreeTable.sort + 1
@@ -1050,7 +1140,7 @@ class UiSchemaRepository extends _database().Repository {
         }
 
         if (nodePosition === 'last') {
-          const maxSort = yield db.sequelize.query(`SELECT ${_this27.database.sequelize.getDialect() === 'postgres' ? 'coalesce' : 'ifnull'}(MAX(TreeTable.sort), 0) as maxsort FROM ${treeTable} as TreeTable
+          const maxSort = yield db.sequelize.query(`SELECT ${_this30.database.sequelize.getDialect() === 'postgres' ? 'coalesce' : 'ifnull'}(MAX(TreeTable.sort), 0) as maxsort FROM ${treeTable} as TreeTable
                                                         LEFT JOIN ${treeTable} as NodeInfo
                                                                   ON NodeInfo.descendant = TreeTable.descendant and NodeInfo.depth = 0
            WHERE TreeTable.depth = 1 AND TreeTable.ancestor = :ancestor and NodeInfo.type = :type`, {
@@ -1094,7 +1184,7 @@ class UiSchemaRepository extends _database().Repository {
                            and TreeTable.sort >= :sort
                            and NodeInfo.type = :type`;
 
-          if (_this27.database.sequelize.getDialect() === 'mysql') {
+          if (_this30.database.sequelize.getDialect() === 'mysql') {
             updateSql = `UPDATE  ${treeTable} as TreeTable
 JOIN ${treeTable} as NodeInfo ON (NodeInfo.descendant = TreeTable.descendant and NodeInfo.depth = 0)
 SET TreeTable.sort = TreeTable.sort + 1
@@ -1124,14 +1214,14 @@ WHERE TreeTable.depth = 1 AND  TreeTable.ancestor = :ancestor and TreeTable.sort
         }); // move node to new parent
 
         if (oldParentUid !== null && oldParentUid !== parentUid) {
-          yield _this27.database.emitAsync('uiSchemaMove', savedNode, {
+          yield _this30.database.emitAsync('uiSchemaMove', savedNode, {
             transaction,
             oldParentUid,
             parentUid
           });
 
           if (options.removeParentsIfNoChildren) {
-            yield _this27.recursivelyRemoveIfNoChildren({
+            yield _this30.recursivelyRemoveIfNoChildren({
               transaction,
               uid: oldParentUid,
               breakRemoveOn: options.breakRemoveOn
@@ -1150,6 +1240,7 @@ WHERE TreeTable.depth = 1 AND  TreeTable.ancestor = :ancestor and TreeTable.sort
         });
       }
 
+      yield _this30.clearXUidPathCache(uid, transaction);
       return savedNode;
     })();
   }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@nocobase/plugin-ui-schema-storage",
-  "version": "0.7.5-alpha.1",
+  "version": "0.7.6-alpha.1",
   "main": "lib/index.js",
   "license": "Apache-2.0",
   "licenses": [
@@ -11,7 +11,7 @@
   ],
   "devDependencies": {
     "@formily/json-schema": "2.0.20",
-    "@nocobase/test": "0.7.5-alpha.1"
+    "@nocobase/test": "0.7.6-alpha.1"
   },
-  "gitHead": "f6eb27b68185bb0c0b4c2cfca1df84205a9b9173"
+  "gitHead": "f20ce011a9ac516dc6aec110979f063a0e63f923"
 }