@fincity/kirun-js 1.3.1 → 1.4.2

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

@@ -1,13 +1,12 @@
 import { Namespaces } from '../../namespaces/Namespaces';
 import { ArraySchemaType } from './array/ArraySchemaType';
-import { AdditionalPropertiesType } from './object/AdditionalPropertiesType';
 import { StringFormat } from './string/StringFormat';
 import { SchemaType } from './type/SchemaType';
 import { TypeUtil } from './type/TypeUtil';
 import { Type } from './type/Type';
 import { isNullValue } from '../../util/NullCheck';
 import { SingleType } from './type/SingleType';
-import { SchemaReferenceException } from './validator/exception/SchemaReferenceException';
+import { MultipleType } from './type/MultipleType';
 
 const ADDITIONAL_PROPERTY: string = 'additionalProperty';
 const ENUMS: string = 'enums';
@@ -18,6 +17,44 @@ const VERSION_STRING: string = 'version';
 const NAMESPACE_STRING: string = 'namespace';
 const TEMPORARY: string = '_';
 
+export class AdditionalPropertiesType {
+    private booleanValue?: boolean;
+    private schemaValue?: Schema;
+
+    constructor(apt: AdditionalPropertiesType | undefined = undefined) {
+        if (!apt) return;
+        this.booleanValue = apt.booleanValue;
+        if (!apt.schemaValue) return;
+        this.schemaValue = new Schema(apt.schemaValue);
+    }
+
+    public getBooleanValue(): boolean | undefined {
+        return this.booleanValue;
+    }
+
+    public getSchemaValue(): Schema | undefined {
+        return this.schemaValue;
+    }
+
+    public setBooleanValue(booleanValue: boolean): AdditionalPropertiesType {
+        this.booleanValue = booleanValue;
+        return this;
+    }
+
+    public setSchemaValue(schemaValue: Schema): AdditionalPropertiesType {
+        this.schemaValue = schemaValue;
+        return this;
+    }
+
+    public static from(obj: any): AdditionalPropertiesType | undefined {
+        if (!obj) return undefined;
+        const ad = new AdditionalPropertiesType();
+        ad.booleanValue = obj.booleanValue;
+        ad.schemaValue = obj.schemaValue;
+        return ad;
+    }
+}
+
 export class Schema {
     public static readonly NULL: Schema = new Schema()
         .setNamespace(Namespaces.SYSTEM)
@@ -389,6 +426,86 @@ export class Schema {
     private $defs?: Map<string, Schema>;
     private permission?: string;
 
+    public constructor(schema?: Schema) {
+        if (!schema) return;
+
+        this.namespace = schema.namespace;
+        this.name = schema.name;
+
+        this.version = schema.version;
+        this.ref = schema.ref;
+
+        this.type =
+            schema.type instanceof SingleType
+                ? new SingleType(schema.type as SingleType)
+                : new MultipleType(schema.type as MultipleType);
+
+        this.anyOf = schema.anyOf?.map((x) => new Schema(x));
+
+        this.allOf = schema.allOf?.map((x) => new Schema(x));
+        this.oneOf = schema.oneOf?.map((x) => new Schema(x));
+
+        this.not = this.not ? new Schema(this.not) : undefined;
+
+        this.description = schema.description;
+        this.examples = schema.examples ? JSON.parse(JSON.stringify(schema.examples)) : undefined;
+
+        this.defaultValue = schema.defaultValue
+            ? JSON.parse(JSON.stringify(schema.defaultValue))
+            : undefined;
+        this.comment = schema.comment;
+        this.enums = schema.enums ? [...schema.enums] : undefined;
+        this.constant = schema.constant ? JSON.parse(JSON.stringify(schema.constant)) : undefined;
+
+        this.pattern = schema.pattern;
+        this.format = schema.format;
+
+        this.minLength = schema.minLength;
+        this.maxLength = schema.maxLength;
+
+        this.multipleOf = schema.multipleOf;
+        this.minimum = schema.minimum;
+        this.maximum = schema.maximum;
+        this.exclusiveMinimum = schema.exclusiveMinimum;
+        this.exclusiveMaximum = schema.exclusiveMaximum;
+
+        this.properties = schema.properties
+            ? new Map(Array.from(schema.properties.entries()).map((e) => [e[0], new Schema(e[1])]))
+            : undefined;
+
+        this.additionalProperties = schema.additionalProperties
+            ? new AdditionalPropertiesType(schema.additionalProperties)
+            : undefined;
+
+        this.required = schema.required ? [...schema.required] : undefined;
+
+        this.propertyNames = schema.propertyNames ? new Schema(schema.propertyNames) : undefined;
+        this.minProperties = schema.minProperties;
+        this.maxProperties = schema.maxProperties;
+
+        this.patternProperties = schema.patternProperties
+            ? new Map(
+                  Array.from(schema.patternProperties.entries()).map((e) => [
+                      e[0],
+                      new Schema(e[1]),
+                  ]),
+              )
+            : undefined;
+
+        this.items = schema.items ? new ArraySchemaType(schema.items) : undefined;
+        this.contains = schema.contains ? new Schema(this.contains) : undefined;
+
+        this.minItems = schema.minItems;
+        this.maxItems = schema.maxItems;
+        this.uniqueItems = schema.uniqueItems;
+
+        this.$defs = schema.$defs
+            ? new Map(Array.from(schema.$defs.entries()).map((e) => [e[0], new Schema(e[1])]))
+            : undefined;
+
+        this.permission = schema.permission;
+    }
+
     public getTitle(): string | undefined {
         return this.getFullName();
     }

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,7 @@ 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';
 
@@ -25,9 +26,17 @@ export class ParameterReference {
     private value: any;
     private expression?: string;
 
-    constructor(type: ParameterReferenceType) {
-        this.type = type;
-        this.key = UUID();
+    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 {

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';
@@ -49,11 +48,38 @@ export class Statement extends AbstractStatement {
     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 {

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

@@ -485,7 +485,7 @@ export class KIRuntime extends AbstractFunction {
 
             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);
             }
@@ -515,6 +515,7 @@ export class KIRuntime extends AbstractFunction {
 
         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++];