@fincity/kirun-js 1.3.0 → 1.4.1

package/src/engine/json/schema/SchemaUtil.ts

@@ -120,7 +120,7 @@ export class SchemaUtil {
     ): Tuple2<Schema, string> | undefined {
         if (!sRepository) return undefined;
 
-        let nms = StringUtil.splitAtFirstOccurance(inSchem?.getRef() ?? '', '/');
+        let nms = StringUtil.splitAtFirstOccurance(ref ?? '', '/');
         if (!nms[0]) return undefined;
 
         let nmspnm = StringUtil.splitAtFirstOccurance(nms[0], '.');

package/src/engine/json/schema/array/ArraySchemaType.ts

@@ -5,6 +5,12 @@ export class ArraySchemaType {
     private singleSchema: Schema | undefined;
     private tupleSchema: Schema[] | undefined;
 
+    public constructor(ast?: ArraySchemaType) {
+        if (!ast) return;
+        this.singleSchema = ast.singleSchema ? new Schema(ast.singleSchema) : undefined;
+        this.tupleSchema = ast.tupleSchema ? ast.tupleSchema.map((e) => new Schema(e)) : undefined;
+    }
+
     public setSingleSchema(schema: Schema): ArraySchemaType {
         this.singleSchema = schema;
         return this;

package/src/engine/json/schema/type/MultipleType.ts

@@ -4,9 +4,12 @@ import { Type } from './Type';
 export class MultipleType extends Type {
     private type: Set<SchemaType>;
 
-    constructor(type: Set<SchemaType>) {
+    public constructor(type: Set<SchemaType> | MultipleType) {
         super();
-        this.type = type;
+
+        if (type instanceof MultipleType)
+            this.type = new Set(Array.from((type as MultipleType).type));
+        else this.type = new Set(Array.from(type));
     }
 
     public getType(): Set<SchemaType> {

package/src/engine/json/schema/type/SingleType.ts

@@ -4,9 +4,11 @@ import { Type } from './Type';
 export class SingleType extends Type {
     private type: SchemaType;
 
-    constructor(type: SchemaType) {
+    public constructor(type: SchemaType | SingleType) {
         super();
-        this.type = type;
+
+        if (type instanceof SingleType) this.type = (type as SingleType).type;
+        else this.type = type as SchemaType;
     }
 
     public getType(): SchemaType {

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

@@ -1,7 +1,6 @@
 import { Repository } from '../../../Repository';
 import { isNullValue } from '../../../util/NullCheck';
-import { AdditionalPropertiesType } from '../object/AdditionalPropertiesType';
-import { Schema } from '../Schema';
+import { AdditionalPropertiesType, Schema } from '../Schema';
 import { SchemaValidationException } from './exception/SchemaValidationException';
 import { SchemaValidator } from './SchemaValidator';
 
@@ -100,7 +99,7 @@ export class ObjectValidator {
                     newParents,
                     apt.getSchemaValue(),
                     repository,
-                    jsonObject.get(key),
+                    jsonObject[key],
                 );
                 jsonObject[key] = element;
             }

package/src/engine/model/AbstractStatement.ts

@@ -6,6 +6,16 @@ export class AbstractStatement {
     private position?: Position;
     private override: boolean = false;
 
+    public constructor(ast?: AbstractStatement) {
+        if (!ast) return;
+        this.comment = ast.comment;
+        this.description = ast.description;
+        this.position = ast.position
+            ? new Position(ast.position.getLeft(), ast.position.getTop())
+            : undefined;
+        this.override = ast.override;
+    }
+
     public getComment(): string | undefined {
         return this.comment;
     }

package/src/engine/model/Event.ts

@@ -1,5 +1,4 @@
-import { AdditionalPropertiesType } from '../json/schema/object/AdditionalPropertiesType';
-import { Schema } from '../json/schema/Schema';
+import { AdditionalPropertiesType, Schema } from '../json/schema/Schema';
 import { SchemaType } from '../json/schema/type/SchemaType';
 import { TypeUtil } from '../json/schema/type/TypeUtil';
 import { SchemaReferenceException } from '../json/schema/validator/exception/SchemaReferenceException';
@@ -30,9 +29,17 @@ export class Event {
     private name: string;
     private parameters: Map<string, Schema>;
 
-    constructor(name: string, parameters: Map<string, Schema>) {
-        this.name = name;
-        this.parameters = parameters;
+    constructor(evn: string | Event, parameters?: Map<string, Schema>) {
+        if (evn instanceof Event) {
+            this.name = evn.name;
+            this.parameters = new Map(
+                Array.from(evn.parameters.entries()).map((e) => [e[0], new Schema(e[1])]),
+            );
+        } else {
+            this.name = evn;
+            if (!parameters) throw new Error('Unknown constructor format');
+            this.parameters = parameters;
+        }
     }
 
     public getName(): string {

package/src/engine/model/FunctionDefinition.ts

@@ -1,5 +1,4 @@
-import { AdditionalPropertiesType } from '../json/schema/object/AdditionalPropertiesType';
-import { Schema } from '../json/schema/Schema';
+import { AdditionalPropertiesType, Schema } from '../json/schema/Schema';
 import { Namespaces } from '../namespaces/Namespaces';
 import { Event } from './Event';
 import { FunctionSignature } from './FunctionSignature';

package/src/engine/model/FunctionSignature.ts

@@ -1,5 +1,4 @@
-import { AdditionalPropertiesType } from '../json/schema/object/AdditionalPropertiesType';
-import { Schema } from '../json/schema/Schema';
+import { AdditionalPropertiesType, Schema } from '../json/schema/Schema';
 import { Namespaces } from '../namespaces/Namespaces';
 import { Event } from './Event';
 import { Parameter } from './Parameter';
@@ -32,8 +31,19 @@ export class FunctionSignature {
     private parameters: Map<string, Parameter> = new Map();
     private events: Map<string, Event> = new Map();
 
-    constructor(name: string) {
-        this.name = name;
+    constructor(value: string | FunctionSignature) {
+        if (value instanceof FunctionSignature) {
+            this.name = value.name;
+            this.namespace = value.namespace;
+            this.parameters = new Map(
+                Array.from(value.parameters.entries()).map((e) => [e[0], new Parameter(e[1])]),
+            );
+            this.events = new Map(
+                Array.from(value.events.entries()).map((e) => [e[0], new Event(e[1])]),
+            );
+        } else {
+            this.name = value;
+        }
     }
 
     public getNamespace(): string {

package/src/engine/model/Parameter.ts

@@ -43,9 +43,19 @@ export class Parameter {
     private variableArgument: boolean = false;
     private type: ParameterType = ParameterType.EXPRESSION;
 
-    constructor(parameterName: string, schema: Schema) {
-        this.schema = schema;
-        this.parameterName = parameterName;
+    constructor(pn: string | Parameter, schema?: Schema) {
+        if (pn instanceof Parameter) {
+            this.schema = new Schema(pn.schema);
+            this.parameterName = pn.parameterName;
+            this.variableArgument = pn.variableArgument;
+            this.type = pn.type;
+        } else {
+            if (!schema) {
+                throw new Error('Unknown constructor signature');
+            }
+            this.schema = schema;
+            this.parameterName = pn;
+        }
     }
 
     public getSchema(): Schema {

package/src/engine/model/ParameterReference.ts

@@ -2,6 +2,8 @@ import { Schema } from '../json/schema/Schema';
 import { SchemaType } from '../json/schema/type/SchemaType';
 import { TypeUtil } from '../json/schema/type/TypeUtil';
 import { Namespaces } from '../namespaces/Namespaces';
+import { isNullValue } from '../util/NullCheck';
+import UUID from '../util/UUID';
 import { ParameterReferenceType } from './ParameterReferenceType';
 
 export class ParameterReference {
@@ -12,17 +14,29 @@ export class ParameterReference {
         .setType(TypeUtil.of(SchemaType.OBJECT))
         .setProperties(
             new Map([
+                ['key', Schema.ofString('key')],
                 ['value', Schema.ofAny('value')],
                 ['expression', Schema.ofString('expression')],
                 ['type', Schema.ofString('type').setEnums(['EXPRESSION', 'VALUE'])],
             ]),
         );
+
+    private key: string;
     private type: ParameterReferenceType;
     private value: any;
     private expression?: string;
 
-    constructor(type: ParameterReferenceType) {
-        this.type = type;
+    constructor(type: ParameterReferenceType | ParameterReference) {
+        if (type instanceof ParameterReference) {
+            let pv = type as ParameterReference;
+            this.key = pv.key;
+            this.type = pv.type;
+            this.value = isNullValue(pv.value) ? undefined : JSON.parse(JSON.stringify(pv.value));
+            this.expression = pv.expression;
+        } else {
+            this.type = type as ParameterReferenceType;
+            this.key = UUID();
+        }
     }
 
     public getType(): ParameterReferenceType {
@@ -32,6 +46,15 @@ export class ParameterReference {
         this.type = type;
         return this;
     }
+
+    public getKey(): string {
+        return this.key;
+    }
+    public setKey(key: string): ParameterReference {
+        this.key = key;
+        return this;
+    }
+
     public getValue(): any {
         return this.value;
     }
@@ -47,18 +70,22 @@ export class ParameterReference {
         return this;
     }
 
-    public static ofExpression(value: any): ParameterReference {
-        return new ParameterReference(ParameterReferenceType.EXPRESSION).setExpression(value);
+    public static ofExpression(value: any): [string, ParameterReference] {
+        const param = new ParameterReference(ParameterReferenceType.EXPRESSION).setExpression(
+            value,
+        );
+        return [param.getKey(), param];
     }
 
-    public static ofValue(value: any): ParameterReference {
-        return new ParameterReference(ParameterReferenceType.VALUE).setValue(value);
+    public static ofValue(value: any): [string, ParameterReference] {
+        const param = new ParameterReference(ParameterReferenceType.VALUE).setValue(value);
+        return [param.getKey(), param];
     }
 
-    public static from(json: any): ParameterReference[] {
-        if (!json) return [];
-        return Array.from(json).map((e: any) =>
-            new ParameterReference(e.type).setValue(e.value).setExpression(e.expression),
-        );
+    public static from(e: any): ParameterReference {
+        return new ParameterReference(e.type)
+            .setValue(e.value)
+            .setExpression(e.expression)
+            .setKey(e.key);
     }
 }

package/src/engine/model/Position.ts

@@ -18,7 +18,7 @@ export class Position {
     private left: number;
     private top: number;
 
-    constructor(left: number, top: number) {
+    public constructor(left: number, top: number) {
         this.left = left;
         this.top = top;
     }

package/src/engine/model/Statement.ts

@@ -1,5 +1,4 @@
-import { AdditionalPropertiesType } from '../json/schema/object/AdditionalPropertiesType';
-import { Schema } from '../json/schema/Schema';
+import { AdditionalPropertiesType, Schema } from '../json/schema/Schema';
 import { SchemaType } from '../json/schema/type/SchemaType';
 import { TypeUtil } from '../json/schema/type/TypeUtil';
 import { Namespaces } from '../namespaces/Namespaces';
@@ -22,7 +21,9 @@ export class Statement extends AbstractStatement {
                 ['name', Schema.ofString('name')],
                 [
                     'dependentStatements',
-                    Schema.ofArray('dependentstatement', Schema.ofString('dependentstatement')),
+                    Schema.ofObject('dependentstatement').setAdditionalProperties(
+                        new AdditionalPropertiesType().setSchemaValue(Schema.ofBoolean('exists')),
+                    ),
                 ],
                 [
                     'parameterMap',
@@ -30,7 +31,11 @@ export class Statement extends AbstractStatement {
                         .setName('parameterMap')
                         .setAdditionalProperties(
                             new AdditionalPropertiesType().setSchemaValue(
-                                Schema.ofArray('parameterReference', ParameterReference.SCHEMA),
+                                Schema.ofObject('parameterReference').setAdditionalProperties(
+                                    new AdditionalPropertiesType().setSchemaValue(
+                                        ParameterReference.SCHEMA,
+                                    ),
+                                ),
                             ),
                         ),
                 ],
@@ -40,14 +45,41 @@ export class Statement extends AbstractStatement {
     private statementName: string;
     private namespace: string;
     private name: string;
-    private parameterMap?: Map<string, ParameterReference[]>;
-    private dependentStatements?: string[];
+    private parameterMap?: Map<string, Map<string, ParameterReference>>;
+    private dependentStatements?: Map<string, boolean>;
 
-    public constructor(statementName: string, namespace: string, name: string) {
-        super();
-        this.statementName = statementName;
-        this.namespace = namespace;
-        this.name = name;
+    public constructor(sn: string | Statement, namespace?: string, name?: string) {
+        super(sn instanceof Statement ? (sn as Statement) : undefined);
+
+        if (sn instanceof Statement) {
+            let x = sn as Statement;
+            this.statementName = x.statementName;
+            this.name = x.name;
+            this.namespace = x.namespace;
+            if (x.parameterMap)
+                this.parameterMap = new Map(
+                    Array.from(x.parameterMap.entries()).map((f) => [
+                        f[0],
+                        new Map(
+                            Array.from(f[1].entries()).map((e) => [
+                                e[0],
+                                new ParameterReference(e[1]),
+                            ]),
+                        ),
+                    ]),
+                );
+
+            if (x.dependentStatements) {
+                this.dependentStatements = new Map(Array.from(x.dependentStatements.entries()));
+            }
+        } else {
+            this.statementName = sn;
+            if (!name || !namespace) {
+                throw new Error('Unknown constructor');
+            }
+            this.namespace = namespace;
+            this.name = name;
+        }
     }
 
     public getStatementName(): string {
@@ -71,20 +103,20 @@ export class Statement extends AbstractStatement {
         this.name = name;
         return this;
     }
-    public getParameterMap(): Map<string, ParameterReference[]> {
+    public getParameterMap(): Map<string, Map<string, ParameterReference>> {
         if (!this.parameterMap) {
             this.parameterMap = new Map();
         }
         return this.parameterMap;
     }
-    public setParameterMap(parameterMap: Map<string, ParameterReference[]>): Statement {
+    public setParameterMap(parameterMap: Map<string, Map<string, ParameterReference>>): Statement {
         this.parameterMap = parameterMap;
         return this;
     }
-    public getDependentStatements(): string[] {
-        return this.dependentStatements ?? [];
+    public getDependentStatements(): Map<string, boolean> {
+        return this.dependentStatements ?? new Map();
     }
-    public setDependentStatements(dependentStatements: string[]): Statement {
+    public setDependentStatements(dependentStatements: Map<string, boolean>): Statement {
         this.dependentStatements = dependentStatements;
         return this;
     }
@@ -102,14 +134,20 @@ export class Statement extends AbstractStatement {
     public static from(json: any): Statement {
         return new Statement(json.statementName, json.namespace, json.name)
             .setParameterMap(
-                new Map<string, ParameterReference[]>(
-                    Object.entries(json.parameterMap ?? {}).map(([k, v]) => [
+                new Map<string, Map<string, ParameterReference>>(
+                    Object.entries(json.parameterMap ?? {}).map(([k, v]: [string, any]) => [
                         k,
-                        ParameterReference.from(v),
+                        new Map<string, ParameterReference>(
+                            Object.entries(v ?? {})
+                                .map(([_, iv]) => ParameterReference.from(iv))
+                                .map((e) => [e.getKey(), e]),
+                        ),
                     ]),
                 ),
             )
-            .setDependentStatements(json.dependentStatements)
+            .setDependentStatements(
+                new Map<string, boolean>(Object.entries(json.dependentStatements ?? {})),
+            )
             .setPosition(Position.from(json.position))
             .setComment(json.comment)
             .setDescription(json.description) as Statement;

package/src/engine/model/StatementGroup.ts

@@ -4,6 +4,7 @@ import { TypeUtil } from '../json/schema/type/TypeUtil';
 import { Namespaces } from '../namespaces/Namespaces';
 import { AbstractStatement } from './AbstractStatement';
 import { Position } from './Position';
+import { Statement } from './Statement';
 
 export class StatementGroup extends AbstractStatement {
     private static readonly SCHEMA_NAME: string = 'StatementGroup';
@@ -21,10 +22,12 @@ export class StatementGroup extends AbstractStatement {
         );
 
     private statementGroupName: string;
+    private statements: Map<string, boolean>;
 
-    constructor(statementGroupName: string) {
+    constructor(statementGroupName: string, statements: Map<string, boolean> = new Map()) {
         super();
         this.statementGroupName = statementGroupName;
+        this.statements = statements;
     }
 
     public getStatementGroupName(): string {
@@ -35,8 +38,25 @@ export class StatementGroup extends AbstractStatement {
         return this;
     }
 
+    public getStatements(): Map<string, boolean> {
+        return this.statements;
+    }
+
+    public setStatements(statements: Map<string, boolean>): StatementGroup {
+        this.statements = statements;
+        return this;
+    }
+
     public static from(json: any): StatementGroup {
-        return new StatementGroup(json.statementGroupName)
+        return new StatementGroup(
+            json.statementGroupName,
+            new Map(
+                Object.entries(json.statements || {}).map(([k, v]) => [
+                    k,
+                    ('' + v)?.toLowerCase() == 'true',
+                ]),
+            ),
+        )
             .setPosition(Position.from(json.position))
             .setComment(json.comment)
             .setDescription(json.description) as StatementGroup;

package/src/engine/runtime/KIRuntime.ts

@@ -417,7 +417,7 @@ export class KIRuntime extends AbstractFunction {
     ): Map<string, any> {
         return Array.from(s.getParameterMap().entries())
             .map((e) => {
-                let prList: ParameterReference[] = e[1];
+                let prList: ParameterReference[] = Array.from(e[1]?.values() ?? []);
 
                 let ret: any = undefined;
 
@@ -483,9 +483,9 @@ export class KIRuntime extends AbstractFunction {
             let p: Parameter | undefined = paramSet.get(param[0]);
             if (!p) continue;
 
-            let refList: ParameterReference[] = param[1];
+            let refList: ParameterReference[] = Array.from(param[1]?.values() ?? []);
 
-            if (!refList.length) {
+            if (!refList.length && !p.isVariableArgument()) {
                 if (isNullValue(SchemaUtil.getDefaultValue(p.getSchema(), sRepo)))
                     se.addMessage(
                         StatementMessageType.ERROR,
@@ -500,7 +500,7 @@ export class KIRuntime extends AbstractFunction {
 
             if (p.isVariableArgument()) {
                 for (let ref of refList) this.parameterReferenceValidation(se, p, ref, sRepo);
-            } else {
+            } else if (refList.length) {
                 let ref: ParameterReference = refList[0];
                 this.parameterReferenceValidation(se, p, ref, sRepo);
             }
@@ -509,12 +509,13 @@ export class KIRuntime extends AbstractFunction {
         }
 
         if (!isNullValue(se.getStatement().getDependentStatements())) {
-            for (let statement of se.getStatement().getDependentStatements())
-                se.addDependency(statement);
+            for (let statement of se.getStatement().getDependentStatements().entries())
+                if (statement[1]) se.addDependency(statement[0]);
         }
 
         if (paramSet.size) {
             for (let param of Array.from(paramSet.values())) {
+                if (param.isVariableArgument()) continue;
                 if (isNullValue(SchemaUtil.getDefaultValue(param.getSchema(), sRepo)))
                     se.addMessage(
                         StatementMessageType.ERROR,

package/src/engine/runtime/expression/Expression.ts

@@ -77,6 +77,33 @@ export class Expression extends ExpressionToken {
                     isPrevOp = result.getT2();
                     break;
                 }
+                case '?': {
+                    if (
+                        i + 1 < length &&
+                        this.expression.charAt(i + 1) != '?' &&
+                        i != 0 &&
+                        this.expression.charAt(i - 1) != '?'
+                    ) {
+                        i = this.processTernaryOperator(length, sb, buff, i, isPrevOp);
+                    } else {
+                        let result: Tuple2<number, boolean> = this.processOthers(
+                            chr,
+                            length,
+                            sb,
+                            buff,
+                            i,
+                            isPrevOp,
+                        );
+                        i = result.getT1();
+                        isPrevOp = result.getT2();
+                        if (isPrevOp && this.ops.peek() == Operation.ARRAY_OPERATOR) {
+                            result = this.process(length, sb, i);
+                            i = result.getT1();
+                            isPrevOp = result.getT2();
+                        }
+                    }
+                    break;
+                }
                 default:
                     let result: Tuple2<number, boolean> = this.processOthers(
                         chr,
@@ -188,6 +215,80 @@ export class Expression extends ExpressionToken {
         return new Tuple2(i, false);
     }
 
+    private processTernaryOperator(
+        length: number,
+        sb: StringBuilder,
+        buff: string,
+        i: number,
+        isPrevOp: boolean,
+    ): number {
+        if (isPrevOp) {
+            throw new ExpressionEvaluationException(
+                this.expression,
+                'Ternary operator is followed by an operator',
+            );
+        }
+
+        if (buff.trim() != '') {
+            this.tokens.push(new Expression(buff));
+            sb.setLength(0);
+        }
+
+        ++i;
+        let cnt: number = 1;
+        let inChr = '';
+        const start = i;
+        while (i < length && cnt > 0) {
+            inChr = this.expression.charAt(i);
+            if (inChr == '?') ++cnt;
+            else if (inChr == ':') --cnt;
+            ++i;
+        }
+
+        if (inChr != ':') {
+            throw new ExpressionEvaluationException(this.expression, "':' operater is missing");
+        }
+
+        if (i >= length) {
+            throw new ExpressionEvaluationException(
+                this.expression,
+                'Third part of the ternary expression is missing',
+            );
+        }
+
+        while (
+            !this.ops.isEmpty() &&
+            this.hasPrecedence(Operation.CONDITIONAL_TERNARY_OPERATOR, this.ops.peek())
+        ) {
+            let prev: Operation = this.ops.pop();
+
+            if (Operation.UNARY_OPERATORS.has(prev)) {
+                const l: ExpressionToken = this.tokens.pop();
+                this.tokens.push(new Expression('', l, undefined, prev));
+            } else {
+                let r = this.tokens.pop();
+                let l = this.tokens.pop();
+
+                this.tokens.push(new Expression('', l, r, prev));
+            }
+        }
+
+        this.ops.push(Operation.CONDITIONAL_TERNARY_OPERATOR);
+        this.tokens.push(new Expression(this.expression.substring(start, i - 1)));
+
+        const secondExp: string = this.expression.substring(i);
+        if (secondExp.trim() === '') {
+            throw new ExpressionEvaluationException(
+                this.expression,
+                'Third part of the ternary expression is missing',
+            );
+        }
+
+        this.tokens.push(new Expression(secondExp));
+
+        return length - 1;
+    }
+
     private processSubExpression(
         length: number,
         sb: StringBuilder,
@@ -329,6 +430,25 @@ export class Expression extends ExpressionToken {
                     )
                     .append(')');
                 ind++;
+            } else if (this.ops.get(i) == Operation.CONDITIONAL_TERNARY_OPERATOR) {
+                let temp: ExpressionToken = tokens[ind++];
+                sb.insert(
+                    0,
+                    temp instanceof Expression ? (temp as Expression).toString() : temp.toString(),
+                );
+                sb.insert(0, ':');
+                temp = tokens[ind++];
+                sb.insert(
+                    0,
+                    temp instanceof Expression ? (temp as Expression).toString() : temp.toString(),
+                );
+                sb.insert(0, '?');
+                temp = tokens[ind++];
+                sb.insert(
+                    0,
+                    temp instanceof Expression ? (temp as Expression).toString() : temp.toString(),
+                ).append(')');
+                sb.insert(0, '(');
             } else {
                 if (ind == 0) {
                     const temp: ExpressionToken = tokens[ind++];