flowquery 1.0.39 → 1.0.40

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "flowquery",
-  "version": "1.0.39",
+  "version": "1.0.40",
   "description": "A declarative query language for data processing pipelines.",
   "main": "dist/index.node.js",
   "types": "dist/index.node.d.ts",

package/src/graph/database.ts

@@ -25,6 +25,12 @@ class Database {
         physical.statement = statement;
         Database.nodes.set(node.label, physical);
     }
+    public removeNode(node: Node): void {
+        if (node.label === null) {
+            throw new Error("Node label is null");
+        }
+        Database.nodes.delete(node.label);
+    }
     public getNode(node: Node): PhysicalNode | null {
         return Database.nodes.get(node.label!) || null;
     }
@@ -38,6 +44,12 @@ class Database {
         physical.target = relationship.target;
         Database.relationships.set(relationship.type, physical);
     }
+    public removeRelationship(relationship: Relationship): void {
+        if (relationship.type === null) {
+            throw new Error("Relationship type is null");
+        }
+        Database.relationships.delete(relationship.type);
+    }
     public getRelationship(relationship: Relationship): PhysicalRelationship | null {
         return Database.relationships.get(relationship.type!) || null;
     }

package/src/parsing/functions/function_factory.ts

@@ -39,6 +39,7 @@ import "./size";
 import "./split";
 import "./string_distance";
 import "./stringify";
+import "./substring";
 // Import built-in functions to ensure their @FunctionDef decorators run
 import "./sum";
 import "./tail";

package/src/parsing/functions/substring.ts

@@ -0,0 +1,65 @@
+import ASTNode from "../ast_node";
+import Function from "./function";
+import { FunctionDef } from "./function_metadata";
+
+@FunctionDef({
+    description:
+        "Returns a substring of a string, starting at a 0-based index with an optional length",
+    category: "scalar",
+    parameters: [
+        { name: "original", description: "The original string", type: "string" },
+        { name: "start", description: "The 0-based start index", type: "integer" },
+        {
+            name: "length",
+            description: "The length of the substring (optional, defaults to remainder of string)",
+            type: "integer",
+        },
+    ],
+    output: { description: "The substring", type: "string", example: "llo" },
+    examples: ["RETURN substring('hello', 1, 3)", "RETURN substring('hello', 2)"],
+})
+class Substring extends Function {
+    constructor() {
+        super("substring");
+    }
+
+    public set parameters(nodes: ASTNode[]) {
+        if (nodes.length < 2 || nodes.length > 3) {
+            throw new Error(
+                `Function substring expected 2 or 3 parameters, but got ${nodes.length}`
+            );
+        }
+        this.children = nodes;
+    }
+
+    public value(): any {
+        const children = this.getChildren();
+        const original = children[0].value();
+        const start = children[1].value();
+
+        if (typeof original !== "string") {
+            throw new Error(
+                "Invalid argument for substring function: expected a string as the first argument"
+            );
+        }
+        if (typeof start !== "number" || !Number.isInteger(start)) {
+            throw new Error(
+                "Invalid argument for substring function: expected an integer as the second argument"
+            );
+        }
+
+        if (children.length === 3) {
+            const length = children[2].value();
+            if (typeof length !== "number" || !Number.isInteger(length)) {
+                throw new Error(
+                    "Invalid argument for substring function: expected an integer as the third argument"
+                );
+            }
+            return original.substring(start, start + length);
+        }
+
+        return original.substring(start);
+    }
+}
+
+export default Substring;

package/src/parsing/operations/delete_node.ts

@@ -0,0 +1,33 @@
+import Database from "../../graph/database";
+import Node from "../../graph/node";
+import Operation from "./operation";
+
+class DeleteNode extends Operation {
+    private _node: Node | null = null;
+    constructor(node: Node) {
+        super();
+        this._node = node;
+    }
+    public get node(): Node | null {
+        return this._node;
+    }
+    public run(): Promise<void> {
+        return new Promise(async (resolve, reject) => {
+            try {
+                if (this._node === null) {
+                    throw new Error("Node is null");
+                }
+                const db: Database = Database.getInstance();
+                db.removeNode(this._node);
+                resolve();
+            } catch (error) {
+                reject(error);
+            }
+        });
+    }
+    public get results(): Record<string, any>[] {
+        return [];
+    }
+}
+
+export default DeleteNode;

package/src/parsing/operations/delete_relationship.ts

@@ -0,0 +1,32 @@
+import Database from "../../graph/database";
+import Relationship from "../../graph/relationship";
+import Operation from "./operation";
+
+class DeleteRelationship extends Operation {
+    private _relationship: Relationship | null = null;
+    constructor(relationship: Relationship) {
+        super();
+        this._relationship = relationship;
+    }
+    public get relationship(): Relationship | null {
+        return this._relationship;
+    }
+    public run(): Promise<void> {
+        return new Promise(async (resolve, reject) => {
+            try {
+                if (this._relationship === null) {
+                    throw new Error("Relationship is null");
+                }
+                const db = Database.getInstance();
+                db.removeRelationship(this._relationship);
+                resolve();
+            } catch (error) {
+                reject(error);
+            }
+        });
+    }
+    public get results(): Record<string, any>[] {
+        return [];
+    }
+}
+export default DeleteRelationship;

package/src/parsing/parser.ts

@@ -53,6 +53,8 @@ import AggregatedWith from "./operations/aggregated_with";
 import Call from "./operations/call";
 import CreateNode from "./operations/create_node";
 import CreateRelationship from "./operations/create_relationship";
+import DeleteNode from "./operations/delete_node";
+import DeleteRelationship from "./operations/delete_relationship";
 import Limit from "./operations/limit";
 import Load from "./operations/load";
 import Match from "./operations/match";
@@ -186,9 +188,13 @@ class Parser extends BaseParser {
             !(operation instanceof Return) &&
             !(operation instanceof Call) &&
             !(operation instanceof CreateNode) &&
-            !(operation instanceof CreateRelationship)
+            !(operation instanceof CreateRelationship) &&
+            !(operation instanceof DeleteNode) &&
+            !(operation instanceof DeleteRelationship)
         ) {
-            throw new Error("Last statement must be a RETURN, WHERE, CALL, or CREATE statement");
+            throw new Error(
+                "Last statement must be a RETURN, WHERE, CALL, CREATE, or DELETE statement"
+            );
         }
         return root;
     }
@@ -201,6 +207,7 @@ class Parser extends BaseParser {
             this.parseLoad() ||
             this.parseCall() ||
             this.parseCreate() ||
+            this.parseDelete() ||
             this.parseMatch()
         );
     }
@@ -459,6 +466,60 @@ class Parser extends BaseParser {
         return create;
     }
 
+    private parseDelete(): DeleteNode | DeleteRelationship | null {
+        if (!this.token.isDelete()) {
+            return null;
+        }
+        this.setNextToken();
+        this.expectAndSkipWhitespaceAndComments();
+        if (!this.token.isVirtual()) {
+            throw new Error("Expected VIRTUAL");
+        }
+        this.setNextToken();
+        this.expectAndSkipWhitespaceAndComments();
+        const node: Node | null = this.parseNode();
+        if (node === null) {
+            throw new Error("Expected node definition");
+        }
+        let relationship: Relationship | null = null;
+        if (this.token.isSubtract() && this.peek()?.isOpeningBracket()) {
+            this.setNextToken();
+            this.setNextToken();
+            if (!this.token.isColon()) {
+                throw new Error("Expected ':' for relationship type");
+            }
+            this.setNextToken();
+            if (!this.token.isIdentifierOrKeyword()) {
+                throw new Error("Expected relationship type identifier");
+            }
+            const type: string = this.token.value || "";
+            this.setNextToken();
+            if (!this.token.isClosingBracket()) {
+                throw new Error("Expected closing bracket for relationship definition");
+            }
+            this.setNextToken();
+            if (!this.token.isSubtract()) {
+                throw new Error("Expected '-' for relationship definition");
+            }
+            this.setNextToken();
+            const target: Node | null = this.parseNode();
+            if (target === null) {
+                throw new Error("Expected target node definition");
+            }
+            relationship = new Relationship();
+            relationship.type = type;
+            relationship.source = node;
+            relationship.target = target;
+        }
+        let result: DeleteNode | DeleteRelationship;
+        if (relationship !== null) {
+            result = new DeleteRelationship(relationship);
+        } else {
+            result = new DeleteNode(node);
+        }
+        return result;
+    }
+
     private parseMatch(): Match | null {
         let optional = false;
         if (this.token.isOptional()) {

package/tests/compute/runner.test.ts

@@ -1,6 +1,7 @@
 import Runner from "../../src/compute/runner";
 import Database from "../../src/graph/database";
 import Node from "../../src/graph/node";
+import Relationship from "../../src/graph/relationship";
 import AsyncFunction from "../../src/parsing/functions/async_function";
 import { FunctionDef } from "../../src/parsing/functions/function_metadata";
 
@@ -725,6 +726,38 @@ test("Test trim function with empty string", async () => {
     expect(results[0]).toEqual({ result: "" });
 });
 
+test("Test substring function with start and length", async () => {
+    const runner = new Runner('RETURN substring("hello", 1, 3) as result');
+    await runner.run();
+    const results = runner.results;
+    expect(results.length).toBe(1);
+    expect(results[0]).toEqual({ result: "ell" });
+});
+
+test("Test substring function with start only", async () => {
+    const runner = new Runner('RETURN substring("hello", 2) as result');
+    await runner.run();
+    const results = runner.results;
+    expect(results.length).toBe(1);
+    expect(results[0]).toEqual({ result: "llo" });
+});
+
+test("Test substring function with zero start", async () => {
+    const runner = new Runner('RETURN substring("hello", 0, 5) as result');
+    await runner.run();
+    const results = runner.results;
+    expect(results.length).toBe(1);
+    expect(results[0]).toEqual({ result: "hello" });
+});
+
+test("Test substring function with zero length", async () => {
+    const runner = new Runner('RETURN substring("hello", 1, 0) as result');
+    await runner.run();
+    const results = runner.results;
+    expect(results.length).toBe(1);
+    expect(results[0]).toEqual({ result: "" });
+});
+
 test("Test associative array with key which is keyword", async () => {
     const runner = new Runner("RETURN {return: 1} as aa");
     await runner.run();
@@ -3903,3 +3936,117 @@ test("Test order by with where", async () => {
     expect(results[3]).toEqual({ x: 4 });
     expect(results[4]).toEqual({ x: 3 });
 });
+
+test("Test delete virtual node operation", async () => {
+    const db = Database.getInstance();
+    // Create a virtual node first
+    const create = new Runner(`
+        CREATE VIRTUAL (:DeleteTestPerson) AS {
+            unwind [
+                {id: 1, name: 'Person 1'},
+                {id: 2, name: 'Person 2'}
+            ] as record
+            RETURN record.id as id, record.name as name
+        }
+    `);
+    await create.run();
+    expect(db.getNode(new Node(null, "DeleteTestPerson"))).not.toBeNull();
+
+    // Delete the virtual node
+    const del = new Runner("DELETE VIRTUAL (:DeleteTestPerson)");
+    await del.run();
+    expect(del.results.length).toBe(0);
+    expect(db.getNode(new Node(null, "DeleteTestPerson"))).toBeNull();
+});
+
+test("Test delete virtual node then match throws", async () => {
+    // Create a virtual node
+    const create = new Runner(`
+        CREATE VIRTUAL (:DeleteMatchPerson) AS {
+            unwind [{id: 1, name: 'Alice'}] as record
+            RETURN record.id as id, record.name as name
+        }
+    `);
+    await create.run();
+
+    // Verify it can be matched
+    const match1 = new Runner("MATCH (n:DeleteMatchPerson) RETURN n");
+    await match1.run();
+    expect(match1.results.length).toBe(1);
+
+    // Delete the virtual node
+    const del = new Runner("DELETE VIRTUAL (:DeleteMatchPerson)");
+    await del.run();
+
+    // Matching should now throw since the node is gone
+    const match2 = new Runner("MATCH (n:DeleteMatchPerson) RETURN n");
+    await expect(match2.run()).rejects.toThrow();
+});
+
+test("Test delete virtual relationship operation", async () => {
+    const db = Database.getInstance();
+    // Create virtual nodes and relationship
+    await new Runner(`
+        CREATE VIRTUAL (:DelRelUser) AS {
+            unwind [
+                {id: 1, name: 'Alice'},
+                {id: 2, name: 'Bob'}
+            ] as record
+            RETURN record.id as id, record.name as name
+        }
+    `).run();
+
+    await new Runner(`
+        CREATE VIRTUAL (:DelRelUser)-[:DEL_KNOWS]-(:DelRelUser) AS {
+            unwind [
+                {left_id: 1, right_id: 2}
+            ] as record
+            RETURN record.left_id as left_id, record.right_id as right_id
+        }
+    `).run();
+
+    // Verify relationship exists
+    const rel = new Relationship();
+    rel.type = "DEL_KNOWS";
+    expect(db.getRelationship(rel)).not.toBeNull();
+
+    // Delete the virtual relationship
+    const del = new Runner("DELETE VIRTUAL (:DelRelUser)-[:DEL_KNOWS]-(:DelRelUser)");
+    await del.run();
+    expect(del.results.length).toBe(0);
+    expect(db.getRelationship(rel)).toBeNull();
+});
+
+test("Test delete virtual node leaves other nodes intact", async () => {
+    const db = Database.getInstance();
+    // Create two virtual node types
+    await new Runner(`
+        CREATE VIRTUAL (:KeepNode) AS {
+            unwind [{id: 1, name: 'Keep'}] as record
+            RETURN record.id as id, record.name as name
+        }
+    `).run();
+
+    await new Runner(`
+        CREATE VIRTUAL (:RemoveNode) AS {
+            unwind [{id: 2, name: 'Remove'}] as record
+            RETURN record.id as id, record.name as name
+        }
+    `).run();
+
+    expect(db.getNode(new Node(null, "KeepNode"))).not.toBeNull();
+    expect(db.getNode(new Node(null, "RemoveNode"))).not.toBeNull();
+
+    // Delete only one
+    await new Runner("DELETE VIRTUAL (:RemoveNode)").run();
+
+    // The other should still exist
+    expect(db.getNode(new Node(null, "KeepNode"))).not.toBeNull();
+    expect(db.getNode(new Node(null, "RemoveNode"))).toBeNull();
+
+    // The remaining node can still be matched
+    const match = new Runner("MATCH (n:KeepNode) RETURN n");
+    await match.run();
+    expect(match.results.length).toBe(1);
+    expect(match.results[0].n.name).toBe("Keep");
+});

package/tests/parsing/parser.test.ts

@@ -521,7 +521,7 @@ test("Test non-well formed statements", () => {
         "Only one RETURN statement is allowed"
     );
     expect(() => new Parser().parse("return 1 with 1 as n")).toThrow(
-        "Last statement must be a RETURN, WHERE, CALL, or CREATE statement"
+        "Last statement must be a RETURN, WHERE, CALL, CREATE, or DELETE statement"
     );
 });