@fincity/kirun-js 2.3.2 → 2.5.0

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@fincity/kirun-js",
-    "version": "2.3.2",
+    "version": "2.5.0",
     "description": "Javascript Runtime for Kinetic Instructions",
     "source": "src/index.ts",
     "main": "dist/index.js",
@@ -35,12 +35,12 @@
         "@parcel/transformer-typescript-types": "^2.7.0",
         "@tsconfig/recommended": "^1.0.1",
         "@types/jest": "^28.1.8",
+        "jest": "^29.5.0",
         "parcel": "^2.7.0",
         "prettier": "2.7.1",
-        "typescript": "^5.1.3",
+        "ts-jest": "^29.1.0",
         "ts-loader": "^9.3.1",
-        "jest": "^29.5.0",
-        "ts-jest": "^29.1.0"
+        "typescript": "^5.1.3"
     },
     "jest": {
         "transform": {

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

@@ -22,6 +22,10 @@ export abstract class AbstractDateFunction extends AbstractFunction {
     public static readonly PARAMETER_DATE_NAME: string = 'isoDate';
 
     public static readonly PARAMETER_FIELD_NAME: string = 'value';
+
+    public static readonly PARAMETER_INT_NAME: string = "intValue";
+
+	public static readonly PARAMETER_UNIT_NAME: string  = "unit";
     
     protected static readonly PARAMETER_DATE: Parameter = new Parameter(
         AbstractDateFunction.PARAMETER_DATE_NAME,
@@ -33,6 +37,17 @@ export abstract class AbstractDateFunction extends AbstractFunction {
         Schema.ofInteger(this.PARAMETER_FIELD_NAME)
     );
 
+    protected static readonly PARAMETER_INT : Parameter = new Parameter(
+        AbstractDateFunction.PARAMETER_INT_NAME,
+        Schema.ofInteger(this.PARAMETER_INT_NAME)
+    );
+
+    protected static readonly PARAMETER_UNIT : Parameter = new Parameter(
+        AbstractDateFunction.PARAMETER_UNIT_NAME,
+        Schema.ofString(this.PARAMETER_UNIT_NAME)
+        .setEnums(["YEAR" , "MONTH" , "DAY" , "HOUR" , "MINUTE" , "SECOND" , "MILLISECOND"])
+    );
+
     protected static readonly EVENT_INT: Event = new Event(
         Event.OUTPUT,
         MapUtil.of(
@@ -41,6 +56,22 @@ export abstract class AbstractDateFunction extends AbstractFunction {
         ),
     );
 
+    protected static readonly EVENT_BOOLEAN: Event = new Event(
+        Event.OUTPUT,
+        MapUtil.of(
+            AbstractDateFunction.EVENT_RESULT_NAME,
+            Schema.ofBoolean(AbstractDateFunction.EVENT_RESULT_NAME)
+        )
+    );
+
+    protected static readonly EVENT_DATE : Event = new Event(
+        Event.OUTPUT,
+        MapUtil.of(
+            AbstractDateFunction.EVENT_RESULT_NAME,
+            Schema.ofString(AbstractDateFunction.EVENT_RESULT_NAME).setRef(Namespaces.DATE + ".timeStamp")
+        )
+    ); 
+
     public getSignature(): FunctionSignature {
         return this.signature;
     }
@@ -79,7 +110,7 @@ export abstract class AbstractDateFunction extends AbstractFunction {
             }
 
 
-        })(Namespaces.DATE, name, AbstractDateFunction.EVENT_INT, AbstractDateFunction.PARAMETER_DATE)];
+        })(Namespaces.DATE, name, AbstractDateFunction.EVENT_BOOLEAN, AbstractDateFunction.PARAMETER_DATE)];
     }
 
     public static ofEntryDateAndIntegerOutput(name: string, fun: (date: string) => number) : [string, Function] {
@@ -101,4 +132,31 @@ export abstract class AbstractDateFunction extends AbstractFunction {
         })(Namespaces.DATE, name, AbstractDateFunction.EVENT_INT, AbstractDateFunction.PARAMETER_DATE)];
     }
 
-}
+    public static ofEntryDateWithIntegerUnitWithOutputName( functionName: string, 
+        func: (date: string, amount: number, unit: string) => string): [string, Function] {
+            return [functionName, new (class extends AbstractDateFunction {
+                constructor(namespace: string, functionName: string, event: Event, ...parameter: Parameter[]) {
+                    super(namespace, functionName, event, ...parameter);
+                }
+
+                protected async internalExecute(context: FunctionExecutionParameters): Promise<FunctionOutput> {
+
+                    const date = context.getArguments()?.get(AbstractDateFunction.PARAMETER_DATE_NAME);
+    
+                    if(isNullValue(date) || !ValidDateTimeUtil.validate(date))
+                        throw new KIRuntimeException("Please provide a valid date object");
+
+                    const value = context.getArguments()?.get(AbstractDateFunction.PARAMETER_INT_NAME);
+
+                    const unit = context.getArguments()?.get(AbstractDateFunction.PARAMETER_UNIT_NAME);
+    
+                    return new FunctionOutput([EventResult.outputOf(MapUtil.of( AbstractDateFunction.EVENT_RESULT_NAME, func(date, value , unit)))]);
+
+                }
+            })(Namespaces.DATE, functionName, AbstractDateFunction.EVENT_DATE,
+                 AbstractDateFunction.PARAMETER_DATE, AbstractDateFunction.PARAMETER_INT, AbstractDateFunction.PARAMETER_UNIT)];
+
+          
+        }
+
+}

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

@@ -3,12 +3,33 @@ import { Repository } from "../../../Repository";
 import { MapUtil } from "../../../util/MapUtil";
 import { AbstractDateFunction } from "./AbstractDateFunction";
 import { Function } from '../../Function';
+import { KIRuntimeException } from "../../../exception/KIRuntimeException";
+import mapEntry from '../../../util/mapEntry';
+import { DateToEpoch } from "./DateToEpoch";
+import { DifferenceOfTimestamps } from "./DifferenceOfTimestamps";
+import { EpochToDate } from "./EpochToDate";
+import { GetCurrentTimeStamp } from "./GetCurrentTimeStamp";
+import { GetTimeAsArray } from "./GetTimeAsArray";
+import { GetTimeAsObject } from "./GetTimeAsObject";
+import { IsValidISODate } from "./IsValidISODate";
+import { MaximumTimestamp } from "./MaximumTimestamp";
+import { MinimumTimestamp } from "./MinimumTimestamp";
 
 
 export class DateFunctionRepository implements Repository<Function> {
 
     private static readonly repoMap: Map<string, Function> = MapUtil.ofArrayEntries(
 
+        mapEntry(new DateToEpoch()),
+        mapEntry(new EpochToDate()),
+        mapEntry(new GetCurrentTimeStamp()),
+        mapEntry(new DifferenceOfTimestamps()),
+        mapEntry(new IsValidISODate()),
+        mapEntry(new GetTimeAsArray()),
+        mapEntry(new GetTimeAsObject()),
+        mapEntry(new MaximumTimestamp()),
+        mapEntry(new MinimumTimestamp()),
+
         AbstractDateFunction.ofEntryDateAndBooleanOutput("IsLeapYear", date => {
            const year = new Date(date).getUTCFullYear();
            return (year % 4 === 0 && year % 100 !== 0) || (year % 400 === 0);
@@ -20,7 +41,7 @@ export class DateFunctionRepository implements Repository<Function> {
 
         AbstractDateFunction.ofEntryDateAndIntegerOutput("GetFullYear", date => new Date(date).getUTCFullYear()),
 
-        AbstractDateFunction.ofEntryDateAndIntegerOutput("GetMonth", date => new Date(date).getUTCMonth() + 1),
+        AbstractDateFunction.ofEntryDateAndIntegerOutput("GetMonth", date => new Date(date).getUTCMonth()),
 
         AbstractDateFunction.ofEntryDateAndIntegerOutput("GetHours", date => new Date(date).getUTCHours()),
 
@@ -31,13 +52,95 @@ export class DateFunctionRepository implements Repository<Function> {
         AbstractDateFunction.ofEntryDateAndIntegerOutput("GetMilliSeconds", date => new Date(date).getUTCMilliseconds()),
 
         AbstractDateFunction.ofEntryDateAndIntegerOutput("GetTime" , date => new Date(date).getTime()),
-    
+
+        AbstractDateFunction.ofEntryDateWithIntegerUnitWithOutputName("AddTime", 
+            (date , value , unit) => this.changeAmountToUnit(date, unit, value, true)
+        ),
+
+        AbstractDateFunction.ofEntryDateWithIntegerUnitWithOutputName("SubtractTime",
+            (date , value , unit) => this.changeAmountToUnit(date, unit, value, false)
+        )
     );
 
     private static readonly filterableNames = Array.from(
         DateFunctionRepository.repoMap.values(),
     ).map((e) => e.getSignature().getFullName());
+
+    private static changeAmountToUnit(inputDate: string , unit: string, value: number, isAdd: boolean): string{
+
+        const amount = isAdd ? value : -1 * value;
+
+        const date = this.getFullUTCDate(inputDate);
+        const originalOffset = this.getTimezoneOffset(inputDate);
+    
+        switch(unit){
+
+            case "MILLISECOND" : date.setMilliseconds(date.getMilliseconds() + amount);
+                                break;
+            case "SECOND" :  date.setSeconds(date.getSeconds() + amount);
+                                break;
+            case "MINUTE" : date.setMinutes(date.getMinutes() + amount);
+                                break;
+            case "HOUR" : date.setHours(date.getHours() + amount);
+                                break;
+            case "DAY" : date.setDate(date.getDate() + amount);
+                                break;
+            case "MONTH" : date.setMonth(date.getMonth() + amount);
+                                break;
+            case "YEAR" : date.setFullYear(date.getFullYear() + amount);
+                                break;
+            default :
+                throw new KIRuntimeException("No such unit: " + unit)
+
+        }
+
+        return this.formatDate(date, originalOffset);
+    }
     
+    private static getTimezoneOffset(dateString: string): string {
+        const lastChar = dateString.charAt(dateString.length - 1);
+        if (lastChar === 'Z') return '+00:00';
+    
+        const offsetStart = dateString.indexOf('+') !== -1 ? dateString.lastIndexOf('+') : dateString.lastIndexOf('-');
+        if (offsetStart === -1) return '+00:00';
+    
+        let offset = dateString.substring(offsetStart);
+        if (offset.length === 3) {
+            offset = offset.substring(0, 1) + '0' + offset.substring(1) + ':00';
+        } else if (offset.length === 5) {
+            offset = offset.substring(0, 3) + ':' + offset.substring(3);
+        }
+    
+        return offset;
+    }
+
+    private static getFullUTCDate(inputDate:string): Date {
+
+        if(inputDate.lastIndexOf('+') !== -1)
+            inputDate = inputDate.substring(0, inputDate.lastIndexOf('+')) + 'Z';
+        else if(inputDate.lastIndexOf('-') !== -1)
+            inputDate = inputDate.substring(0, inputDate.lastIndexOf('-')) + 'Z';
+
+        const date: Date = new Date(inputDate);
+    
+        return new Date(Date.UTC(date.getUTCFullYear(), date.getUTCMonth() + 1, 
+                        date.getUTCDate(), date.getUTCHours(), date.getUTCMinutes(), 
+                        date.getUTCSeconds(), date.getUTCMilliseconds()));
+    }
+
+    private static formatDate(date: Date, offset: string): string {
+        const pad = (num: number) => num.toString().padStart(2, '0');
+        
+        const year = date.getUTCMonth() === 0 ? date.getUTCFullYear() - 1 : date.getUTCFullYear();
+        const month = pad(date.getUTCMonth() === 0 ? 12 : date.getUTCMonth());
+        const day = pad(date.getUTCDate());
+        const hours = pad(date.getUTCHours());
+        const minutes = pad(date.getUTCMinutes());
+        const seconds = pad(date.getUTCSeconds());
+        const milliseconds = pad(date.getUTCMilliseconds());
+        
+        return `${year}-${month}-${day}T${hours}:${minutes}:${seconds}.${milliseconds}${offset}`;
+    }
     
     find(namespace: string, name: string): Promise<Function | undefined> {
         if (namespace != Namespaces.DATE) {

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

@@ -22,17 +22,17 @@ const functionObjectsIndex: { [key: string]: AbstractFunction } = {
         SchemaType.FLOAT,
         SchemaType.DOUBLE,
     ),
-    ACosine: new GenericMathFunction('ArcCosine', (v) => Math.acos(v)),
-    ASine: new GenericMathFunction('ArcSine', (v) => Math.asin(v)),
-    ATangent: new GenericMathFunction('ArcTangent', (v) => Math.atan(v)),
+    ArcCosine: new GenericMathFunction('ArcCosine', (v) => Math.acos(v)),
+    ArcSine: new GenericMathFunction('ArcSine', (v) => Math.asin(v)),
+    ArcTangent: new GenericMathFunction('ArcTangent', (v) => Math.atan(v)),
     Ceiling: new GenericMathFunction('Ceiling', (v) => Math.ceil(v)),
     Cosine: new GenericMathFunction('Cosine', (v) => Math.cos(v)),
-    CosineH: new GenericMathFunction('HyperbolicCosine', (v) => Math.cosh(v)),
+    HyperbolicCosine: new GenericMathFunction('HyperbolicCosine', (v) => Math.cosh(v)),
     CubeRoot: new GenericMathFunction('CubeRoot', (v) => Math.cbrt(v)),
     Exponential: new GenericMathFunction('Exponential', (v) => Math.exp(v)),
-    Expm1: new GenericMathFunction('ExponentialMinus1', (v) => Math.expm1(v)),
+    ExponentialMinus1: new GenericMathFunction('ExponentialMinus1', (v) => Math.expm1(v)),
     Floor: new GenericMathFunction('Floor', (v) => Math.floor(v)),
-    Log: new GenericMathFunction('LogNatural', (v) => Math.log(v)),
+    LogNatural: new GenericMathFunction('LogNatural', (v) => Math.log(v)),
     Log10: new GenericMathFunction('Log10', (v) => Math.log10(v)),
     Round: new GenericMathFunction(
         'Round',
@@ -42,13 +42,13 @@ const functionObjectsIndex: { [key: string]: AbstractFunction } = {
         SchemaType.LONG,
     ),
     Sine: new GenericMathFunction('Sine', (v) => Math.sin(v)),
-    SineH: new GenericMathFunction('HyperbolicSine', (v) => Math.sinh(v)),
+    HyperbolicSine: new GenericMathFunction('HyperbolicSine', (v) => Math.sinh(v)),
     Tangent: new GenericMathFunction('Tangent', (v) => Math.tan(v)),
-    TangentH: new GenericMathFunction('HyperbolicTangent', (v) => Math.tanh(v)),
+    HyperbolicTangent: new GenericMathFunction('HyperbolicTangent', (v) => Math.tanh(v)),
     ToDegrees: new GenericMathFunction('ToDegrees', (v) => v * (Math.PI / 180)),
     ToRadians: new GenericMathFunction('ToRadians', (v) => v * (180 / Math.PI)),
     SquareRoot: new GenericMathFunction('SquareRoot', (v) => Math.sqrt(v)),
-    ArcTangent: new GenericMathFunction('ArcTangent2', (v1, v2) => Math.atan2(v1, v2!), 2),
+    ArcTangent2: new GenericMathFunction('ArcTangent2', (v1, v2) => Math.atan2(v1, v2!), 2),
     Power: new GenericMathFunction('Power', (v1, v2) => Math.pow(v1, v2!), 2),
     Add: new Add(),
     Hypotenuse: new Hypotenuse(),

package/src/engine/runtime/expression/tokenextractor/TokenValueExtractor.ts

@@ -52,8 +52,8 @@ export abstract class TokenValueExtractor {
             .map((e) => e.trim())
             .filter((e) => !StringUtil.isNullOrBlank(e))
             .reduce(
-                (a, c, i) =>
-                    this.resolveForEachPartOfTokenWithBrackets(token, parts, partNumber, c, a, i),
+                (a, c) =>
+                    this.resolveForEachPartOfTokenWithBrackets(token, parts, partNumber, c, a),
                 jsonElement,
             );
 
@@ -64,74 +64,78 @@ export abstract class TokenValueExtractor {
         token: string,
         parts: string[],
         partNumber: number,
-        c: string,
-        a: any,
-        i: any,
+        cPart: string,
+        cElement: any
     ): any {
-        if (isNullValue(a)) return undefined;
+        if (isNullValue(cElement)) return undefined;
 
-        if (i === 0) {
-            if (c === 'length') {
-                const type = typeof a;
-                if (type === 'string' || Array.isArray(a)) return a.length;
-                if (type === 'object') return Object.keys(a).length;
-            }
-            if (Array.isArray(a)) {
-                try {
-                    let index: number = parseInt(c);
-                    if (isNaN(index)) {
-                        throw new Error(StringFormatter.format('$ is not a number', index));
-                    }
-                    if (index >= a.length) return undefined;
-
-                    return a[index];
-                } catch (err: any) {
-                    throw new ExpressionEvaluationException(
-                        token,
-                        StringFormatter.format("$ couldn't be parsed into integer in $", c, token),
-                        err,
-                    );
-                }
-            }
+        if (cPart === 'length') return this.getLength(token, cElement);
 
-            this.checkIfObject(token, parts, partNumber, a);
-            return a[c];
-        } else if (c?.startsWith('"')) {
-            if (!c.endsWith('"') || c.length == 1 || c.length == 2)
-                throw new ExpressionEvaluationException(
-                    token,
-                    StringFormatter.format('$ is missing a double quote or empty key found', token),
-                );
+        if (Array.isArray(cElement)) return this.handleArrayAccess(token, cPart, cElement);
+
+        return this.handleObjectAccess(token, parts, partNumber, cPart, cElement);
+    }
+
+    private getLength(
+        token: string,
+        cElement: any
+    ): any {
+        const type = typeof cElement;
 
-            this.checkIfObject(token, parts, partNumber, a);
-            return a[c.substring(1, c.length - 1)];
+        if (type === 'string' || Array.isArray(cElement)) return cElement.length;
+        if (type === 'object') {
+            if ('length' in cElement) return cElement['length'];
+            else return Object.keys(cElement).length;
         }
 
-        try {
-            let index: number = parseInt(c);
-            if (isNaN(index)) {
-                throw new Error(StringFormatter.format('$ is not a number', index));
-            }
-            if (!Array.isArray(a))
-                throw new ExpressionEvaluationException(
-                    token,
-                    StringFormatter.format(
-                        'Expecting an array with index $ while processing the expression',
-                        index,
-                        token,
-                    ),
-                );
+        throw new ExpressionEvaluationException(token,
+            StringFormatter.format('Length can\'t be found in token $', token))
+    }
+
+    private handleArrayAccess(
+        token: string,
+        cPart: string,
+        cArray: any[]
+    ): any {
+        const index: number = parseInt(cPart);
 
-            if (index >= a.length) return undefined;
+        if (isNaN(index)) {
+            throw new ExpressionEvaluationException(
+                token,
+                StringFormatter.format('$ is not a number', cPart)
+            );
+        }
 
-            return a[index];
-        } catch (err: any) {
+        if (index < 0 || index >= cArray.length) {
             throw new ExpressionEvaluationException(
                 token,
-                StringFormatter.format("$ couldn't be parsed into integer in $", c, token),
-                err,
+                StringFormatter.format('Index $ is out of bounds for array of length $', index, cArray.length)
             );
         }
+
+        return cArray[index];
+    }
+
+    private handleObjectAccess(
+        token: string,
+        parts: string[],
+        partNumber: number,
+        cPart: string,
+        cObject: any
+    ): any {
+        if (cPart.startsWith("\"")) {
+            if (!cPart.endsWith("\"") || cPart.length == 1 || cPart.length == 2) {
+                throw new ExpressionEvaluationException(
+                    token,
+                    StringFormatter.format("$ is missing a double quote or empty key found", token))
+            }
+
+            cPart = cPart.substring(1, parts.length - 2);
+        }
+
+        this.checkIfObject(token, parts, partNumber, cObject);
+
+        return cObject[cPart];
     }
 
     protected checkIfObject(
@@ -144,7 +148,7 @@ export abstract class TokenValueExtractor {
             throw new ExpressionEvaluationException(
                 token,
                 StringFormatter.format(
-                    'Unable to retrive $ from $ in the path $',
+                    'Unable to retrieve $ from $ in the path $',
                     parts[partNumber],
                     jsonElement.toString(),
                     token,