@fincity/kirun-js 1.0.0

package/src/engine/model/Event.ts

@@ -0,0 +1,62 @@
+import { AdditionalPropertiesType } from '../json/schema/object/AdditionalPropertiesType';
+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';
+
+export class Event {
+    public static readonly OUTPUT: string = 'output';
+    public static readonly ERROR: string = 'error';
+    public static readonly ITERATION: string = 'iteration';
+    public static readonly TRUE: string = 'true';
+    public static readonly FALSE: string = 'false';
+    public static readonly SCHEMA_NAME: string = 'Event';
+    public static readonly SCHEMA: Schema = new Schema()
+        .setNamespace(Namespaces.SYSTEM)
+        .setName(Event.SCHEMA_NAME)
+        .setType(TypeUtil.of(SchemaType.OBJECT))
+        .setProperties(
+            new Map([
+                ['name', Schema.ofString('name')],
+                [
+                    'parameters',
+                    Schema.ofObject('parameter').setAdditionalProperties(
+                        new AdditionalPropertiesType().setSchemaValue(Schema.SCHEMA),
+                    ),
+                ],
+            ]),
+        );
+    private name: string;
+    private parameters: Map<string, Schema>;
+
+    constructor(name: string, parameters: Map<string, Schema>) {
+        this.name = name;
+        this.parameters = parameters;
+    }
+
+    public getName(): string {
+        return this.name;
+    }
+    public setName(name: string): Event {
+        this.name = name;
+        return this;
+    }
+    public getParameters(): Map<string, Schema> {
+        return this.parameters;
+    }
+    public setParameters(parameters: Map<string, Schema>): Event {
+        this.parameters = parameters;
+        return this;
+    }
+
+    public static outputEventMapEntry(parameters: Map<string, Schema>): [string, Event] {
+        return Event.eventMapEntry(Event.OUTPUT, parameters);
+    }
+
+    public static eventMapEntry(
+        eventName: string,
+        parameters: Map<string, Schema>,
+    ): [string, Event] {
+        return [eventName, new Event(eventName, parameters)];
+    }
+}

package/src/engine/model/EventResult.ts

@@ -0,0 +1,34 @@
+import { Event } from './Event';
+
+export class EventResult {
+    private name: string;
+    private result: Map<string, any>;
+
+    constructor(name: string, result: Map<string, any>) {
+        this.name = name;
+        this.result = result;
+    }
+
+    public getName(): string {
+        return this.name;
+    }
+    public setName(name: string): EventResult {
+        this.name = name;
+        return this;
+    }
+    public getResult(): Map<string, any> {
+        return this.result;
+    }
+    public setResult(result: Map<string, any>): EventResult {
+        this.result = result;
+        return this;
+    }
+
+    public static outputOf(result: Map<string, any>): EventResult {
+        return EventResult.of(Event.OUTPUT, result);
+    }
+
+    public static of(eventName: string, result: Map<string, any>): EventResult {
+        return new EventResult(eventName, result);
+    }
+}

package/src/engine/model/FunctionDefinition.ts

@@ -0,0 +1,69 @@
+import { AdditionalPropertiesType } from '../json/schema/object/AdditionalPropertiesType';
+import { Schema } from '../json/schema/Schema';
+import { Namespaces } from '../namespaces/Namespaces';
+import { Event } from './Event';
+import { FunctionSignature } from './FunctionSignature';
+import { Parameter } from './Parameter';
+import { Statement } from './Statement';
+import { StatementGroup } from './StatementGroup';
+
+export class FunctionDefinition extends FunctionSignature {
+    private static readonly SCHEMA_NAME1: string = 'FunctionDefinition';
+    public static readonly SCHEMA: Schema = new Schema()
+        .setNamespace(Namespaces.SYSTEM)
+        .setName(FunctionDefinition.SCHEMA_NAME1)
+        .setProperties(
+            new Map([
+                ['name', Schema.ofString('name')],
+                ['namespace', Schema.ofString('namespace')],
+                ['parameters', Schema.ofArray('parameters', Parameter.SCHEMA)],
+                [
+                    'events',
+                    Schema.ofObject('events').setAdditionalProperties(
+                        new AdditionalPropertiesType().setSchemaValue(Event.SCHEMA),
+                    ),
+                ],
+                [
+                    'parts',
+                    Schema.ofObject('parts').setAdditionalProperties(
+                        new AdditionalPropertiesType().setSchemaValue(FunctionSignature.SCHEMA),
+                    ),
+                ],
+                [
+                    'steps',
+                    Schema.ofObject('steps').setAdditionalProperties(
+                        new AdditionalPropertiesType().setSchemaValue(Statement.SCHEMA),
+                    ),
+                ],
+            ]),
+        );
+    private version: number = 1;
+    private steps?: Map<string, Statement>;
+    private stepGroups?: Map<string, StatementGroup>;
+
+    constructor(name: string) {
+        super(name);
+    }
+
+    public getVersion(): number {
+        return this.version;
+    }
+    public setVersion(version: number): FunctionDefinition {
+        this.version = version;
+        return this;
+    }
+    public getSteps(): Map<string, Statement> {
+        return this.steps ?? new Map();
+    }
+    public setSteps(steps: Map<string, Statement>): FunctionDefinition {
+        this.steps = steps;
+        return this;
+    }
+    public getStepGroups(): Map<string, StatementGroup> | undefined {
+        return this.stepGroups;
+    }
+    public setStepGroups(stepGroups: Map<string, StatementGroup>): FunctionDefinition {
+        this.stepGroups = stepGroups;
+        return this;
+    }
+}

package/src/engine/model/FunctionOutput.ts

@@ -0,0 +1,37 @@
+import { KIRuntimeException } from '../exception/KIRuntimeException';
+import { isNullValue } from '../util/NullCheck';
+import { EventResult } from './EventResult';
+import { FunctionOutputGenerator } from './FunctionOutputGenerator';
+
+export class FunctionOutput {
+    private fo: EventResult[];
+
+    private index: number = 0;
+    private generator?: FunctionOutputGenerator;
+
+    public constructor(arg: EventResult[] | FunctionOutputGenerator) {
+        if (isNullValue(arg)) throw new KIRuntimeException('Function output is generating null');
+
+        if (Array.isArray(arg) && arg.length && arg[0] instanceof EventResult) {
+            this.fo = arg as EventResult[];
+        } else {
+            this.fo = [];
+            this.generator = arg as FunctionOutputGenerator;
+        }
+    }
+
+    public next(): EventResult | undefined {
+        if (!this.generator) {
+            if (this.index < this.fo.length) return this.fo[this.index++];
+            return undefined;
+        }
+
+        const er: EventResult | undefined = this.generator.next();
+        if (er) this.fo.push(er);
+        return er;
+    }
+
+    public allResults(): EventResult[] {
+        return this.fo;
+    }
+}

package/src/engine/model/FunctionOutputGenerator.ts

@@ -0,0 +1,5 @@
+import { EventResult } from './EventResult';
+
+export interface FunctionOutputGenerator {
+    next(): EventResult | undefined;
+}

package/src/engine/model/FunctionSignature.ts

@@ -0,0 +1,67 @@
+import { AdditionalPropertiesType } from '../json/schema/object/AdditionalPropertiesType';
+import { Schema } from '../json/schema/Schema';
+import { Namespaces } from '../namespaces/Namespaces';
+import { Event } from './Event';
+import { Parameter } from './Parameter';
+
+export class FunctionSignature {
+    private static readonly SCHEMA_NAME: string = 'FunctionSignature';
+    public static readonly SCHEMA: Schema = new Schema()
+        .setNamespace(Namespaces.SYSTEM)
+        .setName(FunctionSignature.SCHEMA_NAME)
+        .setProperties(
+            new Map([
+                ['name', Schema.ofString('name')],
+                ['namespace', Schema.ofString('namespace')],
+                [
+                    'parameters',
+                    Schema.ofObject('parameters').setAdditionalProperties(
+                        new AdditionalPropertiesType().setSchemaValue(Parameter.SCHEMA),
+                    ),
+                ],
+                [
+                    'events',
+                    Schema.ofObject('events').setAdditionalProperties(
+                        new AdditionalPropertiesType().setSchemaValue(Event.SCHEMA),
+                    ),
+                ],
+            ]),
+        );
+    private namespace: string = '_';
+    private name: string;
+    private parameters: Map<string, Parameter> = new Map();
+    private events: Map<string, Event> = new Map();
+
+    constructor(name: string) {
+        this.name = name;
+    }
+
+    public getNamespace(): string {
+        return this.namespace;
+    }
+    public setNamespace(namespace: string): FunctionSignature {
+        this.namespace = namespace;
+        return this;
+    }
+    public getName(): string {
+        return this.name;
+    }
+    public setName(name: string): FunctionSignature {
+        this.name = name;
+        return this;
+    }
+    public getParameters(): Map<string, Parameter> {
+        return this.parameters;
+    }
+    public setParameters(parameters: Map<string, Parameter>): FunctionSignature {
+        this.parameters = parameters;
+        return this;
+    }
+    public getEvents(): Map<string, Event> {
+        return this.events;
+    }
+    public setEvents(events: Map<string, Event>): FunctionSignature {
+        this.events = events;
+        return this;
+    }
+}

package/src/engine/model/Parameter.ts

@@ -0,0 +1,97 @@
+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 { ParameterType } from './ParameterType';
+
+const VALUE: string = 'value';
+
+export class Parameter {
+    private static readonly SCHEMA_NAME: string = 'Parameter';
+
+    public static readonly SCHEMA: Schema = new Schema()
+        .setNamespace(Namespaces.SYSTEM)
+        .setName(Parameter.SCHEMA_NAME)
+        .setProperties(
+            new Map([
+                ['schema', Schema.SCHEMA],
+                ['parameterName', Schema.ofString('parameterName')],
+                [
+                    'variableArgument',
+                    Schema.of('variableArgument', SchemaType.BOOLEAN).setDefaultValue(false),
+                ],
+            ]),
+        );
+
+    public static readonly EXPRESSION: Schema = new Schema()
+        .setNamespace(Namespaces.SYSTEM)
+        .setName('ParameterExpression')
+        .setType(TypeUtil.of(SchemaType.OBJECT))
+        .setProperties(
+            new Map([
+                ['isExpression', Schema.ofBoolean('isExpression').setDefaultValue(true)],
+                [VALUE, Schema.ofAny(VALUE)],
+            ]),
+        );
+
+    private schema: Schema;
+
+    private parameterName: string;
+    private variableArgument: boolean = false;
+    private type: ParameterType = ParameterType.EXPRESSION;
+
+    constructor(parameterName: string, schema: Schema) {
+        this.schema = schema;
+        this.parameterName = parameterName;
+    }
+
+    public getSchema(): Schema {
+        return this.schema;
+    }
+    public setSchema(schema: Schema): Parameter {
+        this.schema = schema;
+        return this;
+    }
+    public getParameterName(): string {
+        return this.parameterName;
+    }
+    public setParameterName(parameterName: string): Parameter {
+        this.parameterName = parameterName;
+        return this;
+    }
+    public isVariableArgument(): boolean {
+        return this.variableArgument;
+    }
+    public setVariableArgument(variableArgument: boolean): Parameter {
+        this.variableArgument = variableArgument;
+        return this;
+    }
+    public getType(): ParameterType {
+        return this.type;
+    }
+    public setType(type: ParameterType): Parameter {
+        this.type = type;
+        return this;
+    }
+
+    public static ofEntry(
+        name: string,
+        schema: Schema,
+        variableArgument: boolean = false,
+        type: ParameterType = ParameterType.EXPRESSION,
+    ): [string, Parameter] {
+        return [
+            name,
+            new Parameter(name, schema).setType(type).setVariableArgument(variableArgument),
+        ];
+    }
+
+    public static of(
+        name: string,
+        schema: Schema,
+        variableArgument: boolean = false,
+        type: ParameterType = ParameterType.EXPRESSION,
+    ): Parameter {
+        return new Parameter(name, schema).setType(type).setVariableArgument(variableArgument);
+    }
+}

package/src/engine/model/ParameterReference.ts

@@ -0,0 +1,57 @@
+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 { ParameterReferenceType } from './ParameterReferenceType';
+
+export class ParameterReference {
+    private static readonly SCHEMA_NAME: string = 'ParameterReference';
+    public static readonly SCHEMA: Schema = new Schema()
+        .setNamespace(Namespaces.SYSTEM)
+        .setName(ParameterReference.SCHEMA_NAME)
+        .setType(TypeUtil.of(SchemaType.OBJECT))
+        .setProperties(
+            new Map([
+                ['references', Schema.ofString('references')],
+                ['value', Schema.ofAny('value')],
+                ['expression', Schema.ofString('expression')],
+            ]),
+        );
+    private type: ParameterReferenceType;
+    private value: any;
+    private expression?: string;
+
+    constructor(type: ParameterReferenceType) {
+        this.type = type;
+    }
+
+    public getType(): ParameterReferenceType {
+        return this.type;
+    }
+    public setType(type: ParameterReferenceType): ParameterReference {
+        this.type = type;
+        return this;
+    }
+    public getValue(): any {
+        return this.value;
+    }
+    public setValue(value: any): ParameterReference {
+        this.value = value;
+        return this;
+    }
+    public getExpression(): string | undefined {
+        return this.expression;
+    }
+    public setExpression(expression: string): ParameterReference {
+        this.expression = expression;
+        return this;
+    }
+
+    public static ofExpression(value: any): ParameterReference {
+        return new ParameterReference(ParameterReferenceType.EXPRESSION).setExpression(value);
+    }
+
+    public static ofValue(value: any): ParameterReference {
+        return new ParameterReference(ParameterReferenceType.VALUE).setValue(value);
+    }
+}

package/src/engine/model/ParameterReferenceType.ts

@@ -0,0 +1,4 @@
+export enum ParameterReferenceType {
+    VALUE = 'VALUE',
+    EXPRESSION = 'EXPRESSION',
+}

package/src/engine/model/ParameterType.ts

@@ -0,0 +1,4 @@
+export enum ParameterType {
+    CONSTANT = 'CONSTANT',
+    EXPRESSION = 'EXPRESSION',
+}

package/src/engine/model/Position.ts

@@ -0,0 +1,40 @@
+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';
+
+export class Position {
+    public static readonly SCHEMA_NAME: string = 'Position';
+    public static readonly SCHEMA: Schema = new Schema()
+        .setNamespace(Namespaces.SYSTEM)
+        .setName(Position.SCHEMA_NAME)
+        .setType(TypeUtil.of(SchemaType.OBJECT))
+        .setProperties(
+            new Map([
+                ['left', Schema.ofFloat('left')],
+                ['top', Schema.ofFloat('top')],
+            ]),
+        );
+    private left: number;
+    private top: number;
+
+    constructor(left: number, top: number) {
+        this.left = left;
+        this.top = top;
+    }
+
+    public getLeft(): number {
+        return this.left;
+    }
+    public setLeft(left: number): Position {
+        this.left = left;
+        return this;
+    }
+    public getTop(): number {
+        return this.top;
+    }
+    public setTop(top: number): Position {
+        this.top = top;
+        return this;
+    }
+}

package/src/engine/model/Statement.ts

@@ -0,0 +1,101 @@
+import { AdditionalPropertiesType } from '../json/schema/object/AdditionalPropertiesType';
+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 { AbstractStatement } from './AbstractStatement';
+import { ParameterReference } from './ParameterReference';
+import { Position } from './Position';
+
+export class Statement extends AbstractStatement {
+    public static readonly SCHEMA_NAME: string = 'Statement';
+    public static readonly SCHEMA: Schema = new Schema()
+        .setNamespace(Namespaces.SYSTEM)
+        .setName(Statement.SCHEMA_NAME)
+        .setType(TypeUtil.of(SchemaType.OBJECT))
+        .setProperties(
+            new Map([
+                ['statementName', Schema.ofString('statementName')],
+                ['comment', Schema.ofString('comment')],
+                ['description', Schema.ofString('description')],
+                ['namespace', Schema.ofString('namespace')],
+                ['name', Schema.ofString('name')],
+                [
+                    'dependentStatements',
+                    Schema.ofArray('dependentstatement', Schema.ofString('dependentstatement')),
+                ],
+                [
+                    'parameterMap',
+                    new Schema()
+                        .setName('parameterMap')
+                        .setAdditionalProperties(
+                            new AdditionalPropertiesType().setSchemaValue(
+                                Schema.ofArray('parameterReference', ParameterReference.SCHEMA),
+                            ),
+                        ),
+                ],
+                ['position', Position.SCHEMA],
+            ]),
+        );
+    private statementName: string;
+    private namespace: string;
+    private name: string;
+    private parameterMap?: Map<string, ParameterReference[]>;
+    private dependentStatements?: string[];
+
+    public constructor(statementName: string, namespace: string, name: string) {
+        super();
+        this.statementName = statementName;
+        this.namespace = namespace;
+        this.name = name;
+    }
+
+    public getStatementName(): string {
+        return this.statementName;
+    }
+    public setStatementName(statementName: string): Statement {
+        this.statementName = statementName;
+        return this;
+    }
+    public getNamespace(): string {
+        return this.namespace;
+    }
+    public setNamespace(namespace: string): Statement {
+        this.namespace = namespace;
+        return this;
+    }
+    public getName(): string {
+        return this.name;
+    }
+    public setName(name: string): Statement {
+        this.name = name;
+        return this;
+    }
+    public getParameterMap(): Map<string, ParameterReference[]> {
+        if (!this.parameterMap) {
+            this.parameterMap = new Map();
+        }
+        return this.parameterMap;
+    }
+    public setParameterMap(parameterMap: Map<string, ParameterReference[]>): Statement {
+        this.parameterMap = parameterMap;
+        return this;
+    }
+    public getDependentStatements(): string[] {
+        return this.dependentStatements ?? [];
+    }
+    public setDependentStatements(dependentStatements: string[]): Statement {
+        this.dependentStatements = dependentStatements;
+        return this;
+    }
+
+    public equals(obj: any): boolean {
+        if (!(obj instanceof Statement)) return false;
+        let s: Statement = obj as Statement;
+        return s.statementName == this.statementName;
+    }
+
+    public static ofEntry(statement: Statement): [string, Statement] {
+        return [statement.statementName, statement];
+    }
+}

package/src/engine/model/StatementGroup.ts

@@ -0,0 +1,37 @@
+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 { AbstractStatement } from './AbstractStatement';
+import { Position } from './Position';
+
+export class StatementGroup extends AbstractStatement {
+    private static readonly SCHEMA_NAME: string = 'StatementGroup';
+    public static readonly SCHEMA: Schema = new Schema()
+        .setNamespace(Namespaces.SYSTEM)
+        .setName(StatementGroup.SCHEMA_NAME)
+        .setType(TypeUtil.of(SchemaType.OBJECT))
+        .setProperties(
+            new Map([
+                ['statementGroupName', Schema.ofString('statementGroupName')],
+                ['comment', Schema.ofString('comment')],
+                ['description', Schema.ofString('description')],
+                ['position', Position.SCHEMA],
+            ]),
+        );
+
+    private statementGroupName: string;
+
+    constructor(statementGroupName: string) {
+        super();
+        this.statementGroupName = statementGroupName;
+    }
+
+    public getStatementGroupName(): string {
+        return this.statementGroupName;
+    }
+    public setStatementGroupName(statementGroupName: string): StatementGroup {
+        this.statementGroupName = statementGroupName;
+        return this;
+    }
+}

package/src/engine/namespaces/Namespaces.ts

@@ -0,0 +1,11 @@
+export class Namespaces {
+    public static readonly SYSTEM: string = 'System';
+    public static readonly SYSTEM_CTX: string = 'System.Context';
+    public static readonly SYSTEM_LOOP: string = 'System.Loop';
+    public static readonly SYSTEM_ARRAY: string = 'System.Array';
+
+    public static readonly MATH: string = 'System.Math';
+    public static readonly STRING: string = 'System.String';
+
+    private constructor() {}
+}

package/src/engine/repository/KIRunFunctionRepository.ts

@@ -0,0 +1,37 @@
+import { Function } from '../function/Function';
+import { Create } from '../function/system/context/Create';
+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 { CountLoop } from '../function/system/loop/CountLoop';
+import { RangeLoop } from '../function/system/loop/RangeLoop';
+import { MathFunctionRepository } from '../function/system/math/MathFunctionRepository';
+import { HybridRepository } from '../HybridRepository';
+import { Namespaces } from '../namespaces/Namespaces';
+
+function entry(fun: Function): [string, Function] {
+    return [fun.getSignature().getName(), fun];
+}
+
+const map: Map<string, Map<string, Function>> = new Map([
+    [
+        Namespaces.SYSTEM_CTX,
+        new Map([entry(new Create()), entry(new Get()), entry(new SetFunction())]),
+    ],
+    [Namespaces.SYSTEM_LOOP, new Map([entry(new RangeLoop()), entry(new CountLoop())])],
+    [Namespaces.SYSTEM, new Map([entry(new If()), entry(new GenerateEvent())])],
+]);
+
+export class KIRunFunctionRepository extends HybridRepository<Function> {
+    public constructor() {
+        super(
+            {
+                find(namespace: string, name: string): Function | undefined {
+                    return map.get(namespace)?.get(name);
+                },
+            },
+            new MathFunctionRepository(),
+        );
+    }
+}