@ldsg/workflow 0.3.8 → 0.3.9

package/dist/resource.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"resource.d.ts","sourceRoot":"","sources":["../src/resource.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,QAAQ,EAAE,MAAM,gBAAgB,CAAC;AAE1C,OAAO,EAGL,YAAY,EACZ,gBAAgB,EAChB,eAAe,EAEf,YAAY,EACZ,gBAAgB,EAChB,gCAAgC,EAGjC,MAAM,SAAS,CAAC;AAIjB,MAAM,WAAW,0BAA0B;IACzC,oBAAoB,EAAE,gBAAgB,EAAE,CAAC;CAC1C;AAED,MAAM,MAAM,uBAAuB,GAAG,MAAM,0BAA0B,CAAC;AAEvE,MAAM,WAAW,0BAA0B;IACzC,oBAAoB,EAAE,gBAAgB,EAAE,CAAC;CAC1C;AAED,MAAM,MAAM,uBAAuB,GAAG,MAAM,0BAA0B,CAAC;AAEvE,MAAM,WAAW,kBAAkB;IACjC,YAAY,EAAE,YAAY,CAAC;CAC5B;AAED,MAAM,MAAM,eAAe,GAAG,MAAM,kBAAkB,CAAC;AAEvD,MAAM,WAAW,kBAAkB;IACjC,YAAY,EAAE,YAAY,CAAC;CAC5B;AAED,MAAM,MAAM,eAAe,GAAG,MAAM,kBAAkB,CAAC;AAEvD,qBAAa,gBAAiB,SAAQ,QAAQ,CAAC,gCAAgC,CAAC;IAC9E,uBAAuB,EAAE,uBAAuB,CA4B9C;IAEF,uBAAuB,EAAE,uBAAuB,CAsB9C;IAEF,eAAe,EAAE,eAAe,CAiB9B;IAEF,OAAO,EAAE,eAAe,CA+GtB;IAEF,eAAe,EAAE,eAAe,CAY9B;CACH"}
+{"version":3,"file":"resource.d.ts","sourceRoot":"","sources":["../src/resource.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,QAAQ,EAAE,MAAM,gBAAgB,CAAC;AAE1C,OAAO,EAGL,YAAY,EACZ,gBAAgB,EAChB,eAAe,EAEf,YAAY,EACZ,gBAAgB,EAChB,gCAAgC,EAGjC,MAAM,SAAS,CAAC;AAIjB,MAAM,WAAW,0BAA0B;IACzC,oBAAoB,EAAE,gBAAgB,EAAE,CAAC;CAC1C;AAED,MAAM,MAAM,uBAAuB,GAAG,MAAM,0BAA0B,CAAC;AAEvE,MAAM,WAAW,0BAA0B;IACzC,oBAAoB,EAAE,gBAAgB,EAAE,CAAC;CAC1C;AAED,MAAM,MAAM,uBAAuB,GAAG,MAAM,0BAA0B,CAAC;AAEvE,MAAM,WAAW,kBAAkB;IACjC,YAAY,EAAE,YAAY,CAAC;CAC5B;AAED,MAAM,MAAM,eAAe,GAAG,MAAM,kBAAkB,CAAC;AAEvD,MAAM,WAAW,kBAAkB;IACjC,YAAY,EAAE,YAAY,CAAC;CAC5B;AAED,MAAM,MAAM,eAAe,GAAG,MAAM,kBAAkB,CAAC;AAEvD,qBAAa,gBAAiB,SAAQ,QAAQ,CAAC,gCAAgC,CAAC;IAC9E,uBAAuB,EAAE,uBAAuB,CA4B9C;IAEF,uBAAuB,EAAE,uBAAuB,CAsB9C;IAEF,eAAe,EAAE,eAAe,CAiB9B;IAEF,OAAO,EAAE,eAAe,CAiItB;IAEF,eAAe,EAAE,eAAe,CAY9B;CACH"}

package/dist/resource.js

@@ -6,8 +6,8 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.WorkflowResource = void 0;
 const resource_1 = require("@ldsg/resource");
 const lodash_1 = __importDefault(require("lodash"));
-const utils_1 = require("./utils");
 const evaluate_variables_1 = require("./utils/evaluate-variables");
+const get_execution_levels_1 = require("./utils/get-execution-levels");
 class WorkflowResource extends resource_1.Resource {
     constructor() {
         super(...arguments);
@@ -67,52 +67,65 @@ class WorkflowResource extends resource_1.Resource {
             if (!startNode || !endNode) {
                 throw new Error("invalid workflow nodes");
             }
-            const { orderedNodeList } = (0, utils_1.getOrderedNodeList)({
+            const { executionLevels } = (0, get_execution_levels_1.getExecutionLevels)({
                 workflowData,
                 startNode,
                 endNode,
             });
-            const orderedNodeListLength = orderedNodeList.length;
-            if (orderedNodeListLength < 2) {
-                throw new Error("invalid workflow nodes count");
+            if (executionLevels.length < 1) {
+                throw new Error("invalid workflow execution levels");
             }
             let workflowOutputVariables;
-            for (let index = 0; index < orderedNodeListLength; index++) {
-                const node = orderedNodeList[index];
-                const { id, propertiesSchema, execute: nodeExecute } = node;
-                const workflowVariables = Object.fromEntries(workflowVariablesMap);
-                // 输入变量从工作流变量中使用表达式获取
-                const workflowNodePropertiesInputSchema = lodash_1.default.get(propertiesSchema, "properties.input");
-                const workflowNodePropertiesOutputSchema = lodash_1.default.get(propertiesSchema, "properties.output");
-                if (!lodash_1.default.isObject(workflowNodePropertiesInputSchema) ||
-                    !lodash_1.default.isObject(workflowNodePropertiesOutputSchema)) {
-                    throw new Error("invalid workflow node properties schema");
-                }
-                const { variables: workflowNodeInputVariables } = await (0, evaluate_variables_1.evaluateVariables)({
-                    jsonSchema: workflowNodePropertiesInputSchema,
+            // 按层级执行，同一层级的节点可以并行执行
+            for (let levelIndex = 0; levelIndex < executionLevels.length; levelIndex++) {
+                const currentLevel = executionLevels[levelIndex];
+                // 并行执行当前层级的所有节点
+                const levelPromises = currentLevel.map(async (node) => {
+                    const { id, propertiesSchema, execute: nodeExecute } = node;
+                    const workflowVariables = Object.fromEntries(workflowVariablesMap);
+                    // 输入变量从工作流变量中使用表达式获取
+                    const workflowNodePropertiesInputSchema = lodash_1.default.get(propertiesSchema, "properties.input");
+                    const workflowNodePropertiesOutputSchema = lodash_1.default.get(propertiesSchema, "properties.output");
+                    if (!lodash_1.default.isObject(workflowNodePropertiesInputSchema) ||
+                        !lodash_1.default.isObject(workflowNodePropertiesOutputSchema)) {
+                        throw new Error("invalid workflow node properties schema");
+                    }
+                    const { variables: workflowNodeInputVariables } = await (0, evaluate_variables_1.evaluateVariables)({
+                        jsonSchema: workflowNodePropertiesInputSchema,
+                        /**
+                         * 对于开始节点，不忽略 input 表达式，但替换工作流内部变量为工作流输入变量。
+                         */
+                        variables: levelIndex === 0 ? workflowInputVariables : workflowVariables,
+                    });
+                    const { variables: workflowNodeOutputExpressionEvaluateInput } = await nodeExecute({
+                        variables: workflowNodeInputVariables,
+                        context: {
+                            workflowResourceInstance: this,
+                        },
+                    });
                     /**
-                     * 对于开始节点，不忽略 input 表达式，但替换工作流内部变量为工作流输入变量。
+                     * 输出变量从结果中使用表达式获取
+                     * 对于结束节点，不忽略 output 表达式，但表达式固定为取返回变量。
                      */
-                    variables: index === 0 ? workflowInputVariables : workflowVariables,
+                    const { variables: workflowNodeOutputVariables } = await (0, evaluate_variables_1.evaluateVariables)({
+                        jsonSchema: workflowNodePropertiesOutputSchema,
+                        variables: workflowNodeOutputExpressionEvaluateInput,
+                    });
+                    return {
+                        nodeId: id,
+                        variables: workflowNodeOutputVariables,
+                    };
                 });
-                const { variables: workflowNodeOutputExpressionEvaluateInput } = await nodeExecute({
-                    variables: workflowNodeInputVariables,
-                    context: {
-                        workflowResourceInstance: this,
-                    },
+                // 等待当前层级的所有节点执行完成
+                const levelResults = await Promise.all(levelPromises);
+                // 将当前层级的结果更新到工作流变量映射中
+                levelResults.forEach((result) => {
+                    workflowVariablesMap.set(result.nodeId, result.variables);
+                    // 如果是结束节点，保存输出变量
+                    if (result.nodeId === endNode.id) {
+                        workflowOutputVariables = result.variables;
+                    }
                 });
-                /**
-                 * 输出变量从结果中使用表达式获取
-                 * 对于结束节点，不忽略 output 表达式，但表达式固定为取返回变量。
-                 */
-                const { variables: workflowNodeOutputVariables } = await (0, evaluate_variables_1.evaluateVariables)({
-                    jsonSchema: workflowNodePropertiesOutputSchema,
-                    variables: workflowNodeOutputExpressionEvaluateInput,
-                });
-                workflowVariablesMap.set(id, workflowNodeOutputVariables);
-                if (index === orderedNodeListLength - 1) {
-                    workflowOutputVariables = workflowNodeOutputVariables;
-                }
             }
             const res = {
                 variables: workflowOutputVariables,

package/dist/utils/evaluate-variables/index.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=index.test.d.ts.map

package/dist/utils/evaluate-variables/index.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.test.d.ts","sourceRoot":"","sources":["../../../src/utils/evaluate-variables/index.test.ts"],"names":[],"mappings":""}

package/dist/utils/{evaluate-variables.test.js → evaluate-variables/index.test.js}

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-const evaluate_variables_1 = require("./evaluate-variables");
+const _1 = require(".");
 const input = {
     Account: {
         "Account Name": "Firefly",
@@ -177,7 +177,7 @@ const jsonSchema = {
     },
 };
 test("evaluate variables", async () => {
-    const evaluateVariablesRes = await (0, evaluate_variables_1.evaluateVariables)({
+    const evaluateVariablesRes = await (0, _1.evaluateVariables)({
         jsonSchema,
         variables: input,
     });

package/dist/utils/get-execution-levels.d.ts

@@ -0,0 +1,17 @@
+import { WorkflowData, WorkflowNodeInfo } from "../types";
+interface GetExecutionLevelsParams {
+    workflowData: WorkflowData;
+    startNode: WorkflowNodeInfo;
+    endNode: WorkflowNodeInfo;
+}
+interface GetExecutionLevelsRes {
+    executionLevels: WorkflowNodeInfo[][];
+}
+/**
+ * 获取执行层级列表，用于并行执行
+ * 根据节点依赖关系构建执行层级，同一层级的节点可以并行执行
+ * 例如：连线如 1-2、1-3、2-4、3-4、4-5 时，需要 2、3 均执行完成后才执行 4
+ */
+export declare const getExecutionLevels: (params: GetExecutionLevelsParams) => GetExecutionLevelsRes;
+export {};
+//# sourceMappingURL=get-execution-levels.d.ts.map

package/dist/utils/get-execution-levels.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"get-execution-levels.d.ts","sourceRoot":"","sources":["../../src/utils/get-execution-levels.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,YAAY,EAAE,gBAAgB,EAAE,MAAM,UAAU,CAAC;AAE1D,UAAU,wBAAwB;IAChC,YAAY,EAAE,YAAY,CAAC;IAC3B,SAAS,EAAE,gBAAgB,CAAC;IAC5B,OAAO,EAAE,gBAAgB,CAAC;CAC3B;AAED,UAAU,qBAAqB;IAC7B,eAAe,EAAE,gBAAgB,EAAE,EAAE,CAAC;CACvC;AAED;;;;GAIG;AACH,eAAO,MAAM,kBAAkB,GAC7B,QAAQ,wBAAwB,KAC/B,qBAuJF,CAAC"}

package/dist/utils/get-execution-levels.js

@@ -0,0 +1,136 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getExecutionLevels = void 0;
+/**
+ * 获取执行层级列表，用于并行执行
+ * 根据节点依赖关系构建执行层级，同一层级的节点可以并行执行
+ * 例如：连线如 1-2、1-3、2-4、3-4、4-5 时，需要 2、3 均执行完成后才执行 4
+ */
+const getExecutionLevels = (params) => {
+    const { workflowData, startNode, endNode } = params;
+    const { edges, nodes } = workflowData;
+    // 构建节点映射
+    const nodeMap = new Map();
+    nodes.forEach((node) => {
+        nodeMap.set(node.id, node);
+    });
+    // 构建依赖关系图
+    const dependencies = new Map(); // 节点 -> 依赖的节点集合
+    const dependents = new Map(); // 节点 -> 被依赖的节点集合
+    // 初始化所有节点的依赖和被依赖集合
+    nodes.forEach((node) => {
+        dependencies.set(node.id, new Set());
+        dependents.set(node.id, new Set());
+    });
+    // 根据边构建依赖关系
+    edges.forEach((edge) => {
+        var _a, _b;
+        const { sourceWorkflowNodeResourceId, targetWorkflowNodeResourceId } = edge;
+        // target 依赖于 source
+        (_a = dependencies.get(targetWorkflowNodeResourceId)) === null || _a === void 0 ? void 0 : _a.add(sourceWorkflowNodeResourceId);
+        // source 被 target 依赖
+        (_b = dependents.get(sourceWorkflowNodeResourceId)) === null || _b === void 0 ? void 0 : _b.add(targetWorkflowNodeResourceId);
+    });
+    // 使用拓扑排序构建执行层级
+    const executionLevels = [];
+    const completedNodes = new Set();
+    const remainingDependencies = new Map();
+    // 首先进行循环依赖检测
+    const visited = new Set();
+    const recursionStack = new Set();
+    function hasCycle(nodeId) {
+        if (recursionStack.has(nodeId)) {
+            return true; // 发现循环依赖
+        }
+        if (visited.has(nodeId)) {
+            return false; // 已经检查过，没有循环
+        }
+        visited.add(nodeId);
+        recursionStack.add(nodeId);
+        const deps = dependencies.get(nodeId);
+        if (deps) {
+            for (const dep of deps) {
+                if (hasCycle(dep)) {
+                    return true;
+                }
+            }
+        }
+        recursionStack.delete(nodeId);
+        return false;
+    }
+    // 检查所有节点是否存在循环依赖
+    for (const nodeId of dependencies.keys()) {
+        if (hasCycle(nodeId)) {
+            throw new Error("Circular dependency detected in workflow");
+        }
+    }
+    // 复制依赖关系到剩余依赖映射
+    dependencies.forEach((deps, nodeId) => {
+        remainingDependencies.set(nodeId, new Set(deps));
+    });
+    // 开始节点必须在第一层
+    const firstLevel = [startNode];
+    executionLevels.push(firstLevel);
+    completedNodes.add(startNode.id);
+    // 更新剩余依赖
+    remainingDependencies.delete(startNode.id);
+    remainingDependencies.forEach((deps) => {
+        deps.delete(startNode.id);
+    });
+    // 构建后续层级
+    while (remainingDependencies.size > 0) {
+        const currentLevel = [];
+        const nodesToProcess = [];
+        // 找到所有依赖已满足的节点
+        remainingDependencies.forEach((deps, nodeId) => {
+            if (deps.size === 0) {
+                nodesToProcess.push(nodeId);
+                const node = nodeMap.get(nodeId);
+                if (node) {
+                    currentLevel.push(node);
+                }
+            }
+        });
+        // 如果没有找到可以执行的节点，说明存在循环依赖
+        if (currentLevel.length === 0) {
+            throw new Error("Circular dependency detected in workflow");
+        }
+        executionLevels.push(currentLevel);
+        // 标记当前层级的节点为已完成
+        nodesToProcess.forEach((nodeId) => {
+            completedNodes.add(nodeId);
+            remainingDependencies.delete(nodeId);
+        });
+        // 更新剩余依赖
+        const remainingDepsArray = Array.from(remainingDependencies.entries());
+        remainingDepsArray.forEach(([nodeId, deps]) => {
+            nodesToProcess.forEach((processedNodeId) => {
+                deps.delete(processedNodeId);
+            });
+            remainingDependencies.set(nodeId, deps);
+        });
+    }
+    // 确保结束节点在最后一层
+    if (executionLevels.length > 0) {
+        const lastLevel = executionLevels[executionLevels.length - 1];
+        const endNodeInLastLevel = lastLevel.some(node => node.id === endNode.id);
+        if (!endNodeInLastLevel) {
+            // 如果结束节点不在最后一层，需要检查是否已经在某一层中
+            let endNodeFound = false;
+            for (const level of executionLevels) {
+                if (level.some(node => node.id === endNode.id)) {
+                    endNodeFound = true;
+                    break;
+                }
+            }
+            if (!endNodeFound) {
+                // 如果结束节点不在任何层级中，添加到最后一层
+                executionLevels.push([endNode]);
+            }
+        }
+    }
+    return {
+        executionLevels,
+    };
+};
+exports.getExecutionLevels = getExecutionLevels;

package/dist/utils/get-execution-levels.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=get-execution-levels.test.d.ts.map

package/dist/utils/get-execution-levels.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"get-execution-levels.test.d.ts","sourceRoot":"","sources":["../../src/utils/get-execution-levels.test.ts"],"names":[],"mappings":""}

package/dist/utils/get-execution-levels.test.js

@@ -0,0 +1,228 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const get_execution_levels_1 = require("./get-execution-levels");
+// 创建测试节点
+const createTestNode = (id) => ({
+    id,
+    propertiesSchema: {
+        type: "object",
+        properties: {
+            input: { type: "object" },
+            output: { type: "object" },
+        },
+    },
+    execute: async () => ({ variables: {} }),
+});
+describe("getExecutionLevels", () => {
+    test("should create correct execution levels for parallel workflow", () => {
+        // 测试场景：1-2, 1-3, 2-4, 3-4, 4-5
+        // 期望的层级：
+        // Level 0: [1]
+        // Level 1: [2, 3] (并行)
+        // Level 2: [4] (需要2,3都完成)
+        // Level 3: [5]
+        const nodes = [
+            createTestNode("node-1"),
+            createTestNode("node-2"),
+            createTestNode("node-3"),
+            createTestNode("node-4"),
+            createTestNode("node-5"),
+        ];
+        const workflowData = {
+            edges: [
+                {
+                    sourceWorkflowNodeResourceId: "node-1",
+                    targetWorkflowNodeResourceId: "node-2",
+                },
+                {
+                    sourceWorkflowNodeResourceId: "node-1",
+                    targetWorkflowNodeResourceId: "node-3",
+                },
+                {
+                    sourceWorkflowNodeResourceId: "node-2",
+                    targetWorkflowNodeResourceId: "node-4",
+                },
+                {
+                    sourceWorkflowNodeResourceId: "node-3",
+                    targetWorkflowNodeResourceId: "node-4",
+                },
+                {
+                    sourceWorkflowNodeResourceId: "node-4",
+                    targetWorkflowNodeResourceId: "node-5",
+                },
+            ],
+            nodes,
+        };
+        const startNode = nodes[0]; // node-1
+        const endNode = nodes[4]; // node-5
+        const { executionLevels } = (0, get_execution_levels_1.getExecutionLevels)({
+            workflowData,
+            startNode,
+            endNode,
+        });
+        // 验证层级数量
+        expect(executionLevels.length).toBe(4);
+        // 验证第一层（只有node-1）
+        expect(executionLevels[0]).toHaveLength(1);
+        expect(executionLevels[0][0].id).toBe("node-1");
+        // 验证第二层（node-2和node-3，可以并行）
+        expect(executionLevels[1]).toHaveLength(2);
+        const level2NodeIds = executionLevels[1].map((node) => node.id).sort();
+        expect(level2NodeIds).toEqual(["node-2", "node-3"]);
+        // 验证第三层（只有node-4，需要2,3都完成）
+        expect(executionLevels[2]).toHaveLength(1);
+        expect(executionLevels[2][0].id).toBe("node-4");
+        // 验证第四层（只有node-5）
+        expect(executionLevels[3]).toHaveLength(1);
+        expect(executionLevels[3][0].id).toBe("node-5");
+    });
+    test("should handle simple sequential workflow", () => {
+        // 测试简单的顺序工作流：1-2-3
+        const nodes = [
+            createTestNode("node-1"),
+            createTestNode("node-2"),
+            createTestNode("node-3"),
+        ];
+        const workflowData = {
+            edges: [
+                {
+                    sourceWorkflowNodeResourceId: "node-1",
+                    targetWorkflowNodeResourceId: "node-2",
+                },
+                {
+                    sourceWorkflowNodeResourceId: "node-2",
+                    targetWorkflowNodeResourceId: "node-3",
+                },
+            ],
+            nodes,
+        };
+        const startNode = nodes[0]; // node-1
+        const endNode = nodes[2]; // node-3
+        const { executionLevels } = (0, get_execution_levels_1.getExecutionLevels)({
+            workflowData,
+            startNode,
+            endNode,
+        });
+        // 验证层级数量
+        expect(executionLevels.length).toBe(3);
+        // 每层只有一个节点
+        executionLevels.forEach((level, index) => {
+            expect(level).toHaveLength(1);
+            expect(level[0].id).toBe(`node-${index + 1}`);
+        });
+    });
+    test("should handle complex parallel workflow", () => {
+        // 测试更复杂的并行工作流：1-2, 1-3, 1-4, 2-5, 3-5, 4-6, 5-6, 6-7
+        // 期望的层级：
+        // Level 0: [1]
+        // Level 1: [2, 3, 4] (并行)
+        // Level 2: [5] (需要2,3完成)
+        // Level 3: [6] (需要4,5完成)
+        // Level 4: [7]
+        const nodes = [
+            createTestNode("node-1"),
+            createTestNode("node-2"),
+            createTestNode("node-3"),
+            createTestNode("node-4"),
+            createTestNode("node-5"),
+            createTestNode("node-6"),
+            createTestNode("node-7"),
+        ];
+        const workflowData = {
+            edges: [
+                {
+                    sourceWorkflowNodeResourceId: "node-1",
+                    targetWorkflowNodeResourceId: "node-2",
+                },
+                {
+                    sourceWorkflowNodeResourceId: "node-1",
+                    targetWorkflowNodeResourceId: "node-3",
+                },
+                {
+                    sourceWorkflowNodeResourceId: "node-1",
+                    targetWorkflowNodeResourceId: "node-4",
+                },
+                {
+                    sourceWorkflowNodeResourceId: "node-2",
+                    targetWorkflowNodeResourceId: "node-5",
+                },
+                {
+                    sourceWorkflowNodeResourceId: "node-3",
+                    targetWorkflowNodeResourceId: "node-5",
+                },
+                {
+                    sourceWorkflowNodeResourceId: "node-4",
+                    targetWorkflowNodeResourceId: "node-6",
+                },
+                {
+                    sourceWorkflowNodeResourceId: "node-5",
+                    targetWorkflowNodeResourceId: "node-6",
+                },
+                {
+                    sourceWorkflowNodeResourceId: "node-6",
+                    targetWorkflowNodeResourceId: "node-7",
+                },
+            ],
+            nodes,
+        };
+        const startNode = nodes[0]; // node-1
+        const endNode = nodes[6]; // node-7
+        const { executionLevels } = (0, get_execution_levels_1.getExecutionLevels)({
+            workflowData,
+            startNode,
+            endNode,
+        });
+        // 验证层级数量
+        expect(executionLevels.length).toBe(5);
+        // 验证第一层（只有node-1）
+        expect(executionLevels[0]).toHaveLength(1);
+        expect(executionLevels[0][0].id).toBe("node-1");
+        // 验证第二层（node-2, node-3, node-4，可以并行）
+        expect(executionLevels[1]).toHaveLength(3);
+        const level2NodeIds = executionLevels[1].map((node) => node.id).sort();
+        expect(level2NodeIds).toEqual(["node-2", "node-3", "node-4"]);
+        // 验证第三层（只有node-5，需要2,3完成）
+        expect(executionLevels[2]).toHaveLength(1);
+        expect(executionLevels[2][0].id).toBe("node-5");
+        // 验证第四层（只有node-6，需要4,5完成）
+        expect(executionLevels[3]).toHaveLength(1);
+        expect(executionLevels[3][0].id).toBe("node-6");
+        // 验证第五层（只有node-7）
+        expect(executionLevels[4]).toHaveLength(1);
+        expect(executionLevels[4][0].id).toBe("node-7");
+    });
+    test("should throw error for circular dependency", () => {
+        // 测试循环依赖：1-2, 2-3, 3-1
+        const nodes = [
+            createTestNode("node-1"),
+            createTestNode("node-2"),
+            createTestNode("node-3"),
+        ];
+        const workflowData = {
+            edges: [
+                {
+                    sourceWorkflowNodeResourceId: "node-1",
+                    targetWorkflowNodeResourceId: "node-2",
+                },
+                {
+                    sourceWorkflowNodeResourceId: "node-2",
+                    targetWorkflowNodeResourceId: "node-3",
+                },
+                {
+                    sourceWorkflowNodeResourceId: "node-3",
+                    targetWorkflowNodeResourceId: "node-1",
+                },
+            ],
+            nodes,
+        };
+        const startNode = nodes[0]; // node-1
+        const endNode = nodes[2]; // node-3
+        expect(() => {
+            (0, get_execution_levels_1.getExecutionLevels)({
+                workflowData,
+                startNode,
+                endNode,
+            });
+        }).toThrow("Circular dependency detected in workflow");
+    });
+});

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ldsg/workflow",
-  "version": "0.3.8",
+  "version": "0.3.9",
   "description": "",
   "main": "dist/index.js",
   "files": [
@@ -17,15 +17,15 @@
     "json-schema": "0.4.0",
     "json-schema-default": "^1.0.2",
     "lodash": "^4.17.21",
-    "@ldsg/handler": "0.3.8",
-    "@ldsg/resource": "0.3.8",
-    "@ldsg/resource-definition": "0.3.8"
+    "@ldsg/handler": "0.3.9",
+    "@ldsg/resource": "0.3.9",
+    "@ldsg/resource-definition": "0.3.9"
   },
   "devDependencies": {
     "@types/flat": "^5.0.5",
     "@types/json-schema": "^7.0.15",
     "@types/lodash": "^4.14.202",
-    "@ldsg/types": "0.3.8"
+    "@ldsg/types": "0.3.9"
   },
   "scripts": {
     "build": "tsc --project tsconfig.build.json",

package/dist/utils/evaluate-variables.test.d.ts

@@ -1,2 +0,0 @@
-export {};
-//# sourceMappingURL=evaluate-variables.test.d.ts.map

package/dist/utils/evaluate-variables.test.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"evaluate-variables.test.d.ts","sourceRoot":"","sources":["../../src/utils/evaluate-variables.test.ts"],"names":[],"mappings":""}

package/dist/utils/get-ordered-node-list.d.ts

@@ -1,19 +0,0 @@
-import { WorkflowData, WorkflowNodeInfo } from "../types";
-interface GetOrderedNodeListParams {
-    workflowData: WorkflowData;
-    startNode: WorkflowNodeInfo;
-    endNode: WorkflowNodeInfo;
-}
-interface GetOrderedNodeListRes {
-    orderedNodeList: WorkflowNodeInfo[];
-}
-type GetOrderedNodeList = (params: GetOrderedNodeListParams) => GetOrderedNodeListRes;
-/**
- * 获取有序的节点列表
- * 暂时先实现单线工作流，且节点只有开始与目标端口各一个。
- * 1. 找到开始与结束节点
- * 2. 从开始节点逐一向后查找
- */
-export declare const getOrderedNodeList: GetOrderedNodeList;
-export {};
-//# sourceMappingURL=get-ordered-node-list.d.ts.map

package/dist/utils/get-ordered-node-list.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"get-ordered-node-list.d.ts","sourceRoot":"","sources":["../../src/utils/get-ordered-node-list.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,YAAY,EAAE,gBAAgB,EAAE,MAAM,UAAU,CAAC;AAE1D,UAAU,wBAAwB;IAChC,YAAY,EAAE,YAAY,CAAC;IAC3B,SAAS,EAAE,gBAAgB,CAAC;IAC5B,OAAO,EAAE,gBAAgB,CAAC;CAC3B;AAED,UAAU,qBAAqB;IAC7B,eAAe,EAAE,gBAAgB,EAAE,CAAC;CACrC;AAED,KAAK,kBAAkB,GAAG,CACxB,MAAM,EAAE,wBAAwB,KAC7B,qBAAqB,CAAC;AAE3B;;;;;GAKG;AACH,eAAO,MAAM,kBAAkB,EAAE,kBA4ChC,CAAC"}

package/dist/utils/get-ordered-node-list.js

@@ -1,41 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.getOrderedNodeList = void 0;
-/**
- * 获取有序的节点列表
- * 暂时先实现单线工作流，且节点只有开始与目标端口各一个。
- * 1. 找到开始与结束节点
- * 2. 从开始节点逐一向后查找
- */
-const getOrderedNodeList = (params) => {
-    const { workflowData, startNode, endNode } = params;
-    const { edges, nodes } = workflowData;
-    const orderedNodeList = [startNode, endNode];
-    let currentNodeId = startNode.id;
-    let pending = true;
-    do {
-        const currentEdge = edges.find((edge) => edge.sourceWorkflowNodeResourceId === currentNodeId);
-        if (!currentEdge) {
-            throw new Error("invalid edge");
-        }
-        const { targetWorkflowNodeResourceId } = currentEdge;
-        const targetWorkflowNode = nodes.find((node) => node.id === targetWorkflowNodeResourceId);
-        if (targetWorkflowNode) {
-            currentNodeId = targetWorkflowNode.id;
-            if (currentNodeId === endNode.id) {
-                pending = false;
-            }
-            else {
-                orderedNodeList.splice(-1, 0, targetWorkflowNode);
-            }
-        }
-        else {
-            throw new Error("invalid edge");
-        }
-    } while (pending);
-    const res = {
-        orderedNodeList,
-    };
-    return res;
-};
-exports.getOrderedNodeList = getOrderedNodeList;

package/dist/utils/index.d.ts

@@ -1,2 +0,0 @@
-export * from "./get-ordered-node-list";
-//# sourceMappingURL=index.d.ts.map

package/dist/utils/index.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/utils/index.ts"],"names":[],"mappings":"AAAA,cAAc,yBAAyB,CAAC"}

package/dist/utils/index.js

@@ -1,17 +0,0 @@
-"use strict";
-var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    var desc = Object.getOwnPropertyDescriptor(m, k);
-    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
-      desc = { enumerable: true, get: function() { return m[k]; } };
-    }
-    Object.defineProperty(o, k2, desc);
-}) : (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    o[k2] = m[k];
-}));
-var __exportStar = (this && this.__exportStar) || function(m, exports) {
-    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-__exportStar(require("./get-ordered-node-list"), exports);