flowquery 1.0.21 → 1.0.23

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "flowquery",
-  "version": "1.0.21",
+  "version": "1.0.23",
   "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

@@ -39,6 +39,36 @@ class Database {
     public getRelationship(relationship: Relationship): PhysicalRelationship | null {
         return Database.relationships.get(relationship.type!) || null;
     }
+    public async schema(): Promise<Record<string, any>[]> {
+        const result: Record<string, any>[] = [];
+
+        for (const [label, physical] of Database.nodes) {
+            const records = await physical.data();
+            const entry: Record<string, any> = { kind: "node", label };
+            if (records.length > 0) {
+                const { id, ...sample } = records[0];
+                if (Object.keys(sample).length > 0) {
+                    entry.sample = sample;
+                }
+            }
+            result.push(entry);
+        }
+
+        for (const [type, physical] of Database.relationships) {
+            const records = await physical.data();
+            const entry: Record<string, any> = { kind: "relationship", type };
+            if (records.length > 0) {
+                const { left_id, right_id, ...sample } = records[0];
+                if (Object.keys(sample).length > 0) {
+                    entry.sample = sample;
+                }
+            }
+            result.push(entry);
+        }
+
+        return result;
+    }
+
     public async getData(element: Node | Relationship): Promise<NodeData | RelationshipData> {
         if (element instanceof Node) {
             const node = this.getNode(element);

package/src/parsing/functions/function_factory.ts

@@ -18,6 +18,7 @@ import "./rand";
 import "./range";
 import "./replace";
 import "./round";
+import "./schema";
 import "./size";
 import "./split";
 import "./stringify";

package/src/parsing/functions/schema.ts

@@ -0,0 +1,36 @@
+import Database from "../../graph/database";
+import AsyncFunction from "./async_function";
+import { FunctionDef } from "./function_metadata";
+
+/**
+ * Built-in function that returns the graph schema of the database.
+ *
+ * Lists all nodes and relationships with their labels/types and a sample
+ * of their data (excluding id from nodes, left_id and right_id from relationships).
+ *
+ * @example
+ * ```
+ * LOAD FROM schema() AS s RETURN s
+ * ```
+ */
+@FunctionDef({
+    description:
+        "Returns the graph schema listing all nodes and relationships with a sample of their data.",
+    category: "async",
+    parameters: [],
+    output: {
+        description: "Schema entry with kind, label/type, and optional sample data",
+        type: "object",
+    },
+    examples: ["LOAD FROM schema() AS s RETURN s"],
+})
+class Schema extends AsyncFunction {
+    public async *generate(): AsyncGenerator<any> {
+        const entries = await Database.getInstance().schema();
+        for (const entry of entries) {
+            yield entry;
+        }
+    }
+}
+
+export default Schema;

package/src/parsing/parser.ts

@@ -353,7 +353,7 @@ class Parser extends BaseParser {
                 throw new Error("Expected ':' for relationship type");
             }
             this.setNextToken();
-            if (!this.token.isIdentifier()) {
+            if (!this.token.isIdentifierOrKeyword()) {
                 throw new Error("Expected relationship type identifier");
             }
             const type: string = this.token.value || "";
@@ -412,19 +412,19 @@ class Parser extends BaseParser {
         this.setNextToken();
         this.skipWhitespaceAndComments();
         let identifier: string | null = null;
-        if (this.token.isIdentifier()) {
+        if (this.token.isIdentifierOrKeyword()) {
             identifier = this.token.value || "";
             this.setNextToken();
         }
         this.skipWhitespaceAndComments();
         let label: string | null = null;
-        if (!this.token.isColon() && this.peek()?.isIdentifier()) {
+        if (!this.token.isColon() && this.peek()?.isIdentifierOrKeyword()) {
             throw new Error("Expected ':' for node label");
         }
-        if (this.token.isColon() && !this.peek()?.isIdentifier()) {
+        if (this.token.isColon() && !this.peek()?.isIdentifierOrKeyword()) {
             throw new Error("Expected node label identifier");
         }
-        if (this.token.isColon() && this.peek()?.isIdentifier()) {
+        if (this.token.isColon() && this.peek()?.isIdentifierOrKeyword()) {
             this.setNextToken();
             label = this.token.value || "";
             this.setNextToken();
@@ -595,7 +595,7 @@ class Parser extends BaseParser {
         }
         this.setNextToken();
         let variable: string | null = null;
-        if (this.token.isIdentifier()) {
+        if (this.token.isIdentifierOrKeyword()) {
             variable = this.token.value || "";
             this.setNextToken();
         }
@@ -603,7 +603,7 @@ class Parser extends BaseParser {
             throw new Error("Expected ':' for relationship type");
         }
         this.setNextToken();
-        if (!this.token.isIdentifier()) {
+        if (!this.token.isIdentifierOrKeyword()) {
             throw new Error("Expected relationship type identifier");
         }
         const type: string = this.token.value || "";
@@ -745,14 +745,14 @@ class Parser extends BaseParser {
      */
     private parseOperand(expression: Expression): boolean {
         this.skipWhitespaceAndComments();
-        if (this.token.isIdentifier() && !this.peek()?.isLeftParenthesis()) {
+        if (this.token.isIdentifierOrKeyword() && !this.peek()?.isLeftParenthesis()) {
             const identifier: string = this.token.value || "";
             const reference = new Reference(identifier, this.variables.get(identifier));
             this.setNextToken();
             const lookup = this.parseLookup(reference);
             expression.addNode(lookup);
             return true;
-        } else if (this.token.isIdentifier() && this.peek()?.isLeftParenthesis()) {
+        } else if (this.token.isIdentifierOrKeyword() && this.peek()?.isLeftParenthesis()) {
             const func = this.parsePredicateFunction() || this.parseFunction();
             if (func !== null) {
                 const lookup = this.parseLookup(func);
@@ -761,7 +761,7 @@ class Parser extends BaseParser {
             }
         } else if (
             this.token.isLeftParenthesis() &&
-            (this.peek()?.isIdentifier() ||
+            (this.peek()?.isIdentifierOrKeyword() ||
                 this.peek()?.isColon() ||
                 this.peek()?.isRightParenthesis())
         ) {
@@ -857,7 +857,7 @@ class Parser extends BaseParser {
         while (true) {
             if (this.token.isDot()) {
                 this.setNextToken();
-                if (!this.token.isIdentifier() && !this.token.isKeyword()) {
+                if (!this.token.isIdentifierOrKeyword()) {
                     throw new Error("Expected identifier");
                 }
                 lookup = new Lookup();

package/src/tokenization/token.ts

@@ -104,6 +104,10 @@ class Token {
         return this._type === TokenType.IDENTIFIER || this._type === TokenType.BACKTICK_STRING;
     }
 
+    public isIdentifierOrKeyword(): boolean {
+        return this.isIdentifier() || (this.isKeyword() && !this.isKeywordThatCannotBeIdentifier());
+    }
+
     // String token
 
     public static STRING(value: string, quoteChar: string = '"'): Token {
@@ -387,6 +391,18 @@ class Token {
         return this._type === TokenType.KEYWORD;
     }
 
+    public isKeywordThatCannotBeIdentifier(): boolean {
+        return (
+            this.isKeyword() &&
+            (this.isNull() ||
+                this.isCase() ||
+                this.isWhen() ||
+                this.isThen() ||
+                this.isElse() ||
+                this.isEnd())
+        );
+    }
+
     public static get WITH(): Token {
         return new Token(TokenType.KEYWORD, Keyword.WITH);
     }

package/tests/compute/runner.test.ts

@@ -1460,3 +1460,99 @@ test("Test match with leftward double graph pattern", async () => {
     expect(results[0]).toEqual({ name1: "Person 1", name2: "Person 2", name3: "Person 3" });
     expect(results[1]).toEqual({ name1: "Person 2", name2: "Person 3", name3: "Person 4" });
 });
+
+test("Test schema() returns nodes and relationships with sample data", async () => {
+    await new Runner(`
+        CREATE VIRTUAL (:Animal) AS {
+            UNWIND [
+                {id: 1, species: 'Cat', legs: 4},
+                {id: 2, species: 'Dog', legs: 4}
+            ] AS record
+            RETURN record.id AS id, record.species AS species, record.legs AS legs
+        }
+    `).run();
+    await new Runner(`
+        CREATE VIRTUAL (:Animal)-[:CHASES]-(:Animal) AS {
+            UNWIND [
+                {left_id: 2, right_id: 1, speed: 'fast'}
+            ] AS record
+            RETURN record.left_id AS left_id, record.right_id AS right_id, record.speed AS speed
+        }
+    `).run();
+
+    const runner = new Runner(
+        "CALL schema() YIELD kind, label, type, sample RETURN kind, label, type, sample"
+    );
+    await runner.run();
+    const results = runner.results;
+
+    const animal = results.find((r: any) => r.kind === "node" && r.label === "Animal");
+    expect(animal).toBeDefined();
+    expect(animal.sample).toBeDefined();
+    expect(animal.sample).not.toHaveProperty("id");
+    expect(animal.sample).toHaveProperty("species");
+    expect(animal.sample).toHaveProperty("legs");
+
+    const chases = results.find((r: any) => r.kind === "relationship" && r.type === "CHASES");
+    expect(chases).toBeDefined();
+    expect(chases.sample).toBeDefined();
+    expect(chases.sample).not.toHaveProperty("left_id");
+    expect(chases.sample).not.toHaveProperty("right_id");
+    expect(chases.sample).toHaveProperty("speed");
+});
+
+test("Test reserved keywords as identifiers", async () => {
+    const runner = new Runner(`
+        WITH 1 AS return
+        RETURN return
+    `);
+    await runner.run();
+    const results = runner.results;
+    expect(results.length).toBe(1);
+    expect(results[0].return).toBe(1);
+});
+
+test("Test reserved keywords as parts of identifiers", async () => {
+    const runner = new Runner(`
+        unwind [
+            {from: "Alice", to: "Bob", organizer: "Charlie"},
+            {from: "Bob", to: "Charlie", organizer: "Alice"},
+            {from: "Charlie", to: "Alice", organizer: "Bob"}
+        ] as data
+        return data.from as from, data.to as to, data.organizer as organizer
+    `);
+    await runner.run();
+    const results = runner.results;
+    expect(results.length).toBe(3);
+    expect(results[0]).toEqual({ from: "Alice", to: "Bob", organizer: "Charlie" });
+    expect(results[1]).toEqual({ from: "Bob", to: "Charlie", organizer: "Alice" });
+    expect(results[2]).toEqual({ from: "Charlie", to: "Alice", organizer: "Bob" });
+});
+
+test("Test reserved keywords as relationship types and labels", async () => {
+    await new Runner(`
+        CREATE VIRTUAL (:Return) AS {
+            unwind [
+                {id: 1, name: 'Node 1'},
+                {id: 2, name: 'Node 2'}
+            ] as record
+            RETURN record.id as id, record.name as name
+        }
+    `).run();
+    await new Runner(`
+        CREATE VIRTUAL (:Return)-[:With]-(:Return) AS {
+            unwind [
+                {left_id: 1, right_id: 2}
+            ] as record
+            RETURN record.left_id as left_id, record.right_id as right_id
+        }
+    `).run();
+    const match = new Runner(`
+        MATCH (a:Return)-[:With]->(b:Return)
+        RETURN a.name AS name1, b.name AS name2
+    `);
+    await match.run();
+    const results = match.results;
+    expect(results.length).toBe(1);
+    expect(results[0]).toEqual({ name1: "Node 1", name2: "Node 2" });
+});

package/tests/parsing/parser.test.ts

@@ -401,6 +401,15 @@ test("Test case statement", () => {
     );
 });
 
+test("Test case statement with keywords as identifiers", () => {
+    const parser = new Parser();
+    const ast = parser.parse("RETURN CASE WHEN 1 THEN 2 ELSE 3 END");
+    expect(ast.print()).toContain("Case");
+    expect(ast.print()).toContain("When");
+    expect(ast.print()).toContain("Then");
+    expect(ast.print()).toContain("Else");
+});
+
 test("Test functions with wrong number of arguments", () => {
     expect(() => new Parser().parse("RETURN range(1)")).toThrow(
         "Function range expected 2 parameters, but got 1"

package/tests/tokenization/tokenizer.test.ts

@@ -155,3 +155,37 @@ test("Test relationship with hops", () => {
     expect(tokens).toBeDefined();
     expect(tokens.length).toBeGreaterThan(0);
 });
+
+test("Test reserved keywords as identifiers", () => {
+    const tokenizer = new Tokenizer(`
+        WITH 1 AS return
+        RETURN return
+    `);
+    const tokens = tokenizer.tokenize();
+    expect(tokens).toBeDefined();
+    expect(tokens.length).toBeGreaterThan(0);
+});
+
+test("Test reserved keywords as part of identifiers", () => {
+    const tokenizer = new Tokenizer(`
+        unwind [
+            {from: "Alice", to: "Bob", organizer: "Charlie"},
+            {from: "Bob", to: "Charlie", organizer: "Alice"},
+            {from: "Charlie", to: "Alice", organizer: "Bob"}
+        ] as data
+        return data.from, data.to
+    `);
+    const tokens = tokenizer.tokenize();
+    expect(tokens).toBeDefined();
+    expect(tokens.length).toBeGreaterThan(0);
+});
+
+test("Test reserved keywords as relationship types and labels", () => {
+    const tokenizer = new Tokenizer(`
+        MATCH (a:RETURN)-[r:WITH]->(b:RETURN)
+        RETURN a, b
+    `);
+    const tokens = tokenizer.tokenize();
+    expect(tokens).toBeDefined();
+    expect(tokens.length).toBeGreaterThan(0);
+});