@fincity/kirun-js 2.3.1 → 2.4.0

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@fincity/kirun-js",
-    "version": "2.3.1",
+    "version": "2.4.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/array/ArrayFunctionRepository.ts

@@ -33,6 +33,7 @@ import { Insert } from './Insert';
 import { InsertLast } from './InsertLast';
 import { RemoveDuplicates } from './RemoveDuplicates';
 import { ArrayToObject } from './ArrayToObject';
+import { Join } from './Join';
 
 export class ArrayFunctionRepository implements Repository<Function> {
     private static readonly repoMap: Map<string, Function> = MapUtil.ofArrayEntries(
@@ -66,6 +67,7 @@ export class ArrayFunctionRepository implements Repository<Function> {
         mapEntry(new InsertLast()),
         mapEntry(new RemoveDuplicates()),
         mapEntry(new ArrayToObject()),
+        mapEntry(new Join())
     );
 
     private static readonly filterableNames = Array.from(

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

@@ -0,0 +1,162 @@
+import { Schema } from "../../../json/schema/Schema";
+import { FunctionSignature } from "../../../model/FunctionSignature";
+import { Event } from "../../../model/Event";
+import { Parameter } from "../../../model/Parameter";
+import { Namespaces } from "../../../namespaces/Namespaces";
+import { MapUtil } from "../../../util/MapUtil";
+import { AbstractFunction } from "../../AbstractFunction";
+import { KIRuntimeException } from "../../../exception/KIRuntimeException";
+import { EventResult } from "../../../model/EventResult";
+import { FunctionOutput } from "../../../model/FunctionOutput";
+import { FunctionExecutionParameters } from "../../../runtime/FunctionExecutionParameters";
+import { isNullValue } from "../../../util/NullCheck";
+import { ValidDateTimeUtil } from "../../../util/ValidDateTimeUtil";
+import { Function } from "../../../../engine/function/Function";
+
+export abstract class AbstractDateFunction extends AbstractFunction {
+
+    private signature: FunctionSignature;
+
+    public static readonly EVENT_RESULT_NAME: string = 'result';
+
+    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,
+        Schema.ofString(this.PARAMETER_DATE_NAME).setRef(Namespaces.DATE + ".timeStamp")
+    );
+
+    protected static readonly PARAMETER_FIELD : Parameter = new Parameter(
+        AbstractDateFunction.PARAMETER_FIELD_NAME,
+        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(
+            AbstractDateFunction.EVENT_RESULT_NAME,
+            Schema.ofInteger(AbstractDateFunction.EVENT_RESULT_NAME),
+        ),
+    );
+
+    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;
+    }
+
+
+    constructor(namespace: string, functionName: string, event: Event, ...parameter: Parameter[]) {
+
+        super();
+        const paramMap: Map<string, Parameter> = new Map();
+        parameter.forEach((e) => paramMap.set(e.getParameterName(), e));
+
+        this.signature = new FunctionSignature(functionName)
+            .setNamespace(namespace)
+            .setParameters(paramMap)
+            .setEvents(MapUtil.of(event.getName(), event));
+
+    }
+
+    public static ofEntryDateAndBooleanOutput(name: string, fun: ( date : string) => boolean) : [string, Function] {
+    
+        return [name, 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.");
+
+                return new FunctionOutput([EventResult.outputOf(MapUtil.of(AbstractDateFunction.EVENT_RESULT_NAME, fun(date)))]);
+
+            }
+
+
+        })(Namespaces.DATE, name, AbstractDateFunction.EVENT_BOOLEAN, AbstractDateFunction.PARAMETER_DATE)];
+    }
+
+    public static ofEntryDateAndIntegerOutput(name: string, fun: (date: string) => number) : [string, Function] {
+        
+        return [name, 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");
+
+                return new FunctionOutput([EventResult.outputOf(MapUtil.of( AbstractDateFunction.EVENT_RESULT_NAME, fun(date)))])
+            }
+        })(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

@@ -0,0 +1,159 @@
+import { Namespaces } from "../../../namespaces/Namespaces";
+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);
+        }),
+
+        AbstractDateFunction.ofEntryDateAndIntegerOutput("GetDate", date => new Date(date).getUTCDate()),
+
+        AbstractDateFunction.ofEntryDateAndIntegerOutput("GetDay", date => new Date(date).getUTCDay()),
+
+        AbstractDateFunction.ofEntryDateAndIntegerOutput("GetFullYear", date => new Date(date).getUTCFullYear()),
+
+        AbstractDateFunction.ofEntryDateAndIntegerOutput("GetMonth", date => new Date(date).getUTCMonth()),
+
+        AbstractDateFunction.ofEntryDateAndIntegerOutput("GetHours", date => new Date(date).getUTCHours()),
+
+        AbstractDateFunction.ofEntryDateAndIntegerOutput("GetMinutes", date => new Date(date).getUTCMinutes()),
+
+        AbstractDateFunction.ofEntryDateAndIntegerOutput("GetSeconds", date => new Date(date).getUTCSeconds()),
+
+        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) {
+            return Promise.resolve(undefined);
+        }
+        return Promise.resolve(DateFunctionRepository.repoMap.get(name));
+    }
+    filter(name: string): Promise<string[]> {
+
+        return Promise.resolve(
+            DateFunctionRepository.filterableNames.filter(
+                (e) => e.toLowerCase().indexOf(name.toLowerCase()) !== -1,
+            ),
+        );
+    }
+}

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

@@ -0,0 +1,39 @@
+import { Schema } from "../../../json/schema/Schema";
+import { FunctionOutput } from "../../../model/FunctionOutput";
+import { FunctionSignature } from "../../../model/FunctionSignature";
+import { Event } from '../../../model/Event';
+import { Parameter } from "../../../model/Parameter";
+import { Namespaces } from "../../../namespaces/Namespaces";
+import { FunctionExecutionParameters } from "../../../runtime/FunctionExecutionParameters";
+import { MapUtil } from "../../../util/MapUtil";
+import { AbstractFunction } from "../../AbstractFunction";
+import { isNullValue } from "../../../util/NullCheck";
+import { KIRuntimeException } from "../../../exception/KIRuntimeException";
+import { EventResult } from "../../../model/EventResult";
+import { ValidDateTimeUtil } from "../../../util/ValidDateTimeUtil";
+
+const OUTPUT : string = "result";
+
+const VALUE : string = "isoDate";
+
+export class DateToEpoch extends AbstractFunction{
+
+    public getSignature(): FunctionSignature {
+
+        return  new FunctionSignature('DateToEpoch')
+        .setNamespace(Namespaces.DATE)
+        .setParameters(MapUtil.of(VALUE, Parameter.of(VALUE,Schema.ofRef(Namespaces.DATE + ".timeStamp"))))
+        .setEvents(new Map([Event.outputEventMapEntry(new Map([[OUTPUT, Schema.ofLong(OUTPUT)]]))]));
+    }
+
+    protected async internalExecute(context: FunctionExecutionParameters): Promise<FunctionOutput> {
+
+        var date = context.getArguments()?.get(VALUE);
+
+        if(isNullValue(date) || !ValidDateTimeUtil.validate(date))
+            throw new KIRuntimeException("Please provide a valid date object");
+
+        const epochMillis = new Date(date).getTime();
+        return new FunctionOutput([ EventResult.of(OUTPUT , MapUtil.of( OUTPUT  , epochMillis))]);
+    }
+}

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

@@ -0,0 +1,45 @@
+import { KIRuntimeException } from "../../../exception/KIRuntimeException";
+import { Schema } from "../../../json/schema/Schema";
+import { EventResult } from "../../../model/EventResult";
+import { FunctionOutput } from "../../../model/FunctionOutput";
+import { FunctionSignature } from "../../../model/FunctionSignature";
+import { Parameter } from "../../../model/Parameter";
+import { Namespaces } from "../../../namespaces/Namespaces";
+import { FunctionExecutionParameters } from "../../../runtime/FunctionExecutionParameters";
+import { ValidDateTimeUtil } from "../../../util/ValidDateTimeUtil";
+import { AbstractFunction } from "../../AbstractFunction";
+
+const DATE_ONE: string = "isoDateOne";
+const DATE_TWO: string = "isoDateTwo";
+const OUTPUT: string = "result";
+
+const SIGNATURE: FunctionSignature = new FunctionSignature('DifferenceOfTimestamps')
+    .setNamespace(Namespaces.DATE)
+    .setParameters(
+        new Map([
+            [DATE_ONE, new Parameter(DATE_ONE, Schema.ofString(DATE_ONE).setRef(Namespaces.DATE+".timeStamp"))],
+            [DATE_TWO, new Parameter(DATE_TWO, Schema.ofString(DATE_TWO).setRef(Namespaces.DATE+".timeStamp"))]
+        ])
+    );;
+
+export class DifferenceOfTimestamps extends AbstractFunction {
+
+    public getSignature(): FunctionSignature {
+        return SIGNATURE;
+    }
+
+    protected async internalExecute(context: FunctionExecutionParameters): Promise<FunctionOutput> {
+
+        const firstDate:string = context?.getArguments()?.get(DATE_ONE);
+        const secondDate:string = context?.getArguments()?.get(DATE_TWO);
+
+        if(!ValidDateTimeUtil.validate(firstDate) || !ValidDateTimeUtil.validate(secondDate)) 
+            throw new KIRuntimeException("Please provide valid ISO date for both the given dates.");
+
+        const fDate: Date = new Date(firstDate);
+        const sDate: Date = new Date(secondDate);
+
+        return new FunctionOutput([EventResult.outputOf(new Map([[OUTPUT, (sDate.getTime() - fDate.getTime())/60000]]))]);
+    }
+
+}

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

@@ -0,0 +1,76 @@
+import { Schema } from "../../../json/schema/Schema";
+import { FunctionOutput } from "../../../model/FunctionOutput";
+import { FunctionSignature } from "../../../model/FunctionSignature";
+import { Event } from '../../../model/Event';
+import { Parameter } from "../../../model/Parameter";
+import { Namespaces } from "../../../namespaces/Namespaces";
+import { FunctionExecutionParameters } from "../../../runtime/FunctionExecutionParameters";
+import { AbstractFunction } from "../../AbstractFunction";
+import { isNullValue } from "../../../util/NullCheck";
+import { KIRuntimeException } from "../../../exception/KIRuntimeException";
+import { EventResult } from "../../../model/EventResult";
+
+
+const VALUE = 'epoch';
+const OUTPUT = 'date';
+const  ERROR_MSG: string = "Please provide a valid value for epoch.";
+
+const SIGNATURE = new FunctionSignature('EpochToDate')
+    .setNamespace(Namespaces.DATE)
+    .setParameters(
+        new Map([
+            [
+                VALUE,
+                new Parameter(
+                    VALUE,
+                    new Schema().setAnyOf([
+                        Schema.ofInteger(VALUE),
+                        Schema.ofLong(VALUE),
+                        Schema.ofString(VALUE),
+                    ]),
+                ),
+            ],
+        ]),
+    )
+    .setEvents(
+        new Map([
+            Event.outputEventMapEntry(
+                new Map([[OUTPUT, Schema.ofRef(`${Namespaces.DATE}.timeStamp`)]]),
+            ),
+        ]),
+    );
+
+export class EpochToDate extends AbstractFunction{
+
+    public getSignature(): FunctionSignature {
+      return SIGNATURE;
+    }
+    
+    protected async internalExecute(context: FunctionExecutionParameters): Promise<FunctionOutput> {
+
+       var epoch : any =  context.getArguments()?.get(VALUE);
+
+       if(isNullValue(epoch))
+        throw new KIRuntimeException(ERROR_MSG);
+
+       if(typeof epoch === 'boolean')
+            throw new KIRuntimeException(ERROR_MSG);
+
+       if(typeof epoch === 'string')
+            epoch  = parseInt(epoch)
+
+       if(isNaN(epoch))
+        throw new KIRuntimeException(ERROR_MSG);
+
+       epoch = epoch > 999999999999 ? epoch : epoch * 1000;
+
+      
+       return new FunctionOutput([
+           EventResult.outputOf(new Map([
+            [OUTPUT, new Date(epoch).toISOString()]
+            ]))
+       ]);
+
+    }
+    
+}

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

@@ -0,0 +1,36 @@
+import { FunctionOutput } from "../../../model/FunctionOutput";
+import { FunctionSignature } from "../../../model/FunctionSignature";
+import { Event } from '../../../model/Event';
+import { Namespaces } from "../../../namespaces/Namespaces";
+import { FunctionExecutionParameters } from "../../../runtime/FunctionExecutionParameters";
+import { AbstractFunction } from "../../AbstractFunction";
+import { Schema } from "../../../json/schema/Schema";
+import { EventResult } from "../../../model/EventResult";
+
+
+const OUTPUT = 'date';
+
+const SIGNATURE: FunctionSignature = new FunctionSignature("GetCurrentTimeStamp")
+                                        .setNamespace(Namespaces.DATE)
+                                        .setParameters(new Map([]))
+                                        .setEvents(new Map([
+                                            Event.outputEventMapEntry(
+                                                new Map([[OUTPUT, Schema.ofRef(`${Namespaces.DATE}.timeStamp`)]]),
+                                            ),
+                                        ]));
+
+export class GetCurrentTimeStamp extends AbstractFunction{
+
+    public getSignature(): FunctionSignature {
+
+        return SIGNATURE;        
+    }
+    
+
+    protected async internalExecute(context: FunctionExecutionParameters): Promise<FunctionOutput> {
+        
+        const date : string = new Date(Date.now()).toISOString();
+        
+        return new FunctionOutput([EventResult.of(OUTPUT, new Map([ [OUTPUT, date]]))]);
+    }
+}

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

@@ -0,0 +1,48 @@
+import { KIRuntimeException } from "../../../exception/KIRuntimeException";
+import { ArraySchemaType } from "../../../json/schema/array/ArraySchemaType";
+import { Schema } from "../../../json/schema/Schema";
+import { Event } from '../../../model/Event';
+import { EventResult } from "../../../model/EventResult";
+import { FunctionOutput } from "../../../model/FunctionOutput";
+import { FunctionSignature } from "../../../model/FunctionSignature";
+import { Parameter } from "../../../model/Parameter";
+import { Namespaces } from "../../../namespaces/Namespaces";
+import { FunctionExecutionParameters } from "../../../runtime/FunctionExecutionParameters";
+import { MapUtil } from "../../../util/MapUtil";
+import { isNullValue } from "../../../util/NullCheck";
+import { ValidDateTimeUtil } from "../../../util/ValidDateTimeUtil";
+import { AbstractFunction } from "../../AbstractFunction";
+
+
+const VALUE:string = "isoDate";
+
+const OUTPUT:string = "result";
+
+const SIGNATURE = new FunctionSignature('GetTimeAsArray')
+    .setNamespace(Namespaces.DATE)
+    .setParameters(MapUtil.of(VALUE, Parameter.of(VALUE, Schema.ofRef(Namespaces.DATE + ".timeStamp"))))
+    .setEvents(new Map([Event.outputEventMapEntry(new Map([[OUTPUT , Schema.ofArray(OUTPUT).setItems(ArraySchemaType.of(Schema.ofNumber("number")))]]))]))
+
+
+export class GetTimeAsArray extends AbstractFunction{
+    
+    public getSignature(): FunctionSignature {
+        return SIGNATURE;
+    }
+    
+    protected async internalExecute(context: FunctionExecutionParameters): Promise<FunctionOutput> {
+         
+        var inputDate = context.getArguments()?.get(VALUE);
+
+        if(isNullValue(inputDate) || !ValidDateTimeUtil.validate(inputDate))
+            throw new KIRuntimeException("Please provide a valid date object");
+
+        const date = new Date(inputDate);
+
+        const outputArray = [ date.getUTCFullYear(), date.getUTCMonth() + 1, date.getUTCDate()
+            , date.getUTCHours(), date.getUTCMinutes(), date.getUTCSeconds(), date.getUTCMilliseconds()];
+        
+        return new FunctionOutput([EventResult.outputOf(new Map([[OUTPUT , outputArray]]))]);
+    }
+
+}