flowquery 1.0.0

package/tests/compute/runner.test.ts

@@ -0,0 +1,498 @@
+import Runner from '../../src/compute/runner';
+
+test('Test return', async () => {
+    const runner = new Runner('return 1 + 2 as sum');
+    await runner.run();
+    const results = runner.results;
+    expect(results.length).toBe(1);
+    expect(results[0]).toEqual({'sum': 3});
+});
+
+test('Test return with multiple expressions', async () => {
+    const runner = new Runner('return 1 + 2 as sum, 3 + 4 as sum2');
+    await runner.run();
+    const results = runner.results;
+    expect(results.length).toBe(1);
+    expect(results[0]).toEqual({'sum': 3, 'sum2': 7});
+});
+
+test('Test unwind and return', async () => {
+    const runner = new Runner('unwind [1, 2, 3] as num return num');
+    await runner.run();
+    const results = runner.results;
+    expect(results.length).toBe(3);
+    expect(results[0]).toEqual({'num': 1});
+    expect(results[1]).toEqual({'num': 2});
+    expect(results[2]).toEqual({'num': 3});
+});
+
+test('Test load and return', async () => {
+    const runner = new Runner('load json from "https://jsonplaceholder.typicode.com/todos" as todo return todo');
+    await runner.run();
+    const results = runner.results;
+    expect(results.length).toBeGreaterThan(0);
+});
+
+test('Test load with post and return', async () => {
+    const runner = new Runner('load json from "https://jsonplaceholder.typicode.com/posts" post {userId: 1} as data return data');
+    await runner.run();
+    const results = runner.results;
+    expect(results.length).toBe(1);
+});
+
+test('Test aggregated return', async () => {
+    const runner = new Runner('unwind [1, 1, 2, 2] as i unwind [1, 2, 3, 4] as j return i, sum(j) as sum');
+    await runner.run();
+    const results = runner.results;
+    expect(results.length).toBe(2);
+    expect(results[0]).toEqual({'i': 1, 'sum': 20});
+    expect(results[1]).toEqual({'i': 2, 'sum': 20});
+});
+
+test('Test aggregated return with string', async () => {
+    const runner = new Runner('unwind [1, 1, 2, 2] as i unwind ["a", "b", "c", "d"] as j return i, sum(j) as sum');
+    await runner.run();
+    const results = runner.results;
+    expect(results.length).toBe(2);
+    expect(results[0]).toEqual({'i': 1, 'sum': 'abcdabcd'});
+    expect(results[1]).toEqual({'i': 2, 'sum': 'abcdabcd'});
+});
+
+test('Test aggregated return with object', async () => {
+    const runner = new Runner('unwind [1, 1, 2, 2] as i unwind [1, 2, 3 4] as j return i, {sum: sum(j)} as sum');
+    await runner.run();
+    const results = runner.results;
+    expect(results.length).toBe(2);
+    expect(results[0]).toEqual({'i': 1, 'sum': {'sum': 20}});
+    expect(results[1]).toEqual({'i': 2, 'sum': {'sum': 20}});
+});
+
+test('Test aggregated return with array', async () => {
+    const runner = new Runner('unwind [1, 1, 2, 2] as i unwind [1, 2, 3 4] as j return i, [sum(j)] as sum');
+    await runner.run();
+    const results = runner.results;
+    expect(results.length).toBe(2);
+    expect(results[0]).toEqual({'i': 1, 'sum': [20]});
+    expect(results[1]).toEqual({'i': 2, 'sum': [20]});
+});
+
+test('Test aggregated return with multiple aggregates', async () => {
+    const runner = new Runner('unwind [1, 1, 2, 2] as i unwind [1, 2, 3, 4] as j return i, sum(j) as sum, avg(j) as avg');
+    await runner.run();
+    const results = runner.results;
+    expect(results.length).toBe(2);
+    expect(results[0]).toEqual({'i': 1, 'sum': 20, 'avg': 2.5});
+    expect(results[1]).toEqual({'i': 2, 'sum': 20, 'avg': 2.5});
+});
+
+test('Test avg with null', async () => {
+    const runner = new Runner('return avg(null) as avg');
+    await runner.run();
+    const results = runner.results;
+    expect(results.length).toBe(1);
+    expect(results[0]).toEqual({'avg': null});
+});
+
+test('Test sum with null', async () => {
+    const runner = new Runner('return sum(null) as sum');
+    await runner.run();
+    const results = runner.results;
+    expect(results.length).toBe(1);
+    expect(results[0]).toEqual({'sum': null});
+});
+
+test('Test avg with one value', async () => {
+    const runner = new Runner('return avg(1) as avg');
+    await runner.run();
+    const results = runner.results;
+    expect(results.length).toBe(1);
+    expect(results[0]).toEqual({'avg': 1});
+});
+
+test('Test with and return', async () => {
+    const runner = new Runner('with 1 as a return a');
+    await runner.run();
+    const results = runner.results;
+    expect(results.length).toBe(1);
+    expect(results[0]).toEqual({'a': 1});
+});
+
+test('Test nested aggregate functions', async () => {
+    expect(() => {
+        new Runner('unwind [1, 2, 3, 4] as i return sum(sum(i)) as sum')
+    }).toThrow('Aggregate functions cannot be nested');
+});
+
+test('Test with and return with unwind', async () => {
+    const runner = new Runner('with [1, 2, 3] as a unwind a as b return b as renamed');
+    await runner.run();
+    const results = runner.results;
+    expect(results.length).toBe(3);
+    expect(results[0]).toEqual({'renamed': 1});
+    expect(results[1]).toEqual({'renamed': 2});
+    expect(results[2]).toEqual({'renamed': 3});
+});
+
+test('Test predicate function', async () => {
+    const runner = new Runner('RETURN sum(n in [1, 2, 3] | n where n > 1) as sum');
+    await runner.run();
+    const results = runner.results;
+    expect(results.length).toBe(1);
+    expect(results[0]).toEqual({'sum': 5});
+});
+
+test('Test predicate without where', async () => {
+    const runner = new Runner('RETURN sum(n in [1, 2, 3] | n) as sum');
+    await runner.run();
+    const results = runner.results;
+    expect(results.length).toBe(1);
+    expect(results[0]).toEqual({'sum': 6});
+});
+
+test('Test predicate with return expression', async () => {
+    const runner = new Runner('RETURN sum(n in [1+2+3, 2, 3] | n^2) as sum');
+    await runner.run();
+    const results = runner.results;
+    expect(results.length).toBe(1);
+    expect(results[0]).toEqual({'sum': 49});
+});
+
+test('Test range function', async () => {
+    const runner = new Runner('RETURN range(1, 3) as range');
+    await runner.run();
+    const results = runner.results;
+    expect(results.length).toBe(1);
+    expect(results[0]).toEqual({'range': [1, 2, 3]});
+});
+
+test('Test range function with unwind and case', async () => {
+    const runner = new Runner('unwind range(1, 3) as num return case when num > 1 then num else null end as ret');
+    await runner.run();
+    const results = runner.results;
+    expect(results.length).toBe(3);
+    expect(results[0]).toEqual({'ret': null});
+    expect(results[1]).toEqual({'ret': 2});
+    expect(results[2]).toEqual({'ret': 3});
+});
+
+test('Test size function', async () => {
+    const runner = new Runner('RETURN size([1, 2, 3]) as size');
+    await runner.run();
+    const results = runner.results;
+    expect(results.length).toBe(1);
+    expect(results[0]).toEqual({'size': 3});
+});
+
+test('Test rand and round functions', async () => {
+    const runner = new Runner('RETURN round(rand() * 10) as rand');
+    await runner.run();
+    const results = runner.results;
+    expect(results.length).toBe(1);
+    expect(results[0].rand).toBeLessThanOrEqual(10);
+});
+
+test('Test split function', async () => {
+    const runner = new Runner('RETURN split("a,b,c", ",") as split');
+    await runner.run();
+    const results = runner.results;
+    expect(results.length).toBe(1);
+    expect(results[0]).toEqual({'split': ['a', 'b', 'c']});
+});
+
+test('Test f-string', async () => {
+    const runner = new Runner('with range(1,3) as numbers RETURN f"hello {sum(n in numbers | n)}" as f');
+    await runner.run();
+    const results = runner.results;
+    expect(results.length).toBe(1);
+    expect(results[0]).toEqual({'f': 'hello 6'});
+});
+
+test('Test aggregated with and return', async () => {
+    const runner = new Runner(
+        `
+        unwind [1, 1, 2, 2] as i
+        unwind range(1, 3) as j
+        with i, sum(j) as sum
+        return i, sum
+        `
+    );
+    await runner.run();
+    const results = runner.results;
+    expect(results.length).toBe(2);
+    expect(results[0]).toEqual({'i': 1, 'sum': 12});
+    expect(results[1]).toEqual({'i': 2, 'sum': 12});
+});
+
+test('Test aggregated with using collect and return', async () => {
+    const runner = new Runner(
+        `
+        unwind [1, 1, 2, 2] as i
+        unwind range(1, 3) as j
+        with i, collect(j) as collected
+        return i, collected
+        `
+    );
+    await runner.run();
+    const results = runner.results;
+    expect(results.length).toBe(2);
+    expect(results[0]).toEqual({'i': 1, 'collected': [1, 2, 3, 1, 2, 3]});
+    expect(results[1]).toEqual({'i': 2, 'collected': [1, 2, 3, 1, 2, 3]});
+});
+
+test('Test collect distinct', async () => {
+    const runner = new Runner(
+        `
+        unwind [1, 1, 2, 2] as i
+        unwind range(1, 3) as j
+        with i, collect(distinct j) as collected
+        return i, collected
+        `
+    );
+    await runner.run();
+    const results = runner.results;
+    expect(results.length).toBe(2);
+    expect(results[0]).toEqual({'i': 1, 'collected': [1, 2, 3]});
+    expect(results[1]).toEqual({'i': 2, 'collected': [1, 2, 3]});
+});
+
+test('Test collect distinct with associative array', async () => {
+    const runner = new Runner(
+        `
+        unwind [1, 1, 2, 2] as i
+        unwind range(1, 3) as j
+        with i, collect(distinct {j: j}) as collected
+        return i, collected
+        `
+    );
+    await runner.run();
+    const results = runner.results;
+    expect(results.length).toBe(2);
+    expect(results[0]).toEqual({'i': 1, 'collected': [{'j': 1}, {'j': 2}, {'j': 3}]});
+    expect(results[1]).toEqual({'i': 2, 'collected': [{'j': 1}, {'j': 2}, {'j': 3}]});
+});
+
+test('Test join function', async () => {
+    const runner = new Runner('RETURN join(["a", "b", "c"], ",") as join');
+    await runner.run();
+    const results = runner.results;
+    expect(results.length).toBe(1);
+    expect(results[0]).toEqual({'join': 'a,b,c'});
+});
+
+test('Test join function with empty array', async () => {
+    const runner = new Runner('RETURN join([], ",") as join');
+    await runner.run();
+    const results = runner.results;
+    expect(results.length).toBe(1);
+    expect(results[0]).toEqual({'join': ''});
+});
+
+test('Test tojson function', async () => {
+    const runner = new Runner('RETURN tojson(\'{"a": 1, "b": 2}\') as tojson');
+    await runner.run();
+    const results = runner.results;
+    expect(results.length).toBe(1);
+    expect(results[0]).toEqual({'tojson': {'a': 1, 'b': 2}});
+});
+
+test('Test tojson function with lookup', async () => {
+    const runner = new Runner('RETURN tojson(\'{"a": 1, "b": 2}\').a as tojson');
+    await runner.run();
+    const results = runner.results;
+    expect(results.length).toBe(1);
+    expect(results[0]).toEqual({'tojson': 1});
+});
+
+test('Test replace function', async () => {
+    const runner = new Runner('RETURN replace("hello", "l", "x") as replace');
+    await runner.run();
+    const results = runner.results;
+    expect(results.length).toBe(1);
+    expect(results[0]).toEqual({'replace': 'hexxo'});
+});
+
+test('Test f-string with escaped braces', async () => {
+    const runner = new Runner('with range(1,3) as numbers RETURN f"hello {{sum(n in numbers | n)}}" as f');
+    await runner.run();
+    const results = runner.results;
+    expect(results.length).toBe(1);
+    expect(results[0]).toEqual({'f': 'hello {sum(n in numbers | n)}'});
+});
+
+test('Test predicate function with collection from lookup', async () => {
+    const runner = new Runner('RETURN sum(n in tojson(\'{"a": [1, 2, 3]}\').a | n) as sum');
+    await runner.run();
+    const results = runner.results;
+    expect(results.length).toBe(1);
+    expect(results[0]).toEqual({'sum': 6});
+});
+
+test('Test stringify function', async () => {
+    const runner = new Runner('RETURN stringify({a: 1, b: 2}) as stringify');
+    await runner.run();
+    const results = runner.results;
+    expect(results.length).toBe(1);
+    expect(results[0]).toEqual({
+        'stringify': '{\n   "a": 1,\n   "b": 2\n}'
+    });
+});
+
+test('Test associative array with key which is keyword', async () => {
+    const runner = new Runner('RETURN {return: 1} as aa');
+    await runner.run();
+    const results = runner.results;
+    expect(results.length).toBe(1);
+    expect(results[0]).toEqual({'aa': {'return': 1}});
+});
+
+test('Test lookup which is keyword', async () => {
+    const runner = new Runner('RETURN {return: 1}.return as aa');
+    await runner.run();
+    const results = runner.results;
+    expect(results.length).toBe(1);
+    expect(results[0]).toEqual({'aa': 1});
+});
+
+test('Test lookup which is keyword', async () => {
+    const runner = new Runner('RETURN {return: 1}["return"] as aa');
+    await runner.run();
+    const results = runner.results;
+    expect(results.length).toBe(1);
+    expect(results[0]).toEqual({'aa': 1});
+});
+
+test('Test return with expression alias which starts with keyword', async () => {
+    const runner = new Runner('RETURN 1 as return1, ["hello", "world"] as notes');
+    await runner.run();
+    const results = runner.results;
+    expect(results.length).toBe(1);
+    expect(results[0]).toEqual({'return1': 1, 'notes': ['hello', 'world']});
+});
+
+test('Test load which should throw error', async () => {
+    const runner = new Runner('load json from "http://non_existing" as data return data');
+    runner.run().then().catch(e => {
+        expect(e.message).toBe('Failed to load data from http://non_existing. Error: TypeError: fetch failed');
+    });
+});
+
+test('Test return with where clause', async () => {
+    const runner = new Runner('unwind range(1,100) as n with n return n where n >= 20 and n <= 30');
+    await runner.run();
+    const results = runner.results;
+    expect(results.length).toBe(11);
+    expect(results[0]).toEqual({'n': 20});
+    expect(results[10]).toEqual({'n': 30});
+});
+
+test('Test return with where clause and expression alias', async () => {
+    const runner = new Runner('unwind range(1,100) as n with n return n as number where n >= 20 and n <= 30');
+    await runner.run();
+    const results = runner.results;
+    expect(results.length).toBe(11);
+    expect(results[0]).toEqual({'number': 20});
+    expect(results[10]).toEqual({'number': 30});
+});
+
+test('Test aggregated return with where clause', async () => {
+    const runner = new Runner('unwind range(1,100) as n with n where n >= 20 and n <= 30 return sum(n) as sum');
+    await runner.run();
+    const results = runner.results;
+    expect(results.length).toBe(1);
+    expect(results[0]).toEqual({'sum': 275});
+});
+
+test('Test chained aggregated return with where clause', async () => {
+    const runner = new Runner(
+        `
+        unwind [1, 1, 2, 2] as i
+        unwind range(1, 4) as j
+        return i, sum(j) as sum
+        where i = 1
+        `
+    );
+    await runner.run();
+    const results = runner.results;
+    expect(results.length).toBe(1);
+    expect(results[0]).toEqual({'i': 1, 'sum': 20});
+});
+
+test('Test predicate function with collection from function', async () => {
+    const runner = new Runner(
+        `
+        unwind range(1, 10) as i
+        unwind range(1, 10) as j
+        return i, sum(j), avg(j), sum(n in collect(j) | n) as sum
+        `
+    );
+    await runner.run();
+    const results = runner.results;
+    expect(results.length).toBe(10);
+    expect(results[0]).toEqual({'i': 1, 'expr1': 55, 'expr2': 5.5, 'sum': 55});
+});
+
+test('Test limit', async () => {
+    const runner = new Runner(
+        `
+        unwind range(1, 10) as i
+        unwind range(1, 10) as j
+        limit 5
+        return j
+        `
+    );
+    await runner.run();
+    const results = runner.results;
+    expect(results.length).toBe(50);
+});
+
+test('Test range lookup', async () => {
+    const runner = new Runner(
+        `
+        with range(1, 10) as numbers
+        return
+            numbers[:] as subset1,
+            numbers[0:3] as subset2,
+            numbers[:-2] as subset3
+        `
+    );
+    await runner.run();
+    const results = runner.results;
+    expect(results.length).toBe(1);
+    expect(results[0]).toEqual({
+        'subset1': [1, 2, 3, 4, 5, 6, 7, 8, 9, 10],
+        'subset2': [1, 2, 3],
+        'subset3': [1, 2, 3, 4, 5, 6, 7, 8]
+    });
+});
+
+test('Test return -1', async () => {
+    const runner = new Runner('return -1 as num');
+    await runner.run();
+    const results = runner.results;
+    expect(results.length).toBe(1);
+    expect(results[0]).toEqual({'num': -1});
+});
+
+test('Unwind range lookup', async () => {
+    const runner = new Runner(`
+        with range(1,10) as arr
+        unwind arr[2:-2] as a
+        return a
+    `);
+    await runner.run();
+    const results = runner.results;
+    expect(results.length).toBe(6);
+    expect(results[0]).toEqual({'a': 3});
+    expect(results[5]).toEqual({'a': 8});
+});
+
+test('Test range with size', async () => {
+    const runner = new Runner(`
+        with range(1,10) as data
+        return range(0, size(data)-1) as indices
+    `);
+    await runner.run();
+    const results = runner.results;
+    expect(results.length).toBe(1);
+    expect(results[0]).toEqual({'indices': [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]});
+});

package/tests/parsing/context.test.ts

@@ -0,0 +1,27 @@
+import Context from "../../src/parsing/context";
+import Sum from "../../src/parsing/functions/sum";
+import AggregateFunction from "../../src/parsing/functions/aggregate_function";
+
+test('Test Context containsType', () => {
+    const context = new Context();
+    const sum = new Sum();
+    context.push(sum);
+    expect(context.containsType(AggregateFunction)).toBe(true);
+});
+
+test('Test Context containsType false', () => {
+    const context = new Context();
+    expect(context.containsType(AggregateFunction)).toBe(false);
+});
+
+test('Test Context push and pop', () => {
+    const context = new Context();
+    const sum = new Sum();
+    context.push(sum);
+    expect(context.pop()).toBe(sum);
+});
+
+test('Test Context pop undefined', () => {
+    const context = new Context();
+    expect(context.pop()).toBe(undefined);
+});

package/tests/parsing/expression.test.ts

@@ -0,0 +1,40 @@
+import Expression from "../../src/parsing/expressions/expression";
+import { Add, Subtract, Multiply, Power, GreaterThan, And } from "../../src/parsing/expressions/operator";
+import Number from "../../src/parsing/expressions/number";
+
+test('Test Expression Shunting Yard algorithm', () => {
+    const expression = new Expression();
+    expression.addNode(new Number('2'));
+    expression.addNode(new Add());
+    expression.addNode(new Number('3'));
+    expression.addNode(new Multiply());
+    expression.addNode(new Number('4'));
+    expression.addNode(new Subtract());
+    expression.addNode(new Number('2'));
+    expression.addNode(new Power());
+    expression.addNode(new Number('2'));
+    expression.finish();
+    expect(expression.value()).toBe(10);
+});
+
+test('Test Expression with and operator', () => {
+    const expression = new Expression();
+    expression.addNode(new Number('2'));
+    expression.addNode(new And());
+    expression.addNode(new Number('3'));
+    expression.finish();
+    expect(expression.value()).toBe(1);
+});
+
+test('Test 1 > 0 and 2 > 1', () => {
+    const expression = new Expression();
+    expression.addNode(new Number('1'));
+    expression.addNode(new GreaterThan());
+    expression.addNode(new Number('0'));
+    expression.addNode(new And());
+    expression.addNode(new Number('2'));
+    expression.addNode(new GreaterThan());
+    expression.addNode(new Number('1'));
+    expression.finish();
+    expect(expression.value()).toBe(1);
+});