@fincity/kirun-js 1.6.4 → 1.6.5

package/__tests__/engine/function/system/object/ObjectEntriesTest.ts

@@ -0,0 +1,212 @@
+import {
+    FunctionExecutionParameters,
+    KIRunFunctionRepository,
+    KIRunSchemaRepository,
+    MapUtil,
+} from '../../../../../src';
+import { ObjectEntries } from '../../../../../src/engine/function/system/object/ObjectEntries';
+
+const objEnt: ObjectEntries = new ObjectEntries();
+
+test('entry test 1', async () => {
+    let obj = { a: 1, b: 2, d: ['a', 'b', 'c'] };
+
+    let fep: FunctionExecutionParameters = new FunctionExecutionParameters(
+        new KIRunFunctionRepository(),
+        new KIRunSchemaRepository(),
+    );
+
+    fep.setArguments(MapUtil.of('source', obj));
+
+    let res = [
+        ['a', 1],
+        ['b', 2],
+        ['d', ['a', 'b', 'c']],
+    ];
+
+    expect((await objEnt.execute(fep)).allResults()[0]?.getResult()?.get('value')).toStrictEqual(
+        res,
+    );
+});
+
+test('entry null test ', async () => {
+    let obj = null;
+
+    let fep: FunctionExecutionParameters = new FunctionExecutionParameters(
+        new KIRunFunctionRepository(),
+        new KIRunSchemaRepository(),
+    );
+
+    fep.setArguments(MapUtil.of('source', obj));
+
+    expect((await objEnt.execute(fep)).allResults()[0]?.getResult()?.get('value')).toStrictEqual(
+        [],
+    );
+});
+
+test('entry undefined test ', async () => {
+    let obj;
+
+    let fep: FunctionExecutionParameters = new FunctionExecutionParameters(
+        new KIRunFunctionRepository(),
+        new KIRunSchemaRepository(),
+    );
+
+    fep.setArguments(MapUtil.of('source', obj));
+
+    expect((await objEnt.execute(fep)).allResults()[0]?.getResult()?.get('value')).toStrictEqual(
+        [],
+    );
+});
+
+test('entry primitive number test ', async () => {
+    let obj = 423;
+
+    let fep: FunctionExecutionParameters = new FunctionExecutionParameters(
+        new KIRunFunctionRepository(),
+        new KIRunSchemaRepository(),
+    );
+
+    fep.setArguments(MapUtil.of('source', obj));
+
+    expect((await objEnt.execute(fep)).allResults()[0]?.getResult()?.get('value')).toStrictEqual(
+        [],
+    );
+});
+
+test('entry primitive boolean test ', async () => {
+    let obj = false;
+
+    let fep: FunctionExecutionParameters = new FunctionExecutionParameters(
+        new KIRunFunctionRepository(),
+        new KIRunSchemaRepository(),
+    );
+
+    fep.setArguments(MapUtil.of('source', obj));
+
+    expect((await objEnt.execute(fep)).allResults()[0]?.getResult()?.get('value')).toStrictEqual(
+        [],
+    );
+});
+
+test('entry primitive String test ', async () => {
+    let obj = 'surendhar';
+
+    let fep: FunctionExecutionParameters = new FunctionExecutionParameters(
+        new KIRunFunctionRepository(),
+        new KIRunSchemaRepository(),
+    );
+
+    fep.setArguments(MapUtil.of('source', obj));
+
+    expect((await objEnt.execute(fep)).allResults()[0]?.getResult()?.get('value')).toStrictEqual([
+        ['0', 's'],
+        ['1', 'u'],
+        ['2', 'r'],
+        ['3', 'e'],
+        ['4', 'n'],
+        ['5', 'd'],
+        ['6', 'h'],
+        ['7', 'a'],
+        ['8', 'r'],
+    ]);
+});
+
+test('entry nested object test', async () => {
+    let obj = { a: { b: { c: { d: { e: [1, 2, 4, 5] } } } }, c: ['q', 'w', 'e', 'r'] };
+
+    let fep: FunctionExecutionParameters = new FunctionExecutionParameters(
+        new KIRunFunctionRepository(),
+        new KIRunSchemaRepository(),
+    );
+
+    fep.setArguments(MapUtil.of('source', obj));
+
+    let res: any[] = [
+        ['a', { b: { c: { d: { e: [1, 2, 4, 5] } } } }],
+        ['c', ['q', 'w', 'e', 'r']],
+    ];
+
+    expect((await objEnt.execute(fep)).allResults()[0]?.getResult()?.get('value')).toStrictEqual(
+        res,
+    );
+});
+
+test(' entry array test ', async () => {
+    let obj = [1, 2, 3, 4, 1, 12, 3, 4, 5];
+
+    let fep: FunctionExecutionParameters = new FunctionExecutionParameters(
+        new KIRunFunctionRepository(),
+        new KIRunSchemaRepository(),
+    );
+
+    fep.setArguments(MapUtil.of('source', obj));
+
+    let res: any[] = [
+        ['0', 1],
+        ['1', 2],
+        ['2', 3],
+        ['3', 4],
+        ['4', 1],
+        ['5', 12],
+        ['6', 3],
+        ['7', 4],
+        ['8', 5],
+    ];
+
+    expect((await objEnt.execute(fep)).allResults()[0]?.getResult()?.get('value')).toStrictEqual(
+        res,
+    );
+});
+
+test(' entry duplicate entry test ', async () => {
+    let parent = { a: { b: 'c' }, k: { b: 'c' } };
+
+    let obj = { ...parent, a: 'overridden', k: ' so only child objects are returned from child ' }; // trying to replicate duplicate
+
+    let fep: FunctionExecutionParameters = new FunctionExecutionParameters(
+        new KIRunFunctionRepository(),
+        new KIRunSchemaRepository(),
+    );
+
+    fep.setArguments(MapUtil.of('source', obj));
+
+    let childRes: any[] = [
+        ['a', 'overridden'],
+        ['k', ' so only child objects are returned from child '],
+    ];
+
+    expect((await objEnt.execute(fep)).allResults()[0]?.getResult()?.get('value')).toStrictEqual(
+        childRes,
+    );
+
+    let parentRes: any[] = [
+        ['a', { b: 'c' }],
+        ['k', { b: 'c' }],
+    ];
+
+    fep.setArguments(MapUtil.of('source', parent));
+
+    expect((await objEnt.execute(fep)).allResults()[0]?.getResult()?.get('value')).toStrictEqual(
+        parentRes,
+    );
+});
+
+test('entry primitive String test ', async () => {
+    let obj = 'ab cd';
+
+    let fep: FunctionExecutionParameters = new FunctionExecutionParameters(
+        new KIRunFunctionRepository(),
+        new KIRunSchemaRepository(),
+    );
+
+    fep.setArguments(MapUtil.of('source', obj));
+
+    expect((await objEnt.execute(fep)).allResults()[0]?.getResult()?.get('value')).toStrictEqual([
+        ['0', 'a'],
+        ['1', 'b'],
+        ['2', ' '],
+        ['3', 'c'],
+        ['4', 'd'],
+    ]);
+});

package/__tests__/engine/function/system/object/ObjectKeysTest.ts

@@ -0,0 +1,168 @@
+import {
+    FunctionExecutionParameters,
+    KIRunFunctionRepository,
+    KIRunSchemaRepository,
+    MapUtil,
+} from '../../../../../src';
+import { ObjectKeys } from '../../../../../src/engine/function/system/object/ObjectKeys';
+
+const objKeys: ObjectKeys = new ObjectKeys();
+
+test('keys test 1', async () => {
+    let obj = { a: 1, b: 2, d: ['a', 'b', 'c'] };
+
+    let fep: FunctionExecutionParameters = new FunctionExecutionParameters(
+        new KIRunFunctionRepository(),
+        new KIRunSchemaRepository(),
+    );
+
+    fep.setArguments(MapUtil.of('source', obj));
+
+    let res = ['a', 'b', 'd'];
+
+    expect((await objKeys.execute(fep)).allResults()[0]?.getResult()?.get('value')).toStrictEqual(
+        res,
+    );
+});
+
+test('entry null test ', async () => {
+    let obj = null;
+
+    let fep: FunctionExecutionParameters = new FunctionExecutionParameters(
+        new KIRunFunctionRepository(),
+        new KIRunSchemaRepository(),
+    );
+
+    fep.setArguments(MapUtil.of('source', obj));
+
+    expect((await objKeys.execute(fep)).allResults()[0]?.getResult()?.get('value')).toStrictEqual(
+        [],
+    );
+});
+
+test('entry undefined test ', async () => {
+    let obj;
+
+    let fep: FunctionExecutionParameters = new FunctionExecutionParameters(
+        new KIRunFunctionRepository(),
+        new KIRunSchemaRepository(),
+    );
+
+    fep.setArguments(MapUtil.of('source', obj));
+
+    expect((await objKeys.execute(fep)).allResults()[0]?.getResult()?.get('value')).toStrictEqual(
+        [],
+    );
+});
+
+test('entry primitive number test ', async () => {
+    let obj = 423;
+
+    let fep: FunctionExecutionParameters = new FunctionExecutionParameters(
+        new KIRunFunctionRepository(),
+        new KIRunSchemaRepository(),
+    );
+
+    fep.setArguments(MapUtil.of('source', obj));
+
+    expect((await objKeys.execute(fep)).allResults()[0]?.getResult()?.get('value')).toStrictEqual(
+        [],
+    );
+});
+
+test('entry primitive boolean test ', async () => {
+    let obj = false;
+
+    let fep: FunctionExecutionParameters = new FunctionExecutionParameters(
+        new KIRunFunctionRepository(),
+        new KIRunSchemaRepository(),
+    );
+
+    fep.setArguments(MapUtil.of('source', obj));
+
+    expect((await objKeys.execute(fep)).allResults()[0]?.getResult()?.get('value')).toStrictEqual(
+        [],
+    );
+});
+
+test('entry primitive String test ', async () => {
+    let obj = 'surendhar';
+
+    let fep: FunctionExecutionParameters = new FunctionExecutionParameters(
+        new KIRunFunctionRepository(),
+        new KIRunSchemaRepository(),
+    );
+
+    fep.setArguments(MapUtil.of('source', obj));
+
+    expect((await objKeys.execute(fep)).allResults()[0]?.getResult()?.get('value')).toStrictEqual([
+        '0',
+        '1',
+        '2',
+        '3',
+        '4',
+        '5',
+        '6',
+        '7',
+        '8',
+    ]);
+});
+
+test('entry nested object test', async () => {
+    let obj = { a: { b: { c: { d: { e: [1, 2, 4, 5] } } } }, c: ['q', 'w', 'e', 'r'] };
+
+    let fep: FunctionExecutionParameters = new FunctionExecutionParameters(
+        new KIRunFunctionRepository(),
+        new KIRunSchemaRepository(),
+    );
+
+    fep.setArguments(MapUtil.of('source', obj));
+
+    let res: any[] = ['a', 'c'];
+
+    expect((await objKeys.execute(fep)).allResults()[0]?.getResult()?.get('value')).toStrictEqual(
+        res,
+    );
+});
+
+test(' entry array test ', async () => {
+    let obj = [1, 2, 3, 4, 1, 12, 3, 4, 5];
+
+    let fep: FunctionExecutionParameters = new FunctionExecutionParameters(
+        new KIRunFunctionRepository(),
+        new KIRunSchemaRepository(),
+    );
+
+    fep.setArguments(MapUtil.of('source', obj));
+
+    let res: any[] = ['0', '1', '2', '3', '4', '5', '6', '7', '8'];
+
+    expect((await objKeys.execute(fep)).allResults()[0]?.getResult()?.get('value')).toStrictEqual(
+        res,
+    );
+});
+
+test(' entry duplicate entry test ', async () => {
+    let parent = { a: { b: 'c' }, k: { b: 'c' } };
+
+    let obj = { ...parent, a: 'overridden', k: ' so only child objects are returned from child ' }; // trying to replicate duplicate
+
+    let fep: FunctionExecutionParameters = new FunctionExecutionParameters(
+        new KIRunFunctionRepository(),
+        new KIRunSchemaRepository(),
+    );
+
+    fep.setArguments(MapUtil.of('source', obj));
+
+    let childRes: any[] = ['a', 'k'];
+
+    expect((await objKeys.execute(fep)).allResults()[0]?.getResult()?.get('value')).toStrictEqual(
+        childRes,
+    );
+
+    fep.setArguments(MapUtil.of('source', parent));
+
+    expect((await objKeys.execute(fep)).allResults()[0]?.getResult()?.get('value')).toStrictEqual(
+        childRes,
+    );
+});

package/__tests__/engine/function/system/object/ObjectValuesTest.ts

@@ -0,0 +1,170 @@
+import {
+    FunctionExecutionParameters,
+    KIRunFunctionRepository,
+    KIRunSchemaRepository,
+    MapUtil,
+} from '../../../../../src';
+import { ObjectValues } from '../../../../../src/engine/function/system/object/ObjectValues';
+
+const objVals: ObjectValues = new ObjectValues();
+
+test('entry test 1', async () => {
+    let obj = { a: 1, b: 2, d: ['a', 'b', 'c'] };
+
+    let fep: FunctionExecutionParameters = new FunctionExecutionParameters(
+        new KIRunFunctionRepository(),
+        new KIRunSchemaRepository(),
+    );
+
+    fep.setArguments(MapUtil.of('source', obj));
+
+    let res = [1, 2, ['a', 'b', 'c']];
+
+    expect((await objVals.execute(fep)).allResults()[0]?.getResult()?.get('value')).toStrictEqual(
+        res,
+    );
+});
+
+test('entry null test ', async () => {
+    let obj = null;
+
+    let fep: FunctionExecutionParameters = new FunctionExecutionParameters(
+        new KIRunFunctionRepository(),
+        new KIRunSchemaRepository(),
+    );
+
+    fep.setArguments(MapUtil.of('source', obj));
+
+    expect((await objVals.execute(fep)).allResults()[0]?.getResult()?.get('value')).toStrictEqual(
+        [],
+    );
+});
+
+test('entry undefined test ', async () => {
+    let obj;
+
+    let fep: FunctionExecutionParameters = new FunctionExecutionParameters(
+        new KIRunFunctionRepository(),
+        new KIRunSchemaRepository(),
+    );
+
+    fep.setArguments(MapUtil.of('source', obj));
+
+    expect((await objVals.execute(fep)).allResults()[0]?.getResult()?.get('value')).toStrictEqual(
+        [],
+    );
+});
+
+test('entry primitive number test ', async () => {
+    let obj = 423;
+
+    let fep: FunctionExecutionParameters = new FunctionExecutionParameters(
+        new KIRunFunctionRepository(),
+        new KIRunSchemaRepository(),
+    );
+
+    fep.setArguments(MapUtil.of('source', obj));
+
+    expect((await objVals.execute(fep)).allResults()[0]?.getResult()?.get('value')).toStrictEqual(
+        [],
+    );
+});
+
+test('entry primitive boolean test ', async () => {
+    let obj = false;
+
+    let fep: FunctionExecutionParameters = new FunctionExecutionParameters(
+        new KIRunFunctionRepository(),
+        new KIRunSchemaRepository(),
+    );
+
+    fep.setArguments(MapUtil.of('source', obj));
+
+    expect((await objVals.execute(fep)).allResults()[0]?.getResult()?.get('value')).toStrictEqual(
+        [],
+    );
+});
+
+test('entry primitive String test ', async () => {
+    let obj = 'surendhar';
+
+    let fep: FunctionExecutionParameters = new FunctionExecutionParameters(
+        new KIRunFunctionRepository(),
+        new KIRunSchemaRepository(),
+    );
+
+    fep.setArguments(MapUtil.of('source', obj));
+
+    expect((await objVals.execute(fep)).allResults()[0]?.getResult()?.get('value')).toStrictEqual([
+        's',
+        'u',
+        'r',
+        'e',
+        'n',
+        'd',
+        'h',
+        'a',
+        'r',
+    ]);
+});
+
+test('entry nested object test', async () => {
+    let obj = { a: { b: { c: { d: { e: [1, 2, 4, 5] } } } }, c: ['q', 'w', 'e', 'r'] };
+
+    let fep: FunctionExecutionParameters = new FunctionExecutionParameters(
+        new KIRunFunctionRepository(),
+        new KIRunSchemaRepository(),
+    );
+
+    fep.setArguments(MapUtil.of('source', obj));
+
+    let res: any[] = [{ b: { c: { d: { e: [1, 2, 4, 5] } } } }, ['q', 'w', 'e', 'r']];
+
+    expect((await objVals.execute(fep)).allResults()[0]?.getResult()?.get('value')).toStrictEqual(
+        res,
+    );
+});
+
+test(' entry array test ', async () => {
+    let obj = [1, 2, 3, 4, 1, 12, 3, 4, 5];
+
+    let fep: FunctionExecutionParameters = new FunctionExecutionParameters(
+        new KIRunFunctionRepository(),
+        new KIRunSchemaRepository(),
+    );
+
+    fep.setArguments(MapUtil.of('source', obj));
+
+    let res: any[] = [1, 2, 3, 4, 1, 12, 3, 4, 5];
+
+    expect((await objVals.execute(fep)).allResults()[0]?.getResult()?.get('value')).toStrictEqual(
+        res,
+    );
+});
+
+test(' entry duplicate entry test ', async () => {
+    let parent = { a: { b: 'c' }, k: { b: 'c' } };
+
+    let obj = { ...parent, a: 'overridden', k: ' so only child objects are returned from child ' }; // trying to replicate duplicate
+
+    let fep: FunctionExecutionParameters = new FunctionExecutionParameters(
+        new KIRunFunctionRepository(),
+        new KIRunSchemaRepository(),
+    );
+
+    fep.setArguments(MapUtil.of('source', obj));
+
+    let childRes: any[] = ['overridden', ' so only child objects are returned from child '];
+
+    expect((await objVals.execute(fep)).allResults()[0]?.getResult()?.get('value')).toStrictEqual(
+        childRes,
+    );
+
+    let parentRes: any[] = [{ b: 'c' }, { b: 'c' }];
+
+    fep.setArguments(MapUtil.of('source', parent));
+
+    expect((await objVals.execute(fep)).allResults()[0]?.getResult()?.get('value')).toStrictEqual(
+        parentRes,
+    );
+});

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@fincity/kirun-js",
-    "version": "1.6.4",
+    "version": "1.6.5",
     "description": "Javascript Runtime for Kinetic Instructions",
     "source": "src/index.ts",
     "main": "dist/index.js",

package/src/engine/function/system/object/AbstractObjectFunction.ts

@@ -0,0 +1,31 @@
+import { FunctionOutput } from '../../../model/FunctionOutput';
+import { FunctionSignature } from '../../../model/FunctionSignature';
+import { FunctionExecutionParameters } from '../../../runtime/FunctionExecutionParameters';
+import { AbstractFunction } from '../../AbstractFunction';
+
+import { Namespaces } from '../../../namespaces/Namespaces';
+import { Event } from '../../../model/Event';
+import { Schema } from '../../../json/schema/Schema';
+import { Parameter } from '../../../model/Parameter';
+
+const VALUE = 'value';
+
+const SOURCE = 'source';
+
+export abstract class AbstractObjectFunction extends AbstractFunction {
+    private SIGNATURE: FunctionSignature;
+
+    protected constructor(functionName: string) {
+        super();
+        this.SIGNATURE = new FunctionSignature(functionName)
+            .setNamespace(Namespaces.SYSTEM)
+            .setParameters(new Map([[SOURCE, new Parameter(SOURCE, Schema.ofAny(SOURCE))]]))
+            .setEvents(
+                new Map([Event.outputEventMapEntry(new Map([[VALUE, Schema.ofArray(VALUE)]]))]),
+            );
+    }
+
+    public getSignature(): FunctionSignature {
+        return this.SIGNATURE;
+    }
+}

package/src/engine/function/system/object/ObjectEntries.ts

@@ -0,0 +1,25 @@
+import { FunctionOutput } from '../../../model/FunctionOutput';
+import { FunctionExecutionParameters } from '../../../runtime/FunctionExecutionParameters';
+
+import { isNullValue } from '../../../util/NullCheck';
+import { EventResult } from '../../../model/EventResult';
+import { AbstractObjectFunction } from './AbstractObjectFunction';
+
+const VALUE = 'value';
+
+export class ObjectEntries extends AbstractObjectFunction {
+    public constructor() {
+        super('ObjectEntries');
+    }
+
+    protected async internalExecute(context: FunctionExecutionParameters): Promise<FunctionOutput> {
+        var source = context.getArguments()?.get('source');
+
+        if (isNullValue(source))
+            return new FunctionOutput([EventResult.outputOf(new Map([[VALUE, []]]))]);
+
+        let entries = Object.entries(source);
+
+        return new FunctionOutput([EventResult.outputOf(new Map([[VALUE, entries]]))]);
+    }
+}

package/src/engine/function/system/object/ObjectKeys.ts

@@ -0,0 +1,25 @@
+import { FunctionOutput } from '../../../model/FunctionOutput';
+import { FunctionExecutionParameters } from '../../../runtime/FunctionExecutionParameters';
+
+import { isNullValue } from '../../../util/NullCheck';
+import { EventResult } from '../../../model/EventResult';
+import { AbstractObjectFunction } from './AbstractObjectFunction';
+
+const VALUE = 'value';
+
+export class ObjectKeys extends AbstractObjectFunction {
+    public constructor() {
+        super('ObjectEntries');
+    }
+
+    protected async internalExecute(context: FunctionExecutionParameters): Promise<FunctionOutput> {
+        var source = context.getArguments()?.get('source');
+
+        if (isNullValue(source))
+            return new FunctionOutput([EventResult.outputOf(new Map([[VALUE, []]]))]);
+
+        let keys: String[] = Object.keys(source);
+
+        return new FunctionOutput([EventResult.outputOf(new Map([[VALUE, keys]]))]);
+    }
+}

package/src/engine/function/system/object/ObjectValues.ts

@@ -0,0 +1,25 @@
+import { FunctionOutput } from '../../../model/FunctionOutput';
+import { FunctionExecutionParameters } from '../../../runtime/FunctionExecutionParameters';
+
+import { isNullValue } from '../../../util/NullCheck';
+import { EventResult } from '../../../model/EventResult';
+import { AbstractObjectFunction } from './AbstractObjectFunction';
+
+const VALUE = 'value';
+
+export class ObjectValues extends AbstractObjectFunction {
+    public constructor() {
+        super('ObjectValues');
+    }
+
+    protected async internalExecute(context: FunctionExecutionParameters): Promise<FunctionOutput> {
+        var source = context.getArguments()?.get('source');
+
+        if (isNullValue(source))
+            return new FunctionOutput([EventResult.outputOf(new Map([[VALUE, []]]))]);
+
+        let objectValues: String[] = Object.values(source);
+
+        return new FunctionOutput([EventResult.outputOf(new Map([[VALUE, objectValues]]))]);
+    }
+}