@fincity/kirun-js 1.0.0

package/src/engine/repository/KIRunSchemaRepository.ts

@@ -0,0 +1,24 @@
+import { Schema } from '../json/schema/Schema';
+import { Parameter } from '../model/Parameter';
+import { Namespaces } from '../namespaces/Namespaces';
+import { Repository } from '../Repository';
+
+const map: Map<string, Schema> = new Map([
+    ['any', Schema.ofAny('any').setNamespace(Namespaces.SYSTEM)],
+    ['boolean', Schema.ofBoolean('boolean').setNamespace(Namespaces.SYSTEM)],
+    ['double', Schema.ofDouble('double').setNamespace(Namespaces.SYSTEM)],
+    ['float', Schema.ofFloat('float').setNamespace(Namespaces.SYSTEM)],
+    ['integer', Schema.ofInteger('integer').setNamespace(Namespaces.SYSTEM)],
+    ['long', Schema.ofLong('long').setNamespace(Namespaces.SYSTEM)],
+    ['number', Schema.ofNumber('number').setNamespace(Namespaces.SYSTEM)],
+    ['string', Schema.ofString('string').setNamespace(Namespaces.SYSTEM)],
+    [Parameter.EXPRESSION.getName()!, Parameter.EXPRESSION],
+]);
+
+export class KIRunSchemaRepository implements Repository<Schema> {
+    public find(namespace: string, name: string): Schema | undefined {
+        if (Namespaces.SYSTEM != namespace) return undefined;
+
+        return map.get(name);
+    }
+}

package/src/engine/runtime/ContextElement.ts

@@ -0,0 +1,28 @@
+import { Schema } from '../json/schema/Schema';
+
+export class ContextElement {
+    public static readonly NULL: ContextElement = new ContextElement(Schema.NULL, undefined);
+
+    private schema?: Schema;
+    private element: any;
+
+    public constructor(schema?: Schema, element?: any) {
+        this.schema = schema;
+        this.element = element;
+    }
+
+    public getSchema(): Schema | undefined {
+        return this.schema;
+    }
+    public setSchema(schema: Schema): ContextElement {
+        this.schema = schema;
+        return this;
+    }
+    public getElement(): any {
+        return this.element;
+    }
+    public setElement(element: any): ContextElement {
+        this.element = element;
+        return this;
+    }
+}

package/src/engine/runtime/FunctionExecutionParameters.ts

@@ -0,0 +1,74 @@
+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';
+
+export class FunctionExecutionParameters {
+    private context?: Map<string, ContextElement>;
+    private args?: Map<string, any>;
+    private events?: Map<string, Map<string, any>[]>;
+    private statementExecution?: StatementExecution;
+    private steps?: Map<string, Map<string, Map<string, any>>>;
+    private count: number = 0;
+
+    private valueExtractors: Map<string, TokenValueExtractor> = new Map();
+
+    public getContext(): Map<string, ContextElement> | undefined {
+        return this.context;
+    }
+    public setContext(context: Map<string, ContextElement>): FunctionExecutionParameters {
+        this.context = context;
+        let x: TokenValueExtractor = new ContextTokenValueExtractor(context);
+        this.valueExtractors.set(x.getPrefix(), x);
+        return this;
+    }
+    public getArguments(): Map<string, any> | undefined {
+        return this.args;
+    }
+    public setArguments(args: Map<string, any>): FunctionExecutionParameters {
+        this.args = args;
+        let x: TokenValueExtractor = new ArgumentsTokenValueExtractor(args);
+        this.valueExtractors.set(x.getPrefix(), x);
+        return this;
+    }
+    public getEvents(): Map<string, Map<string, any>[]> | undefined {
+        return this.events;
+    }
+    public setEvents(events: Map<string, Map<string, any>[]>): FunctionExecutionParameters {
+        this.events = events;
+        return this;
+    }
+    public getStatementExecution(): StatementExecution | undefined {
+        return this.statementExecution;
+    }
+    public setStatementExecution(
+        statementExecution: StatementExecution,
+    ): FunctionExecutionParameters {
+        this.statementExecution = statementExecution;
+        return this;
+    }
+    public getSteps(): Map<string, Map<string, Map<string, any>>> | undefined {
+        return this.steps;
+    }
+    public setSteps(
+        steps: Map<string, Map<string, Map<string, any>>>,
+    ): FunctionExecutionParameters {
+        this.steps = steps;
+        let x: TokenValueExtractor = new OutputMapTokenValueExtractor(steps);
+        this.valueExtractors.set(x.getPrefix(), x);
+        return this;
+    }
+    public getCount(): number {
+        return this.count;
+    }
+    public setCount(count: number): FunctionExecutionParameters {
+        this.count = count;
+        return this;
+    }
+
+    public getValuesMap(): Map<string, TokenValueExtractor> {
+        return this.valueExtractors;
+    }
+}