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

package/dist/server/repository.js

@@ -52,11 +52,6 @@ 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) => {
@@ -82,7 +77,6 @@ function transaction(transactionAbleArgPosition) {
           return results;
         } catch (e) {
           await transaction2.rollback();
-          await (0, import_ensure_lock.emitFlowModelTransactionRollback)(this.database, transaction2);
           throw e;
         }
       } else {
@@ -436,78 +430,121 @@ const _FlowModelRepository = class _FlowModelRepository extends import_database.
     return result;
   }
   async duplicate(modelUid, options) {
-    const nodes = await this.prepareNodesForDuplicate(modelUid, { ...options, includeAsyncNode: true });
-    if (!nodes.length) {
+    let nodes = await this.findNodesById(modelUid, { ...options, includeAsyncNode: true });
+    if (!(nodes == null ? void 0 : nodes.length)) {
       return null;
     }
-    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);
+    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 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;
-      return Number(a.sort ?? 0) - Number(b.sort ?? 0);
+      const as = a.sort ?? 0;
+      const bs = b.sort ?? 0;
+      return as - bs;
     });
-  }
-  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;
+    for (const n of sorted) {
+      const oldUid = n["uid"];
       const newUid = uidMap[oldUid];
-      const newParentUid = node.parent ? uidMap[node.parent] ?? null : null;
+      const oldParentUid = n["parent"];
+      const newParentUid = uidMap[oldParentUid] ?? null;
       const optionsObj = this.replaceStepParamsModelUids(
-        import_lodash.default.cloneDeep(_FlowModelRepository.optionsToJson(node.options ?? {})),
+        import_lodash.default.isPlainObject(n.options) ? n.options : JSON.parse(n.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"]: !!node.async,
+        ["x-async"]: !!n.async,
         ...optionsObj
       };
       if (newParentUid) {
         schemaNode.childOptions = {
           parentUid: newParentUid,
-          type: node.type,
+          type: n.type,
           position: "last"
         };
       }
-      await this.insertSingleNode(schemaNode, { transaction: options.transaction });
+      await this.insertSingleNode(schemaNode, { transaction: options == null ? void 0 : 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 uidMap[options.sourceUid];
+    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;
   }
   async insert(schema, options) {
     const nodes = _FlowModelRepository.schemaToSingleNodes(schema);
@@ -756,11 +793,6 @@ WHERE TreeTable.depth = 1 AND  TreeTable.ancestor = :ancestor and TreeTable.sort
         transaction: transaction2
       });
       if (oldParentUid !== null && oldParentUid !== parentUid) {
-        await this.database.emitAsync("uiSchemaMove", savedNode, {
-          transaction: transaction2,
-          oldParentUid,
-          parentUid
-        });
         if (options.removeParentsIfNoChildren) {
           await this.recursivelyRemoveIfNoChildren({
             transaction: transaction2,
@@ -973,13 +1005,12 @@ 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.length === 0) {
+    if (nodes[0].length == 0) {
       return [];
     }
-    return nodes;
+    return nodes[0];
   }
   async doGetJsonSchema(uid2, options) {
     const nodes = await this.findNodesById(uid2, options);
@@ -1087,8 +1118,7 @@ WHERE TreeTable.depth = 1 AND  TreeTable.ancestor = :ancestor and TreeTable.sort
     const { uid: uid2, name, options } = node;
     const model = {
       uid: uid2,
-      ...(0, import_duplicate_helpers.stripDuplicateReplayMarker)(this.optionsToJson(options)),
-      async: !!(node == null ? void 0 : node.async)
+      ...options
     };
     return model;
   }
@@ -1106,8 +1136,7 @@ WHERE TreeTable.depth = 1 AND  TreeTable.ancestor = :ancestor and TreeTable.sort
       if (!subKey) continue;
       const model = _FlowModelRepository.nodesToModel(nodes, child["uid"]) || {
         uid: child["uid"],
-        ...(0, import_duplicate_helpers.stripDuplicateReplayMarker)(this.optionsToJson(child.options)),
-        async: !!(child == null ? void 0 : child.async),
+        ...this.optionsToJson(child.options),
         sortIndex: child.sort
       };
       model.sortIndex = child.sort;
@@ -1133,8 +1162,7 @@ WHERE TreeTable.depth = 1 AND  TreeTable.ancestor = :ancestor and TreeTable.sort
     }
     return {
       uid: rootNode["uid"],
-      ...(0, import_duplicate_helpers.stripDuplicateReplayMarker)(this.optionsToJson(rootNode.options)),
-      async: !!(rootNode == null ? void 0 : rootNode.async),
+      ...this.optionsToJson(rootNode.options),
       ...Object.keys(filteredSubModels).length > 0 ? { subModels: filteredSubModels } : {}
     };
   }
@@ -1215,217 +1243,6 @@ 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();
@@ -1433,35 +1250,19 @@ 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 import_errors.FlowModelOperationError({
-        status: 400,
-        code: "INVALID_PARAMS",
-        message: "flowModels:attach missing required params"
-      });
+      throw new Error("flowModels:attach missing required params");
     }
     if (modelUid === parentId) {
-      throw new import_errors.FlowModelOperationError({
-        status: 400,
-        code: "INVALID_PARAMS",
-        message: "flowModels:attach cannot attach model to itself"
-      });
+      throw new Error("flowModels:attach cannot attach model to itself");
     }
     const treeTable = this.flowModelTreePathTableName;
     const modelInstance = await this.model.findByPk(modelUid, { transaction: transaction2 });
     if (!modelInstance) {
-      throw new import_errors.FlowModelOperationError({
-        status: 404,
-        code: "NOT_FOUND",
-        message: `flowModels:attach uid '${modelUid}' not found`
-      });
+      throw new Error(`flowModels:attach uid '${modelUid}' not found`);
     }
     const parentInstance = await this.model.findByPk(parentId, { transaction: transaction2 });
     if (!parentInstance) {
-      throw new import_errors.FlowModelOperationError({
-        status: 404,
-        code: "NOT_FOUND",
-        message: `flowModels:attach parentId '${parentId}' not found`
-      });
+      throw new Error(`flowModels:attach parentId '${parentId}' not found`);
     }
     const cycle = await this.database.sequelize.query(
       `SELECT 1 as v
@@ -1478,11 +1279,7 @@ WHERE TreeTable.depth = 1 AND  TreeTable.ancestor = :ancestor and TreeTable.sort
       }
     );
     if (cycle == null ? void 0 : cycle.length) {
-      throw new import_errors.FlowModelOperationError({
-        status: 409,
-        code: "CYCLE_DETECTED",
-        message: "flowModels:attach cycle detected"
-      });
+      throw new Error("flowModels:attach cycle detected");
     }
     if (subType === "object") {
       const conflict = await this.database.sequelize.query(
@@ -1507,11 +1304,7 @@ WHERE TreeTable.depth = 1 AND  TreeTable.ancestor = :ancestor and TreeTable.sort
         }
       );
       if (conflict == null ? void 0 : conflict.length) {
-        throw new import_errors.FlowModelOperationError({
-          status: 409,
-          code: "CONFLICT",
-          message: `flowModels:attach subKey '${subKey}' already exists on parent '${parentId}'`
-        });
+        throw new Error(`flowModels:attach subKey '${subKey}' already exists on parent '${parentId}'`);
       }
     }
     const normalizePosition = (input) => {
@@ -1525,21 +1318,13 @@ WHERE TreeTable.depth = 1 AND  TreeTable.ancestor = :ancestor and TreeTable.sort
           return { type, target };
         }
       }
-      throw new import_errors.FlowModelOperationError({
-        status: 400,
-        code: "INVALID_PARAMS",
-        message: "flowModels:attach invalid position"
-      });
+      throw new Error("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 import_errors.FlowModelOperationError({
-          status: 400,
-          code: "INVALID_PARAMS",
-          message: "flowModels:attach position target cannot be itself"
-        });
+        throw new Error("flowModels:attach position target cannot be itself");
       }
       const ok = await this.database.sequelize.query(
         `SELECT 1 as v
@@ -1563,11 +1348,7 @@ WHERE TreeTable.depth = 1 AND  TreeTable.ancestor = :ancestor and TreeTable.sort
         }
       );
       if (!(ok == null ? void 0 : ok.length)) {
-        throw new import_errors.FlowModelOperationError({
-          status: 400,
-          code: "INVALID_PARAMS",
-          message: "flowModels:attach position target is not a sibling under the same parent/subKey"
-        });
+        throw new Error("flowModels:attach position target is not a sibling under the same parent/subKey");
       }
     }
     await this.clearXUidPathCache(modelUid, transaction2);
@@ -1597,99 +1378,11 @@ WHERE TreeTable.depth = 1 AND  TreeTable.ancestor = :ancestor and TreeTable.sort
     );
     return await this.findModelById(modelUid, { transaction: transaction2, includeAsyncNode: true });
   }
-  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 }
-    );
+  async move(options) {
+    const { sourceId, targetId, position } = options;
+    return await this.insertAdjacent(position === "after" ? "afterEnd" : "beforeBegin", targetId, {
+      ["uid"]: sourceId
+    });
   }
 };
 __decorateClass([
@@ -1749,18 +1442,9 @@ __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: