@fincity/kirun-js 3.3.0 → 3.5.0

package/__tests__/engine/function/system/array/ReverseTest.ts

@@ -197,6 +197,90 @@ test('Rev test 4', async () => {
     expect((await rev.execute(fep)).allResults()[0].getResult().get('result')).toMatchObject(res1);
 });
 
+test('Reverse test - full array reverse with len -1', async () => {
+    let src: any[] = [1, 2, 3, 4, 5];
+
+    let fep: FunctionExecutionParameters = new FunctionExecutionParameters(
+        new KIRunFunctionRepository(),
+        new KIRunSchemaRepository(),
+    )
+        .setArguments(
+            new Map<string, any>([
+                [Reverse.PARAMETER_ARRAY_SOURCE.getParameterName(), src],
+                [Reverse.PARAMETER_INT_SOURCE_FROM.getParameterName(), 0],
+                [Reverse.PARAMETER_INT_LENGTH.getParameterName(), -1],
+            ]),
+        )
+        .setContext(new Map([]))
+        .setSteps(new Map([]));
+
+    let res = [5, 4, 3, 2, 1];
+    expect((await rev.execute(fep)).allResults()[0].getResult().get('result')).toStrictEqual(res);
+});
+
+test('Reverse test - full array reverse with explicit length', async () => {
+    let src: any[] = ['a', 'b', 'c', 'd'];
+
+    let fep: FunctionExecutionParameters = new FunctionExecutionParameters(
+        new KIRunFunctionRepository(),
+        new KIRunSchemaRepository(),
+    )
+        .setArguments(
+            new Map<string, any>([
+                [Reverse.PARAMETER_ARRAY_SOURCE.getParameterName(), src],
+                [Reverse.PARAMETER_INT_SOURCE_FROM.getParameterName(), 0],
+                [Reverse.PARAMETER_INT_LENGTH.getParameterName(), 4],
+            ]),
+        )
+        .setContext(new Map([]))
+        .setSteps(new Map([]));
+
+    let res = ['d', 'c', 'b', 'a'];
+    expect((await rev.execute(fep)).allResults()[0].getResult().get('result')).toStrictEqual(res);
+});
+
+test('Reverse test - single element array', async () => {
+    let src: any[] = [42];
+
+    let fep: FunctionExecutionParameters = new FunctionExecutionParameters(
+        new KIRunFunctionRepository(),
+        new KIRunSchemaRepository(),
+    )
+        .setArguments(
+            new Map<string, any>([
+                [Reverse.PARAMETER_ARRAY_SOURCE.getParameterName(), src],
+                [Reverse.PARAMETER_INT_SOURCE_FROM.getParameterName(), 0],
+                [Reverse.PARAMETER_INT_LENGTH.getParameterName(), -1],
+            ]),
+        )
+        .setContext(new Map([]))
+        .setSteps(new Map([]));
+
+    let res = [42];
+    expect((await rev.execute(fep)).allResults()[0].getResult().get('result')).toStrictEqual(res);
+});
+
+test('Reverse test - full reverse from non-zero start', async () => {
+    let src: any[] = [1, 2, 3, 4, 5];
+
+    let fep: FunctionExecutionParameters = new FunctionExecutionParameters(
+        new KIRunFunctionRepository(),
+        new KIRunSchemaRepository(),
+    )
+        .setArguments(
+            new Map<string, any>([
+                [Reverse.PARAMETER_ARRAY_SOURCE.getParameterName(), src],
+                [Reverse.PARAMETER_INT_SOURCE_FROM.getParameterName(), 0],
+                [Reverse.PARAMETER_INT_LENGTH.getParameterName(), 5],
+            ]),
+        )
+        .setContext(new Map([]))
+        .setSteps(new Map([]));
+
+    let res = [5, 4, 3, 2, 1];
+    expect((await rev.execute(fep)).allResults()[0].getResult().get('result')).toStrictEqual(res);
+});
+
 test('rev test 5', async () => {
     let arr: any[] = [];
     arr.push('a');

package/__tests__/engine/function/system/string/ReverseTest.ts

@@ -32,12 +32,57 @@ test('reverse test2', async () => {
     expect((await reve.execute(fep)).allResults()[0].getResult().get('value')).toBe(reveresed);
 });
 
-// test('reverse test3', async () => {
-//     let fep: FunctionExecutionParameters = new FunctionExecutionParameters(new KIRunFunctionRepository(), new KIRunSchemaRepository());
+test('reverse test - empty string', async () => {
+    let fep: FunctionExecutionParameters = new FunctionExecutionParameters(
+        new KIRunFunctionRepository(),
+        new KIRunSchemaRepository(),
+    );
+
+    fep.setArguments(MapUtil.of('value', ''));
+
+    expect((await reve.execute(fep)).allResults()[0].getResult().get('value')).toBe('');
+});
+
+test('reverse test - single character', async () => {
+    let fep: FunctionExecutionParameters = new FunctionExecutionParameters(
+        new KIRunFunctionRepository(),
+        new KIRunSchemaRepository(),
+    );
+
+    fep.setArguments(MapUtil.of('value', 'a'));
+
+    expect((await reve.execute(fep)).allResults()[0].getResult().get('value')).toBe('a');
+});
+
+test('reverse test - palindrome', async () => {
+    let fep: FunctionExecutionParameters = new FunctionExecutionParameters(
+        new KIRunFunctionRepository(),
+        new KIRunSchemaRepository(),
+    );
+
+    fep.setArguments(MapUtil.of('value', 'racecar'));
+
+    expect((await reve.execute(fep)).allResults()[0].getResult().get('value')).toBe('racecar');
+});
+
+test('reverse test - special characters', async () => {
+    let fep: FunctionExecutionParameters = new FunctionExecutionParameters(
+        new KIRunFunctionRepository(),
+        new KIRunSchemaRepository(),
+    );
 
-//     fep.setArguments(MapUtil.of('value', null));
+    fep.setArguments(MapUtil.of('value', '!@#$%'));
 
-//     let reveresed: string = ' ';
+    expect((await reve.execute(fep)).allResults()[0].getResult().get('value')).toBe('%$#@!');
+});
 
-//     expect((await reve.execute(fep)).allResults()[0].getResult().get('value')).toBe(reveresed);
-// });
+test('reverse test - numbers in string', async () => {
+    let fep: FunctionExecutionParameters = new FunctionExecutionParameters(
+        new KIRunFunctionRepository(),
+        new KIRunSchemaRepository(),
+    );
+
+    fep.setArguments(MapUtil.of('value', '12345'));
+
+    expect((await reve.execute(fep)).allResults()[0].getResult().get('value')).toBe('54321');
+});

package/__tests__/engine/runtime/KIRuntimeParallelTest.ts

@@ -0,0 +1,200 @@
+import {
+    Function,
+    FunctionDefinition,
+    HybridRepository,
+    KIRunFunctionRepository,
+    Repository,
+    KIRuntime,
+    FunctionExecutionParameters,
+    KIRunSchemaRepository,
+} from '../../../src';
+
+const oldLog = console.log;
+
+test('KIRuntime parallel execution waits for all paths to complete', async () => {
+    // 3 separate functions, one per parallel path:
+    //   Path1: Wait 2000ms -> Print "2000 Finished"
+    //   Path2: Wait 3000ms -> Print "3000 Finished"
+    //   Path3: Print "Without Time Finished" (instant)
+    //
+    // Main function calls all 3 in parallel and should wait for all to complete.
+
+    const path1 = new KIRuntime(
+        FunctionDefinition.from(
+            JSON.parse(`{
+                "name": "Path1",
+                "namespace": "Internal",
+                "events": {
+                    "output": { "name": "output", "parameters": {} }
+                },
+                "steps": {
+                    "wait": {
+                        "statementName": "wait",
+                        "namespace": "System",
+                        "name": "Wait",
+                        "parameterMap": {
+                            "millis": { "one": { "key": "one", "type": "VALUE", "value": 2000 } }
+                        }
+                    },
+                    "print": {
+                        "statementName": "print",
+                        "namespace": "System",
+                        "name": "Print",
+                        "parameterMap": {
+                            "values": { "one": { "key": "one", "type": "VALUE", "value": "2000 Finished" } }
+                        },
+                        "dependentStatements": { "Steps.wait.output": true }
+                    },
+                    "genOutput": {
+                        "statementName": "genOutput",
+                        "namespace": "System",
+                        "name": "GenerateEvent",
+                        "dependentStatements": { "Steps.print.output": true },
+                        "parameterMap": {
+                            "eventName": { "one": { "key": "one", "type": "VALUE", "value": "output" } }
+                        }
+                    }
+                }
+            }`),
+        ),
+    );
+
+    const path2 = new KIRuntime(
+        FunctionDefinition.from(
+            JSON.parse(`{
+                "name": "Path2",
+                "namespace": "Internal",
+                "events": {
+                    "output": { "name": "output", "parameters": {} }
+                },
+                "steps": {
+                    "wait": {
+                        "statementName": "wait",
+                        "namespace": "System",
+                        "name": "Wait",
+                        "parameterMap": {
+                            "millis": { "one": { "key": "one", "type": "VALUE", "value": 3000 } }
+                        }
+                    },
+                    "print": {
+                        "statementName": "print",
+                        "namespace": "System",
+                        "name": "Print",
+                        "parameterMap": {
+                            "values": { "one": { "key": "one", "type": "VALUE", "value": "3000 Finished" } }
+                        },
+                        "dependentStatements": { "Steps.wait.output": true }
+                    },
+                    "genOutput": {
+                        "statementName": "genOutput",
+                        "namespace": "System",
+                        "name": "GenerateEvent",
+                        "dependentStatements": { "Steps.print.output": true },
+                        "parameterMap": {
+                            "eventName": { "one": { "key": "one", "type": "VALUE", "value": "output" } }
+                        }
+                    }
+                }
+            }`),
+        ),
+    );
+
+    const path3 = new KIRuntime(
+        FunctionDefinition.from(
+            JSON.parse(`{
+                "name": "Path3",
+                "namespace": "Internal",
+                "events": {
+                    "output": { "name": "output", "parameters": {} }
+                },
+                "steps": {
+                    "print": {
+                        "statementName": "print",
+                        "namespace": "System",
+                        "name": "Print",
+                        "parameterMap": {
+                            "values": { "one": { "key": "one", "type": "VALUE", "value": "Without Time Finished" } }
+                        }
+                    },
+                    "genOutput": {
+                        "statementName": "genOutput",
+                        "namespace": "System",
+                        "name": "GenerateEvent",
+                        "dependentStatements": { "Steps.print.output": true },
+                        "parameterMap": {
+                            "eventName": { "one": { "key": "one", "type": "VALUE", "value": "output" } }
+                        }
+                    }
+                }
+            }`),
+        ),
+    );
+
+    // Main function calls all 3 paths in parallel
+    const mainDef = FunctionDefinition.from({
+        name: 'TestParallel',
+        namespace: 'UIApp',
+
+        steps: {
+            exPath1: {
+                statementName: 'exPath1',
+                name: 'Path1',
+                namespace: 'Internal',
+                parameterMap: {},
+            },
+            exPath2: {
+                statementName: 'exPath2',
+                name: 'Path2',
+                namespace: 'Internal',
+                parameterMap: {},
+            },
+            exPath3: {
+                statementName: 'exPath3',
+                name: 'Path3',
+                namespace: 'Internal',
+                parameterMap: {},
+            },
+        },
+    });
+
+    class InternalRepository implements Repository<Function> {
+        async find(namespace: string, name: string): Promise<Function | undefined> {
+            if (namespace !== 'Internal') return undefined;
+            if (name === 'Path1') return path1;
+            if (name === 'Path2') return path2;
+            if (name === 'Path3') return path3;
+            return undefined;
+        }
+
+        async filter(name: string): Promise<string[]> {
+            return [
+                path1.getSignature().getFullName(),
+                path2.getSignature().getFullName(),
+                path3.getSignature().getFullName(),
+            ].filter((e) => e.toLowerCase().includes(name.toLowerCase()));
+        }
+    }
+
+    const repo = new HybridRepository(new KIRunFunctionRepository(), new InternalRepository());
+    const mock = jest.spyOn(global.console, 'log').mockImplementation(oldLog);
+
+    const startTime = Date.now();
+
+    await new KIRuntime(mainDef, false).execute(
+        new FunctionExecutionParameters(repo, new KIRunSchemaRepository()),
+    );
+
+    const elapsed = Date.now() - startTime;
+
+    // All 3 print statements should have been called
+    expect(mock).toHaveBeenCalledTimes(3);
+    expect(mock).toHaveBeenCalledWith('Without Time Finished');
+    expect(mock).toHaveBeenCalledWith('2000 Finished');
+    expect(mock).toHaveBeenCalledWith('3000 Finished');
+
+    // Execution should have waited for the longest path (3000ms).
+    // If parallel execution finishes early (before all paths), elapsed would be < 2000ms.
+    expect(elapsed).toBeGreaterThanOrEqual(2000);
+
+    mock.mockRestore();
+}, 15000);

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

@@ -0,0 +1,84 @@
+import {
+    ExpressionEvaluator,
+    KIRunSchemaRepository,
+    FunctionExecutionParameters,
+    KIRunFunctionRepository,
+} from '../../../../src';
+
+// Reproduces the sitezump buyTokens status-filter chip label expression.
+//
+// Kirun's equality operator is '=' (Operation.EQUAL = new Operation('=')),
+// NOT '=='. Writing '==' makes the lexer read two consecutive '=' tokens,
+// which leaves a dangling operator and throws "Extra operator ... found."
+// This is exactly the error reported on the chip label.
+
+let inMap: Map<string, any> = new Map();
+inMap.set('status', 'PAID'); // Page.invoiceQuery.status equivalent (active)
+inMap.set('emptyStatus', ''); // Page.invoiceQuery.status when "All" (inactive)
+inMap.set('value', 'PAID'); // Parent.value equivalent
+inMap.set('label', 'Paid'); // Parent.label equivalent
+
+let output: Map<string, Map<string, Map<string, any>>> = new Map([
+    ['step1', new Map([['output', inMap]])],
+]);
+
+let parameters: FunctionExecutionParameters = new FunctionExecutionParameters(
+    new KIRunFunctionRepository(),
+    new KIRunSchemaRepository(),
+)
+    .setArguments(new Map())
+    .setSteps(output);
+
+test('Double-equals (==) is not a valid Kirun operator and throws', () => {
+    const expr = new ExpressionEvaluator(
+        "((Steps.step1.output.status ?? '') == Steps.step1.output.value ? '● ' : '') + Steps.step1.output.label",
+    );
+    expect(() => expr.evaluate(parameters.getValuesMap())).toThrow();
+});
+
+test('Single-equals (=) evaluates the chip label correctly', () => {
+    // active chip: status = value -> prefixed with the bullet
+    let expr = new ExpressionEvaluator(
+        "((Steps.step1.output.status ?? '') = Steps.step1.output.value ? '● ' : '') + Steps.step1.output.label",
+    );
+    expect(expr.evaluate(parameters.getValuesMap())).toBe('● Paid');
+
+    // inactive chip: emptyStatus (All) != value -> no prefix
+    expr = new ExpressionEvaluator(
+        "((Steps.step1.output.emptyStatus ?? '') = Steps.step1.output.value ? '● ' : '') + Steps.step1.output.label",
+    );
+    expect(expr.evaluate(parameters.getValuesMap())).toBe('Paid');
+});
+
+// Investigating Kiran's hypothesis: does an expression that ENDS with a string
+// literal (like the original chip label that ended in '') need a trailing space?
+test('Expression ending in a string literal: trailing space should not matter', () => {
+    // exact shape Kiran quoted, ending in '' — no trailing space
+    let noTrail = new ExpressionEvaluator(
+        "(Steps.step1.output.status ?? '') = Steps.step1.output.value ? '● ' : ''",
+    );
+    expect(noTrail.evaluate(parameters.getValuesMap())).toBe('● ');
+
+    // same, WITH a trailing space
+    let withTrail = new ExpressionEvaluator(
+        "(Steps.step1.output.status ?? '') = Steps.step1.output.value ? '● ' : '' ",
+    );
+    expect(withTrail.evaluate(parameters.getValuesMap())).toBe('● ');
+});
+
+test('Bare string literals at end of expression, with/without trailing space', () => {
+    expect(new ExpressionEvaluator("'hello'").evaluate(parameters.getValuesMap())).toBe('hello');
+    expect(new ExpressionEvaluator("'hello' ").evaluate(parameters.getValuesMap())).toBe('hello');
+    expect(new ExpressionEvaluator("''").evaluate(parameters.getValuesMap())).toBe('');
+    expect(new ExpressionEvaluator("'' ").evaluate(parameters.getValuesMap())).toBe('');
+});
+
+// Kiran's platform example: a {{ }} template that expands to a bare quoted string
+// literal followed by trailing spaces. Before the fix this evaluated to undefined,
+// which would have made e.g. a FetchData url resolve to undefined.
+test('Template expanding to a quoted literal with trailing spaces resolves (not undefined)', () => {
+    const expr = new ExpressionEvaluator(
+        '"api/ui/personalization/{{Steps.step1.output.label}}/{{Steps.step1.output.value}}"  ',
+    );
+    expect(expr.evaluate(parameters.getValuesMap())).toBe('api/ui/personalization/Paid/PAID');
+});