@nocobase/plugin-flow-engine 2.1.0-alpha.45 → 2.1.0-alpha.46

package/dist/server/flow-surfaces/types.d.ts

@@ -229,6 +229,9 @@ export type FlowSurfaceComposeValues = {
     target: FlowSurfaceWriteTarget;
     mode?: FlowSurfaceComposeMode;
     blocks?: Array<Record<string, any>>;
+    assets?: {
+        charts?: Record<string, any>;
+    };
     layout?: Record<string, any>;
     defaults?: FlowSurfaceApplyBlueprintDefaults;
 };

package/dist/server/repository.d.ts

@@ -25,6 +25,12 @@ export interface FlowModelAttachOptions {
     subType: 'array' | 'object';
     position?: FlowModelAttachPosition;
 }
+type FlowModelMovePosition = 'before' | 'after';
+interface FlowModelMoveOptions {
+    sourceId: string;
+    targetId: string;
+    position?: FlowModelMovePosition;
+}
 type BreakRemoveOnType = {
     [key: string]: any;
 };
@@ -59,6 +65,8 @@ export declare class FlowModelRepository extends Repository {
     getParentProperty(uid: string, options?: GetPropertiesOptions): Promise<any>;
     getJsonSchema(uid: string, options?: GetJsonSchemaOptions): Promise<any>;
     static optionsToJson(options: any): any;
+    private static getSortNumber;
+    private static compareBySortAndUid;
     nodesToSchema(nodes: any, rootUid: any): {
         uid: any;
         "x-async": boolean;
@@ -90,6 +98,9 @@ export declare class FlowModelRepository extends Repository {
     protected childrenCount(uid: any, transaction: any): Promise<number>;
     protected isLeafNode(uid: any, transaction: any): Promise<boolean>;
     protected findParentUid(uid: any, transaction?: any): Promise<string>;
+    private findSiblingInfo;
+    private findSiblingSortRows;
+    private writeSiblingSorts;
     protected findNodeSchemaWithParent(uid: any, transaction: any): Promise<{
         parentUid: string;
         schema: any;
@@ -122,6 +133,6 @@ export declare class FlowModelRepository extends Repository {
         subKey?: string;
     }): Promise<any>;
     attach(uid: string, attachOptions: FlowModelAttachOptions, options?: Transactionable): Promise<any>;
-    move(options: any): Promise<any>;
+    move(options: FlowModelMoveOptions, transactionOptions?: Transactionable): Promise<any>;
 }
 export default FlowModelRepository;

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,70 @@ 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 findNodeSchemaWithParent(uid2, transaction2) {
     const schema = await this.database.getRepository("flowModels").findOne({
       filter: {
@@ -1155,22 +1262,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 +1296,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 +1317,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 +1325,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 +1504,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 +1527,52 @@ 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;
+    if (sourceUid === targetUid) {
+      const sourceInfo2 = await this.findSiblingInfo(sourceUid, transaction2);
+      if (sourceInfo2) {
+        const siblingRows2 = await this.findSiblingSortRows(sourceInfo2.parentUid, sourceInfo2.type, transaction2);
+        await this.writeSiblingSorts(
+          sourceInfo2.parentUid,
+          siblingRows2.map((row) => row.uid),
+          transaction2
+        );
+      }
+      return null;
+    }
+    const sourceInfo = await this.findSiblingInfo(sourceUid, transaction2);
+    const targetInfo = await this.findSiblingInfo(targetUid, transaction2);
+    if (!sourceInfo || !targetInfo) {
+      throw new Error("flowModels:move source or target is not attached to a parent");
+    }
+    if (sourceInfo.parentUid !== targetInfo.parentUid || sourceInfo.type !== targetInfo.type) {
+      throw new Error("flowModels:move source and target must be sibling nodes under the same parent/subKey");
+    }
+    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 });
   }
 };
 __decorateClass([
@@ -1466,6 +1635,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/swagger/flow-surfaces.d.ts

@@ -4001,6 +4001,118 @@ declare const _default: {
                         type: string;
                         enum: string[];
                     };
+                    errorCount: {
+                        type: string;
+                        description: string;
+                    };
+                    details: {
+                        type: string;
+                        description: string;
+                        properties: {
+                            errorCount: {
+                                type: string;
+                                description: string;
+                                example: number;
+                            };
+                            mustFixAllErrorsBeforeRetry: {
+                                type: string;
+                                example: boolean;
+                            };
+                            retryPolicy: {
+                                type: string;
+                                example: string;
+                            };
+                            sameWriteRetryRequired: {
+                                type: string;
+                                example: boolean;
+                            };
+                            agentInstruction: {
+                                type: string;
+                                description: string;
+                            };
+                            requiredBlockPolicy: {
+                                type: string;
+                                properties: {
+                                    requiredBlockTypes: {
+                                        type: string;
+                                        items: {
+                                            type: string;
+                                        };
+                                    };
+                                    fixStrategy: {
+                                        type: string;
+                                        example: string;
+                                    };
+                                    doNotReplaceOrDrop: {
+                                        type: string;
+                                        example: boolean;
+                                    };
+                                };
+                                additionalProperties: boolean;
+                            };
+                        };
+                        additionalProperties: boolean;
+                    };
+                    errors: {
+                        type: string;
+                        description: string;
+                        items: {
+                            type: string;
+                            properties: {
+                                index: {
+                                    type: string;
+                                    description: string;
+                                    example: number;
+                                };
+                                code: {
+                                    type: string;
+                                    description: string;
+                                    example: string;
+                                };
+                                message: {
+                                    type: string;
+                                    description: string;
+                                };
+                                status: {
+                                    type: string;
+                                    description: string;
+                                    example: number;
+                                };
+                                type: {
+                                    type: string;
+                                    description: string;
+                                    example: string;
+                                    enum: string[];
+                                };
+                                path: {
+                                    type: string;
+                                    description: string;
+                                    example: string;
+                                };
+                                ruleId: {
+                                    type: string;
+                                    description: string;
+                                    example: string;
+                                };
+                                details: {
+                                    type: string;
+                                    description: string;
+                                    additionalProperties: boolean;
+                                    example: {
+                                        action: string;
+                                        fieldPath: string;
+                                        titleField: string;
+                                        targetCollection: string;
+                                        invalidReason: string;
+                                        availableFields: string[];
+                                        suggestion: string;
+                                    };
+                                };
+                            };
+                            required: string[];
+                            additionalProperties: boolean;
+                        };
+                    };
                 };
                 required: string[];
                 additionalProperties: boolean;
@@ -5250,11 +5362,74 @@ declare const _default: {
                     }[];
                 };
                 properties: {
+                    message: {
+                        type: string;
+                        description: string;
+                        example: string;
+                    };
+                    errorCount: {
+                        type: string;
+                        description: string;
+                        example: number;
+                    };
+                    details: {
+                        type: string;
+                        description: string;
+                        properties: {
+                            errorCount: {
+                                type: string;
+                                description: string;
+                                example: number;
+                            };
+                            mustFixAllErrorsBeforeRetry: {
+                                type: string;
+                                example: boolean;
+                            };
+                            retryPolicy: {
+                                type: string;
+                                example: string;
+                            };
+                            sameWriteRetryRequired: {
+                                type: string;
+                                example: boolean;
+                            };
+                            agentInstruction: {
+                                type: string;
+                                description: string;
+                            };
+                            requiredBlockPolicy: {
+                                type: string;
+                                properties: {
+                                    requiredBlockTypes: {
+                                        type: string;
+                                        items: {
+                                            type: string;
+                                        };
+                                    };
+                                    fixStrategy: {
+                                        type: string;
+                                        example: string;
+                                    };
+                                    doNotReplaceOrDrop: {
+                                        type: string;
+                                        example: boolean;
+                                    };
+                                };
+                                additionalProperties: boolean;
+                            };
+                        };
+                        additionalProperties: boolean;
+                    };
                     errors: {
                         type: string;
                         items: {
                             type: string;
                             properties: {
+                                index: {
+                                    type: string;
+                                    description: string;
+                                    example: number;
+                                };
                                 code: {
                                     type: string;
                                     description: string;