@fincity/kirun-js 2.16.0 → 2.16.2

package/__tests__/engine/function/system/MakeTest.ts

@@ -0,0 +1,317 @@
+import {
+    FunctionExecutionParameters,
+    KIRunFunctionRepository,
+    KIRunSchemaRepository,
+} from '../../../../src';
+import { Make } from '../../../../src/engine/function/system/Make';
+
+const make: Make = new Make();
+
+function createOutputMap(data: Record<string, any>): Map<string, Map<string, Map<string, any>>> {
+    return new Map([
+        [
+            'step1',
+            new Map([
+                [
+                    'output',
+                    new Map(Object.entries(data)),
+                ],
+            ]),
+        ],
+    ]);
+}
+
+test('test simple object with expression', async () => {
+    const source = { name: 'John', age: 30 };
+
+    const resultShape = {
+        fullName: '{{Steps.step1.output.source.name}}',
+        userAge: '{{Steps.step1.output.source.age}}',
+    };
+
+    const fep: FunctionExecutionParameters = new FunctionExecutionParameters(
+        new KIRunFunctionRepository(),
+        new KIRunSchemaRepository(),
+    );
+
+    fep.setArguments(new Map<string, any>([['resultShape', resultShape]]));
+    fep.setContext(new Map());
+    fep.setSteps(createOutputMap({ source }));
+
+    const result = await make.execute(fep);
+    const value = result.allResults()[0]?.getResult()?.get('value');
+
+    expect(value).toStrictEqual({
+        fullName: 'John',
+        userAge: 30,
+    });
+});
+
+test('test nested object with expressions', async () => {
+    const source = {
+        user: { firstName: 'John', lastName: 'Doe' },
+        address: { city: 'NYC', zip: '10001' },
+    };
+
+    const resultShape = {
+        person: {
+            name: '{{Steps.step1.output.source.user.firstName}}',
+            surname: '{{Steps.step1.output.source.user.lastName}}',
+        },
+        location: {
+            cityName: '{{Steps.step1.output.source.address.city}}',
+            postalCode: '{{Steps.step1.output.source.address.zip}}',
+        },
+    };
+
+    const fep: FunctionExecutionParameters = new FunctionExecutionParameters(
+        new KIRunFunctionRepository(),
+        new KIRunSchemaRepository(),
+    );
+
+    fep.setArguments(new Map<string, any>([['resultShape', resultShape]]));
+    fep.setContext(new Map());
+    fep.setSteps(createOutputMap({ source }));
+
+    const result = await make.execute(fep);
+    const value = result.allResults()[0]?.getResult()?.get('value');
+
+    expect(value).toStrictEqual({
+        person: {
+            name: 'John',
+            surname: 'Doe',
+        },
+        location: {
+            cityName: 'NYC',
+            postalCode: '10001',
+        },
+    });
+});
+
+test('test array with expressions', async () => {
+    const source = {
+        items: ['apple', 'banana', 'cherry'],
+    };
+
+    const resultShape = {
+        fruits: [
+            '{{Steps.step1.output.source.items[0]}}',
+            '{{Steps.step1.output.source.items[1]}}',
+            '{{Steps.step1.output.source.items[2]}}',
+        ],
+    };
+
+    const fep: FunctionExecutionParameters = new FunctionExecutionParameters(
+        new KIRunFunctionRepository(),
+        new KIRunSchemaRepository(),
+    );
+
+    fep.setArguments(new Map<string, any>([['resultShape', resultShape]]));
+    fep.setContext(new Map());
+    fep.setSteps(createOutputMap({ source }));
+
+    const result = await make.execute(fep);
+    const value = result.allResults()[0]?.getResult()?.get('value');
+
+    expect(value).toStrictEqual({
+        fruits: ['apple', 'banana', 'cherry'],
+    });
+});
+
+test('test deeply nested structure with arrays', async () => {
+    const source = {
+        data: {
+            users: [
+                { id: 1, name: 'Alice' },
+                { id: 2, name: 'Bob' },
+            ],
+        },
+    };
+
+    const resultShape = {
+        level1: {
+            level2: {
+                level3: {
+                    userList: [
+                        {
+                            userId: '{{Steps.step1.output.source.data.users[0].id}}',
+                            userName: '{{Steps.step1.output.source.data.users[0].name}}',
+                        },
+                        {
+                            userId: '{{Steps.step1.output.source.data.users[1].id}}',
+                            userName: '{{Steps.step1.output.source.data.users[1].name}}',
+                        },
+                    ],
+                },
+            },
+        },
+    };
+
+    const fep: FunctionExecutionParameters = new FunctionExecutionParameters(
+        new KIRunFunctionRepository(),
+        new KIRunSchemaRepository(),
+    );
+
+    fep.setArguments(new Map<string, any>([['resultShape', resultShape]]));
+    fep.setContext(new Map());
+    fep.setSteps(createOutputMap({ source }));
+
+    const result = await make.execute(fep);
+    const value = result.allResults()[0]?.getResult()?.get('value');
+
+    expect(value).toStrictEqual({
+        level1: {
+            level2: {
+                level3: {
+                    userList: [
+                        { userId: 1, userName: 'Alice' },
+                        { userId: 2, userName: 'Bob' },
+                    ],
+                },
+            },
+        },
+    });
+});
+
+test('test mixed static and dynamic values', async () => {
+    const source = { dynamicValue: 'from source' };
+
+    const resultShape = {
+        static: 'static string',
+        dynamic: '{{Steps.step1.output.source.dynamicValue}}',
+        nested: {
+            staticNum: 42,
+            dynamicNum: '{{Steps.step1.output.source.dynamicValue}}',
+        },
+        array: ['static', '{{Steps.step1.output.source.dynamicValue}}', 123],
+    };
+
+    const fep: FunctionExecutionParameters = new FunctionExecutionParameters(
+        new KIRunFunctionRepository(),
+        new KIRunSchemaRepository(),
+    );
+
+    fep.setArguments(new Map<string, any>([['resultShape', resultShape]]));
+    fep.setContext(new Map());
+    fep.setSteps(createOutputMap({ source }));
+
+    const result = await make.execute(fep);
+    const value = result.allResults()[0]?.getResult()?.get('value');
+
+    expect(value).toStrictEqual({
+        static: 'static string',
+        dynamic: 'from source',
+        nested: {
+            staticNum: 42,
+            dynamicNum: 'from source',
+        },
+        array: ['static', 'from source', 123],
+    });
+});
+
+test('test null and undefined handling', async () => {
+    const resultShape = {
+        nullValue: null,
+        nested: {
+            inner: null,
+        },
+    };
+
+    const fep: FunctionExecutionParameters = new FunctionExecutionParameters(
+        new KIRunFunctionRepository(),
+        new KIRunSchemaRepository(),
+    );
+
+    fep.setArguments(new Map<string, any>([['resultShape', resultShape]]));
+    fep.setContext(new Map());
+    fep.setSteps(new Map());
+
+    const result = await make.execute(fep);
+    const value = result.allResults()[0]?.getResult()?.get('value');
+
+    expect(value).toStrictEqual({
+        nullValue: null,
+        nested: {
+            inner: null,
+        },
+    });
+});
+
+test('test array of arrays', async () => {
+    const source = {
+        matrix: [
+            [1, 2],
+            [3, 4],
+        ],
+    };
+
+    const resultShape = {
+        grid: [
+            ['{{Steps.step1.output.source.matrix[0][0]}}', '{{Steps.step1.output.source.matrix[0][1]}}'],
+            ['{{Steps.step1.output.source.matrix[1][0]}}', '{{Steps.step1.output.source.matrix[1][1]}}'],
+        ],
+    };
+
+    const fep: FunctionExecutionParameters = new FunctionExecutionParameters(
+        new KIRunFunctionRepository(),
+        new KIRunSchemaRepository(),
+    );
+
+    fep.setArguments(new Map<string, any>([['resultShape', resultShape]]));
+    fep.setContext(new Map());
+    fep.setSteps(createOutputMap({ source }));
+
+    const result = await make.execute(fep);
+    const value = result.allResults()[0]?.getResult()?.get('value');
+
+    expect(value).toStrictEqual({
+        grid: [
+            [1, 2],
+            [3, 4],
+        ],
+    });
+});
+
+test('test primitive result shape', async () => {
+    const source = { value: 'hello' };
+
+    const resultShape = '{{Steps.step1.output.source.value}}';
+
+    const fep: FunctionExecutionParameters = new FunctionExecutionParameters(
+        new KIRunFunctionRepository(),
+        new KIRunSchemaRepository(),
+    );
+
+    fep.setArguments(new Map<string, any>([['resultShape', resultShape]]));
+    fep.setContext(new Map());
+    fep.setSteps(createOutputMap({ source }));
+
+    const result = await make.execute(fep);
+    const value = result.allResults()[0]?.getResult()?.get('value');
+
+    expect(value).toBe('hello');
+});
+
+test('test array as root result shape', async () => {
+    const source = { a: 1, b: 2, c: 3 };
+
+    const resultShape = [
+        '{{Steps.step1.output.source.a}}',
+        '{{Steps.step1.output.source.b}}',
+        '{{Steps.step1.output.source.c}}',
+    ];
+
+    const fep: FunctionExecutionParameters = new FunctionExecutionParameters(
+        new KIRunFunctionRepository(),
+        new KIRunSchemaRepository(),
+    );
+
+    fep.setArguments(new Map<string, any>([['resultShape', resultShape]]));
+    fep.setContext(new Map());
+    fep.setSteps(createOutputMap({ source }));
+
+    const result = await make.execute(fep);
+    const value = result.allResults()[0]?.getResult()?.get('value');
+
+    expect(value).toStrictEqual([1, 2, 3]);
+});

package/__tests__/engine/runtime/expression/ExpressionEvaluatorBracketNotationTest.ts

@@ -0,0 +1,282 @@
+import { ExpressionEvaluator } from '../../../../src/engine/runtime/expression/ExpressionEvaluator';
+import { TokenValueExtractor } from '../../../../src/engine/runtime/expression/tokenextractor/TokenValueExtractor';
+
+class TestExtractor extends TokenValueExtractor {
+    private data: any;
+
+    constructor(data: any) {
+        super();
+        this.data = data;
+    }
+
+    protected getValueInternal(token: string): any {
+        const prefix = this.getPrefix();
+        const path = token.substring(prefix.length);
+        const parts = TokenValueExtractor['splitPath'](path);
+        return this.retrieveElementFrom(token, parts, 0, this.data);
+    }
+
+    public getPrefix(): string {
+        return 'Context.';
+    }
+
+    public getStore(): any {
+        return this.data;
+    }
+
+    // Expose retrieveElementFrom for testing
+    public retrieveElementFrom(
+        token: string,
+        parts: string[],
+        partNumber: number,
+        jsonElement: any,
+    ): any {
+        return super.retrieveElementFrom(token, parts, partNumber, jsonElement);
+    }
+}
+
+describe('ExpressionEvaluator with Bracket Notation', () => {
+    let testData: any;
+    let extractor: TestExtractor;
+    let evaluatorMap: Map<string, TokenValueExtractor>;
+
+    beforeEach(() => {
+        testData = {
+            obj: {
+                'mail.props.port': 587,
+                'mail.props.host': 'smtp.example.com',
+                'api.key.secret': 'secret123',
+                simple: 'value',
+                count: 100,
+            },
+            arr: [10, 20, 30, 40, 50],
+            nested: {
+                'field.with.dots': 'nestedValue',
+                regular: 'regularValue',
+            },
+        };
+        extractor = new TestExtractor(testData);
+        evaluatorMap = new Map([['Context.', extractor]]);
+    });
+
+    describe('Basic bracket notation with dotted keys', () => {
+        test('should access property with double quotes', () => {
+            const result = new ExpressionEvaluator('Context.obj["mail.props.port"]').evaluate(
+                evaluatorMap,
+            );
+            expect(result).toBe(587);
+        });
+
+        test('should access property with single quotes', () => {
+            const result = new ExpressionEvaluator("Context.obj['mail.props.host']").evaluate(
+                evaluatorMap,
+            );
+            expect(result).toBe('smtp.example.com');
+        });
+
+        test('should access nested property with dotted key', () => {
+            const result = new ExpressionEvaluator(
+                "Context.nested['field.with.dots']",
+            ).evaluate(evaluatorMap);
+            expect(result).toBe('nestedValue');
+        });
+    });
+
+    describe('Comparison operators with bracket notation', () => {
+        test('should work with equality operator (=)', () => {
+            const result = new ExpressionEvaluator(
+                'Context.obj["mail.props.port"] = 587',
+            ).evaluate(evaluatorMap);
+            expect(result).toBe(true);
+        });
+
+        test('should work with not equal operator (!=)', () => {
+            const result = new ExpressionEvaluator(
+                'Context.obj["mail.props.port"] != 500',
+            ).evaluate(evaluatorMap);
+            expect(result).toBe(true);
+        });
+
+        test('should work with greater than operator (>)', () => {
+            const result = new ExpressionEvaluator(
+                'Context.obj["mail.props.port"] > 500',
+            ).evaluate(evaluatorMap);
+            expect(result).toBe(true);
+        });
+
+        test('should work with greater than or equal operator (>=)', () => {
+            const result = new ExpressionEvaluator(
+                'Context.obj["mail.props.port"] >= 587',
+            ).evaluate(evaluatorMap);
+            expect(result).toBe(true);
+        });
+
+        test('should work with less than operator (<)', () => {
+            const result = new ExpressionEvaluator(
+                'Context.obj["mail.props.port"] < 600',
+            ).evaluate(evaluatorMap);
+            expect(result).toBe(true);
+        });
+
+        test('should work with less than or equal operator (<=)', () => {
+            const result = new ExpressionEvaluator(
+                'Context.obj["mail.props.port"] <= 587',
+            ).evaluate(evaluatorMap);
+            expect(result).toBe(true);
+        });
+    });
+
+    describe('Arithmetic operators with bracket notation', () => {
+        test('should work with addition', () => {
+            const result = new ExpressionEvaluator(
+                'Context.obj["mail.props.port"] + 13',
+            ).evaluate(evaluatorMap);
+            expect(result).toBe(600);
+        });
+
+        test('should work with subtraction', () => {
+            const result = new ExpressionEvaluator(
+                'Context.obj["mail.props.port"] - 87',
+            ).evaluate(evaluatorMap);
+            expect(result).toBe(500);
+        });
+
+        test('should work with multiplication', () => {
+            const result = new ExpressionEvaluator('Context.obj["count"] * 2').evaluate(
+                evaluatorMap,
+            );
+            expect(result).toBe(200);
+        });
+
+        test('should work with division', () => {
+            const result = new ExpressionEvaluator('Context.obj["count"] / 4').evaluate(
+                evaluatorMap,
+            );
+            expect(result).toBe(25);
+        });
+    });
+
+    describe('Ternary operator with bracket notation', () => {
+        test('should work with ternary operator', () => {
+            const result = new ExpressionEvaluator(
+                'Context.obj["mail.props.port"] > 500 ? "high" : "low"',
+            ).evaluate(evaluatorMap);
+            expect(result).toBe('high');
+        });
+
+        test('should return false branch of ternary', () => {
+            const result = new ExpressionEvaluator(
+                'Context.obj["mail.props.port"] < 500 ? "high" : "low"',
+            ).evaluate(evaluatorMap);
+            expect(result).toBe('low');
+        });
+    });
+
+    describe('Logical operators with bracket notation', () => {
+        test('should work with logical AND', () => {
+            const result = new ExpressionEvaluator(
+                'Context.obj["mail.props.port"] > 500 and Context.obj["count"] = 100',
+            ).evaluate(evaluatorMap);
+            expect(result).toBe(true);
+        });
+
+        test('should work with logical OR', () => {
+            const result = new ExpressionEvaluator(
+                'Context.obj["mail.props.port"] < 500 or Context.obj["count"] = 100',
+            ).evaluate(evaluatorMap);
+            expect(result).toBe(true);
+        });
+
+        test('should work with logical NOT', () => {
+            const result = new ExpressionEvaluator(
+                'not Context.obj["mail.props.port"] < 500',
+            ).evaluate(evaluatorMap);
+            expect(result).toBe(true);
+        });
+    });
+
+    describe('Mixed bracket and dot notation', () => {
+        test('should work with bracket notation followed by dot notation', () => {
+            testData.obj['mail.props.port'] = { subfield: 'subvalue' };
+            const result = new ExpressionEvaluator(
+                'Context.obj["mail.props.port"].subfield',
+            ).evaluate(evaluatorMap);
+            expect(result).toBe('subvalue');
+        });
+
+        test('should work with dot notation followed by bracket notation', () => {
+            const result = new ExpressionEvaluator(
+                "Context.nested['field.with.dots']",
+            ).evaluate(evaluatorMap);
+            expect(result).toBe('nestedValue');
+        });
+    });
+
+    describe('Array bracket notation (pre-existing functionality)', () => {
+        test('should work with array index access', () => {
+            const result = new ExpressionEvaluator('Context.arr[0]').evaluate(evaluatorMap);
+            expect(result).toBe(10);
+        });
+
+        test('should work with array index and comparison', () => {
+            const result = new ExpressionEvaluator('Context.arr[0] = 10').evaluate(
+                evaluatorMap,
+            );
+            expect(result).toBe(true);
+        });
+
+        test('should work with array index and arithmetic', () => {
+            const result = new ExpressionEvaluator('Context.arr[1] + Context.arr[2]').evaluate(
+                evaluatorMap,
+            );
+            expect(result).toBe(50);
+        });
+    });
+
+    describe('Complex expressions', () => {
+        test('should work with multiple bracket notations in one expression', () => {
+            const result = new ExpressionEvaluator(
+                'Context.obj["mail.props.port"] + Context.obj["count"]',
+            ).evaluate(evaluatorMap);
+            expect(result).toBe(687);
+        });
+
+        test('should work with bracket notation in nested expression', () => {
+            const result = new ExpressionEvaluator(
+                '(Context.obj["mail.props.port"] > 500) and (Context.obj["count"] < 200)',
+            ).evaluate(evaluatorMap);
+            expect(result).toBe(true);
+        });
+
+        test('should work with string concatenation', () => {
+            const result = new ExpressionEvaluator(
+                'Context.obj["mail.props.host"] + ":587"',
+            ).evaluate(evaluatorMap);
+            expect(result).toBe('smtp.example.com:587');
+        });
+    });
+
+    describe('Edge cases', () => {
+        test('should handle property with multiple dots', () => {
+            testData.obj['a.b.c.d'] = 'deepValue';
+            const result = new ExpressionEvaluator('Context.obj["a.b.c.d"]').evaluate(
+                evaluatorMap,
+            );
+            expect(result).toBe('deepValue');
+        });
+
+        test('should handle empty string key (though unusual)', () => {
+            testData.obj[''] = 'emptyKey';
+            const result = new ExpressionEvaluator('Context.obj[""]').evaluate(evaluatorMap);
+            expect(result).toBe('emptyKey');
+        });
+
+        test('should handle key with special characters', () => {
+            testData.obj['key@#$%'] = 'specialValue';
+            const result = new ExpressionEvaluator('Context.obj["key@#$%"]').evaluate(
+                evaluatorMap,
+            );
+            expect(result).toBe('specialValue');
+        });
+    });
+});

package/__tests__/engine/runtime/expression/ExpressionTest.ts

@@ -37,3 +37,31 @@ test('Expression Test', () => {
     opInTheName = new Expression('Store.a.b.corStore.c.d.x');
     expect(opInTheName.toString()).toBe('(Store.(a.(b.(corStore.(c.(d.x))))))');
 });
+
+test('Expression with bracket notation and quoted keys', () => {
+    // Test bracket notation with quoted keys containing dots
+    let expr = new Expression('Context.obj["mail.props.port"]');
+    expect(expr.toString()).toBe('(Context.(obj["mail.props.port"]))');
+
+    // Test with single quotes
+    expr = new Expression("Context.obj['api.key.secret']");
+    expect(expr.toString()).toBe("(Context.(obj['api.key.secret']))");
+
+    // Test with comparison operators
+    expr = new Expression('Context.obj["mail.props.port"] = 587');
+    expect(expr.toString()).toBe('((Context.(obj["mail.props.port"]))=587)');
+
+    expr = new Expression('Context.obj["mail.props.port"] != 500');
+    expect(expr.toString()).toBe('((Context.(obj["mail.props.port"]))!=500)');
+
+    expr = new Expression('Context.obj["mail.props.port"] > 500');
+    expect(expr.toString()).toBe('((Context.(obj["mail.props.port"]))>500)');
+
+    // Test with ternary operator
+    expr = new Expression('Context.obj["mail.props.port"] > 500 ? "high" : "low"');
+    expect(expr.toString()).toBe('(((Context.(obj["mail.props.port"]))>500)?"high":"low")');
+
+    // Test mix of bracket and dot notation
+    expr = new Expression('Context.obj["mail.props.port"].value');
+    expect(expr.toString()).toBe('(Context.(obj["mail.props.port"].value))');
+});