flowquery 1.0.15 → 1.0.17

package/tests/extensibility.test.ts

@@ -1,19 +1,19 @@
 import {
-    Function,
     AggregateFunction,
     AsyncFunction,
-    PredicateFunction,
-    ReducerElement,
+    Function,
+    FunctionCategory,
     FunctionDef,
-    FunctionMetadata,
     FunctionDefOptions,
-    ParameterSchema,
+    FunctionMetadata,
     OutputSchema,
-    FunctionCategory
+    ParameterSchema,
+    PredicateFunction,
+    ReducerElement,
 } from "../src/extensibility";
 import {
     getFunctionMetadata,
-    getRegisteredFunctionFactory
+    getRegisteredFunctionFactory,
 } from "../src/parsing/functions/function_metadata";
 
 describe("Extensibility API Exports", () => {
@@ -23,12 +23,12 @@ describe("Extensibility API Exports", () => {
                 super("customFunc");
                 this._expectedParameterCount = 1;
             }
-            
+
             public value(): string {
                 return "custom value";
             }
         }
-        
+
         const func = new CustomFunction();
         expect(func.name).toBe("customFunc");
         expect(func.toString()).toBe("Function (customFunc)");
@@ -42,9 +42,9 @@ describe("Extensibility API Exports", () => {
                 this._expectedParameterCount = 2;
             }
         }
-        
+
         const func = new TwoParamFunction();
-        
+
         // Should throw when wrong number of parameters
         expect(() => {
             func.parameters = [];
@@ -58,7 +58,7 @@ describe("Extensibility API Exports", () => {
                 // _expectedParameterCount is null by default
             }
         }
-        
+
         const func = new FlexibleFunction();
         // Should not throw
         func.parameters = [];
@@ -75,37 +75,37 @@ describe("Extensibility API Exports", () => {
                 this._value = v;
             }
         }
-        
+
         class CustomSum extends AggregateFunction {
             private _total: number = 0;
-            
+
             constructor() {
                 super("customSum");
             }
-            
+
             public reduce(element: ReducerElement): void {
                 this._total += element.value;
             }
-            
+
             public element(): ReducerElement {
                 const el = new SumElement();
                 el.value = this._total;
                 return el;
             }
-            
+
             public value(): number {
                 return this._total;
             }
         }
-        
+
         const agg = new CustomSum();
         expect(agg.name).toBe("customSum");
-        
+
         const elem = new SumElement();
         elem.value = 5;
         agg.reduce(elem);
         expect(agg.value()).toBe(5);
-        
+
         const elem2 = new SumElement();
         elem2.value = 3;
         agg.reduce(elem2);
@@ -117,12 +117,12 @@ describe("Extensibility API Exports", () => {
             constructor() {
                 super("customPredicate");
             }
-            
+
             public value(): boolean {
                 return true;
             }
         }
-        
+
         const pred = new CustomPredicate();
         expect(pred.name).toBe("customPredicate");
         expect(pred.toString()).toBe("PredicateFunction (customPredicate)");
@@ -137,16 +137,16 @@ describe("Extensibility API Exports", () => {
     test("ReducerElement class is exported and can be extended", () => {
         class NumberElement extends ReducerElement {
             private _num: number = 0;
-            
+
             public get value(): number {
                 return this._num;
             }
-            
+
             public set value(v: number) {
                 this._num = v;
             }
         }
-        
+
         const elem = new NumberElement();
         elem.value = 42;
         expect(elem.value).toBe(42);
@@ -158,23 +158,21 @@ describe("FunctionDef Decorator", () => {
         @FunctionDef({
             description: "Test function for extensibility",
             category: "scalar",
-            parameters: [
-                { name: "input", description: "Input value", type: "string" }
-            ],
+            parameters: [{ name: "input", description: "Input value", type: "string" }],
             output: { description: "Output value", type: "string" },
-            examples: ["RETURN testExtFunc('hello')"]
+            examples: ["RETURN testExtFunc('hello')"],
         })
         class TestExtFunc extends Function {
             constructor() {
                 super("testExtFunc");
                 this._expectedParameterCount = 1;
             }
-            
+
             public value(): string {
                 return "test result";
             }
         }
-        
+
         // Verify the decorated class still works correctly
         const instance = new TestExtFunc();
         expect(instance.name).toBe("testExtFunc");
@@ -185,23 +183,21 @@ describe("FunctionDef Decorator", () => {
         @FunctionDef({
             description: "Test aggregate function",
             category: "aggregate",
-            parameters: [
-                { name: "value", description: "Numeric value", type: "number" }
-            ],
-            output: { description: "Aggregated result", type: "number" }
+            parameters: [{ name: "value", description: "Numeric value", type: "number" }],
+            output: { description: "Aggregated result", type: "number" },
         })
         class TestAggExt extends AggregateFunction {
             private _sum: number = 0;
-            
+
             constructor() {
                 super("testAggExt");
             }
-            
+
             public value(): number {
                 return this._sum;
             }
         }
-        
+
         const instance = new TestAggExt();
         expect(instance.name).toBe("testAggExt");
         expect(instance.value()).toBe(0);
@@ -212,9 +208,15 @@ describe("FunctionDef Decorator", () => {
             description: "Test async provider for extensibility",
             category: "async",
             parameters: [
-                { name: "count", description: "Number of items", type: "number", required: false, default: 1 }
+                {
+                    name: "count",
+                    description: "Number of items",
+                    type: "number",
+                    required: false,
+                    default: 1,
+                },
             ],
-            output: { description: "Data object", type: "object" }
+            output: { description: "Data object", type: "object" },
         })
         class Simple extends AsyncFunction {
             public async *generate(count: number = 1): AsyncGenerator<any> {
@@ -223,7 +225,7 @@ describe("FunctionDef Decorator", () => {
                 }
             }
         }
-        
+
         // Verify the decorated class still works correctly
         const loader = new Simple("simple");
         const results: any[] = [];
@@ -233,12 +235,12 @@ describe("FunctionDef Decorator", () => {
         expect(results.length).toBe(2);
         expect(results[0]).toEqual({ id: 0, data: "item0" });
         expect(results[1]).toEqual({ id: 1, data: "item1" });
-        
+
         // Verify the async provider was registered
         const provider = getRegisteredFunctionFactory("simple", "async");
         expect(provider).toBeDefined();
         expect(typeof provider).toBe("function");
-        
+
         // Verify the metadata was registered
         const metadata = getFunctionMetadata("simple", "async");
         expect(metadata).toBeDefined();
@@ -251,21 +253,19 @@ describe("FunctionDef Decorator", () => {
         @FunctionDef({
             description: "Test predicate function",
             category: "predicate",
-            parameters: [
-                { name: "list", description: "List to check", type: "array" }
-            ],
-            output: { description: "Boolean result", type: "boolean" }
+            parameters: [{ name: "list", description: "List to check", type: "array" }],
+            output: { description: "Boolean result", type: "boolean" },
         })
         class TestPredExt extends PredicateFunction {
             constructor() {
                 super("testPredExt");
             }
-            
+
             public value(): boolean {
                 return true;
             }
         }
-        
+
         const instance = new TestPredExt();
         expect(instance.name).toBe("testPredExt");
         expect(instance.value()).toBe(true);
@@ -279,9 +279,9 @@ describe("Type Exports", () => {
             description: "Testing type exports",
             category: "scalar",
             parameters: [],
-            output: { description: "Output", type: "string" }
+            output: { description: "Output", type: "string" },
         };
-        
+
         expect(meta.name).toBe("typeTest");
         expect(meta.description).toBe("Testing type exports");
     });
@@ -293,9 +293,9 @@ describe("Type Exports", () => {
             type: "string",
             required: true,
             default: "default value",
-            example: "example value"
+            example: "example value",
         };
-        
+
         expect(param.name).toBe("testParam");
         expect(param.required).toBe(true);
     });
@@ -307,20 +307,20 @@ describe("Type Exports", () => {
             type: "array",
             items: {
                 description: "Item in array",
-                type: "string"
-            }
+                type: "string",
+            },
         };
-        
+
         const objectParam: ParameterSchema = {
             name: "config",
             description: "Configuration object",
             type: "object",
             properties: {
                 enabled: { description: "Is enabled", type: "boolean" },
-                value: { description: "Value", type: "number" }
-            }
+                value: { description: "Value", type: "number" },
+            },
         };
-        
+
         expect(arrayParam.items?.type).toBe("string");
         expect(objectParam.properties?.enabled.type).toBe("boolean");
     });
@@ -331,11 +331,11 @@ describe("Type Exports", () => {
             type: "object",
             properties: {
                 success: { description: "Success flag", type: "boolean" },
-                data: { description: "Result data", type: "array" }
+                data: { description: "Result data", type: "array" },
             },
-            example: { success: true, data: [] }
+            example: { success: true, data: [] },
         };
-        
+
         expect(output.type).toBe("object");
         expect(output.properties?.success.type).toBe("boolean");
     });
@@ -346,7 +346,7 @@ describe("Type Exports", () => {
         const predicate: FunctionCategory = "predicate";
         const async: FunctionCategory = "async";
         const custom: FunctionCategory = "myCustomCategory";
-        
+
         expect(scalar).toBe("scalar");
         expect(aggregate).toBe("aggregate");
         expect(predicate).toBe("predicate");
@@ -360,9 +360,9 @@ describe("Type Exports", () => {
             category: "scalar",
             parameters: [],
             output: { description: "Output", type: "string" },
-            notes: "Some additional notes"
+            notes: "Some additional notes",
         };
-        
+
         expect(options.description).toBe("Function options test");
         expect(options.notes).toBe("Some additional notes");
     });
@@ -378,14 +378,14 @@ describe("Plugin Functions Integration with FlowQuery", () => {
             description: "Doubles a number",
             category: "scalar",
             parameters: [{ name: "value", description: "Number to double", type: "number" }],
-            output: { description: "Doubled value", type: "number" }
+            output: { description: "Doubled value", type: "number" },
         })
         class Double extends Function {
             constructor() {
                 super("double");
                 this._expectedParameterCount = 1;
             }
-            
+
             public value(): number {
                 return this.getChildren()[0].value() * 2;
             }
@@ -394,7 +394,7 @@ describe("Plugin Functions Integration with FlowQuery", () => {
         // Execute a FlowQuery statement that uses the custom function
         const runner = new Runner("WITH 5 AS num RETURN double(num) AS result");
         await runner.run();
-        
+
         expect(runner.results.length).toBe(1);
         expect(runner.results[0]).toEqual({ result: 10 });
     });
@@ -404,25 +404,25 @@ describe("Plugin Functions Integration with FlowQuery", () => {
             description: "Reverses a string",
             category: "scalar",
             parameters: [{ name: "text", description: "String to reverse", type: "string" }],
-            output: { description: "Reversed string", type: "string" }
+            output: { description: "Reversed string", type: "string" },
         })
         class StrReverse extends Function {
             constructor() {
                 super("strreverse");
                 this._expectedParameterCount = 1;
             }
-            
+
             public value(): string {
                 const input = String(this.getChildren()[0].value());
-                return input.split('').reverse().join('');
+                return input.split("").reverse().join("");
             }
         }
 
         const runner = new Runner("WITH 'hello' AS s RETURN strreverse(s) AS reversed");
         await runner.run();
-        
+
         expect(runner.results.length).toBe(1);
-        expect(runner.results[0]).toEqual({ reversed: 'olleh' });
+        expect(runner.results[0]).toEqual({ reversed: "olleh" });
     });
 
     test("Custom aggregate function can be used in a FlowQuery statement", async () => {
@@ -441,18 +441,18 @@ describe("Plugin Functions Integration with FlowQuery", () => {
             description: "Calculates the product of values",
             category: "aggregate",
             parameters: [{ name: "value", description: "Number to multiply", type: "number" }],
-            output: { description: "Product of all values", type: "number" }
+            output: { description: "Product of all values", type: "number" },
         })
         class Product extends AggregateFunction {
             constructor() {
                 super("product");
                 this._expectedParameterCount = 1;
             }
-            
+
             public reduce(element: ReducerElement): void {
                 element.value = this.firstChild().value();
             }
-            
+
             public element(): ReducerElement {
                 return new ProductElement();
             }
@@ -460,7 +460,7 @@ describe("Plugin Functions Integration with FlowQuery", () => {
 
         const runner = new Runner("UNWIND [2, 3, 4] AS num RETURN product(num) AS result");
         await runner.run();
-        
+
         expect(runner.results.length).toBe(1);
         expect(runner.results[0]).toEqual({ result: 24 });
     });
@@ -470,14 +470,14 @@ describe("Plugin Functions Integration with FlowQuery", () => {
             description: "Adds 100 to a number",
             category: "scalar",
             parameters: [{ name: "value", description: "Number", type: "number" }],
-            output: { description: "Number plus 100", type: "number" }
+            output: { description: "Number plus 100", type: "number" },
         })
         class AddHundred extends Function {
             constructor() {
                 super("addhundred");
                 this._expectedParameterCount = 1;
             }
-            
+
             public value(): number {
                 return this.getChildren()[0].value() + 100;
             }
@@ -486,7 +486,7 @@ describe("Plugin Functions Integration with FlowQuery", () => {
         // Use the custom function with expressions
         const runner = new Runner("WITH 5 * 3 AS num RETURN addhundred(num) + 1 AS result");
         await runner.run();
-        
+
         expect(runner.results.length).toBe(1);
         expect(runner.results[0]).toEqual({ result: 116 }); // (5*3) + 100 + 1 = 116
     });
@@ -496,14 +496,14 @@ describe("Plugin Functions Integration with FlowQuery", () => {
             description: "Triples a number",
             category: "scalar",
             parameters: [{ name: "value", description: "Number to triple", type: "number" }],
-            output: { description: "Tripled value", type: "number" }
+            output: { description: "Tripled value", type: "number" },
         })
         class Triple extends Function {
             constructor() {
                 super("triple");
                 this._expectedParameterCount = 1;
             }
-            
+
             public value(): number {
                 return this.getChildren()[0].value() * 3;
             }
@@ -513,14 +513,14 @@ describe("Plugin Functions Integration with FlowQuery", () => {
             description: "Squares a number",
             category: "scalar",
             parameters: [{ name: "value", description: "Number to square", type: "number" }],
-            output: { description: "Squared value", type: "number" }
+            output: { description: "Squared value", type: "number" },
         })
         class Square extends Function {
             constructor() {
                 super("square");
                 this._expectedParameterCount = 1;
             }
-            
+
             public value(): number {
                 const v = this.getChildren()[0].value();
                 return v * v;
@@ -528,9 +528,11 @@ describe("Plugin Functions Integration with FlowQuery", () => {
         }
 
         // Use both custom functions in a query
-        const runner = new Runner("WITH 2 AS num RETURN triple(num) AS tripled, square(num) AS squared");
+        const runner = new Runner(
+            "WITH 2 AS num RETURN triple(num) AS tripled, square(num) AS squared"
+        );
         await runner.run();
-        
+
         expect(runner.results.length).toBe(1);
         expect(runner.results[0]).toEqual({ tripled: 6, squared: 4 });
     });
@@ -540,7 +542,7 @@ describe("Plugin Functions Integration with FlowQuery", () => {
             description: "Provides example data for testing",
             category: "async",
             parameters: [],
-            output: { description: "Example data o.bject", type: "object" }
+            output: { description: "Example data o.bject", type: "object" },
         })
         class GetExampleData extends AsyncFunction {
             public async *generate(): AsyncGenerator<any> {
@@ -553,9 +555,11 @@ describe("Plugin Functions Integration with FlowQuery", () => {
         expect(getRegisteredFunctionFactory("getExampleData", "async")).toBeDefined();
 
         // Use the async provider in a FlowQuery statement
-        const runner = new Runner("LOAD JSON FROM getExampleData() AS data RETURN data.id AS id, data.name AS name");
+        const runner = new Runner(
+            "LOAD JSON FROM getExampleData() AS data RETURN data.id AS id, data.name AS name"
+        );
         await runner.run();
-        
+
         expect(runner.results.length).toBe(2);
         expect(runner.results[0]).toEqual({ id: 1, name: "Alice" });
         expect(runner.results[1]).toEqual({ id: 2, name: "Bob" });
@@ -566,7 +570,7 @@ describe("Plugin Functions Integration with FlowQuery", () => {
             description: "Test function for case insensitivity",
             category: "async",
             parameters: [],
-            output: { description: "Test data", type: "object" }
+            output: { description: "Test data", type: "object" },
         })
         class MixedCaseFunc extends AsyncFunction {
             public async *generate(): AsyncGenerator<any> {
@@ -604,14 +608,14 @@ describe("Plugin Functions Integration with FlowQuery", () => {
             description: "A unique test function for introspection",
             category: "scalar",
             parameters: [{ name: "x", description: "Input value", type: "number" }],
-            output: { description: "Output value", type: "number" }
+            output: { description: "Output value", type: "number" },
         })
         class IntrospectTestFunc extends Function {
             constructor() {
                 super("introspectTestFunc");
                 this._expectedParameterCount = 1;
             }
-            
+
             public value(): number {
                 return this.getChildren()[0].value() + 42;
             }
@@ -630,7 +634,7 @@ describe("Plugin Functions Integration with FlowQuery", () => {
             RETURN f.name AS name, f.description AS description, f.category AS category
         `);
         await runner.run();
-        
+
         expect(runner.results.length).toBe(1);
         expect(runner.results[0].name).toBe("introspecttestfunc");
         expect(runner.results[0].description).toBe("A unique test function for introspection");

package/tests/graph/create.test.ts

@@ -0,0 +1,36 @@
+import Database from "../../src/graph/database";
+import PhysicalNode from "../../src/graph/physical_node";
+import PhysicalRelationship from "../../src/graph/physical_relationship";
+import CreateNode from "../../src/parsing/operations/create_node";
+import CreateRelationship from "../../src/parsing/operations/create_relationship";
+import Parser from "../../src/parsing/parser";
+
+test("Test CreateNode operation", async () => {
+    const node = new PhysicalNode(null, "Person");
+    expect(node.label).toBe("Person");
+    expect(node.statement).toBeNull();
+    const parser = new Parser();
+    const statement = parser.parse("WITH 1 as x RETURN x");
+    const op = new CreateNode(node, statement);
+    await op.run();
+    const db = Database.getInstance();
+    const found = db.getNode(node);
+    expect(found!.label).toBe(node.label);
+    const data = await found!.data();
+    expect(data).toEqual([{ x: 1 }]);
+});
+
+test("Test CreateRelationship operation", async () => {
+    const relationship = new PhysicalRelationship();
+    relationship.type = "KNOWS";
+    expect(relationship.type).toBe("KNOWS");
+    expect(relationship.statement).toBeNull();
+    const parser = new Parser();
+    const statement = parser.parse("WITH 1 as x RETURN x");
+    const op = new CreateRelationship(relationship, statement);
+    await op.run();
+    const db = Database.getInstance();
+    const found = db.getRelationship(relationship);
+    const data = await found!.data();
+    expect(data).toEqual([{ x: 1 }]);
+});

package/tests/graph/data.test.ts

@@ -0,0 +1,58 @@
+import Data from "../../src/graph/data";
+import NodeData from "../../src/graph/node_data";
+import RelationshipData from "../../src/graph/relationship_data";
+
+test("Data iteration", () => {
+    const records = [
+        { id: "1", name: "Alice" },
+        { id: "2", name: "Bob" },
+        { id: "3", name: "Charlie" },
+    ];
+    const data = new Data(records);
+    expect(data.next()).toBe(true);
+    expect(data.next()).toBe(true);
+    expect(data.next()).toBe(true);
+    expect(data.next()).toBe(false);
+});
+
+test("Data find", () => {
+    const records = [
+        { id: "1", name: "Alice" },
+        { id: "2", name: "Bob" },
+        { id: "3", name: "Charlie" },
+        { id: "2", name: "Bob Duplicate" },
+    ];
+    const data: NodeData = new NodeData(records);
+    data.find("2");
+    expect(data.current()).toEqual({ id: "2", name: "Bob" });
+    expect(data.find("2")).toBe(true);
+    expect(data.current()).toEqual({ id: "2", name: "Bob Duplicate" });
+    expect(data.find("2")).toBe(false);
+});
+
+test("Data find non-existing", () => {
+    const records = [
+        { id: "1", name: "Alice" },
+        { id: "2", name: "Bob" },
+    ];
+    const data: NodeData = new NodeData(records);
+    expect(data.find("3")).toBe(false);
+});
+
+test("RelationshipData find", () => {
+    const records = [
+        { left_id: "1", right_id: "2", type: "FRIEND", id: "r1" },
+        { left_id: "2", right_id: "3", type: "COLLEAGUE", id: "r2" },
+        { left_id: "1", right_id: "3", type: "FRIEND", id: "r3" },
+    ];
+    const data: RelationshipData = new RelationshipData(records);
+    data.find("1");
+    expect(data.current()).toEqual({ left_id: "1", right_id: "2", type: "FRIEND", id: "r1" });
+    expect(data.find("1")).toBe(true);
+    expect(data.current()).toEqual({ left_id: "1", right_id: "3", type: "FRIEND", id: "r3" });
+    expect(data.find("1")).toBe(false);
+    expect(data.find("2")).toBe(true);
+    expect(data.current()).toEqual({ left_id: "2", right_id: "3", type: "COLLEAGUE", id: "r2" });
+    expect(data.find("2")).toBe(false);
+    expect(data.find("4")).toBe(false);
+});