@fincity/kirun-js 2.8.6 → 2.10.0

package/src/engine/function/system/array/Join.ts

@@ -13,39 +13,40 @@ const VALUE = 'source';
 const DELIMITTER = 'delimiter';
 const OUTPUT = 'result';
 
-const SIGNATURE = new FunctionSignature('Join')
-    .setNamespace(Namespaces.SYSTEM_ARRAY)
-    .setParameters(
-        new Map([
-            [
-                VALUE,
-                new Parameter(
+export class Join extends AbstractFunction {
+    private readonly signature = new FunctionSignature('Join')
+        .setNamespace(Namespaces.SYSTEM_ARRAY)
+        .setParameters(
+            new Map([
+                [
                     VALUE,
-                    Schema.ofArray(
+                    new Parameter(
                         VALUE,
-                        Schema.of(
-                            'each',
-                            SchemaType.STRING,
-                            SchemaType.INTEGER,
-                            SchemaType.LONG,
-                            SchemaType.DOUBLE,
-                            SchemaType.FLOAT,
-                            SchemaType.NULL,
+                        Schema.ofArray(
+                            VALUE,
+                            Schema.of(
+                                'each',
+                                SchemaType.STRING,
+                                SchemaType.INTEGER,
+                                SchemaType.LONG,
+                                SchemaType.DOUBLE,
+                                SchemaType.FLOAT,
+                                SchemaType.NULL,
+                            ),
                         ),
                     ),
-                ),
-            ],
-            [
-                DELIMITTER,
-                new Parameter(DELIMITTER, Schema.ofString(DELIMITTER).setDefaultValue('')),
-            ],
-        ]),
-    )
-    .setEvents(new Map([Event.outputEventMapEntry(new Map([[OUTPUT, Schema.ofString(OUTPUT)]]))]));
-
-export class Join extends AbstractFunction {
+                ],
+                [
+                    DELIMITTER,
+                    new Parameter(DELIMITTER, Schema.ofString(DELIMITTER).setDefaultValue('')),
+                ],
+            ]),
+        )
+        .setEvents(
+            new Map([Event.outputEventMapEntry(new Map([[OUTPUT, Schema.ofString(OUTPUT)]]))]),
+        );
     public getSignature(): FunctionSignature {
-        return SIGNATURE;
+        return this.signature;
     }
 
     protected async internalExecute(context: FunctionExecutionParameters): Promise<FunctionOutput> {

package/src/engine/function/system/context/Create.ts

@@ -18,30 +18,28 @@ import { AbstractFunction } from '../../AbstractFunction';
 
 const NAME = 'name';
 const SCHEMA = 'schema';
-
-const SIGNATURE: FunctionSignature = new FunctionSignature('Create')
-    .setNamespace(Namespaces.SYSTEM_CTX)
-    .setParameters(
-        new Map([
-            Parameter.ofEntry(
-                NAME,
-                new Schema()
-                    .setName(NAME)
-                    .setType(TypeUtil.of(SchemaType.STRING))
-                    .setMinLength(1)
-                    .setFormat(StringFormat.REGEX)
-                    .setPattern('^[a-zA-Z_$][a-zA-Z_$0-9]*$'),
-                false,
-                ParameterType.CONSTANT,
-            ),
-            Parameter.ofEntry(SCHEMA, Schema.SCHEMA, false, ParameterType.CONSTANT),
-        ]),
-    )
-    .setEvents(new Map([Event.outputEventMapEntry(new Map())]));
-
 export class Create extends AbstractFunction {
+    private readonly signature = new FunctionSignature('Create')
+        .setNamespace(Namespaces.SYSTEM_CTX)
+        .setParameters(
+            new Map([
+                Parameter.ofEntry(
+                    NAME,
+                    new Schema()
+                        .setName(NAME)
+                        .setType(TypeUtil.of(SchemaType.STRING))
+                        .setMinLength(1)
+                        .setFormat(StringFormat.REGEX)
+                        .setPattern('^[a-zA-Z_$][a-zA-Z_$0-9]*$'),
+                    false,
+                    ParameterType.CONSTANT,
+                ),
+                Parameter.ofEntry(SCHEMA, Schema.SCHEMA, false, ParameterType.CONSTANT),
+            ]),
+        )
+        .setEvents(new Map([Event.outputEventMapEntry(new Map())]));
     public getSignature(): FunctionSignature {
-        return SIGNATURE;
+        return this.signature;
     }
 
     protected async internalExecute(context: FunctionExecutionParameters): Promise<FunctionOutput> {

package/src/engine/function/system/context/Get.ts

@@ -16,28 +16,28 @@ import { AbstractFunction } from '../../AbstractFunction';
 
 const NAME = 'name';
 const VALUE = 'value';
-const SIGNATURE = new FunctionSignature('Get')
-    .setNamespace(Namespaces.SYSTEM_CTX)
-    .setParameters(
-        new Map([
-            Parameter.ofEntry(
-                NAME,
-                new Schema()
-                    .setName(NAME)
-                    .setType(TypeUtil.of(SchemaType.STRING))
-                    .setMinLength(1)
-                    .setFormat(StringFormat.REGEX)
-                    .setPattern('^[a-zA-Z_$][a-zA-Z_$0-9]*$'),
-                false,
-                ParameterType.CONSTANT,
-            ),
-        ]),
-    )
-    .setEvents(new Map([Event.outputEventMapEntry(new Map([[VALUE, Schema.ofAny(VALUE)]]))]));
 
 export class Get extends AbstractFunction {
+    private readonly signature = new FunctionSignature('Get')
+        .setNamespace(Namespaces.SYSTEM_CTX)
+        .setParameters(
+            new Map([
+                Parameter.ofEntry(
+                    NAME,
+                    new Schema()
+                        .setName(NAME)
+                        .setType(TypeUtil.of(SchemaType.STRING))
+                        .setMinLength(1)
+                        .setFormat(StringFormat.REGEX)
+                        .setPattern('^[a-zA-Z_$][a-zA-Z_$0-9]*$'),
+                    false,
+                    ParameterType.CONSTANT,
+                ),
+            ]),
+        )
+        .setEvents(new Map([Event.outputEventMapEntry(new Map([[VALUE, Schema.ofAny(VALUE)]]))]));
     public getSignature(): FunctionSignature {
-        return SIGNATURE;
+        return this.signature;
     }
 
     protected async internalExecute(context: FunctionExecutionParameters): Promise<FunctionOutput> {

package/src/engine/function/system/context/SetFunction.ts

@@ -23,23 +23,26 @@ import { AbstractFunction } from '../../AbstractFunction';
 
 const NAME = 'name';
 const VALUE = 'value';
-const SIGNATURE = new FunctionSignature('Set')
-    .setNamespace(Namespaces.SYSTEM_CTX)
-    .setParameters(
-        new Map([
-            Parameter.ofEntry(
-                NAME,
-                new Schema().setName(NAME).setType(TypeUtil.of(SchemaType.STRING)).setMinLength(1),
-                false,
-            ),
-            Parameter.ofEntry(VALUE, Schema.ofAny(VALUE)),
-        ]),
-    )
-    .setEvents(new Map([Event.outputEventMapEntry(new Map())]));
 
 export class SetFunction extends AbstractFunction {
+    private readonly signature = new FunctionSignature('Set')
+        .setNamespace(Namespaces.SYSTEM_CTX)
+        .setParameters(
+            new Map([
+                Parameter.ofEntry(
+                    NAME,
+                    new Schema()
+                        .setName(NAME)
+                        .setType(TypeUtil.of(SchemaType.STRING))
+                        .setMinLength(1),
+                    false,
+                ),
+                Parameter.ofEntry(VALUE, Schema.ofAny(VALUE)),
+            ]),
+        )
+        .setEvents(new Map([Event.outputEventMapEntry(new Map())]));
     public getSignature(): FunctionSignature {
-        return SIGNATURE;
+        return this.signature;
     }
 
     protected async internalExecute(context: FunctionExecutionParameters): Promise<FunctionOutput> {

package/src/engine/function/system/date/DateFunctionRepository.ts

@@ -23,7 +23,7 @@ import { FromDateString } from './FromDateString';
 import { GetCurrentTimestamp } from './GetCurrent';
 
 export class DateFunctionRepository implements Repository<Function> {
-    private static readonly repoMap: Map<string, Function> = MapUtil.ofArrayEntries(
+    private readonly repoMap: Map<string, Function> = MapUtil.ofArrayEntries(
         ['EpochSecondsToTimestamp', new EpochToTimestamp('EpochSecondsToTimestamp', true)],
         [
             'EpochMillisecondsToTimestamp',
@@ -246,21 +246,19 @@ export class DateFunctionRepository implements Repository<Function> {
         ['FromDateString', new FromDateString()],
     );
 
-    private static readonly filterableNames = Array.from(
-        DateFunctionRepository.repoMap.values(),
-    ).map((e) => e.getSignature().getFullName());
+    private readonly filterableNames = Array.from(this.repoMap.values()).map((e) =>
+        e.getSignature().getFullName(),
+    );
 
     find(namespace: string, name: string): Promise<Function | undefined> {
         if (namespace != Namespaces.DATE) {
             return Promise.resolve(undefined);
         }
-        return Promise.resolve(DateFunctionRepository.repoMap.get(name));
+        return Promise.resolve(this.repoMap.get(name));
     }
     filter(name: string): Promise<string[]> {
         return Promise.resolve(
-            DateFunctionRepository.filterableNames.filter(
-                (e) => e.toLowerCase().indexOf(name.toLowerCase()) !== -1,
-            ),
+            this.filterableNames.filter((e) => e.toLowerCase().indexOf(name.toLowerCase()) !== -1),
         );
     }
 }

package/src/engine/function/system/date/EpochToTimestamp.ts

@@ -12,7 +12,6 @@ import { AbstractFunction } from '../../AbstractFunction';
 import { AbstractDateFunction } from './AbstractDateFunction';
 
 export class EpochToTimestamp extends AbstractFunction {
-    private readonly signature: FunctionSignature;
     private readonly isSeconds: boolean;
     private readonly paramName: string;
 
@@ -51,6 +50,7 @@ export class EpochToTimestamp extends AbstractFunction {
             );
     }
 
+    private readonly signature;
     public getSignature(): FunctionSignature {
         return this.signature;
     }

package/src/engine/function/system/date/GetNames.ts

@@ -65,7 +65,7 @@ export class GetNames extends AbstractDateFunction {
 
         if (unit === 'WEEKDAYS') {
             return [1, 2, 3, 4, 5, 6, 7].map((day) =>
-                DateTime.now().setLocale(locale).set({ month: 7, day }).toFormat('EEEE'),
+                DateTime.now().setLocale(locale).set({ month: 7, year: 2024, day }).toFormat('EEEE'),
             );
         }
 

package/src/engine/function/system/date/IsValidISODate.ts

@@ -12,7 +12,7 @@ import { AbstractDateFunction } from './AbstractDateFunction';
 import { DateTime } from 'luxon';
 
 export class IsValidISODate extends AbstractFunction {
-    private static readonly SIGNATURE = new FunctionSignature('IsValidISODate')
+    private readonly signature = new FunctionSignature('IsValidISODate')
         .setNamespace(Namespaces.DATE)
         .setParameters(
             new Map([
@@ -43,15 +43,13 @@ export class IsValidISODate extends AbstractFunction {
         return Promise.resolve(
             new FunctionOutput([
                 EventResult.outputOf(
-                    MapUtil.of(
-                        AbstractDateFunction.EVENT_RESULT_NAME,
-                        dt.isValid,
-                    ),
+                    MapUtil.of(AbstractDateFunction.EVENT_RESULT_NAME, dt.isValid),
                 ),
             ]),
         );
     }
+
     public getSignature(): FunctionSignature {
-        return IsValidISODate.SIGNATURE;
+        return this.signature;
     }
 }

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

@@ -10,15 +10,15 @@ import { FunctionExecutionParameters } from '../../../runtime/FunctionExecutionP
 import { AbstractFunction } from '../../AbstractFunction';
 
 const STEP_NAME = 'stepName';
-
-const SIGNATURE = new FunctionSignature('Break')
-    .setNamespace(Namespaces.SYSTEM_LOOP)
-    .setParameters(new Map([Parameter.ofEntry(STEP_NAME, Schema.of(STEP_NAME, SchemaType.STRING))]))
-    .setEvents(new Map([Event.outputEventMapEntry(new Map([]))]));
-
 export class Break extends AbstractFunction {
+    private readonly signature = new FunctionSignature('Break')
+        .setNamespace(Namespaces.SYSTEM_LOOP)
+        .setParameters(
+            new Map([Parameter.ofEntry(STEP_NAME, Schema.of(STEP_NAME, SchemaType.STRING))]),
+        )
+        .setEvents(new Map([Event.outputEventMapEntry(new Map([]))]));
     public getSignature(): FunctionSignature {
-        return SIGNATURE;
+        return this.signature;
     }
 
     protected async internalExecute(context: FunctionExecutionParameters): Promise<FunctionOutput> {

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

@@ -13,22 +13,21 @@ const COUNT = 'count';
 const VALUE = 'value';
 const INDEX = 'index';
 
-const SIGNATURE = new FunctionSignature('CountLoop')
-    .setNamespace(Namespaces.SYSTEM_LOOP)
-    .setParameters(new Map([Parameter.ofEntry(COUNT, Schema.of(COUNT, SchemaType.INTEGER))]))
-    .setEvents(
-        new Map([
-            Event.eventMapEntry(
-                Event.ITERATION,
-                new Map([[INDEX, Schema.of(INDEX, SchemaType.INTEGER)]]),
-            ),
-            Event.outputEventMapEntry(new Map([[VALUE, Schema.of(VALUE, SchemaType.INTEGER)]])),
-        ]),
-    );
-
 export class CountLoop extends AbstractFunction {
+    private readonly signature = new FunctionSignature('CountLoop')
+        .setNamespace(Namespaces.SYSTEM_LOOP)
+        .setParameters(new Map([Parameter.ofEntry(COUNT, Schema.of(COUNT, SchemaType.INTEGER))]))
+        .setEvents(
+            new Map([
+                Event.eventMapEntry(
+                    Event.ITERATION,
+                    new Map([[INDEX, Schema.of(INDEX, SchemaType.INTEGER)]]),
+                ),
+                Event.outputEventMapEntry(new Map([[VALUE, Schema.of(VALUE, SchemaType.INTEGER)]])),
+            ]),
+        );
     public getSignature(): FunctionSignature {
-        return SIGNATURE;
+        return this.signature;
     }
 
     protected async internalExecute(context: FunctionExecutionParameters): Promise<FunctionOutput> {

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

@@ -14,27 +14,26 @@ 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 {
+    private readonly 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)]])),
+            ]),
+        );
     public getSignature(): FunctionSignature {
-        return SIGNATURE;
+        return this.signature;
     }
 
     protected async internalExecute(context: FunctionExecutionParameters): Promise<FunctionOutput> {

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

@@ -15,81 +15,80 @@ const STEP = 'step';
 const VALUE = 'value';
 const INDEX = 'index';
 
-const SIGNATURE = new FunctionSignature('RangeLoop')
-    .setNamespace(Namespaces.SYSTEM_LOOP)
-    .setParameters(
-        new Map([
-            Parameter.ofEntry(
-                FROM,
-                Schema.of(
+export class RangeLoop extends AbstractFunction {
+    private readonly signature = new FunctionSignature('RangeLoop')
+        .setNamespace(Namespaces.SYSTEM_LOOP)
+        .setParameters(
+            new Map([
+                Parameter.ofEntry(
                     FROM,
-                    SchemaType.INTEGER,
-                    SchemaType.LONG,
-                    SchemaType.FLOAT,
-                    SchemaType.DOUBLE,
-                ).setDefaultValue(0),
-            ),
-            Parameter.ofEntry(
-                TO,
-                Schema.of(
+                    Schema.of(
+                        FROM,
+                        SchemaType.INTEGER,
+                        SchemaType.LONG,
+                        SchemaType.FLOAT,
+                        SchemaType.DOUBLE,
+                    ).setDefaultValue(0),
+                ),
+                Parameter.ofEntry(
                     TO,
-                    SchemaType.INTEGER,
-                    SchemaType.LONG,
-                    SchemaType.FLOAT,
-                    SchemaType.DOUBLE,
-                ).setDefaultValue(1),
-            ),
-            Parameter.ofEntry(
-                STEP,
-                Schema.of(
+                    Schema.of(
+                        TO,
+                        SchemaType.INTEGER,
+                        SchemaType.LONG,
+                        SchemaType.FLOAT,
+                        SchemaType.DOUBLE,
+                    ).setDefaultValue(1),
+                ),
+                Parameter.ofEntry(
                     STEP,
-                    SchemaType.INTEGER,
-                    SchemaType.LONG,
-                    SchemaType.FLOAT,
-                    SchemaType.DOUBLE,
-                )
-                    .setDefaultValue(1)
-                    .setNot(new Schema().setConstant(0)),
-            ),
-        ]),
-    )
-    .setEvents(
-        new Map([
-            Event.eventMapEntry(
-                Event.ITERATION,
-                new Map([
-                    [
-                        INDEX,
-                        Schema.of(
+                    Schema.of(
+                        STEP,
+                        SchemaType.INTEGER,
+                        SchemaType.LONG,
+                        SchemaType.FLOAT,
+                        SchemaType.DOUBLE,
+                    )
+                        .setDefaultValue(1)
+                        .setNot(new Schema().setConstant(0)),
+                ),
+            ]),
+        )
+        .setEvents(
+            new Map([
+                Event.eventMapEntry(
+                    Event.ITERATION,
+                    new Map([
+                        [
                             INDEX,
-                            SchemaType.INTEGER,
-                            SchemaType.LONG,
-                            SchemaType.FLOAT,
-                            SchemaType.DOUBLE,
-                        ),
-                    ],
-                ]),
-            ),
-            Event.outputEventMapEntry(
-                new Map([
-                    [
-                        VALUE,
-                        Schema.of(
+                            Schema.of(
+                                INDEX,
+                                SchemaType.INTEGER,
+                                SchemaType.LONG,
+                                SchemaType.FLOAT,
+                                SchemaType.DOUBLE,
+                            ),
+                        ],
+                    ]),
+                ),
+                Event.outputEventMapEntry(
+                    new Map([
+                        [
                             VALUE,
-                            SchemaType.INTEGER,
-                            SchemaType.LONG,
-                            SchemaType.FLOAT,
-                            SchemaType.DOUBLE,
-                        ),
-                    ],
-                ]),
-            ),
-        ]),
-    );
-
-export class RangeLoop extends AbstractFunction {
+                            Schema.of(
+                                VALUE,
+                                SchemaType.INTEGER,
+                                SchemaType.LONG,
+                                SchemaType.FLOAT,
+                                SchemaType.DOUBLE,
+                            ),
+                        ],
+                    ]),
+                ),
+            ]),
+        );
     public getSignature(): FunctionSignature {
-        return SIGNATURE;
+        return this.signature;
     }
 
     protected async internalExecute(context: FunctionExecutionParameters): Promise<FunctionOutput> {

package/src/engine/function/system/math/Add.ts

@@ -9,17 +9,19 @@ import { FunctionExecutionParameters } from '../../../runtime/FunctionExecutionP
 import { AbstractFunction } from '../../AbstractFunction';
 
 const VALUE = 'value';
-
-const SIGNATURE = new FunctionSignature('Add')
-    .setNamespace(Namespaces.MATH)
-    .setParameters(
-        new Map([[VALUE, new Parameter(VALUE, Schema.ofNumber(VALUE)).setVariableArgument(true)]]),
-    )
-    .setEvents(new Map([Event.outputEventMapEntry(new Map([[VALUE, Schema.ofNumber(VALUE)]]))]));
-
 export class Add extends AbstractFunction {
+    private readonly signature = new FunctionSignature('Add')
+        .setNamespace(Namespaces.MATH)
+        .setParameters(
+            new Map([
+                [VALUE, new Parameter(VALUE, Schema.ofNumber(VALUE)).setVariableArgument(true)],
+            ]),
+        )
+        .setEvents(
+            new Map([Event.outputEventMapEntry(new Map([[VALUE, Schema.ofNumber(VALUE)]]))]),
+        );
     public getSignature(): FunctionSignature {
-        return SIGNATURE;
+        return this.signature;
     }
 
     protected async internalExecute(context: FunctionExecutionParameters): Promise<FunctionOutput> {

package/src/engine/function/system/math/GenericMathFunction.ts

@@ -15,22 +15,11 @@ const VALUE = 'value';
 const VALUE1 = 'value1';
 const VALUE2 = 'value2';
 
-const paramFunctions = [
-    () => {
-        return new Map([[VALUE, new Parameter(VALUE, Schema.ofNumber(VALUE))]]);
-    },
-    () => {
-        return new Map([
-            [VALUE1, new Parameter(VALUE1, Schema.ofNumber(VALUE1))],
-            [VALUE2, new Parameter(VALUE2, Schema.ofNumber(VALUE2))],
-        ]);
-    },
-];
-
 export class GenericMathFunction extends AbstractFunction {
     private signature: FunctionSignature;
     private parametersNumber: number;
     private mathFunction: (v1: number, v2?: number) => number;
+    private readonly paramFunctions: Array<() => Map<string, Parameter>>;
 
     public constructor(
         functionName: string,
@@ -39,12 +28,23 @@ export class GenericMathFunction extends AbstractFunction {
         ...returnType: SchemaType[]
     ) {
         super();
+        this.paramFunctions = [
+            () => {
+                return new Map([[VALUE, new Parameter(VALUE, Schema.ofNumber(VALUE))]]);
+            },
+            () => {
+                return new Map([
+                    [VALUE1, new Parameter(VALUE1, Schema.ofNumber(VALUE1))],
+                    [VALUE2, new Parameter(VALUE2, Schema.ofNumber(VALUE2))],
+                ]);
+            },
+        ];
         if (!returnType || !returnType.length) returnType = [SchemaType.DOUBLE];
         this.parametersNumber = parametersNumber;
         this.mathFunction = mathFunction;
         this.signature = new FunctionSignature(functionName)
             .setNamespace(Namespaces.MATH)
-            .setParameters(paramFunctions[parametersNumber - 1]())
+            .setParameters(this.paramFunctions[parametersNumber - 1]())
             .setEvents(
                 new Map([
                     Event.outputEventMapEntry(

package/src/engine/function/system/math/Hypotenuse.ts

@@ -13,7 +13,7 @@ import { AbstractFunction } from '../../AbstractFunction';
 const VALUE = 'value';
 
 export class Hypotenuse extends AbstractFunction {
-    private static readonly SIGNATURE: FunctionSignature = new FunctionSignature('Hypotenuse')
+    private readonly signature: FunctionSignature = new FunctionSignature('Hypotenuse')
         .setNamespace(Namespaces.MATH)
         .setParameters(
             new Map([
@@ -38,7 +38,7 @@ export class Hypotenuse extends AbstractFunction {
     }
 
     public getSignature(): FunctionSignature {
-        return Hypotenuse.SIGNATURE;
+        return this.signature;
     }
 
     protected async internalExecute(context: FunctionExecutionParameters): Promise<FunctionOutput> {