flowquery 1.0.21 → 1.0.22

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "flowquery",
-  "version": "1.0.21",
+  "version": "1.0.22",
   "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/tests/compute/runner.test.ts

@@ -1460,3 +1460,43 @@ 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");
+});