flowquery 1.0.43 → 1.0.45

package/tests/compute/runner.test.ts

@@ -758,6 +758,120 @@ test("Test substring function with zero length", async () => {
     expect(results[0]).toEqual({ result: "" });
 });
 
+// --- Null propagation tests ---
+
+test("Test toLower with null returns null", async () => {
+    const runner = new Runner("RETURN toLower(null) as result");
+    await runner.run();
+    const results = runner.results;
+    expect(results.length).toBe(1);
+    expect(results[0]).toEqual({ result: null });
+});
+
+test("Test trim with null returns null", async () => {
+    const runner = new Runner("RETURN trim(null) as result");
+    await runner.run();
+    const results = runner.results;
+    expect(results.length).toBe(1);
+    expect(results[0]).toEqual({ result: null });
+});
+
+test("Test replace with null returns null", async () => {
+    const runner = new Runner("RETURN replace(null, 'a', 'b') as result");
+    await runner.run();
+    const results = runner.results;
+    expect(results.length).toBe(1);
+    expect(results[0]).toEqual({ result: null });
+});
+
+test("Test substring with null returns null", async () => {
+    const runner = new Runner("RETURN substring(null, 0, 3) as result");
+    await runner.run();
+    const results = runner.results;
+    expect(results.length).toBe(1);
+    expect(results[0]).toEqual({ result: null });
+});
+
+test("Test split with null returns null", async () => {
+    const runner = new Runner("RETURN split(null, ',') as result");
+    await runner.run();
+    const results = runner.results;
+    expect(results.length).toBe(1);
+    expect(results[0]).toEqual({ result: null });
+});
+
+test("Test size with null returns null", async () => {
+    const runner = new Runner("RETURN size(null) as result");
+    await runner.run();
+    const results = runner.results;
+    expect(results.length).toBe(1);
+    expect(results[0]).toEqual({ result: null });
+});
+
+test("Test round with null returns null", async () => {
+    const runner = new Runner("RETURN round(null) as result");
+    await runner.run();
+    const results = runner.results;
+    expect(results.length).toBe(1);
+    expect(results[0]).toEqual({ result: null });
+});
+
+test("Test join with null returns null", async () => {
+    const runner = new Runner("RETURN join(null, ',') as result");
+    await runner.run();
+    const results = runner.results;
+    expect(results.length).toBe(1);
+    expect(results[0]).toEqual({ result: null });
+});
+
+test("Test string_distance with null returns null", async () => {
+    const runner = new Runner("RETURN string_distance(null, 'hello') as result");
+    await runner.run();
+    const results = runner.results;
+    expect(results.length).toBe(1);
+    expect(results[0]).toEqual({ result: null });
+});
+
+test("Test stringify with null returns null", async () => {
+    const runner = new Runner("RETURN stringify(null) as result");
+    await runner.run();
+    const results = runner.results;
+    expect(results.length).toBe(1);
+    expect(results[0]).toEqual({ result: null });
+});
+
+test("Test toJson with null returns null", async () => {
+    const runner = new Runner("RETURN tojson(null) as result");
+    await runner.run();
+    const results = runner.results;
+    expect(results.length).toBe(1);
+    expect(results[0]).toEqual({ result: null });
+});
+
+test("Test range with null returns null", async () => {
+    const runner = new Runner("RETURN range(null, 5) as result");
+    await runner.run();
+    const results = runner.results;
+    expect(results.length).toBe(1);
+    expect(results[0]).toEqual({ result: null });
+});
+
+test("Test toString with null returns null", async () => {
+    const runner = new Runner("RETURN toString(null) as result");
+    await runner.run();
+    const results = runner.results;
+    expect(results.length).toBe(1);
+    expect(results[0]).toEqual({ result: null });
+});
+
+test("Test keys with null returns null", async () => {
+    const runner = new Runner("RETURN keys(null) as result");
+    await runner.run();
+    const results = runner.results;
+    expect(results.length).toBe(1);
+    expect(results[0]).toEqual({ result: null });
+});
+
 test("Test associative array with key which is keyword", async () => {
     const runner = new Runner("RETURN {return: 1} as aa");
     await runner.run();
@@ -4000,6 +4114,126 @@ test("Test order by with where", async () => {
     expect(results[4]).toEqual({ x: 3 });
 });
 
+test("Test order by with property access expression", async () => {
+    const runner = new Runner(`
+        unwind [{name: 'Charlie', age: 30}, {name: 'Alice', age: 25}, {name: 'Bob', age: 35}] as person
+        return person.name as name, person.age as age
+        order by person.name asc
+    `);
+    await runner.run();
+    const results = runner.results;
+    expect(results.length).toBe(3);
+    expect(results[0]).toEqual({ name: "Alice", age: 25 });
+    expect(results[1]).toEqual({ name: "Bob", age: 35 });
+    expect(results[2]).toEqual({ name: "Charlie", age: 30 });
+});
+
+test("Test order by with function expression", async () => {
+    const runner = new Runner(`
+        unwind ['BANANA', 'apple', 'Cherry'] as fruit
+        return fruit
+        order by toLower(fruit)
+    `);
+    await runner.run();
+    const results = runner.results;
+    expect(results.length).toBe(3);
+    expect(results[0]).toEqual({ fruit: "apple" });
+    expect(results[1]).toEqual({ fruit: "BANANA" });
+    expect(results[2]).toEqual({ fruit: "Cherry" });
+});
+
+test("Test order by with function expression descending", async () => {
+    const runner = new Runner(`
+        unwind ['BANANA', 'apple', 'Cherry'] as fruit
+        return fruit
+        order by toLower(fruit) desc
+    `);
+    await runner.run();
+    const results = runner.results;
+    expect(results.length).toBe(3);
+    expect(results[0]).toEqual({ fruit: "Cherry" });
+    expect(results[1]).toEqual({ fruit: "BANANA" });
+    expect(results[2]).toEqual({ fruit: "apple" });
+});
+
+test("Test order by with nested function expression", async () => {
+    const runner = new Runner(`
+        unwind ['Alice', 'Bob', 'ALICE', 'bob'] as name
+        return name
+        order by string_distance(toLower(name), toLower('alice')) asc
+    `);
+    await runner.run();
+    const results = runner.results;
+    expect(results.length).toBe(4);
+    // 'Alice' and 'ALICE' have distance 0 from 'alice', should come first
+    expect(results[0].name).toBe("Alice");
+    expect(results[1].name).toBe("ALICE");
+    // 'Bob' and 'bob' have higher distance from 'alice'
+    expect(results[2].name).toBe("Bob");
+    expect(results[3].name).toBe("bob");
+});
+
+test("Test order by with arithmetic expression", async () => {
+    const runner = new Runner(`
+        unwind [{a: 3, b: 1}, {a: 1, b: 5}, {a: 2, b: 2}] as item
+        return item.a as a, item.b as b
+        order by item.a + item.b asc
+    `);
+    await runner.run();
+    const results = runner.results;
+    expect(results.length).toBe(3);
+    expect(results[0]).toEqual({ a: 3, b: 1 }); // sum = 4
+    expect(results[1]).toEqual({ a: 2, b: 2 }); // sum = 4
+    expect(results[2]).toEqual({ a: 1, b: 5 }); // sum = 6
+});
+
+test("Test order by expression does not leak synthetic keys", async () => {
+    const runner = new Runner(`
+        unwind ['B', 'a', 'C'] as x
+        return x
+        order by toLower(x) asc
+    `);
+    await runner.run();
+    const results = runner.results;
+    expect(results.length).toBe(3);
+    // Results should only contain 'x', no __orderBy_ keys
+    for (const r of results) {
+        expect(Object.keys(r)).toEqual(["x"]);
+    }
+    expect(results[0]).toEqual({ x: "a" });
+    expect(results[1]).toEqual({ x: "B" });
+    expect(results[2]).toEqual({ x: "C" });
+});
+
+test("Test order by with expression and limit", async () => {
+    const runner = new Runner(`
+        unwind ['BANANA', 'apple', 'Cherry', 'date', 'ELDERBERRY'] as fruit
+        return fruit
+        order by toLower(fruit) asc
+        limit 3
+    `);
+    await runner.run();
+    const results = runner.results;
+    expect(results.length).toBe(3);
+    expect(results[0]).toEqual({ fruit: "apple" });
+    expect(results[1]).toEqual({ fruit: "BANANA" });
+    expect(results[2]).toEqual({ fruit: "Cherry" });
+});
+
+test("Test order by with mixed simple and expression fields", async () => {
+    const runner = new Runner(`
+        unwind [{name: 'Alice', score: 3}, {name: 'Alice', score: 1}, {name: 'Bob', score: 2}] as item
+        return item.name as name, item.score as score
+        order by name asc, item.score desc
+    `);
+    await runner.run();
+    const results = runner.results;
+    expect(results.length).toBe(3);
+    expect(results[0]).toEqual({ name: "Alice", score: 3 }); // Alice, score 3 desc
+    expect(results[1]).toEqual({ name: "Alice", score: 1 }); // Alice, score 1 desc
+    expect(results[2]).toEqual({ name: "Bob", score: 2 }); // Bob
+});
+
 test("Test delete virtual node operation", async () => {
     const db = Database.getInstance();
     // Create a virtual node first

package/tests/parsing/parser.test.ts

@@ -1269,3 +1269,59 @@ test("OPTIONAL without MATCH throws error", () => {
     const parser = new Parser();
     expect(() => parser.parse("OPTIONAL RETURN 1")).toThrow("Expected MATCH after OPTIONAL");
 });
+
+// ORDER BY expression tests
+
+test("ORDER BY with simple identifier parses correctly", () => {
+    const parser = new Parser();
+    const ast = parser.parse("unwind [1, 2] as x return x order by x");
+    expect(ast).toBeDefined();
+});
+
+test("ORDER BY with property access parses correctly", () => {
+    const parser = new Parser();
+    const ast = parser.parse(
+        "unwind [{name: 'Bob'}, {name: 'Alice'}] as person return person.name as name order by person.name asc"
+    );
+    expect(ast).toBeDefined();
+});
+
+test("ORDER BY with function call parses correctly", () => {
+    const parser = new Parser();
+    const ast = parser.parse(
+        "unwind ['HELLO', 'WORLD'] as word return word order by toLower(word) asc"
+    );
+    expect(ast).toBeDefined();
+});
+
+test("ORDER BY with nested function calls parses correctly", () => {
+    const parser = new Parser();
+    const ast = parser.parse(
+        "unwind ['Alice', 'Bob'] as name return name order by string_distance(toLower(name), toLower('alice')) asc"
+    );
+    expect(ast).toBeDefined();
+});
+
+test("ORDER BY with arithmetic expression parses correctly", () => {
+    const parser = new Parser();
+    const ast = parser.parse(
+        "unwind [{a: 3, b: 1}, {a: 1, b: 5}] as item return item.a as a, item.b as b order by item.a + item.b desc"
+    );
+    expect(ast).toBeDefined();
+});
+
+test("ORDER BY with multiple expression fields parses correctly", () => {
+    const parser = new Parser();
+    const ast = parser.parse(
+        "unwind [{a: 1, b: 2}] as item return item.a as a, item.b as b order by toLower(item.a) asc, item.b desc"
+    );
+    expect(ast).toBeDefined();
+});
+
+test("ORDER BY with expression and LIMIT parses correctly", () => {
+    const parser = new Parser();
+    const ast = parser.parse(
+        "unwind ['c', 'a', 'b'] as x return x order by toLower(x) asc limit 2"
+    );
+    expect(ast).toBeDefined();
+});