@nocobase/plugin-flow-engine 2.1.0-alpha.10 → 2.1.0-alpha.12

package/dist/server/repository.js

@@ -52,6 +52,11 @@ module.exports = __toCommonJS(repository_exports);
 var import_database = require("@nocobase/database");
 var import_utils = require("@nocobase/utils");
 var import_lodash = __toESM(require("lodash"));
+var import_node_crypto = require("node:crypto");
+var import_sequelize = require("sequelize");
+var import_ensure_lock = require("./flow-models/repository-internals/ensure-lock");
+var import_duplicate_helpers = require("./flow-models/repository-internals/duplicate-helpers");
+var import_errors = require("./flow-models/repository-internals/errors");
 const nodeKeys = ["properties", "definitions", "patternProperties", "additionalProperties", "items"];
 function transaction(transactionAbleArgPosition) {
   return (target, propertyKey, descriptor) => {
@@ -77,6 +82,7 @@ function transaction(transactionAbleArgPosition) {
           return results;
         } catch (e) {
           await transaction2.rollback();
+          await (0, import_ensure_lock.emitFlowModelTransactionRollback)(this.database, transaction2);
           throw e;
         }
       } else {
@@ -430,121 +436,78 @@ const _FlowModelRepository = class _FlowModelRepository extends import_database.
     return result;
   }
   async duplicate(modelUid, options) {
-    let nodes = await this.findNodesById(modelUid, { ...options, includeAsyncNode: true });
-    if (!(nodes == null ? void 0 : nodes.length)) {
+    const nodes = await this.prepareNodesForDuplicate(modelUid, { ...options, includeAsyncNode: true });
+    if (!nodes.length) {
       return null;
     }
-    nodes = this.dedupeNodesForDuplicate(nodes, modelUid);
-    const uidMap = {};
-    for (const n of nodes) {
-      uidMap[n["uid"]] = (0, import_utils.uid)();
-    }
-    const sorted = [...nodes].sort((a, b) => {
-      if (a.depth !== b.depth) return a.depth - b.depth;
+    const duplicatedRootUid = await this.cloneNodesWithUidMap(nodes, {
+      sourceUid: modelUid,
+      transaction: options == null ? void 0 : options.transaction,
+      buildUid: () => (0, import_utils.uid)()
+    });
+    return this.findModelById(duplicatedRootUid, { ...options });
+  }
+  dedupeNodesForDuplicate(nodes, rootUid) {
+    return (0, import_duplicate_helpers.dedupeNodesForDuplicate)(nodes, rootUid);
+  }
+  replaceStepParamsModelUids(options, uidMap) {
+    return (0, import_duplicate_helpers.replaceStepParamsModelUids)(options, uidMap);
+  }
+  sortNodesForDuplicate(nodes) {
+    return [...nodes].sort((a, b) => {
+      if (a.depth !== b.depth) return Number(a.depth ?? 0) - Number(b.depth ?? 0);
       const ap = a.parent || "";
       const bp = b.parent || "";
       if (ap !== bp) return ap < bp ? -1 : 1;
       const at = a.type || "";
       const bt = b.type || "";
       if (at !== bt) return at < bt ? -1 : 1;
-      const as = a.sort ?? 0;
-      const bs = b.sort ?? 0;
-      return as - bs;
+      return Number(a.sort ?? 0) - Number(b.sort ?? 0);
     });
-    for (const n of sorted) {
-      const oldUid = n["uid"];
+  }
+  async prepareNodesForDuplicate(uid2, options) {
+    const nodes = await this.findNodesById(uid2, { ...options, includeAsyncNode: true });
+    if (!nodes.length) {
+      return [];
+    }
+    return this.sortNodesForDuplicate(this.dedupeNodesForDuplicate(nodes, uid2));
+  }
+  async cloneNodesWithUidMap(nodes, options) {
+    var _a;
+    const uidMap = {};
+    for (const node of nodes) {
+      uidMap[node.uid] = options.buildUid(node.uid);
+    }
+    for (const node of nodes) {
+      const oldUid = node.uid;
       const newUid = uidMap[oldUid];
-      const oldParentUid = n["parent"];
-      const newParentUid = uidMap[oldParentUid] ?? null;
+      const newParentUid = node.parent ? uidMap[node.parent] ?? null : null;
       const optionsObj = this.replaceStepParamsModelUids(
-        import_lodash.default.isPlainObject(n.options) ? n.options : JSON.parse(n.options),
+        import_lodash.default.cloneDeep(_FlowModelRepository.optionsToJson(node.options ?? {})),
         uidMap
       );
+      if (oldUid === options.sourceUid) {
+        (_a = options.patchRootOptions) == null ? void 0 : _a.call(options, optionsObj);
+      }
       if (newParentUid) {
         optionsObj.parent = newParentUid;
         optionsObj.parentId = newParentUid;
       }
       const schemaNode = {
         uid: newUid,
-        ["x-async"]: !!n.async,
+        ["x-async"]: !!node.async,
         ...optionsObj
       };
       if (newParentUid) {
         schemaNode.childOptions = {
           parentUid: newParentUid,
-          type: n.type,
+          type: node.type,
           position: "last"
         };
       }
-      await this.insertSingleNode(schemaNode, { transaction: options == null ? void 0 : options.transaction });
+      await this.insertSingleNode(schemaNode, { transaction: options.transaction });
     }
-    return this.findModelById(uidMap[modelUid], { ...options });
-  }
-  dedupeNodesForDuplicate(nodes, rootUid) {
-    if (!Array.isArray(nodes) || nodes.length <= 1) {
-      return nodes;
-    }
-    const rowsByUid = import_lodash.default.groupBy(nodes, "uid");
-    const uniqueUids = Object.keys(rowsByUid);
-    if (uniqueUids.length === nodes.length) {
-      return nodes;
-    }
-    const uidsInSubtree = new Set(uniqueUids);
-    const rootDepthByUid = /* @__PURE__ */ new Map();
-    for (const uid2 of uniqueUids) {
-      const rows = rowsByUid[uid2] || [];
-      const depths = rows.map((row) => Number((row == null ? void 0 : row.depth) ?? 0));
-      rootDepthByUid.set(uid2, depths.length ? Math.min(...depths) : 0);
-    }
-    const pickRowForUid = (uid2, rows) => {
-      if (!(rows == null ? void 0 : rows.length)) return null;
-      if (rows.length === 1) return rows[0];
-      if (uid2 === rootUid) return rows[0];
-      let bestRow = rows[0];
-      let bestParentRootDepth = -1;
-      for (const row of rows) {
-        const parentUid = row == null ? void 0 : row.parent;
-        if (!parentUid || !uidsInSubtree.has(parentUid)) {
-          continue;
-        }
-        const parentRootDepth = rootDepthByUid.get(parentUid) ?? -1;
-        if (parentRootDepth > bestParentRootDepth) {
-          bestParentRootDepth = parentRootDepth;
-          bestRow = row;
-        }
-      }
-      return bestRow;
-    };
-    const uidsInQueryOrder = [];
-    const seenUidsInQueryOrder = /* @__PURE__ */ new Set();
-    for (const row of nodes) {
-      const uid2 = row == null ? void 0 : row.uid;
-      if (!uid2 || seenUidsInQueryOrder.has(uid2)) continue;
-      seenUidsInQueryOrder.add(uid2);
-      uidsInQueryOrder.push(uid2);
-    }
-    return uidsInQueryOrder.map((uid2) => pickRowForUid(uid2, rowsByUid[uid2])).filter(Boolean);
-  }
-  replaceStepParamsModelUids(options, uidMap) {
-    const opts = options && typeof options === "object" ? options : {};
-    const replaceUidString = (v) => typeof v === "string" && uidMap[v] ? uidMap[v] : v;
-    const replaceInPlace = (val) => {
-      if (Array.isArray(val)) {
-        for (let i = 0; i < val.length; i++) {
-          val[i] = replaceInPlace(val[i]);
-        }
-        return val;
-      }
-      if (val && typeof val === "object") {
-        for (const k of Object.keys(val)) {
-          val[k] = replaceInPlace(val[k]);
-        }
-        return val;
-      }
-      return replaceUidString(val);
-    };
-    if (opts.stepParams) opts.stepParams = replaceInPlace(opts.stepParams);
-    return opts;
+    return uidMap[options.sourceUid];
   }
   async insert(schema, options) {
     const nodes = _FlowModelRepository.schemaToSingleNodes(schema);
@@ -1010,12 +973,13 @@ WHERE TreeTable.depth = 1 AND  TreeTable.ancestor = :ancestor and TreeTable.sort
       replacements: {
         ancestor: uid2
       },
+      type: import_sequelize.QueryTypes.SELECT,
       transaction: options == null ? void 0 : options.transaction
     });
-    if (nodes[0].length == 0) {
+    if (nodes.length === 0) {
       return [];
     }
-    return nodes[0];
+    return nodes;
   }
   async doGetJsonSchema(uid2, options) {
     const nodes = await this.findNodesById(uid2, options);
@@ -1123,7 +1087,8 @@ WHERE TreeTable.depth = 1 AND  TreeTable.ancestor = :ancestor and TreeTable.sort
     const { uid: uid2, name, options } = node;
     const model = {
       uid: uid2,
-      ...options
+      ...(0, import_duplicate_helpers.stripDuplicateReplayMarker)(this.optionsToJson(options)),
+      async: !!(node == null ? void 0 : node.async)
     };
     return model;
   }
@@ -1141,7 +1106,8 @@ WHERE TreeTable.depth = 1 AND  TreeTable.ancestor = :ancestor and TreeTable.sort
       if (!subKey) continue;
       const model = _FlowModelRepository.nodesToModel(nodes, child["uid"]) || {
         uid: child["uid"],
-        ...this.optionsToJson(child.options),
+        ...(0, import_duplicate_helpers.stripDuplicateReplayMarker)(this.optionsToJson(child.options)),
+        async: !!(child == null ? void 0 : child.async),
         sortIndex: child.sort
       };
       model.sortIndex = child.sort;
@@ -1167,7 +1133,8 @@ WHERE TreeTable.depth = 1 AND  TreeTable.ancestor = :ancestor and TreeTable.sort
     }
     return {
       uid: rootNode["uid"],
-      ...this.optionsToJson(rootNode.options),
+      ...(0, import_duplicate_helpers.stripDuplicateReplayMarker)(this.optionsToJson(rootNode.options)),
+      async: !!(rootNode == null ? void 0 : rootNode.async),
       ...Object.keys(filteredSubModels).length > 0 ? { subModels: filteredSubModels } : {}
     };
   }
@@ -1248,6 +1215,217 @@ WHERE TreeTable.depth = 1 AND  TreeTable.ancestor = :ancestor and TreeTable.sort
     }
     return null;
   }
+  async ensureModel(values, options) {
+    const includeAsyncNode = !!(options == null ? void 0 : options.includeAsyncNode);
+    const { transaction: transaction2 } = options || {};
+    const uidValue = String((values == null ? void 0 : values.uid) || "").trim();
+    const parentIdValue = String((values == null ? void 0 : values.parentId) || "").trim();
+    const subKeyValue = String((values == null ? void 0 : values.subKey) || "").trim();
+    const subTypeValue = values == null ? void 0 : values.subType;
+    const hasUidLocator = !!uidValue;
+    const hasObjectChildLocator = !!parentIdValue || !!subKeyValue || subTypeValue !== void 0;
+    if (hasUidLocator && hasObjectChildLocator) {
+      throw new import_errors.FlowModelOperationError({
+        status: 400,
+        code: "INVALID_PARAMS",
+        message: "flowModels:ensure requires either 'uid' OR ('parentId'+'subKey'+'subType=object'), not both"
+      });
+    }
+    if (!hasUidLocator && !hasObjectChildLocator) {
+      throw new import_errors.FlowModelOperationError({
+        status: 400,
+        code: "INVALID_PARAMS",
+        message: "flowModels:ensure missing locator: provide 'uid' OR ('parentId'+'subKey'+'subType=object')"
+      });
+    }
+    if (uidValue) {
+      const exists = await this.model.findByPk(uidValue, { transaction: transaction2 });
+      if (exists) {
+        return await this.findModelById(uidValue, { transaction: transaction2, includeAsyncNode });
+      }
+      const use = String((values == null ? void 0 : values.use) || "").trim();
+      if (!use) {
+        throw new import_errors.FlowModelOperationError({
+          status: 400,
+          code: "INVALID_PARAMS",
+          message: "flowModels:ensure missing required field 'use' when creating by uid"
+        });
+      }
+      try {
+        const modelToEnsure = {
+          ...import_lodash.default.cloneDeep(values),
+          uid: uidValue,
+          use
+        };
+        await this.database.sequelize.transaction({ transaction: transaction2 }, async (innerTransaction) => {
+          await this.upsertModel(modelToEnsure, { transaction: innerTransaction });
+        });
+      } catch (error) {
+        if ((0, import_errors.isFlowModelUniqueConstraintError)(error)) {
+          const createdByOther = await this.model.findByPk(uidValue, { transaction: transaction2 });
+          if (createdByOther) {
+            return await this.findModelById(uidValue, { transaction: transaction2, includeAsyncNode });
+          }
+        }
+        throw error;
+      }
+      return await this.findModelById(uidValue, { transaction: transaction2, includeAsyncNode });
+    }
+    if (!parentIdValue || !subKeyValue || subTypeValue !== "object") {
+      throw new import_errors.FlowModelOperationError({
+        status: 400,
+        code: "INVALID_PARAMS",
+        message: "flowModels:ensure by parent requires 'parentId'+'subKey' and 'subType' must be 'object'"
+      });
+    }
+    const ensureObjectChild = async () => {
+      const supportsForUpdate = this.database.sequelize.getDialect() === "postgres" || this.database.isMySQLCompatibleDialect();
+      const lockedParent = await this.database.sequelize.query(
+        this.sqlAdapter(
+          `SELECT "uid" FROM ${this.flowModelsTableName} WHERE "uid" = :uid${supportsForUpdate ? " FOR UPDATE" : ""}`
+        ),
+        {
+          type: "SELECT",
+          replacements: { uid: parentIdValue },
+          transaction: transaction2
+        }
+      );
+      if (!(lockedParent == null ? void 0 : lockedParent.length)) {
+        throw new import_errors.FlowModelOperationError({
+          status: 404,
+          code: "NOT_FOUND",
+          message: `flowModels:ensure parentId '${parentIdValue}' not found`
+        });
+      }
+      const treeTable = this.flowModelTreePathTableName;
+      const existingChildren = await this.database.sequelize.query(
+        `SELECT TreeTable.descendant as uid
+         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
+         ORDER BY TreeTable.sort ASC`,
+        {
+          type: import_sequelize.QueryTypes.SELECT,
+          replacements: {
+            ancestor: parentIdValue,
+            type: subKeyValue
+          },
+          transaction: transaction2
+        }
+      );
+      if (existingChildren == null ? void 0 : existingChildren.length) {
+        if (existingChildren.length > 1) {
+          this.database.logger.warn("flowModels:ensure found duplicate object children; using first child", {
+            action: "flowModels:ensure",
+            type: "flow-model-duplicate-object-child",
+            parentId: parentIdValue,
+            subKey: subKeyValue,
+            childUids: existingChildren.map((child) => String((child == null ? void 0 : child.uid) || "").trim()).filter(Boolean)
+          });
+        }
+        const existingChild = existingChildren.at(0);
+        const childUid = String((existingChild == null ? void 0 : existingChild.uid) ?? "").trim();
+        if (!childUid) {
+          throw new import_errors.FlowModelOperationError({
+            status: 500,
+            code: "INTERNAL_ERROR",
+            message: "flowModels:ensure failed to resolve existing child uid"
+          });
+        }
+        const childInstance = await this.model.findByPk(childUid, { transaction: transaction2 });
+        if (!childInstance) {
+          throw new import_errors.FlowModelOperationError({
+            status: 500,
+            code: "INTERNAL_ERROR",
+            message: `flowModels:ensure child uid '${childUid}' not found`
+          });
+        }
+        const childOptions = _FlowModelRepository.optionsToJson(childInstance.get("options"));
+        if ((childOptions == null ? void 0 : childOptions.subType) && childOptions.subType !== "object") {
+          throw new import_errors.FlowModelOperationError({
+            status: 409,
+            code: "CONFLICT",
+            message: `flowModels:ensure object subKey '${subKeyValue}' conflicts with existing subType '${childOptions.subType}'`
+          });
+        }
+        return await this.findModelById(childUid, { transaction: transaction2, includeAsyncNode });
+      }
+      const use = String((values == null ? void 0 : values.use) || "").trim();
+      if (!use) {
+        throw new import_errors.FlowModelOperationError({
+          status: 400,
+          code: "INVALID_PARAMS",
+          message: "flowModels:ensure missing required field 'use' when creating object child model"
+        });
+      }
+      const newUid = `ens_${(0, import_node_crypto.createHash)("sha256").update(`${parentIdValue}\0${subKeyValue}\0object`).digest("hex").slice(0, 24)}`;
+      try {
+        const modelToEnsure = {
+          ...import_lodash.default.cloneDeep(values),
+          uid: newUid,
+          parentId: parentIdValue,
+          subKey: subKeyValue,
+          subType: "object",
+          use
+        };
+        await this.database.sequelize.transaction({ transaction: transaction2 }, async (innerTransaction) => {
+          await this.upsertModel(modelToEnsure, { transaction: innerTransaction });
+        });
+      } catch (error) {
+        if ((0, import_errors.isFlowModelUniqueConstraintError)(error)) {
+          const existing = await this.database.sequelize.query(
+            `SELECT TreeTable.descendant as uid
+             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
+             ORDER BY TreeTable.sort ASC`,
+            {
+              type: import_sequelize.QueryTypes.SELECT,
+              replacements: {
+                ancestor: parentIdValue,
+                type: subKeyValue
+              },
+              transaction: transaction2
+            }
+          );
+          if (existing == null ? void 0 : existing.length) {
+            const existingChild = existing.at(0);
+            const childUid = String((existingChild == null ? void 0 : existingChild.uid) ?? "").trim();
+            if (childUid) {
+              return await this.findModelById(childUid, { transaction: transaction2, includeAsyncNode });
+            }
+          }
+        }
+        throw error;
+      }
+      return await this.findModelById(newUid, { transaction: transaction2, includeAsyncNode });
+    };
+    const lockKey = (0, import_ensure_lock.getEnsureObjectChildLockKey)(parentIdValue, subKeyValue);
+    if ((0, import_ensure_lock.isEnsureObjectChildLockOwner)(lockKey, transaction2)) {
+      return await ensureObjectChild();
+    }
+    const releaseEnsureObjectChildLock = await (0, import_ensure_lock.acquireEnsureObjectChildLock)(lockKey, (0, import_ensure_lock.getTransactionId)(transaction2));
+    let releaseEnsureObjectChildLockAfterTransaction = false;
+    try {
+      const model = await ensureObjectChild();
+      if ((0, import_ensure_lock.registerEnsureObjectChildLockRelease)(this.database, transaction2, releaseEnsureObjectChildLock)) {
+        releaseEnsureObjectChildLockAfterTransaction = true;
+      }
+      return model;
+    } finally {
+      if (!releaseEnsureObjectChildLockAfterTransaction) {
+        releaseEnsureObjectChildLock();
+      }
+    }
+  }
   async attach(uid2, attachOptions, options) {
     const { transaction: transaction2 } = options || {};
     const modelUid = String(uid2 || "").trim();
@@ -1255,19 +1433,35 @@ WHERE TreeTable.depth = 1 AND  TreeTable.ancestor = :ancestor and TreeTable.sort
     const subKey = String((attachOptions == null ? void 0 : attachOptions.subKey) || "").trim();
     const subType = attachOptions == null ? void 0 : attachOptions.subType;
     if (!modelUid || !parentId || !subKey || subType !== "array" && subType !== "object") {
-      throw new Error("flowModels:attach missing required params");
+      throw new import_errors.FlowModelOperationError({
+        status: 400,
+        code: "INVALID_PARAMS",
+        message: "flowModels:attach missing required params"
+      });
     }
     if (modelUid === parentId) {
-      throw new Error("flowModels:attach cannot attach model to itself");
+      throw new import_errors.FlowModelOperationError({
+        status: 400,
+        code: "INVALID_PARAMS",
+        message: "flowModels:attach cannot attach model to itself"
+      });
     }
     const treeTable = this.flowModelTreePathTableName;
     const modelInstance = await this.model.findByPk(modelUid, { transaction: transaction2 });
     if (!modelInstance) {
-      throw new Error(`flowModels:attach uid '${modelUid}' not found`);
+      throw new import_errors.FlowModelOperationError({
+        status: 404,
+        code: "NOT_FOUND",
+        message: `flowModels:attach uid '${modelUid}' not found`
+      });
     }
     const parentInstance = await this.model.findByPk(parentId, { transaction: transaction2 });
     if (!parentInstance) {
-      throw new Error(`flowModels:attach parentId '${parentId}' not found`);
+      throw new import_errors.FlowModelOperationError({
+        status: 404,
+        code: "NOT_FOUND",
+        message: `flowModels:attach parentId '${parentId}' not found`
+      });
     }
     const cycle = await this.database.sequelize.query(
       `SELECT 1 as v
@@ -1284,7 +1478,11 @@ WHERE TreeTable.depth = 1 AND  TreeTable.ancestor = :ancestor and TreeTable.sort
       }
     );
     if (cycle == null ? void 0 : cycle.length) {
-      throw new Error("flowModels:attach cycle detected");
+      throw new import_errors.FlowModelOperationError({
+        status: 409,
+        code: "CYCLE_DETECTED",
+        message: "flowModels:attach cycle detected"
+      });
     }
     if (subType === "object") {
       const conflict = await this.database.sequelize.query(
@@ -1309,7 +1507,11 @@ WHERE TreeTable.depth = 1 AND  TreeTable.ancestor = :ancestor and TreeTable.sort
         }
       );
       if (conflict == null ? void 0 : conflict.length) {
-        throw new Error(`flowModels:attach subKey '${subKey}' already exists on parent '${parentId}'`);
+        throw new import_errors.FlowModelOperationError({
+          status: 409,
+          code: "CONFLICT",
+          message: `flowModels:attach subKey '${subKey}' already exists on parent '${parentId}'`
+        });
       }
     }
     const normalizePosition = (input) => {
@@ -1323,13 +1525,21 @@ WHERE TreeTable.depth = 1 AND  TreeTable.ancestor = :ancestor and TreeTable.sort
           return { type, target };
         }
       }
-      throw new Error("flowModels:attach invalid position");
+      throw new import_errors.FlowModelOperationError({
+        status: 400,
+        code: "INVALID_PARAMS",
+        message: "flowModels:attach invalid position"
+      });
     };
     const position = subType === "object" ? "last" : normalizePosition(attachOptions == null ? void 0 : attachOptions.position);
     if (typeof position === "object") {
       const target = String(position.target || "").trim();
       if (target === modelUid) {
-        throw new Error("flowModels:attach position target cannot be itself");
+        throw new import_errors.FlowModelOperationError({
+          status: 400,
+          code: "INVALID_PARAMS",
+          message: "flowModels:attach position target cannot be itself"
+        });
       }
       const ok = await this.database.sequelize.query(
         `SELECT 1 as v
@@ -1353,7 +1563,11 @@ WHERE TreeTable.depth = 1 AND  TreeTable.ancestor = :ancestor and TreeTable.sort
         }
       );
       if (!(ok == null ? void 0 : ok.length)) {
-        throw new Error("flowModels:attach position target is not a sibling under the same parent/subKey");
+        throw new import_errors.FlowModelOperationError({
+          status: 400,
+          code: "INVALID_PARAMS",
+          message: "flowModels:attach position target is not a sibling under the same parent/subKey"
+        });
       }
     }
     await this.clearXUidPathCache(modelUid, transaction2);
@@ -1383,11 +1597,99 @@ WHERE TreeTable.depth = 1 AND  TreeTable.ancestor = :ancestor and TreeTable.sort
     );
     return await this.findModelById(modelUid, { transaction: transaction2, includeAsyncNode: true });
   }
-  async move(options) {
-    const { sourceId, targetId, position } = options;
-    return await this.insertAdjacent(position === "after" ? "afterEnd" : "beforeBegin", targetId, {
-      ["uid"]: sourceId
-    });
+  async duplicateWithTargetUid(modelUid, targetUid, options) {
+    const sourceUid = String(modelUid || "").trim();
+    const desiredUid = String(targetUid || "").trim();
+    const includeAsyncNode = !!(options == null ? void 0 : options.includeAsyncNode);
+    const { transaction: transaction2 } = options || {};
+    if (!sourceUid || !desiredUid) {
+      throw new import_errors.FlowModelOperationError({
+        status: 400,
+        code: "INVALID_PARAMS",
+        message: "flowModels:mutate duplicate requires 'uid' and 'targetUid'"
+      });
+    }
+    const targetInstance = await this.model.findByPk(desiredUid, { transaction: transaction2 });
+    if (targetInstance) {
+      const targetOptions = _FlowModelRepository.optionsToJson(targetInstance.get("options"));
+      const marker = targetOptions == null ? void 0 : targetOptions.__mutateDuplicate;
+      if ((marker == null ? void 0 : marker.sourceUid) === sourceUid) {
+        return await this.findModelById(desiredUid, { transaction: transaction2, includeAsyncNode });
+      }
+      throw new import_errors.FlowModelOperationError({
+        status: 409,
+        code: "CONFLICT",
+        message: `flowModels:mutate duplicate targetUid '${desiredUid}' already exists`
+      });
+    }
+    const nodes = await this.prepareNodesForDuplicate(sourceUid, { ...options, includeAsyncNode: true });
+    if (!nodes.length) {
+      throw new import_errors.FlowModelOperationError({
+        status: 404,
+        code: "NOT_FOUND",
+        message: `flowModels:mutate duplicate uid '${sourceUid}' not found`
+      });
+    }
+    const buildUid = (root, old) => {
+      if (old === sourceUid) return root;
+      const h = (0, import_node_crypto.createHash)("sha256").update(`${root}:${old}`).digest("hex").slice(0, 24);
+      return `d_${h}`;
+    };
+    try {
+      await this.cloneNodesWithUidMap(nodes, {
+        sourceUid,
+        transaction: transaction2,
+        buildUid: (oldUid) => buildUid(desiredUid, oldUid),
+        patchRootOptions: (rootOptions) => {
+          rootOptions.__mutateDuplicate = { sourceUid };
+        }
+      });
+    } catch (error) {
+      if ((0, import_errors.isFlowModelUniqueConstraintError)(error)) {
+        const existingTarget = await this.model.findByPk(desiredUid, { transaction: transaction2 });
+        if (existingTarget) {
+          const targetOptions = _FlowModelRepository.optionsToJson(existingTarget.get("options"));
+          const marker = targetOptions == null ? void 0 : targetOptions.__mutateDuplicate;
+          if ((marker == null ? void 0 : marker.sourceUid) === sourceUid) {
+            return await this.findModelById(desiredUid, { transaction: transaction2, includeAsyncNode });
+          }
+        }
+        throw new import_errors.FlowModelOperationError({
+          status: 409,
+          code: "CONFLICT",
+          message: `flowModels:mutate duplicate targetUid '${desiredUid}' already exists`
+        });
+      }
+      throw error;
+    }
+    return await this.findModelById(desiredUid, { transaction: transaction2, includeAsyncNode });
+  }
+  async move(moveOptions, options) {
+    const { transaction: transaction2 } = options || {};
+    const sourceId = String((moveOptions == null ? void 0 : moveOptions.sourceId) || "").trim();
+    const targetId = String((moveOptions == null ? void 0 : moveOptions.targetId) || "").trim();
+    const position = moveOptions == null ? void 0 : moveOptions.position;
+    if (!sourceId || !targetId || position !== "before" && position !== "after") {
+      throw new import_errors.FlowModelOperationError({
+        status: 400,
+        code: "INVALID_PARAMS",
+        message: "flowModels:move requires 'sourceId'+'targetId'+'position=before|after'"
+      });
+    }
+    if (sourceId === targetId) {
+      const currentModel = await this.findModelById(sourceId, { transaction: transaction2, includeAsyncNode: true });
+      if (currentModel) {
+        return currentModel;
+      }
+    }
+    return await this.insertAdjacent(
+      position === "after" ? "afterEnd" : "beforeBegin",
+      targetId,
+      {
+        ["uid"]: sourceId
+      },
+      { transaction: transaction2 }
+    );
   }
 };
 __decorateClass([
@@ -1447,9 +1749,18 @@ __decorateClass([
 __decorateClass([
   transaction()
 ], _FlowModelRepository.prototype, "upsertModel", 1);
+__decorateClass([
+  transaction()
+], _FlowModelRepository.prototype, "ensureModel", 1);
 __decorateClass([
   transaction()
 ], _FlowModelRepository.prototype, "attach", 1);
+__decorateClass([
+  transaction()
+], _FlowModelRepository.prototype, "duplicateWithTargetUid", 1);
+__decorateClass([
+  transaction()
+], _FlowModelRepository.prototype, "move", 1);
 let FlowModelRepository = _FlowModelRepository;
 var repository_default = FlowModelRepository;
 // Annotate the CommonJS export names for ESM import in node: