@ldsg/workflow 0.3.9 → 0.3.11

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.js

@@ -1,80 +1,80 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 const resource_1 = require("../../resource");
-const numberIdList = ["1", "2", "3", "4", "5"];
+const numberIdList = ['1', '2', '3', '4', '5'];
 const nodeIdList = numberIdList.map((id) => `node-${id}`);
 const nodes = nodeIdList.map((nodeId) => {
     const workflowNodeExecute = async (params) => {
         const { variables: workflowNodeInputVariables } = params;
         const workflowNodeOutputVariables = workflowNodeInputVariables;
         const res = {
-            variables: workflowNodeOutputVariables,
+            variables: workflowNodeOutputVariables
         };
         return res;
     };
     let input;
     let output;
     switch (nodeId) {
-        case "node-1": {
+        case 'node-1': {
             input = {
-                type: "object",
+                type: 'object',
                 properties: {
                     hello: {
-                        type: "string",
-                        "x-expression": "hello",
-                    },
-                },
+                        type: 'string',
+                        'x-expression': 'hello'
+                    }
+                }
             };
             output = {
-                type: "object",
+                type: 'object',
                 properties: {
                     hello: {
-                        type: "string",
-                        "x-expression": "hello",
-                    },
-                },
+                        type: 'string',
+                        'x-expression': 'hello'
+                    }
+                }
             };
             break;
         }
-        case "node-5": {
+        case 'node-5': {
             input = {
-                type: "object",
+                type: 'object',
                 properties: {
                     hello: {
-                        type: "string",
-                        "x-expression": `$."node-1".hello`,
-                    },
-                },
+                        type: 'string',
+                        'x-expression': `$."node-1".hello`
+                    }
+                }
             };
             output = {
-                type: "object",
+                type: 'object',
                 properties: {
                     hello: {
-                        type: "string",
-                        "x-expression": "hello",
-                    },
-                },
+                        type: 'string',
+                        'x-expression': 'hello'
+                    }
+                }
             };
             break;
         }
         default: {
             input = {
-                type: "object",
+                type: 'object',
                 properties: {
                     hello: {
-                        type: "string",
-                        default: "other",
-                    },
-                },
+                        type: 'string',
+                        default: 'other'
+                    }
+                }
             };
             output = {
-                type: "object",
+                type: 'object',
                 properties: {
                     hello: {
-                        type: "string",
-                        default: "other",
-                    },
-                },
+                        type: 'string',
+                        default: 'other'
+                    }
+                }
             };
             break;
         }
@@ -82,39 +82,39 @@ const nodes = nodeIdList.map((nodeId) => {
     const res = {
         id: nodeId,
         propertiesSchema: {
-            type: "object",
+            type: 'object',
             properties: {
                 input,
-                output,
-            },
+                output
+            }
         },
-        execute: workflowNodeExecute,
+        execute: workflowNodeExecute
     };
     return res;
 });
 const workflowData = {
     edges: [
         {
-            sourceWorkflowNodeResourceId: "node-1",
-            targetWorkflowNodeResourceId: "node-2",
+            sourceWorkflowNodeResourceId: 'node-1',
+            targetWorkflowNodeResourceId: 'node-2'
         },
         {
-            sourceWorkflowNodeResourceId: "node-2",
-            targetWorkflowNodeResourceId: "node-3",
+            sourceWorkflowNodeResourceId: 'node-2',
+            targetWorkflowNodeResourceId: 'node-3'
         },
         {
-            sourceWorkflowNodeResourceId: "node-3",
-            targetWorkflowNodeResourceId: "node-4",
+            sourceWorkflowNodeResourceId: 'node-3',
+            targetWorkflowNodeResourceId: 'node-4'
         },
         {
-            sourceWorkflowNodeResourceId: "node-4",
-            targetWorkflowNodeResourceId: "node-5",
-        },
+            sourceWorkflowNodeResourceId: 'node-4',
+            targetWorkflowNodeResourceId: 'node-5'
+        }
     ],
-    nodes,
+    nodes
 };
 const getWorkflowDataRes = {
-    workflowData,
+    workflowData
 };
 class TestWorkflowResource extends resource_1.WorkflowResource {
     constructor() {
@@ -124,26 +124,27 @@ class TestWorkflowResource extends resource_1.WorkflowResource {
         };
     }
 }
-test("WorkflowResource execute", async () => {
+test('WorkflowResource execute', async () => {
     const testWorkflowResource = new TestWorkflowResource({
-        id: "test",
-        kind: "workflow",
-        parentId: "root",
+        id: 'test',
+        kind: 'workflow',
+        parentId: 'root',
         settings: {
-            title: "",
-            description: "",
-            startWorkflowNodeResourceId: "node-1",
-            endWorkflowNodeResourceId: "node-5",
-        },
+            title: '',
+            description: '',
+            startWorkflowNodeResourceId: 'node-1',
+            endWorkflowNodeResourceId: 'node-5'
+        }
     });
     const workflowInputVariables = {
-        hello: "world",
+        hello: 'world'
     };
     const workflowOutputVariables = {
-        hello: "world",
+        hello: 'world'
     };
     const { variables } = await testWorkflowResource.execute({
-        variables: workflowInputVariables,
+        context: {},
+        variables: workflowInputVariables
     });
     expect(variables).toMatchObject(workflowOutputVariables);
 });

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":""}