@nocobase/plugin-flow-engine 2.1.0-beta.43 → 2.1.0-beta.45

package/dist/server/repository.js

@@ -207,6 +207,32 @@ const _FlowModelRepository = class _FlowModelRepository extends import_database.
   static optionsToJson(options) {
     return import_lodash.default.isPlainObject(options) ? options : JSON.parse(options);
   }
+  static getSortNumber(value) {
+    if (typeof value === "number" && Number.isFinite(value)) {
+      return value;
+    }
+    if (typeof value === "string" && value.trim()) {
+      const parsed = Number(value);
+      if (Number.isFinite(parsed)) {
+        return parsed;
+      }
+    }
+    return null;
+  }
+  static compareBySortAndUid(a, b) {
+    const aSort = _FlowModelRepository.getSortNumber(a.sort);
+    const bSort = _FlowModelRepository.getSortNumber(b.sort);
+    if (aSort !== null && bSort !== null && aSort !== bSort) {
+      return aSort - bSort;
+    }
+    if (aSort !== null && bSort === null) {
+      return -1;
+    }
+    if (aSort === null && bSort !== null) {
+      return 1;
+    }
+    return String(a.uid || "").localeCompare(String(b.uid || ""));
+  }
   nodesToSchema(nodes, rootUid) {
     const nodeAttributeSanitize = (node) => {
       const schema = {
@@ -215,8 +241,9 @@ const _FlowModelRepository = class _FlowModelRepository extends import_database.
         ["uid"]: node["uid"],
         ["x-async"]: !!node.async
       };
-      if (import_lodash.default.isNumber(node.sort)) {
-        schema["x-index"] = node.sort;
+      const sort = _FlowModelRepository.getSortNumber(node.sort);
+      if (sort !== null) {
+        schema["x-index"] = sort;
       }
       return schema;
     };
@@ -228,7 +255,12 @@ const _FlowModelRepository = class _FlowModelRepository extends import_database.
       if (children.length > 0) {
         const childrenGroupByType = import_lodash.default.groupBy(children, "type");
         for (const childType of Object.keys(childrenGroupByType)) {
-          const properties = childrenGroupByType[childType].map((child) => buildTree(child)).sort((a, b) => a["x-index"] - b["x-index"]);
+          const properties = childrenGroupByType[childType].map((child) => buildTree(child)).sort(
+            (a, b) => _FlowModelRepository.compareBySortAndUid(
+              { sort: a["x-index"], uid: a.uid },
+              { sort: b["x-index"], uid: b.uid }
+            )
+          );
           rootNode[childType] = childType == "items" ? properties.length == 1 ? properties[0] : properties : properties.reduce((carry, item) => {
             carry[item.name] = item;
             delete item["name"];
@@ -289,7 +321,10 @@ const _FlowModelRepository = class _FlowModelRepository extends import_database.
     await this.clearXUidPathCache(rootUid, transaction2);
     if (!newSchema["properties"]) {
       const s = await this.model.findByPk(rootUid, { transaction: transaction2 });
-      s.set("options", { ...s.toJSON(), ...newSchema });
+      s.set("options", {
+        ...import_lodash.default.omit(_FlowModelRepository.optionsToJson(s.get("options") || {}), ["uid"]),
+        ...import_lodash.default.omit(newSchema, ["uid", "name", "options"])
+      });
       await s.save({ transaction: transaction2, hooks: false });
       await this.emitAfterSaveEvent(s, options);
       if (newSchema["x-server-hooks"]) {
@@ -478,17 +513,25 @@ const _FlowModelRepository = class _FlowModelRepository extends import_database.
       const oldParentUid = n["parent"];
       const newParentUid = uidMap[oldParentUid] ?? null;
       const optionsObj = this.replaceStepParamsModelUids(
-        import_lodash.default.isPlainObject(n.options) ? n.options : JSON.parse(n.options),
+        import_lodash.default.cloneDeep(_FlowModelRepository.optionsToJson(n.options)),
         uidMap
       );
+      delete optionsObj.uid;
+      delete optionsObj.name;
+      delete optionsObj.childOptions;
+      delete optionsObj["x-async"];
       if (newParentUid) {
         optionsObj.parent = newParentUid;
         optionsObj.parentId = newParentUid;
+      } else {
+        delete optionsObj.parent;
+        delete optionsObj.parentId;
       }
       const schemaNode = {
+        ...optionsObj,
         uid: newUid,
-        ["x-async"]: !!n.async,
-        ...optionsObj
+        name: newUid,
+        ["x-async"]: !!n.async
       };
       if (newParentUid) {
         schemaNode.childOptions = {
@@ -847,7 +890,7 @@ WHERE TreeTable.depth = 1 AND  TreeTable.ancestor = :ancestor and TreeTable.sort
     await nodeModel.update(
       {
         options: {
-          ...nodeModel.get("options"),
+          ...import_lodash.default.omit(_FlowModelRepository.optionsToJson(nodeModel.get("options") || {}), ["uid"]),
           ...import_lodash.default.omit(schema, ["x-async", "name", "uid", "properties"])
         }
       },
@@ -889,6 +932,115 @@ WHERE TreeTable.depth = 1 AND  TreeTable.ancestor = :ancestor and TreeTable.sort
     });
     return parent ? parent.get("ancestor") : null;
   }
+  async findSiblingInfo(uid2, transaction2) {
+    const rows = await this.database.sequelize.query(
+      this.sqlAdapter(`SELECT ParentPath.ancestor as parent, NodeInfo.type as type
+        FROM ${this.flowModelTreePathTableName} as ParentPath
+        LEFT JOIN ${this.flowModelTreePathTableName} as NodeInfo
+          ON NodeInfo.ancestor = ParentPath.descendant
+          AND NodeInfo.descendant = ParentPath.descendant
+          AND NodeInfo.depth = 0
+        WHERE ParentPath.descendant = :uid AND ParentPath.depth = 1`),
+      {
+        type: "SELECT",
+        replacements: { uid: uid2 },
+        transaction: transaction2
+      }
+    );
+    const row = rows[0];
+    if (!(row == null ? void 0 : row.parent) || !(row == null ? void 0 : row.type)) {
+      return null;
+    }
+    return {
+      parentUid: row.parent,
+      type: row.type
+    };
+  }
+  async findSiblingSortRows(parentUid, type, transaction2) {
+    const treeTable = this.flowModelTreePathTableName;
+    const rows = await this.database.sequelize.query(
+      this.sqlAdapter(`SELECT ChildPath.descendant as uid, ChildPath.sort as sort
+        FROM ${treeTable} as ChildPath
+        LEFT JOIN ${treeTable} as NodeInfo
+          ON NodeInfo.ancestor = ChildPath.descendant
+          AND NodeInfo.descendant = ChildPath.descendant
+          AND NodeInfo.depth = 0
+        WHERE ChildPath.ancestor = :parentUid
+          AND ChildPath.depth = 1
+          AND NodeInfo.type = :type`),
+      {
+        type: "SELECT",
+        replacements: { parentUid, type },
+        transaction: transaction2
+      }
+    );
+    return rows.sort((a, b) => _FlowModelRepository.compareBySortAndUid(a, b));
+  }
+  async writeSiblingSorts(parentUid, orderedUids, transaction2) {
+    const treeTable = this.flowModelTreePathTableName;
+    for (const [index, uid2] of orderedUids.entries()) {
+      await this.database.sequelize.query(
+        this.sqlAdapter(
+          `UPDATE ${treeTable} SET sort = :sort WHERE ancestor = :parentUid AND descendant = :uid AND depth = 1`
+        ),
+        {
+          type: "UPDATE",
+          replacements: {
+            parentUid,
+            uid: uid2,
+            sort: index + 1
+          },
+          transaction: transaction2
+        }
+      );
+    }
+    await this.clearXUidPathCache(parentUid, transaction2);
+  }
+  async normalizeSiblingSorts(info, transaction2) {
+    if (!info) {
+      return;
+    }
+    const siblingRows = await this.findSiblingSortRows(info.parentUid, info.type, transaction2);
+    await this.writeSiblingSorts(
+      info.parentUid,
+      siblingRows.map((row) => row.uid),
+      transaction2
+    );
+  }
+  async isAncestorOf(ancestorUid, descendantUid, transaction2) {
+    const rows = await this.database.sequelize.query(
+      this.sqlAdapter(`SELECT 1 as v
+        FROM ${this.flowModelTreePathTableName}
+        WHERE ancestor = :ancestorUid
+          AND descendant = :descendantUid
+          AND depth > 0
+        LIMIT 1`),
+      {
+        type: "SELECT",
+        replacements: { ancestorUid, descendantUid },
+        transaction: transaction2
+      }
+    );
+    return rows.length > 0;
+  }
+  async updateModelParentOptions(uid2, parentId, subKey, subType, transaction2) {
+    const modelInstance = await this.model.findByPk(uid2, { transaction: transaction2 });
+    if (!modelInstance) {
+      throw new Error(`flowModels:move sourceId '${uid2}' not found`);
+    }
+    await modelInstance.update(
+      {
+        options: {
+          ...import_lodash.default.omit(_FlowModelRepository.optionsToJson(modelInstance.get("options") || {}), ["uid"]),
+          parentId,
+          parent: parentId,
+          subKey,
+          subType
+        }
+      },
+      { transaction: transaction2, hooks: false }
+    );
+  }
   async findNodeSchemaWithParent(uid2, transaction2) {
     const schema = await this.database.getRepository("flowModels").findOne({
       filter: {
@@ -1155,22 +1307,30 @@ WHERE TreeTable.depth = 1 AND  TreeTable.ancestor = :ancestor and TreeTable.sort
     for (const child of children) {
       const { subKey, subType } = this.optionsToJson(child.options);
       if (!subKey) continue;
-      const model = _FlowModelRepository.nodesToModel(nodes, child["uid"]) || {
-        uid: child["uid"],
+      const model2 = _FlowModelRepository.nodesToModel(nodes, child["uid"]) || {
         ...this.optionsToJson(child.options),
+        uid: child["uid"],
         sortIndex: child.sort
       };
-      model.sortIndex = child.sort;
+      model2.sortIndex = child.sort;
       if (subType === "array") {
         if (!subModels[subKey]) subModels[subKey] = [];
-        subModels[subKey].push(model);
+        subModels[subKey].push(model2);
       } else {
-        subModels[subKey] = model;
+        subModels[subKey] = model2;
       }
     }
     for (const key in subModels) {
       if (Array.isArray(subModels[key])) {
-        subModels[key].sort((a, b) => (a.sortIndex ?? 0) - (b.sortIndex ?? 0));
+        subModels[key] = subModels[key].sort(
+          (a, b) => _FlowModelRepository.compareBySortAndUid(
+            { sort: a.sortIndex, uid: a.uid },
+            { sort: b.sortIndex, uid: b.uid }
+          )
+        ).map((item, index) => {
+          item.sortIndex = index + 1;
+          return item;
+        });
       }
     }
     const filteredSubModels = {};
@@ -1181,11 +1341,19 @@ WHERE TreeTable.depth = 1 AND  TreeTable.ancestor = :ancestor and TreeTable.sort
         continue;
       filteredSubModels[key] = value;
     }
-    return {
-      uid: rootNode["uid"],
+    const model = {
       ...this.optionsToJson(rootNode.options),
+      uid: rootNode["uid"],
       ...Object.keys(filteredSubModels).length > 0 ? { subModels: filteredSubModels } : {}
     };
+    if (rootNode.parent) {
+      model.parent = rootNode.parent;
+      model.parentId = rootNode.parent;
+    } else {
+      delete model.parent;
+      delete model.parentId;
+    }
+    return model;
   }
   async insertModel(model, options) {
     const nodes = _FlowModelRepository.modelToSingleNodes(model);
@@ -1194,6 +1362,7 @@ WHERE TreeTable.depth = 1 AND  TreeTable.ancestor = :ancestor and TreeTable.sort
     return await this.findModelById(rootUid, options);
   }
   async updateSingleNode(node, options) {
+    var _a;
     const instance = await this.model.findByPk(node["uid"], {
       transaction: options == null ? void 0 : options.transaction
     });
@@ -1201,8 +1370,12 @@ WHERE TreeTable.depth = 1 AND  TreeTable.ancestor = :ancestor and TreeTable.sort
       await instance.update(
         {
           options: {
-            ...instance.get("options"),
-            ...import_lodash.default.omit(node, ["x-async", "name", "uid", "childOptions"])
+            ...import_lodash.default.omit(instance.get("options"), ["uid"]),
+            ...import_lodash.default.omit(node, ["x-async", "name", "uid", "childOptions"]),
+            ...((_a = node.childOptions) == null ? void 0 : _a.parentUid) ? {
+              parent: node.childOptions.parentUid,
+              parentId: node.childOptions.parentUid
+            } : {}
           }
         },
         {
@@ -1376,7 +1549,7 @@ WHERE TreeTable.depth = 1 AND  TreeTable.ancestor = :ancestor and TreeTable.sort
     await modelInstance.update(
       {
         options: {
-          ...modelInstance.get("options"),
+          ...import_lodash.default.omit(modelInstance.get("options"), ["uid"]),
           parentId,
           parent: parentId,
           subKey,
@@ -1399,11 +1572,74 @@ WHERE TreeTable.depth = 1 AND  TreeTable.ancestor = :ancestor and TreeTable.sort
     );
     return await this.findModelById(modelUid, { transaction: transaction2, includeAsyncNode: true });
   }
-  async move(options) {
+  async move(options, transactionOptions) {
     const { sourceId, targetId, position } = options;
-    return await this.insertAdjacent(position === "after" ? "afterEnd" : "beforeBegin", targetId, {
-      ["uid"]: sourceId
-    });
+    const sourceUid = String(sourceId || "").trim();
+    const targetUid = String(targetId || "").trim();
+    if (!sourceUid || !targetUid) {
+      throw new Error("flowModels:move missing required params");
+    }
+    if (position !== "before" && position !== "after") {
+      throw new Error("flowModels:move invalid position");
+    }
+    const transaction2 = transactionOptions == null ? void 0 : transactionOptions.transaction;
+    const sourceInstance = await this.model.findByPk(sourceUid, { transaction: transaction2 });
+    if (!sourceInstance) {
+      throw new Error(`flowModels:move sourceId '${sourceUid}' not found`);
+    }
+    if (sourceUid === targetUid) {
+      await this.normalizeSiblingSorts(await this.findSiblingInfo(sourceUid, transaction2), transaction2);
+      return null;
+    }
+    const sourceInfo = await this.findSiblingInfo(sourceUid, transaction2);
+    const targetInfo = await this.findSiblingInfo(targetUid, transaction2);
+    if (!targetInfo) {
+      throw new Error("flowModels:move target is not attached to a parent");
+    }
+    const targetInstance = await this.model.findByPk(targetUid, { transaction: transaction2 });
+    const targetOptions = _FlowModelRepository.optionsToJson((targetInstance == null ? void 0 : targetInstance.get("options")) || {});
+    const targetSubType = targetOptions.subType === "object" ? "object" : "array";
+    if (targetInfo.parentUid === sourceUid || await this.isAncestorOf(sourceUid, targetInfo.parentUid, transaction2)) {
+      throw new Error("flowModels:move cycle detected");
+    }
+    if ((sourceInfo == null ? void 0 : sourceInfo.parentUid) === targetInfo.parentUid && sourceInfo.type === targetInfo.type) {
+      const siblingRows = await this.findSiblingSortRows(sourceInfo.parentUid, sourceInfo.type, transaction2);
+      const sourceRow = siblingRows.find((row) => row.uid === sourceUid);
+      const targetIndex = siblingRows.findIndex((row) => row.uid === targetUid);
+      if (!sourceRow || targetIndex === -1) {
+        throw new Error("flowModels:move source and target must be sibling nodes under the same parent/subKey");
+      }
+      const rowsWithoutSource = siblingRows.filter((row) => row.uid !== sourceUid);
+      const insertIndex = rowsWithoutSource.findIndex((row) => row.uid === targetUid);
+      rowsWithoutSource.splice(position === "after" ? insertIndex + 1 : insertIndex, 0, sourceRow);
+      await this.writeSiblingSorts(
+        sourceInfo.parentUid,
+        rowsWithoutSource.map((row) => row.uid),
+        transaction2
+      );
+      return await this.findModelById(sourceUid, { transaction: transaction2 });
+    }
+    await this.normalizeSiblingSorts(sourceInfo, transaction2);
+    await this.normalizeSiblingSorts(targetInfo, transaction2);
+    await this.updateModelParentOptions(sourceUid, targetInfo.parentUid, targetInfo.type, targetSubType, transaction2);
+    await this.insertSingleNode(
+      {
+        uid: sourceUid,
+        name: sourceUid,
+        childOptions: {
+          parentUid: targetInfo.parentUid,
+          type: targetInfo.type,
+          position: {
+            type: position,
+            target: targetUid
+          }
+        }
+      },
+      { transaction: transaction2, removeParentsIfNoChildren: false }
+    );
+    await this.normalizeSiblingSorts(sourceInfo, transaction2);
+    await this.normalizeSiblingSorts(await this.findSiblingInfo(sourceUid, transaction2), transaction2);
+    return await this.findModelById(sourceUid, { transaction: transaction2 });
   }
 };
 __decorateClass([
@@ -1466,6 +1702,9 @@ __decorateClass([
 __decorateClass([
   transaction()
 ], _FlowModelRepository.prototype, "attach", 1);
+__decorateClass([
+  transaction()
+], _FlowModelRepository.prototype, "move", 1);
 let FlowModelRepository = _FlowModelRepository;
 var repository_default = FlowModelRepository;
 // Annotate the CommonJS export names for ESM import in node:

package/dist/server/template/contexts.d.ts

@@ -50,6 +50,8 @@ export declare class ServerBaseContext {
     delegate(ctx: ServerBaseContext): void;
     /** 清空所有委托 */
     clearDelegates(): void;
+    getSandboxKeys(): string[];
+    getSandboxValue(key: string, current?: ServerBaseContext): any;
     /** 创建并返回代理对象（同一实例下保持稳定引用） */
     createProxy(): any;
 }

package/dist/server/template/contexts.js

@@ -42,6 +42,10 @@ __export(contexts_exports, {
 });
 module.exports = __toCommonJS(contexts_exports);
 var import_lodash = __toESM(require("lodash"));
+const BLOCKED_SANDBOX_KEYS = /* @__PURE__ */ new Set(["__proto__", "prototype", "constructor", "then"]);
+function isBlockedSandboxKey(key) {
+  return BLOCKED_SANDBOX_KEYS.has(key);
+}
 class ServerBaseContext {
   _props = {};
   _methods = {};
@@ -106,6 +110,36 @@ class ServerBaseContext {
   clearDelegates() {
     this._delegates = [];
   }
+  getSandboxKeys() {
+    const keys = /* @__PURE__ */ new Set();
+    for (const key of Object.keys(this._props)) {
+      if (!isBlockedSandboxKey(key)) keys.add(key);
+    }
+    for (const key of Object.keys(this._methods)) {
+      if (!isBlockedSandboxKey(key)) keys.add(key);
+    }
+    for (const d of this._delegates) {
+      for (const key of d.getSandboxKeys()) {
+        if (!isBlockedSandboxKey(key)) keys.add(key);
+      }
+    }
+    return Array.from(keys);
+  }
+  getSandboxValue(key, current = this.createProxy()) {
+    if (isBlockedSandboxKey(key)) return void 0;
+    if (Object.prototype.hasOwnProperty.call(this._props, key)) {
+      return this._getOwn(key, current);
+    }
+    if (Object.prototype.hasOwnProperty.call(this._methods, key)) {
+      const fn = this._methods[key];
+      return typeof fn === "function" ? fn.bind(this) : fn;
+    }
+    for (const d of this._delegates) {
+      if (!d.getSandboxKeys().includes(key)) continue;
+      return d.getSandboxValue(key, current);
+    }
+    return void 0;
+  }
   /** 创建并返回代理对象（同一实例下保持稳定引用） */
   createProxy() {
     if (this._proxy) return this._proxy;