@fincity/kirun-js 1.6.17 → 1.8.0

package/src/engine/function/system/loop/ForEachLoop.ts

@@ -0,0 +1,70 @@
+import { Schema } from '../../../json/schema/Schema';
+import { SchemaType } from '../../../json/schema/type/SchemaType';
+import { Event } from '../../../model/Event';
+import { EventResult } from '../../../model/EventResult';
+import { FunctionOutput } from '../../../model/FunctionOutput';
+import { FunctionSignature } from '../../../model/FunctionSignature';
+import { Parameter } from '../../../model/Parameter';
+import { Namespaces } from '../../../namespaces/Namespaces';
+import { FunctionExecutionParameters } from '../../../runtime/FunctionExecutionParameters';
+import { AbstractFunction } from '../../AbstractFunction';
+
+const SOURCE = 'source';
+const EACH = 'each';
+const INDEX = 'index';
+const VALUE = 'value';
+
+const SIGNATURE = new FunctionSignature('ForEachLoop')
+    .setNamespace(Namespaces.SYSTEM_LOOP)
+    .setParameters(
+        new Map([Parameter.ofEntry(SOURCE, Schema.ofArray(SOURCE, Schema.ofAny(SOURCE)))]),
+    )
+    .setEvents(
+        new Map([
+            Event.eventMapEntry(
+                Event.ITERATION,
+                new Map([
+                    [INDEX, Schema.of(INDEX, SchemaType.INTEGER)],
+                    [EACH, Schema.ofAny(EACH)],
+                ]),
+            ),
+            Event.outputEventMapEntry(new Map([[VALUE, Schema.of(VALUE, SchemaType.INTEGER)]])),
+        ]),
+    );
+
+export class ForEachLoop extends AbstractFunction {
+    public getSignature(): FunctionSignature {
+        return SIGNATURE;
+    }
+
+    protected async internalExecute(context: FunctionExecutionParameters): Promise<FunctionOutput> {
+        let source: any[] = context.getArguments()?.get(SOURCE);
+
+        let current = 0;
+
+        let statementName = context.getStatementExecution()?.getStatement()?.getStatementName();
+
+        return new FunctionOutput({
+            next(): EventResult {
+                if (
+                    current >= source.length ||
+                    (statementName && context.getExecutionContext()?.get(statementName)) //check for breaks;
+                ) {
+                    if (statementName) context.getExecutionContext()?.delete(statementName);
+                    return EventResult.outputOf(new Map([[VALUE, current]]));
+                }
+
+                const eve = EventResult.of(
+                    Event.ITERATION,
+                    new Map([
+                        [INDEX, current],
+                        [EACH, source[current]],
+                    ]),
+                );
+                ++current;
+
+                return eve;
+            },
+        });
+    }
+}

package/src/engine/function/system/loop/RangeLoop.ts

@@ -100,13 +100,19 @@ export class RangeLoop extends AbstractFunction {
         const forward = step > 0;
         let current: number = from;
         let done: boolean = false;
+        let statementName = context.getStatementExecution()?.getStatement()?.getStatementName();
 
         return new FunctionOutput({
             next(): EventResult | undefined {
                 if (done) return undefined;
 
-                if ((forward && current >= to) || (!forward && current <= to)) {
+                if (
+                    (forward && current >= to) ||
+                    (!forward && current <= to) ||
+                    (statementName && context.getExecutionContext()?.get(statementName)) //Check for break;
+                ) {
                     done = true;
+                    if (statementName) context.getExecutionContext()?.delete(statementName);
                     return EventResult.outputOf(new Map([[VALUE, current]]));
                 }
 

package/src/engine/function/system/object/ObjectFunctionRepository.ts

@@ -6,6 +6,7 @@ import { Function } from '../../Function';
 import { ObjectDeleteKey } from './ObjectDeleteKey';
 import { ObjectEntries } from './ObjectEntries';
 import { ObjectKeys } from './ObjectKeys';
+import { ObjectPutValue } from './ObjectPutValue';
 import { ObjectValues } from './ObjectValues';
 
 const functionObjectsIndex: { [key: string]: AbstractFunction } = {
@@ -13,6 +14,7 @@ const functionObjectsIndex: { [key: string]: AbstractFunction } = {
     ObjectKeys: new ObjectKeys(),
     ObjectEntries: new ObjectEntries(),
     ObjectDeleteKey: new ObjectDeleteKey(),
+    ObjectPutValue: new ObjectPutValue(),
 };
 
 const filterableNames = Object.values(functionObjectsIndex).map((e) =>

package/src/engine/function/system/object/ObjectPutValue.ts

@@ -0,0 +1,61 @@
+import { FunctionOutput } from '../../../model/FunctionOutput';
+import { FunctionExecutionParameters } from '../../../runtime/FunctionExecutionParameters';
+
+import { Schema } from '../../../json/schema/Schema';
+import { Event } from '../../../model/Event';
+import { EventResult } from '../../../model/EventResult';
+import { FunctionSignature } from '../../../model/FunctionSignature';
+import { Parameter } from '../../../model/Parameter';
+import { Namespaces } from '../../../namespaces/Namespaces';
+import { duplicate } from '../../../util/duplicate';
+import { AbstractFunction } from '../../AbstractFunction';
+import { isNullValue } from '../../../util/NullCheck';
+import { ObjectValueSetterExtractor } from '../../../runtime/expression/tokenextractor/ObjectValueSetterExtractor';
+
+const VALUE = 'value';
+const SOURCE = 'source';
+const KEY = 'key';
+const OVERWRITE = 'overwrite';
+const DELETE_KEY_ON_NULL = 'deleteKeyOnNull';
+
+export class ObjectPutValue extends AbstractFunction {
+    private signature: FunctionSignature;
+
+    public constructor() {
+        super();
+        this.signature = new FunctionSignature('ObjectPutValue')
+            .setNamespace(Namespaces.SYSTEM_OBJECT)
+            .setParameters(
+                new Map([
+                    Parameter.ofEntry(SOURCE, Schema.ofObject(SOURCE)),
+                    Parameter.ofEntry(KEY, Schema.ofString(KEY)),
+                    Parameter.ofEntry(VALUE, Schema.ofAny(VALUE)),
+                    Parameter.ofEntry(OVERWRITE, Schema.ofBoolean(OVERWRITE).setDefaultValue(true)),
+                    Parameter.ofEntry(
+                        DELETE_KEY_ON_NULL,
+                        Schema.ofBoolean(DELETE_KEY_ON_NULL).setDefaultValue(false),
+                    ),
+                ]),
+            )
+            .setEvents(
+                new Map([Event.outputEventMapEntry(new Map([[VALUE, Schema.ofObject(VALUE)]]))]),
+            );
+    }
+
+    public getSignature(): FunctionSignature {
+        return this.signature;
+    }
+
+    protected async internalExecute(context: FunctionExecutionParameters): Promise<FunctionOutput> {
+        let source = context.getArguments()?.get(SOURCE);
+        let key = context.getArguments()?.get(KEY);
+        let value = context.getArguments()?.get(VALUE);
+        let overwrite = context.getArguments()?.get(OVERWRITE);
+        let deleteKeyOnNull = context.getArguments()?.get(DELETE_KEY_ON_NULL);
+
+        const ove = new ObjectValueSetterExtractor(source, 'Data.');
+        ove.setValue(key, value, overwrite, deleteKeyOnNull);
+
+        return new FunctionOutput([EventResult.outputOf(new Map([[VALUE, ove.getStore()]]))]);
+    }
+}

package/src/engine/json/schema/validator/SchemaValidator.ts

@@ -1,4 +1,5 @@
 import { Repository } from '../../../Repository';
+import { deepEqual } from '../../../util/deepEqual';
 import { isNullValue } from '../../../util/NullCheck';
 import { StringUtil } from '../../../util/string/StringUtil';
 import { Schema } from '../Schema';
@@ -40,7 +41,7 @@ export class SchemaValidator {
             return JSON.parse(JSON.stringify(schema.getDefaultValue()));
         }
 
-        if (schema.getConstant()) {
+        if (!isNullValue(schema.getConstant())) {
             return SchemaValidator.constantValidation(parents, schema, element);
         }
 
@@ -92,7 +93,7 @@ export class SchemaValidator {
     }
 
     public static constantValidation(parents: Schema[], schema: Schema, element: any): any {
-        if (!schema.getConstant().equals(element)) {
+        if (!deepEqual(schema.getConstant(), element)) {
             throw new SchemaValidationException(
                 SchemaValidator.path(parents),
                 'Expecting a constant value : ' + element,

package/src/engine/repository/KIRunFunctionRepository.ts

@@ -5,6 +5,7 @@ import { Get } from '../function/system/context/Get';
 import { SetFunction } from '../function/system/context/SetFunction';
 import { GenerateEvent } from '../function/system/GenerateEvent';
 import { If } from '../function/system/If';
+import { Break } from '../function/system/loop/Break';
 import { CountLoop } from '../function/system/loop/CountLoop';
 import { RangeLoop } from '../function/system/loop/RangeLoop';
 import { MathFunctionRepository } from '../function/system/math/MathFunctionRepository';
@@ -20,7 +21,10 @@ const map: Map<string, Map<string, Function>> = new Map([
         Namespaces.SYSTEM_CTX,
         new Map([mapEntry(new Create()), mapEntry(new Get()), mapEntry(new SetFunction())]),
     ],
-    [Namespaces.SYSTEM_LOOP, new Map([mapEntry(new RangeLoop()), mapEntry(new CountLoop())])],
+    [
+        Namespaces.SYSTEM_LOOP,
+        new Map([mapEntry(new RangeLoop()), mapEntry(new CountLoop()), mapEntry(new Break())]),
+    ],
     [
         Namespaces.SYSTEM,
         new Map([mapEntry(new If()), mapEntry(new GenerateEvent()), mapEntry(new Print())]),

package/src/engine/runtime/FunctionExecutionParameters.ts

@@ -5,7 +5,6 @@ import UUID from '../util/UUID';
 import { ContextElement } from './ContextElement';
 import { TokenValueExtractor } from './expression/tokenextractor/TokenValueExtractor';
 import { StatementExecution } from './StatementExecution';
-import { ArgumentsTokenValueExtractor } from './tokenextractor/ArgumentsTokenValueExtractor';
 import { ContextTokenValueExtractor } from './tokenextractor/ContextTokenValueExtractor';
 import { OutputMapTokenValueExtractor } from './tokenextractor/OutputMapTokenValueExtractor';
 
@@ -19,6 +18,7 @@ export class FunctionExecutionParameters {
     private functionRepository: Repository<Function>;
     private schemaRepository: Repository<Schema>;
     private executionId: string;
+    private executionContext: Map<string, any> = new Map();
 
     private valueExtractors: Map<string, TokenValueExtractor> = new Map();
 
@@ -121,4 +121,13 @@ export class FunctionExecutionParameters {
 
         return this;
     }
+
+    public setExecutionContext(executionContext: Map<string, any>): FunctionExecutionParameters {
+        this.executionContext = executionContext;
+        return this;
+    }
+
+    public getExecutionContext(): Map<string, any> {
+        return this.executionContext;
+    }
 }

package/src/engine/runtime/KIRuntime.ts

@@ -359,7 +359,8 @@ export class KIRuntime extends AbstractFunction {
                 .setEvents(inContext.getEvents()!)
                 .setSteps(inContext.getSteps()!)
                 .setStatementExecution(vertex.getData())
-                .setCount(inContext.getCount());
+                .setCount(inContext.getCount())
+                .setExecutionContext(inContext.getExecutionContext());
         }
 
         let result: FunctionOutput = await fun.execute(fep);

package/src/engine/runtime/expression/operators/binary/ArithmeticAdditionOperator.ts

@@ -1,9 +1,10 @@
-import { Operation } from '../../Operation';
+import { isNullValue } from '../../../../util/NullCheck';
 import { BinaryOperator } from './BinaryOperator';
 
 export class ArithmeticAdditionOperator extends BinaryOperator {
     public apply(t: any, u: any): any {
-        this.nullCheck(t, u, Operation.ADDITION);
+        if (isNullValue(t)) return u;
+        else if (isNullValue(u)) return t;
         return t + u;
     }
 }

package/src/engine/runtime/expression/tokenextractor/ObjectValueSetterExtractor.ts

@@ -0,0 +1,172 @@
+import { KIRuntimeException } from '../../../exception/KIRuntimeException';
+import { isNullValue } from '../../../util/NullCheck';
+import { duplicate } from '../../../util/duplicate';
+import { StringFormatter } from '../../../util/string/StringFormatter';
+import { StringUtil } from '../../../util/string/StringUtil';
+import { Expression } from '../Expression';
+import { ExpressionTokenValue } from '../ExpressionTokenValue';
+import { Operation } from '../Operation';
+import { ExpressionEvaluationException } from '../exception/ExpressionEvaluationException';
+import { TokenValueExtractor } from './TokenValueExtractor';
+
+export class ObjectValueSetterExtractor extends TokenValueExtractor {
+    private store: any;
+    private prefix: string;
+    constructor(store: any, prefix: string) {
+        super();
+        this.store = store;
+        this.prefix = prefix;
+    }
+    protected getValueInternal(token: string) {
+        let parts: string[] = token.split(TokenValueExtractor.REGEX_DOT);
+        return this.retrieveElementFrom(token, parts, 1, this.store);
+    }
+
+    public getStore(): any {
+        return this.store;
+    }
+    public setStore(store: any): ObjectValueSetterExtractor {
+        this.store = store;
+        return this;
+    }
+
+    public setValue(
+        token: string,
+        value: any,
+        overwrite: boolean = true,
+        deleteOnNull: boolean = false,
+    ) {
+        this.store = duplicate(this.store);
+        this.modifyStore(token, value, overwrite, deleteOnNull);
+    }
+
+    private modifyStore(
+        stringToken: string,
+        value: any,
+        overwrite: boolean,
+        deleteOnNull: boolean,
+    ) {
+        const exp = new Expression(stringToken);
+        const tokens = exp.getTokens();
+        tokens.removeLast();
+        const ops = exp.getOperations();
+
+        let op = ops.removeLast();
+        let token = tokens.removeLast();
+        let mem =
+            token instanceof ExpressionTokenValue
+                ? (token as ExpressionTokenValue).getElement()
+                : token.getExpression();
+
+        let el = this.store;
+
+        while (!ops.isEmpty()) {
+            if (op == Operation.OBJECT_OPERATOR) {
+                el = this.getDataFromObject(el, mem, ops.peekLast());
+            } else {
+                el = this.getDataFromArray(el, mem, ops.peekLast());
+            }
+
+            op = ops.removeLast();
+            token = tokens.removeLast();
+            mem =
+                token instanceof ExpressionTokenValue
+                    ? (token as ExpressionTokenValue).getElement()
+                    : token.getExpression();
+        }
+
+        if (op == Operation.OBJECT_OPERATOR)
+            this.putDataInObject(el, mem, value, overwrite, deleteOnNull);
+        else this.putDataInArray(el, mem, value, overwrite, deleteOnNull);
+    }
+
+    private getDataFromArray(el: any, mem: string, nextOp: Operation): any {
+        if (!Array.isArray(el))
+            throw new KIRuntimeException(
+                StringFormatter.format('Expected an array but found $', el),
+            );
+
+        const index = parseInt(mem);
+        if (isNaN(index))
+            throw new KIRuntimeException(
+                StringFormatter.format('Expected an array index but found $', mem),
+            );
+        if (index < 0)
+            throw new KIRuntimeException(
+                StringFormatter.format('Array index is out of bound - $', mem),
+            );
+
+        let je = el[index];
+
+        if (isNullValue(je)) {
+            je = nextOp == Operation.OBJECT_OPERATOR ? {} : [];
+            el[index] = je;
+        }
+        return je;
+    }
+
+    private getDataFromObject(el: any, mem: string, nextOp: Operation): any {
+        if (Array.isArray(el) || typeof el !== 'object')
+            throw new KIRuntimeException(
+                StringFormatter.format('Expected an object but found $', el),
+            );
+
+        let je = el[mem];
+
+        if (isNullValue(je)) {
+            je = nextOp == Operation.OBJECT_OPERATOR ? {} : [];
+            el[mem] = je;
+        }
+        return je;
+    }
+
+    private putDataInArray(
+        el: any,
+        mem: string,
+        value: any,
+        overwrite: boolean,
+        deleteOnNull: boolean,
+    ): void {
+        if (!Array.isArray(el))
+            throw new KIRuntimeException(
+                StringFormatter.format('Expected an array but found $', el),
+            );
+
+        const index = parseInt(mem);
+        if (isNaN(index))
+            throw new KIRuntimeException(
+                StringFormatter.format('Expected an array index but found $', mem),
+            );
+        if (index < 0)
+            throw new KIRuntimeException(
+                StringFormatter.format('Array index is out of bound - $', mem),
+            );
+
+        if (overwrite || isNullValue(el[index])) {
+            if (deleteOnNull && isNullValue(value)) el.splice(index, 1);
+            else el[index] = value;
+        }
+    }
+
+    private putDataInObject(
+        el: any,
+        mem: string,
+        value: any,
+        overwrite: boolean,
+        deleteOnNull: boolean,
+    ): void {
+        if (Array.isArray(el) || typeof el !== 'object')
+            throw new KIRuntimeException(
+                StringFormatter.format('Expected an object but found $', el),
+            );
+
+        if (overwrite || isNullValue(el[mem])) {
+            if (deleteOnNull && isNullValue(value)) delete el[mem];
+            else el[mem] = value;
+        }
+    }
+
+    getPrefix(): string {
+        return this.prefix;
+    }
+}

package/src/engine/runtime/expression/tokenextractor/TokenValueExtractor.ts

@@ -115,7 +115,7 @@ export abstract class TokenValueExtractor {
         }
     }
 
-    private checkIfObject(
+    protected checkIfObject(
         token: string,
         parts: string[],
         partNumber: number,

package/src/index.ts

@@ -27,6 +27,7 @@ export * from './engine/runtime/FunctionExecutionParameters';
 export * from './engine/runtime/expression/Expression';
 export * from './engine/runtime/expression/tokenextractor/TokenValueExtractor';
 export * from './engine/runtime/expression/tokenextractor/LiteralTokenValueExtractor';
+export * from './engine/runtime/expression/tokenextractor/ObjectValueSetterExtractor';
 export * from './engine/runtime/expression/ExpressionEvaluator';
 export * from './engine/runtime/expression/Operation';
 export * from './engine/runtime/expression/ExpressionToken';