@fincity/kirun-js 1.0.0

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

@@ -0,0 +1,62 @@
+import { KIRuntimeException } from '../../../exception/KIRuntimeException';
+import { EventResult } from '../../../model/EventResult';
+import { FunctionOutput } from '../../../model/FunctionOutput';
+import { FunctionExecutionParameters } from '../../../runtime/FunctionExecutionParameters';
+import { PrimitiveUtil } from '../../../util/primitive/PrimitiveUtil';
+import { AbstractArrayFunction } from './AbstractArrayFunction';
+
+export class LastIndexOf extends AbstractArrayFunction {
+    public constructor() {
+        super(
+            'LastIndexOf',
+            [
+                LastIndexOf.PARAMETER_ARRAY_SOURCE,
+                LastIndexOf.PARAMETER_ANY_NOT_NULL,
+                LastIndexOf.PARAMETER_INT_FIND_FROM,
+            ],
+            LastIndexOf.EVENT_RESULT_INTEGER,
+        );
+    }
+
+    protected internalExecute(context: FunctionExecutionParameters): FunctionOutput {
+        let source: any[] = context
+            ?.getArguments()
+            ?.get(LastIndexOf.PARAMETER_ARRAY_SOURCE.getParameterName());
+
+        var find = context
+            ?.getArguments()
+            ?.get(LastIndexOf.PARAMETER_ANY_NOT_NULL.getParameterName());
+
+        let len = context
+            ?.getArguments()
+            ?.get(LastIndexOf.PARAMETER_INT_FIND_FROM.getParameterName());
+
+        if (source.length == 0)
+            return new FunctionOutput([
+                EventResult.outputOf(new Map([[LastIndexOf.EVENT_RESULT_INTEGER.getName(), -1]])),
+            ]);
+
+        if (len < 0 || len > source.length)
+            throw new KIRuntimeException(
+                "The value of length shouldn't the exceed the size of the array or shouldn't be in terms",
+            );
+
+        let index: number = -1;
+
+        if (typeof find == null || typeof find == undefined)
+            throw new KIRuntimeException(
+                'Please provide the valid find object or primitive in order to verify',
+            );
+
+        for (let i: number = source.length - 1; i >= len; i--) {
+            if (PrimitiveUtil.compare(source[i], find) == 0) {
+                index = i;
+                break;
+            }
+        }
+
+        return new FunctionOutput([
+            EventResult.outputOf(new Map([[LastIndexOf.EVENT_RESULT_INTEGER.getName(), index]])),
+        ]);
+    }
+}

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

@@ -0,0 +1,70 @@
+import { KIRuntimeException } from '../../../exception/KIRuntimeException';
+import { EventResult } from '../../../model/EventResult';
+import { FunctionOutput } from '../../../model/FunctionOutput';
+import { FunctionExecutionParameters } from '../../../runtime/FunctionExecutionParameters';
+import { PrimitiveUtil } from '../../../util/primitive/PrimitiveUtil';
+import { AbstractArrayFunction } from './AbstractArrayFunction';
+
+export class LastIndexOfArray extends AbstractArrayFunction {
+    public constructor() {
+        super(
+            'LastIndexOfArray',
+            [
+                LastIndexOfArray.PARAMETER_ARRAY_SOURCE,
+                LastIndexOfArray.PARAMETER_ARRAY_SECOND_SOURCE,
+                LastIndexOfArray.PARAMETER_INT_FIND_FROM,
+            ],
+            LastIndexOfArray.EVENT_RESULT_INTEGER,
+        );
+    }
+
+    protected internalExecute(context: FunctionExecutionParameters): FunctionOutput {
+        let source: any[] = context
+            ?.getArguments()
+            ?.get(LastIndexOfArray.PARAMETER_ARRAY_SOURCE.getParameterName());
+
+        let secondSource: any[] = context
+            ?.getArguments()
+            ?.get(LastIndexOfArray.PARAMETER_ARRAY_SECOND_SOURCE.getParameterName());
+
+        let from: any = context
+            ?.getArguments()
+            ?.get(LastIndexOfArray.PARAMETER_INT_FIND_FROM.getParameterName());
+
+        if (source.length == 0)
+            return new FunctionOutput([
+                EventResult.outputOf(
+                    new Map([[LastIndexOfArray.EVENT_RESULT_ARRAY.getName(), -1]]),
+                ),
+            ]);
+
+        if (from < 0 || from > source.length || secondSource.length > source.length)
+            throw new KIRuntimeException(
+                'Given from index is more than the size of the source array',
+            );
+
+        let secondSourceSize: number = secondSource.length;
+        let index: number = -1;
+
+        for (let i: number = from; i < source.length; i++) {
+            let j: number = 0;
+            if (PrimitiveUtil.compare(source[i], secondSource[j]) == 0) {
+                while (j < secondSourceSize) {
+                    if (PrimitiveUtil.compare(source[i + j], secondSource[j]) != 0) {
+                        break;
+                    }
+                    j++;
+                }
+                if (j == secondSourceSize) {
+                    index = i;
+                }
+            }
+        }
+
+        return new FunctionOutput([
+            EventResult.outputOf(
+                new Map([[LastIndexOfArray.EVENT_RESULT_INTEGER.getName(), index]]),
+            ),
+        ]);
+    }
+}

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

@@ -0,0 +1,31 @@
+import { KIRuntimeException } from '../../../exception/KIRuntimeException';
+import { EventResult } from '../../../model/EventResult';
+import { FunctionOutput } from '../../../model/FunctionOutput';
+import { FunctionExecutionParameters } from '../../../runtime/FunctionExecutionParameters';
+import { AbstractArrayFunction } from './AbstractArrayFunction';
+import { PrimitiveUtil } from '../../../util/primitive/PrimitiveUtil';
+
+export class Max extends AbstractArrayFunction {
+    public constructor() {
+        super('Max', [Max.PARAMETER_ARRAY_SOURCE_PRIMITIVE], Max.EVENT_RESULT_ANY);
+    }
+
+    protected internalExecute(context: FunctionExecutionParameters): FunctionOutput {
+        let source: any[] = context
+            ?.getArguments()
+            ?.get(Max.PARAMETER_ARRAY_SOURCE_PRIMITIVE.getParameterName());
+
+        if (source.length == 0) throw new KIRuntimeException('Search source array cannot be empty');
+
+        let max: any = source[0];
+        for (let i: number = 1; i < source.length; i++) {
+            let y: any = source[i];
+            if (PrimitiveUtil.comparePrimitive(max, y) >= 0) continue;
+            max = y;
+        }
+
+        return new FunctionOutput([
+            EventResult.outputOf(new Map([[Max.EVENT_RESULT_ANY.getName(), max]])),
+        ]);
+    }
+}

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

@@ -0,0 +1,32 @@
+import { KIRuntimeException } from '../../../exception/KIRuntimeException';
+import { EventResult } from '../../../model/EventResult';
+import { FunctionOutput } from '../../../model/FunctionOutput';
+import { FunctionExecutionParameters } from '../../../runtime/FunctionExecutionParameters';
+import { AbstractArrayFunction } from './AbstractArrayFunction';
+import { PrimitiveUtil } from '../../../util/primitive/PrimitiveUtil';
+import { isNullValue } from '../../../util/NullCheck';
+
+export class Min extends AbstractArrayFunction {
+    public constructor() {
+        super('Min', [Min.PARAMETER_ARRAY_SOURCE_PRIMITIVE], Min.EVENT_RESULT_ANY);
+    }
+
+    protected internalExecute(context: FunctionExecutionParameters): FunctionOutput {
+        let source: any[] = context
+            ?.getArguments()
+            ?.get(Min.PARAMETER_ARRAY_SOURCE_PRIMITIVE.getParameterName());
+
+        if (source.length == 0) throw new KIRuntimeException('Search source array cannot be empty');
+
+        let min: any = undefined;
+        for (let i: number = 0; i < source.length; i++) {
+            if (isNullValue(source[i])) continue;
+            if (min === undefined || PrimitiveUtil.comparePrimitive(source[i], min) < 0)
+                min = source[i];
+        }
+
+        return new FunctionOutput([
+            EventResult.outputOf(new Map([[Min.EVENT_RESULT_ANY.getName(), min]])),
+        ]);
+    }
+}

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

@@ -0,0 +1,66 @@
+import { KIRuntimeException } from '../../../exception/KIRuntimeException';
+import { EventResult } from '../../../model/EventResult';
+import { FunctionOutput } from '../../../model/FunctionOutput';
+import { FunctionExecutionParameters } from '../../../runtime/FunctionExecutionParameters';
+import { AbstractArrayFunction } from './AbstractArrayFunction';
+
+export class MisMatch extends AbstractArrayFunction {
+    public constructor() {
+        super(
+            'MisMatch',
+            [
+                MisMatch.PARAMETER_ARRAY_SOURCE,
+                MisMatch.PARAMETER_INT_FIND_FROM,
+                MisMatch.PARAMETER_ARRAY_SECOND_SOURCE,
+                MisMatch.PARAMETER_INT_SECOND_SOURCE_FROM,
+                MisMatch.PARAMETER_INT_LENGTH,
+            ],
+            MisMatch.EVENT_RESULT_INTEGER,
+        );
+    }
+
+    protected internalExecute(context: FunctionExecutionParameters): FunctionOutput {
+        let firstSource: any[] = context
+            ?.getArguments()
+            ?.get(MisMatch.PARAMETER_ARRAY_SOURCE.getParameterName());
+
+        let firstFind: number = context
+            ?.getArguments()
+            ?.get(MisMatch.PARAMETER_INT_FIND_FROM.getParameterName());
+
+        let secondSource: any[] = context
+            ?.getArguments()
+            ?.get(MisMatch.PARAMETER_ARRAY_SECOND_SOURCE.getParameterName());
+
+        let secondFind: number = context
+            ?.getArguments()
+            ?.get(MisMatch.PARAMETER_INT_SECOND_SOURCE_FROM.getParameterName());
+
+        let length: number = context
+            ?.getArguments()
+            ?.get(MisMatch.PARAMETER_INT_LENGTH.getParameterName());
+
+        // write check conditions
+
+        let first: number = firstFind < firstSource.length && firstFind > 0 ? firstFind : 0;
+        let second: number = secondFind < secondSource.length && secondFind > 0 ? secondFind : 0;
+
+        if (first + length >= firstSource.length || second + length > secondSource.length)
+            throw new KIRuntimeException(
+                'The size of the array for first and second which was being requested is more than size of the given array',
+            );
+
+        let index: number = -1;
+
+        for (let i: number = 0; i < length; i++) {
+            if (firstSource[first + i] != secondSource[second + i]) {
+                index = i;
+                break;
+            }
+        }
+
+        return new FunctionOutput([
+            EventResult.outputOf(new Map([[MisMatch.EVENT_RESULT_INTEGER.getName(), index]])),
+        ]);
+    }
+}

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

@@ -0,0 +1,50 @@
+import { KIRuntimeException } from '../../../exception/KIRuntimeException';
+import { EventResult } from '../../../model/EventResult';
+import { FunctionOutput } from '../../../model/FunctionOutput';
+import { FunctionExecutionParameters } from '../../../runtime/FunctionExecutionParameters';
+import { AbstractArrayFunction } from './AbstractArrayFunction';
+
+export class Reverse extends AbstractArrayFunction {
+    public constructor() {
+        super(
+            'Reverse',
+            [
+                Reverse.PARAMETER_ARRAY_SOURCE,
+                Reverse.PARAMETER_INT_SOURCE_FROM,
+                Reverse.PARAMETER_INT_LENGTH,
+            ],
+            Reverse.EVENT_RESULT_EMPTY,
+        );
+    }
+
+    protected internalExecute(context: FunctionExecutionParameters): FunctionOutput {
+        let source: any[] = context
+            ?.getArguments()
+            ?.get(Reverse.PARAMETER_ARRAY_SOURCE.getParameterName());
+
+        let st: number = context
+            ?.getArguments()
+            ?.get(Reverse.PARAMETER_INT_SOURCE_FROM.getParameterName());
+
+        let len: number = context
+            ?.getArguments()
+            ?.get(Reverse.PARAMETER_INT_LENGTH.getParameterName());
+
+        if (len == -1) len = source.length - st;
+
+        if (len >= source.length || len < 0 || st < 0)
+            throw new KIRuntimeException(
+                'Please provide start point between the start and end indexes or provide the length which was less than the source size ',
+            );
+
+        let endpoint: number = st + len - 1;
+        while (st <= endpoint) {
+            let first: any = source[st];
+            let last: any = source[endpoint];
+            source[st++] = last;
+            source[endpoint--] = first;
+        }
+
+        return new FunctionOutput([EventResult.outputOf(new Map([]))]);
+    }
+}

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

@@ -0,0 +1,43 @@
+import { EventResult } from '../../../model/EventResult';
+import { FunctionOutput } from '../../../model/FunctionOutput';
+import { FunctionExecutionParameters } from '../../../runtime/FunctionExecutionParameters';
+import { AbstractArrayFunction } from './AbstractArrayFunction';
+
+export class Rotate extends AbstractArrayFunction {
+    public constructor() {
+        super(
+            'Rotate',
+            [Rotate.PARAMETER_ARRAY_SOURCE, Rotate.PARAMETER_ROTATE_LENGTH],
+            Rotate.EVENT_RESULT_EMPTY,
+        );
+    }
+
+    protected internalExecute(context: FunctionExecutionParameters): FunctionOutput {
+        let source: any[] = context
+            ?.getArguments()
+            ?.get(Rotate.PARAMETER_ARRAY_SOURCE.getParameterName());
+
+        let rotLen: number = context
+            ?.getArguments()
+            ?.get(Rotate.PARAMETER_ROTATE_LENGTH.getParameterName());
+
+        if (source.length == 0) return new FunctionOutput([EventResult.outputOf(new Map([]))]);
+
+        let size: number = source.length;
+        rotLen = rotLen % size;
+
+        this.rotate(source, 0, rotLen - 1);
+        this.rotate(source, rotLen, size - 1);
+        this.rotate(source, 0, size - 1);
+
+        return new FunctionOutput([EventResult.outputOf(new Map([]))]);
+    }
+
+    private rotate(elements: any[], start: number, end: number): void {
+        while (start < end) {
+            let temp: any = elements[start];
+            elements[start++] = elements[end];
+            elements[end--] = temp;
+        }
+    }
+}

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

@@ -0,0 +1,31 @@
+import { EventResult } from '../../../model/EventResult';
+import { FunctionOutput } from '../../../model/FunctionOutput';
+import { FunctionExecutionParameters } from '../../../runtime/FunctionExecutionParameters';
+import { AbstractArrayFunction } from './AbstractArrayFunction';
+
+export class Shuffle extends AbstractArrayFunction {
+    public constructor() {
+        super('Shuffle', [Shuffle.PARAMETER_ARRAY_SOURCE], Shuffle.EVENT_RESULT_EMPTY);
+    }
+
+    protected internalExecute(context: FunctionExecutionParameters): FunctionOutput {
+        let source: any[] = context
+            ?.getArguments()
+            ?.get(Shuffle.PARAMETER_ARRAY_SOURCE.getParameterName());
+
+        if (source.length <= 1) return new FunctionOutput([EventResult.outputOf(new Map([]))]);
+
+        let x: number = 0;
+        let size: number = source.length;
+
+        for (let i: number = 0; i < size; i++) {
+            let y: number = Math.floor(Math.random() * size) % size;
+            let temp: any = source[x];
+            source[x] = source[y];
+            source[y] = temp;
+            x = y;
+        }
+
+        return new FunctionOutput([EventResult.outputOf(new Map([]))]);
+    }
+}

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

@@ -0,0 +1,70 @@
+import { KIRuntimeException } from '../../../exception/KIRuntimeException';
+import { EventResult } from '../../../model/EventResult';
+import { FunctionOutput } from '../../../model/FunctionOutput';
+import { FunctionExecutionParameters } from '../../../runtime/FunctionExecutionParameters';
+
+import { AbstractArrayFunction } from './AbstractArrayFunction';
+
+export class Sort extends AbstractArrayFunction {
+    public constructor() {
+        super(
+            'Sort',
+            [
+                Sort.PARAMETER_ARRAY_SOURCE_PRIMITIVE,
+                Sort.PARAMETER_INT_FIND_FROM,
+                Sort.PARAMETER_INT_LENGTH,
+                Sort.PARAMETER_BOOLEAN_ASCENDING,
+            ],
+            Sort.EVENT_RESULT_EMPTY,
+        );
+    }
+
+    protected internalExecute(context: FunctionExecutionParameters): FunctionOutput {
+        let source: any[] = context
+            ?.getArguments()
+            ?.get(Sort.PARAMETER_ARRAY_SOURCE_PRIMITIVE.getParameterName());
+
+        let start: number = context
+            ?.getArguments()
+            ?.get(Sort.PARAMETER_INT_FIND_FROM.getParameterName());
+
+        let len: number = context
+            ?.getArguments()
+            ?.get(Sort.PARAMETER_INT_LENGTH.getParameterName());
+
+        let ascending: boolean = context
+            ?.getArguments()
+            ?.get(Sort.PARAMETER_BOOLEAN_ASCENDING.getParameterName());
+
+        if (source.length == 0)
+            return new FunctionOutput([
+                EventResult.outputOf(new Map([[Sort.EVENT_RESULT_EMPTY.getName(), source]])),
+            ]);
+
+        if (len == -1) len = source.length - start;
+
+        if (start < 0 || start >= source.length || start + len > source.length)
+            throw new KIRuntimeException(
+                'Given start point is more than the size of the array or not available at that point',
+            );
+
+        let slicedArray: any[] = source.slice(start, start + len + 1);
+
+        slicedArray.sort((a, b) => compareFunction(a, b, ascending));
+
+        source.splice(start, len, ...slicedArray);
+
+        return new FunctionOutput([
+            EventResult.outputOf(new Map([[Sort.EVENT_RESULT_EMPTY.getName(), source]])),
+        ]);
+    }
+}
+
+function compareFunction(a: any, b: any, ascending: boolean): number {
+    if (a === b) return 0;
+    if (a === null) return 1;
+    if (b === null) return -1;
+    if (!ascending) return a < b ? -1 : 1;
+
+    return a < b ? 1 : -1;
+}

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

@@ -0,0 +1,48 @@
+import { KIRuntimeException } from '../../../exception/KIRuntimeException';
+import { EventResult } from '../../../model/EventResult';
+import { FunctionOutput } from '../../../model/FunctionOutput';
+import { FunctionExecutionParameters } from '../../../runtime/FunctionExecutionParameters';
+import { AbstractArrayFunction } from './AbstractArrayFunction';
+
+export class SubArray extends AbstractArrayFunction {
+    public constructor() {
+        super(
+            'SubArray',
+            [
+                SubArray.PARAMETER_ARRAY_SOURCE,
+                SubArray.PARAMETER_INT_FIND_FROM,
+                SubArray.PARAMETER_INT_LENGTH,
+            ],
+            SubArray.EVENT_RESULT_ARRAY,
+        );
+    }
+
+    protected internalExecute(context: FunctionExecutionParameters): FunctionOutput {
+        let source: any[] = context
+            ?.getArguments()
+            ?.get(SubArray.PARAMETER_ARRAY_SOURCE.getParameterName());
+
+        let start: number = context
+            ?.getArguments()
+            ?.get(SubArray.PARAMETER_INT_FIND_FROM.getParameterName());
+
+        let len: number = context
+            ?.getArguments()
+            ?.get(SubArray.PARAMETER_INT_LENGTH.getParameterName());
+
+        if (len == -1) len = source.length - start;
+
+        if (len <= 0) return new FunctionOutput([EventResult.outputOf(new Map([]))]);
+
+        if (!(start >= 0 && start < source.length) || start + len > source.length)
+            throw new KIRuntimeException(
+                'Given find from point is more than the source size array or the Requested length for the subarray was more than the source size',
+            );
+
+        let slicedArray: any[] = source.slice(start, start + len);
+
+        return new FunctionOutput([
+            EventResult.outputOf(new Map([[SubArray.EVENT_RESULT_ARRAY.getName(), slicedArray]])),
+        ]);
+    }
+}

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

@@ -0,0 +1,73 @@
+import { KIRuntimeException } from '../../../exception/KIRuntimeException';
+import { Schema } from '../../../json/schema/Schema';
+import { StringFormat } from '../../../json/schema/string/StringFormat';
+import { SchemaType } from '../../../json/schema/type/SchemaType';
+import { TypeUtil } from '../../../json/schema/type/TypeUtil';
+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 { ParameterType } from '../../../model/ParameterType';
+import { Namespaces } from '../../../namespaces/Namespaces';
+import { ContextElement } from '../../../runtime/ContextElement';
+import { FunctionExecutionParameters } from '../../../runtime/FunctionExecutionParameters';
+import { isNullValue } from '../../../util/NullCheck';
+import { StringFormatter } from '../../../util/string/StringFormatter';
+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 {
+    public getSignature(): FunctionSignature {
+        return SIGNATURE;
+    }
+
+    protected internalExecute(context: FunctionExecutionParameters): FunctionOutput {
+        const name: string = context?.getArguments()?.get(NAME);
+
+        if (context?.getContext()?.has(name))
+            throw new KIRuntimeException(
+                StringFormatter.format("Context already has an element for '$' ", name),
+            );
+
+        let s: Schema | undefined = Schema.from(context?.getArguments()?.get(SCHEMA));
+
+        if (!s) {
+            throw new KIRuntimeException('Schema is not supplied.');
+        }
+
+        context
+            .getContext()!
+            .set(
+                name,
+                new ContextElement(
+                    s,
+                    isNullValue(s.getDefaultValue()) ? undefined : s.getDefaultValue(),
+                ),
+            );
+
+        return new FunctionOutput([EventResult.outputOf(new Map())]);
+    }
+}

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

@@ -0,0 +1,55 @@
+import { KIRuntimeException } from '../../../exception/KIRuntimeException';
+import { Schema } from '../../../json/schema/Schema';
+import { StringFormat } from '../../../json/schema/string/StringFormat';
+import { SchemaType } from '../../../json/schema/type/SchemaType';
+import { TypeUtil } from '../../../json/schema/type/TypeUtil';
+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 { ParameterType } from '../../../model/ParameterType';
+import { Namespaces } from '../../../namespaces/Namespaces';
+import { FunctionExecutionParameters } from '../../../runtime/FunctionExecutionParameters';
+import { StringFormatter } from '../../../util/string/StringFormatter';
+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 {
+    public getSignature(): FunctionSignature {
+        return SIGNATURE;
+    }
+
+    protected internalExecute(context: FunctionExecutionParameters): FunctionOutput {
+        const name: string = context?.getArguments()?.get(NAME);
+
+        if (!context.getContext()?.has(name))
+            throw new KIRuntimeException(
+                StringFormatter.format("Context don't have an element for '$' ", name),
+            );
+
+        return new FunctionOutput([
+            EventResult.outputOf(new Map([VALUE, context.getContext()?.get(name)?.getElement()])),
+        ]);
+    }
+}