@ldsg/workflow 0.3.10 → 0.3.17

package/dist/__tests__/unit/evaluate-variables.prefixItems.test.d.ts

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

package/dist/__tests__/unit/evaluate-variables.prefixItems.test.d.ts.map

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

package/dist/__tests__/unit/evaluate-variables.prefixItems.test.js

@@ -0,0 +1,391 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const evaluate_variables_1 = require("../../utils/evaluate-variables");
+describe('evaluateVariables with prefixItems', () => {
+    describe('basic prefixItems functionality', () => {
+        it('should return array with all evaluated expressions', async () => {
+            const variables = {
+                '694bf14e2af2addf73c8c849': {
+                    data: {
+                        suite_access_token: 'token_from_first_source'
+                    }
+                },
+                '694c81a0f12010773020eafb': {
+                    suite_access_token: 'token_from_second_source'
+                }
+            };
+            const jsonSchema = {
+                type: 'object',
+                properties: {
+                    tokens: {
+                        type: 'array',
+                        prefixItems: [
+                            {
+                                'x-expression': '$.\"694bf14e2af2addf73c8c849\".\"data\".\"suite_access_token\"'
+                            },
+                            {
+                                'x-expression': '$.\"694c81a0f12010773020eafb\".\"suite_access_token\"'
+                            }
+                        ]
+                    }
+                }
+            };
+            const result = await (0, evaluate_variables_1.evaluateVariables)({ jsonSchema, variables });
+            expect(result.variables.tokens).toEqual(['token_from_first_source', 'token_from_second_source']);
+        });
+        it('should handle single prefixItem', async () => {
+            const variables = {
+                source1: {
+                    value: 'test_value'
+                }
+            };
+            const jsonSchema = {
+                type: 'object',
+                properties: {
+                    items: {
+                        type: 'array',
+                        prefixItems: [
+                            {
+                                'x-expression': '$.source1.value'
+                            }
+                        ]
+                    }
+                }
+            };
+            const result = await (0, evaluate_variables_1.evaluateVariables)({ jsonSchema, variables });
+            expect(result.variables.items).toEqual(['test_value']);
+        });
+    });
+    describe('handling different value types', () => {
+        it('should handle null values in prefixItems', async () => {
+            const variables = {
+                source1: {
+                    value: null
+                },
+                source2: {
+                    value: 'valid_value'
+                }
+            };
+            const jsonSchema = {
+                type: 'object',
+                properties: {
+                    items: {
+                        type: 'array',
+                        prefixItems: [
+                            {
+                                'x-expression': '$.source1.value'
+                            },
+                            {
+                                'x-expression': '$.source2.value'
+                            }
+                        ]
+                    }
+                }
+            };
+            const result = await (0, evaluate_variables_1.evaluateVariables)({ jsonSchema, variables });
+            expect(result.variables.items).toEqual([null, 'valid_value']);
+        });
+        it('should handle undefined values in prefixItems', async () => {
+            const variables = {
+                source2: {
+                    value: 'valid_value'
+                }
+            };
+            const jsonSchema = {
+                type: 'object',
+                properties: {
+                    items: {
+                        type: 'array',
+                        prefixItems: [
+                            {
+                                'x-expression': '$.source1.value'
+                            },
+                            {
+                                'x-expression': '$.source2.value'
+                            }
+                        ]
+                    }
+                }
+            };
+            const result = await (0, evaluate_variables_1.evaluateVariables)({ jsonSchema, variables });
+            expect(result.variables.items).toEqual([undefined, 'valid_value']);
+        });
+        it('should handle number values', async () => {
+            const variables = {
+                source1: {
+                    value: 42
+                },
+                source2: {
+                    value: 100
+                }
+            };
+            const jsonSchema = {
+                type: 'object',
+                properties: {
+                    numbers: {
+                        type: 'array',
+                        prefixItems: [
+                            {
+                                'x-expression': '$.source1.value'
+                            },
+                            {
+                                'x-expression': '$.source2.value'
+                            }
+                        ]
+                    }
+                }
+            };
+            const result = await (0, evaluate_variables_1.evaluateVariables)({ jsonSchema, variables });
+            expect(result.variables.numbers).toEqual([42, 100]);
+        });
+        it('should handle boolean values', async () => {
+            const variables = {
+                source1: {
+                    value: true
+                },
+                source2: {
+                    value: false
+                }
+            };
+            const jsonSchema = {
+                type: 'object',
+                properties: {
+                    booleans: {
+                        type: 'array',
+                        prefixItems: [
+                            {
+                                'x-expression': '$.source1.value'
+                            },
+                            {
+                                'x-expression': '$.source2.value'
+                            }
+                        ]
+                    }
+                }
+            };
+            const result = await (0, evaluate_variables_1.evaluateVariables)({ jsonSchema, variables });
+            expect(result.variables.booleans).toEqual([true, false]);
+        });
+        it('should handle object values', async () => {
+            const variables = {
+                source1: {
+                    data: {
+                        name: 'Alice',
+                        age: 30
+                    }
+                },
+                source2: {
+                    data: {
+                        name: 'Bob',
+                        age: 25
+                    }
+                }
+            };
+            const jsonSchema = {
+                type: 'object',
+                properties: {
+                    users: {
+                        type: 'array',
+                        prefixItems: [
+                            {
+                                'x-expression': '$.source1.data'
+                            },
+                            {
+                                'x-expression': '$.source2.data'
+                            }
+                        ]
+                    }
+                }
+            };
+            const result = await (0, evaluate_variables_1.evaluateVariables)({ jsonSchema, variables });
+            expect(result.variables.users).toEqual([
+                { name: 'Alice', age: 30 },
+                { name: 'Bob', age: 25 }
+            ]);
+        });
+    });
+    describe('complex expressions', () => {
+        it('should handle complex jsonata expressions', async () => {
+            const variables = {
+                Account: {
+                    'Account Name': 'TestAccount',
+                    Order: [
+                        { OrderID: 'order1', total: 100 },
+                        { OrderID: 'order2', total: 200 }
+                    ]
+                }
+            };
+            const jsonSchema = {
+                type: 'object',
+                properties: {
+                    results: {
+                        type: 'array',
+                        prefixItems: [
+                            {
+                                'x-expression': 'Account."Account Name"'
+                            },
+                            {
+                                'x-expression': '$sum(Account.Order.total)'
+                            }
+                        ]
+                    }
+                }
+            };
+            const result = await (0, evaluate_variables_1.evaluateVariables)({ jsonSchema, variables });
+            expect(result.variables.results).toEqual(['TestAccount', 300]);
+        });
+    });
+    describe('mixed schema features', () => {
+        it('should work with nested objects', async () => {
+            const variables = {
+                source1: { value: 'first' },
+                source2: { value: 'second' }
+            };
+            const jsonSchema = {
+                type: 'object',
+                properties: {
+                    nested: {
+                        type: 'object',
+                        properties: {
+                            items: {
+                                type: 'array',
+                                prefixItems: [
+                                    {
+                                        'x-expression': '$.source1.value'
+                                    },
+                                    {
+                                        'x-expression': '$.source2.value'
+                                    }
+                                ]
+                            }
+                        }
+                    }
+                }
+            };
+            const result = await (0, evaluate_variables_1.evaluateVariables)({ jsonSchema, variables });
+            expect(result.variables.nested.items).toEqual(['first', 'second']);
+        });
+        it('should work alongside regular properties', async () => {
+            const variables = {
+                source1: { value: 'a' },
+                source2: { value: 'b' },
+                source3: { value: 'c' }
+            };
+            const jsonSchema = {
+                type: 'object',
+                properties: {
+                    singleValue: {
+                        'x-expression': '$.source3.value'
+                    },
+                    arrayValue: {
+                        type: 'array',
+                        prefixItems: [
+                            {
+                                'x-expression': '$.source1.value'
+                            },
+                            {
+                                'x-expression': '$.source2.value'
+                            }
+                        ]
+                    }
+                }
+            };
+            const result = await (0, evaluate_variables_1.evaluateVariables)({ jsonSchema, variables });
+            expect(result.variables.singleValue).toBe('c');
+            expect(result.variables.arrayValue).toEqual(['a', 'b']);
+        });
+    });
+    describe('user schema example', () => {
+        it('should handle the exact schema from user requirement', async () => {
+            const variables = {
+                '694bf14e2af2addf73c8c849': {
+                    data: {
+                        suite_access_token: 'token_from_first_source'
+                    }
+                },
+                '694c81a0f12010773020eafb': {
+                    suite_access_token: 'token_from_second_source'
+                }
+            };
+            const jsonSchema = {
+                type: 'object',
+                properties: {
+                    input: {
+                        type: 'object',
+                        properties: {
+                            value: {
+                                title: '值',
+                                description: '取首个有效值',
+                                type: 'array',
+                                prefixItems: [
+                                    {
+                                        'x-expression': '$.\"694bf14e2af2addf73c8c849\".\"data\".\"suite_access_token\"'
+                                    },
+                                    {
+                                        'x-expression': '$.\"694c81a0f12010773020eafb\".\"suite_access_token\"'
+                                    }
+                                ]
+                            }
+                        }
+                    },
+                    output: {
+                        type: 'object',
+                        properties: {
+                            value: {
+                                title: '值',
+                                type: 'object'
+                            }
+                        },
+                        'x-expression': '$',
+                        'x-expression-const': '$'
+                    }
+                }
+            };
+            const result = await (0, evaluate_variables_1.evaluateVariables)({ jsonSchema, variables });
+            expect(result.variables.input.value).toEqual(['token_from_first_source', 'token_from_second_source']);
+            expect(result.variables.output).toBeDefined();
+        });
+    });
+    describe('edge cases', () => {
+        it('should handle empty prefixItems array', async () => {
+            const variables = {};
+            const jsonSchema = {
+                type: 'object',
+                properties: {
+                    items: {
+                        type: 'array',
+                        prefixItems: []
+                    }
+                }
+            };
+            const result = await (0, evaluate_variables_1.evaluateVariables)({ jsonSchema, variables });
+            expect(result.variables.items).toEqual([]);
+        });
+        it('should handle multiple prefixItems with same expression', async () => {
+            const variables = {
+                source: { value: 'same_value' }
+            };
+            const jsonSchema = {
+                type: 'object',
+                properties: {
+                    items: {
+                        type: 'array',
+                        prefixItems: [
+                            {
+                                'x-expression': '$.source.value'
+                            },
+                            {
+                                'x-expression': '$.source.value'
+                            },
+                            {
+                                'x-expression': '$.source.value'
+                            }
+                        ]
+                    }
+                }
+            };
+            const result = await (0, evaluate_variables_1.evaluateVariables)({ jsonSchema, variables });
+            expect(result.variables.items).toEqual(['same_value', 'same_value', 'same_value']);
+        });
+    });
+});

package/dist/__tests__/unit/resource.portId.test.d.ts

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

package/dist/__tests__/unit/resource.portId.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"resource.portId.test.d.ts","sourceRoot":"","sources":["../../../src/__tests__/unit/resource.portId.test.ts"],"names":[],"mappings":""}

package/dist/__tests__/unit/resource.portId.test.js

@@ -0,0 +1,275 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const resource_1 = require("../../resource");
+// 创建测试节点
+const createNode = (nodeId, inputSchema, outputSchema, execute) => ({
+    id: nodeId,
+    propertiesSchema: {
+        type: 'object',
+        properties: {
+            input: inputSchema,
+            output: outputSchema
+        }
+    },
+    execute
+});
+// 测试 portId 功能
+test('WorkflowResource execute with portId', async () => {
+    // 创建节点
+    const startNode = createNode('start', {
+        type: 'object',
+        properties: {
+            value: {
+                type: 'string',
+                default: 'start'
+            }
+        }
+    }, {
+        type: 'object',
+        properties: {
+            value: {
+                type: 'string',
+                'x-expression': 'value'
+            }
+        }
+    }, async ({ variables }) => ({
+        variables: { value: variables.value || 'start' }, // 确保输出有 value 字段
+        portId: 'port-success' // 返回成功端口
+    }));
+    const successNode = createNode('success', {
+        type: 'object',
+        properties: {
+            value: {
+                type: 'string',
+                'x-expression': `$."start".value`
+            }
+        }
+    }, {
+        type: 'object',
+        properties: {
+            result: {
+                type: 'string',
+                'x-expression': 'result'
+            }
+        }
+    }, async ({ variables }) => ({
+        variables: { result: `success: ${variables.value}` }
+    }));
+    const failureNode = createNode('failure', {
+        type: 'object',
+        properties: {
+            value: {
+                type: 'string',
+                'x-expression': `$."start".value`
+            }
+        }
+    }, {
+        type: 'object',
+        properties: {
+            result: {
+                type: 'string',
+                'x-expression': 'value'
+            }
+        }
+    }, async ({ variables }) => ({
+        variables: { result: `failure: ${variables.value}` }
+    }));
+    const endNode = createNode('end', {
+        type: 'object',
+        properties: {
+            result: {
+                type: 'string',
+                'x-expression': '$."success".result'
+            }
+        }
+    }, {
+        type: 'object',
+        properties: {
+            result: {
+                type: 'string',
+                'x-expression': 'result'
+            }
+        }
+    }, async ({ variables }) => ({
+        variables // 直接返回评估后的变量
+    }));
+    // 创建工作流数据
+    // start -> success -> end (使用 port-success)
+    // start -> failure (使用 port-failure, 不会被执行)
+    const workflowData = {
+        edges: [
+            {
+                sourceWorkflowNodeResourceId: 'start',
+                sourceWorkflowNodePortId: 'port-success',
+                targetWorkflowNodeResourceId: 'success'
+            },
+            {
+                sourceWorkflowNodeResourceId: 'start',
+                sourceWorkflowNodePortId: 'port-failure',
+                targetWorkflowNodeResourceId: 'failure'
+            },
+            {
+                sourceWorkflowNodeResourceId: 'success',
+                targetWorkflowNodeResourceId: 'end'
+            }
+        ],
+        nodes: [startNode, successNode, failureNode, endNode]
+    };
+    const getWorkflowDataRes = {
+        workflowData
+    };
+    class TestWorkflowResource extends resource_1.WorkflowResource {
+        constructor() {
+            super(...arguments);
+            this.getWorkflowData = () => {
+                return getWorkflowDataRes;
+            };
+        }
+    }
+    const testWorkflowResource = new TestWorkflowResource({
+        id: 'test',
+        kind: 'workflow',
+        parentId: 'root',
+        settings: {
+            title: '',
+            description: '',
+            startWorkflowNodeResourceId: 'start',
+            endWorkflowNodeResourceId: 'end'
+        }
+    });
+    const { variables } = await testWorkflowResource.execute({
+        context: {},
+        variables: {}
+    });
+    // 验证只有 success 分支被执行
+    expect(variables.result).toBe('success: start');
+});
+// 测试默认端口（无 portId）
+test('WorkflowResource execute without portId', async () => {
+    const startNode = createNode('start', {
+        type: 'object',
+        properties: {
+            value: {
+                type: 'string',
+                default: 'default'
+            }
+        }
+    }, {
+        type: 'object',
+        properties: {
+            value: {
+                type: 'string',
+                'x-expression': 'value'
+            }
+        }
+    }, async ({ variables }) => ({
+        variables: { value: variables.value || 'default' }
+        // 不返回 portId，使用默认端口
+    }));
+    const defaultNode = createNode('default', {
+        type: 'object',
+        properties: {
+            value: {
+                type: 'string',
+                'x-expression': `$."start".value`
+            }
+        }
+    }, {
+        type: 'object',
+        properties: {
+            result: {
+                type: 'string',
+                'x-expression': 'result'
+            }
+        }
+    }, async ({ variables }) => ({
+        variables: { result: `default: ${variables.value}` }
+    }));
+    const specificNode = createNode('specific', {
+        type: 'object',
+        properties: {
+            value: {
+                type: 'string',
+                'x-expression': `$."start".value`
+            }
+        }
+    }, {
+        type: 'object',
+        properties: {
+            result: {
+                type: 'string',
+                'x-expression': 'result'
+            }
+        }
+    }, async ({ variables }) => ({
+        variables: { result: `specific: ${variables.value}` }
+    }));
+    const endNode = createNode('end', {
+        type: 'object',
+        properties: {
+            result: {
+                type: 'string',
+                'x-expression': '$."default".result'
+            }
+        }
+    }, {
+        type: 'object',
+        properties: {
+            result: {
+                type: 'string',
+                'x-expression': 'result'
+            }
+        }
+    }, async ({ variables }) => ({
+        variables // 直接返回评估后的变量
+    }));
+    // start -> default -> end (默认端口，无 portId)
+    // start -> specific (使用 port-specific, 不会被执行)
+    const workflowData = {
+        edges: [
+            {
+                sourceWorkflowNodeResourceId: 'start',
+                // 无 sourceWorkflowNodePortId，表示默认端口
+                targetWorkflowNodeResourceId: 'default'
+            },
+            {
+                sourceWorkflowNodeResourceId: 'start',
+                sourceWorkflowNodePortId: 'port-specific',
+                targetWorkflowNodeResourceId: 'specific'
+            },
+            {
+                sourceWorkflowNodeResourceId: 'default',
+                targetWorkflowNodeResourceId: 'end'
+            }
+        ],
+        nodes: [startNode, defaultNode, specificNode, endNode]
+    };
+    const getWorkflowDataRes = {
+        workflowData
+    };
+    class TestWorkflowResource extends resource_1.WorkflowResource {
+        constructor() {
+            super(...arguments);
+            this.getWorkflowData = () => {
+                return getWorkflowDataRes;
+            };
+        }
+    }
+    const testWorkflowResource = new TestWorkflowResource({
+        id: 'test',
+        kind: 'workflow',
+        parentId: 'root',
+        settings: {
+            title: '',
+            description: '',
+            startWorkflowNodeResourceId: 'start',
+            endWorkflowNodeResourceId: 'end'
+        }
+    });
+    const { variables } = await testWorkflowResource.execute({
+        context: {},
+        variables: {}
+    });
+    // 验证只有默认分支被执行
+    expect(variables.result).toBe('default: default');
+});

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,CAsB9C;IAEF,uBAAuB,EAAE,uBAAuB,CAsB9C;IAEF,eAAe,EAAE,eAAe,CAiB9B;IAEF,OAAO,EAAE,eAAe,CAgHtB;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,EACf,YAAY,EACZ,gBAAgB,EAChB,gCAAgC,EACjC,MAAM,SAAS,CAAC;AAGjB,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,CAsB9C;IAEF,uBAAuB,EAAE,uBAAuB,CAsB9C;IAEF,eAAe,EAAE,eAAe,CAiB9B;IAEF,OAAO,EAAE,eAAe,CAuBtB;IAEF,eAAe,EAAE,eAAe,CAY9B;CACH"}