flowquery 1.0.33 → 1.0.35

package/package.json

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

@@ -34,20 +34,34 @@ class Database {
         }
         const physical = new PhysicalRelationship(null, relationship.type);
         physical.statement = statement;
+        physical.source = relationship.source;
+        physical.target = relationship.target;
         Database.relationships.set(relationship.type, physical);
     }
     public getRelationship(relationship: Relationship): PhysicalRelationship | null {
         return Database.relationships.get(relationship.type!) || null;
     }
+    public getRelationships(relationship: Relationship): PhysicalRelationship[] {
+        const result: PhysicalRelationship[] = [];
+        for (const type of relationship.types) {
+            const physical = Database.relationships.get(type);
+            if (physical) {
+                result.push(physical);
+            }
+        }
+        return result;
+    }
     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 };
+            const entry: Record<string, any> = { kind: "Node", label };
             if (records.length > 0) {
                 const { id, ...sample } = records[0];
-                if (Object.keys(sample).length > 0) {
+                const properties = Object.keys(sample);
+                if (properties.length > 0) {
+                    entry.properties = properties;
                     entry.sample = sample;
                 }
             }
@@ -56,10 +70,17 @@ class Database {
 
         for (const [type, physical] of Database.relationships) {
             const records = await physical.data();
-            const entry: Record<string, any> = { kind: "relationship", type };
+            const entry: Record<string, any> = {
+                kind: "Relationship",
+                type,
+                from_label: physical.source?.label || null,
+                to_label: physical.target?.label || null,
+            };
             if (records.length > 0) {
                 const { left_id, right_id, ...sample } = records[0];
-                if (Object.keys(sample).length > 0) {
+                const properties = Object.keys(sample);
+                if (properties.length > 0) {
+                    entry.properties = properties;
                     entry.sample = sample;
                 }
             }
@@ -78,6 +99,23 @@ class Database {
             const data = await node.data();
             return new NodeData(data as NodeRecord[]);
         } else if (element instanceof Relationship) {
+            if (element.types.length > 1) {
+                const physicals = this.getRelationships(element);
+                if (physicals.length === 0) {
+                    throw new Error(
+                        `No physical relationships found for types ${element.types.join(", ")}`
+                    );
+                }
+                const allRecords: RelationshipRecord[] = [];
+                for (let i = 0; i < physicals.length; i++) {
+                    const records = (await physicals[i].data()) as RelationshipRecord[];
+                    const typeName = element.types[i];
+                    for (const record of records) {
+                        allRecords.push({ ...record, _type: typeName });
+                    }
+                }
+                return new RelationshipData(allRecords);
+            }
             const relationship = this.getRelationship(element);
             if (relationship === null) {
                 throw new Error(`Physical relationship not found for type ${element.type}`);

package/src/graph/relationship.ts

@@ -9,7 +9,7 @@ import RelationshipMatchCollector, {
 
 class Relationship extends ASTNode {
     protected _identifier: string | null = null;
-    protected _type: string | null = null;
+    protected _types: string[] = [];
     protected _properties: Map<string, Expression> = new Map();
     protected _hops: Hops = new Hops();
 
@@ -25,7 +25,9 @@ class Relationship extends ASTNode {
     constructor(identifier: string | null = null, type: string | null = null) {
         super();
         this._identifier = identifier;
-        this._type = type;
+        if (type !== null) {
+            this._types = [type];
+        }
     }
     public set identifier(identifier: string) {
         this._identifier = identifier;
@@ -34,10 +36,16 @@ class Relationship extends ASTNode {
         return this._identifier;
     }
     public set type(type: string) {
-        this._type = type;
+        this._types = [type];
     }
     public get type(): string | null {
-        return this._type;
+        return this._types.length > 0 ? this._types[0] : null;
+    }
+    public set types(types: string[]) {
+        this._types = types;
+    }
+    public get types(): string[] {
+        return this._types;
     }
     public get properties(): Map<string, Expression> {
         return this._properties;

package/src/graph/relationship_data.ts

@@ -18,7 +18,7 @@ class RelationshipData extends Data {
     public properties(): Record<string, any> | null {
         const current = this.current();
         if (current) {
-            const { left_id, right_id, ...props } = current;
+            const { left_id, right_id, _type, ...props } = current;
             return props;
         }
         return null;

package/src/graph/relationship_match_collector.ts

@@ -12,11 +12,15 @@ class RelationshipMatchCollector {
     private _nodeIds: Array<string> = [];
 
     public push(relationship: Relationship, traversalId: string): RelationshipMatchRecord {
+        const data = relationship.getData();
+        const currentRecord = data?.current();
+        const actualType =
+            currentRecord && "_type" in currentRecord ? currentRecord["_type"] : relationship.type!;
         const match: RelationshipMatchRecord = {
-            type: relationship.type!,
+            type: actualType,
             startNode: relationship.source?.value() || {},
             endNode: null,
-            properties: relationship.getData()?.properties() as Record<string, any>,
+            properties: data?.properties() as Record<string, any>,
         };
         this._matches.push(match);
         this._nodeIds.push(traversalId);

package/src/graph/relationship_reference.ts

@@ -6,7 +6,7 @@ class RelationshipReference extends Relationship {
     constructor(base: Relationship, reference: Relationship) {
         super();
         this._identifier = base.identifier;
-        this._type = base.type;
+        this._types = base.types;
         this._hops = base.hops!;
         this._source = base.source;
         this._target = base.target;

package/src/parsing/functions/function_factory.ts

@@ -27,6 +27,9 @@ import "./stringify";
 // Import built-in functions to ensure their @FunctionDef decorators run
 import "./sum";
 import "./to_json";
+import "./to_lower";
+import "./to_string";
+import "./trim";
 import "./type";
 
 // Re-export AsyncDataProvider for backwards compatibility

package/src/parsing/functions/predicate_sum.ts

@@ -1,17 +1,26 @@
-import PredicateFunction from "./predicate_function";
 import { FunctionDef } from "./function_metadata";
+import PredicateFunction from "./predicate_function";
 
 @FunctionDef({
-    description: "Calculates the sum of values in an array with optional filtering. Uses list comprehension syntax: sum(variable IN array [WHERE condition] | expression)",
+    description:
+        "Calculates the sum of values in an array with optional filtering. Uses list comprehension syntax: sum(variable IN array [WHERE condition] | expression)",
     category: "predicate",
     parameters: [
         { name: "variable", description: "Variable name to bind each element", type: "string" },
         { name: "array", description: "Array to iterate over", type: "array" },
         { name: "expression", description: "Expression to sum for each element", type: "any" },
-        { name: "where", description: "Optional filter condition", type: "boolean", required: false }
+        {
+            name: "where",
+            description: "Optional filter condition",
+            type: "boolean",
+            required: false,
+        },
     ],
     output: { description: "Sum of the evaluated expressions", type: "number", example: 6 },
-    examples: ["WITH [1, 2, 3] AS nums RETURN sum(n IN nums | n)", "WITH [1, 2, 3, 4] AS nums RETURN sum(n IN nums WHERE n > 1 | n * 2)"]
+    examples: [
+        "WITH [1, 2, 3] AS nums RETURN sum(n IN nums | n)",
+        "WITH [1, 2, 3, 4] AS nums RETURN sum(n IN nums WHERE n > 1 | n * 2)",
+    ],
 })
 class PredicateSum extends PredicateFunction {
     constructor() {
@@ -24,19 +33,15 @@ class PredicateSum extends PredicateFunction {
         if (array === null || !Array.isArray(array)) {
             throw new Error("Invalid array for sum function");
         }
-        let _sum: any | null = null;
-        for(let i = 0; i < array.length; i++) {
+        let _sum: number = 0;
+        for (let i = 0; i < array.length; i++) {
             this._valueHolder.holder = array[i];
             if (this.where === null || this.where.value()) {
-                if (_sum === null) {
-                    _sum = this._return.value();
-                } else {
-                    _sum += this._return.value();
-                }
+                _sum += this._return.value();
             }
         }
         return _sum;
     }
 }
 
-export default PredicateSum;
+export default PredicateSum;

package/src/parsing/functions/schema.ts

@@ -5,8 +5,11 @@ 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).
+ * Lists all nodes and relationships with their labels/types, properties,
+ * and a sample of their data (excluding id from nodes, left_id and right_id from relationships).
+ *
+ * Nodes: {label, properties, sample}
+ * Relationships: {type, from_label, to_label, properties, sample}
  *
  * @example
  * ```
@@ -15,11 +18,11 @@ import { FunctionDef } from "./function_metadata";
  */
 @FunctionDef({
     description:
-        "Returns the graph schema listing all nodes and relationships with a sample of their data.",
+        "Returns the graph schema listing all nodes and relationships with their properties and a sample of their data.",
     category: "async",
     parameters: [],
     output: {
-        description: "Schema entry with kind, label/type, and optional sample data",
+        description: "Schema entry with label/type, properties, and optional sample data",
         type: "object",
     },
     examples: ["LOAD FROM schema() AS s RETURN s"],

package/src/parsing/functions/to_lower.ts

@@ -0,0 +1,25 @@
+import Function from "./function";
+import { FunctionDef } from "./function_metadata";
+
+@FunctionDef({
+    description: "Converts a string to lowercase",
+    category: "scalar",
+    parameters: [{ name: "text", description: "String to convert to lowercase", type: "string" }],
+    output: { description: "Lowercase string", type: "string", example: "hello world" },
+    examples: ["WITH 'Hello World' AS s RETURN toLower(s)", "WITH 'FOO' AS s RETURN toLower(s)"],
+})
+class ToLower extends Function {
+    constructor() {
+        super("tolower");
+        this._expectedParameterCount = 1;
+    }
+    public value(): any {
+        const val = this.getChildren()[0].value();
+        if (typeof val !== "string") {
+            throw new Error("Invalid argument for toLower function: expected a string");
+        }
+        return val.toLowerCase();
+    }
+}
+
+export default ToLower;

package/src/parsing/functions/to_string.ts

@@ -0,0 +1,32 @@
+import Function from "./function";
+import { FunctionDef } from "./function_metadata";
+
+@FunctionDef({
+    description: "Converts a value to its string representation",
+    category: "scalar",
+    parameters: [{ name: "value", description: "Value to convert to a string", type: "any" }],
+    output: { description: "String representation of the value", type: "string", example: "42" },
+    examples: [
+        "WITH 42 AS n RETURN toString(n)",
+        "WITH true AS b RETURN toString(b)",
+        "WITH [1, 2, 3] AS arr RETURN toString(arr)",
+    ],
+})
+class ToString extends Function {
+    constructor() {
+        super("tostring");
+        this._expectedParameterCount = 1;
+    }
+    public value(): any {
+        const val = this.getChildren()[0].value();
+        if (val === null || val === undefined) {
+            return String(val);
+        }
+        if (typeof val === "object") {
+            return JSON.stringify(val);
+        }
+        return String(val);
+    }
+}
+
+export default ToString;

package/src/parsing/functions/trim.ts

@@ -0,0 +1,25 @@
+import Function from "./function";
+import { FunctionDef } from "./function_metadata";
+
+@FunctionDef({
+    description: "Removes leading and trailing whitespace from a string",
+    category: "scalar",
+    parameters: [{ name: "text", description: "String to trim", type: "string" }],
+    output: { description: "Trimmed string", type: "string", example: "hello" },
+    examples: ["WITH '  hello  ' AS s RETURN trim(s)", "WITH '\\tfoo\\n' AS s RETURN trim(s)"],
+})
+class Trim extends Function {
+    constructor() {
+        super("trim");
+        this._expectedParameterCount = 1;
+    }
+    public value(): any {
+        const val = this.getChildren()[0].value();
+        if (typeof val !== "string") {
+            throw new Error("Invalid argument for trim function: expected a string");
+        }
+        return val.trim();
+    }
+}
+
+export default Trim;

package/src/parsing/operations/group_by.ts

@@ -106,7 +106,10 @@ class GroupBy extends Projection {
                 yield* this.generate_results(mapperIndex + 1, child);
             }
         } else {
-            node.elements?.forEach((element, reducerIndex) => {
+            if (node.elements === null) {
+                node.elements = this.reducers.map((reducer) => reducer.element());
+            }
+            node.elements.forEach((element, reducerIndex) => {
                 this.reducers[reducerIndex].overridden = element.value;
             });
             const record: Record<string, any> = {};

package/src/parsing/parser.ts

@@ -420,6 +420,8 @@ class Parser extends BaseParser {
             }
             relationship = new Relationship();
             relationship.type = type;
+            relationship.source = node;
+            relationship.target = target;
         }
         this.expectAndSkipWhitespaceAndComments();
         if (!this.token.isAs()) {
@@ -673,8 +675,19 @@ class Parser extends BaseParser {
         if (!this.token.isIdentifierOrKeyword()) {
             throw new Error("Expected relationship type identifier");
         }
-        const type: string = this.token.value || "";
+        const types: string[] = [this.token.value || ""];
         this.setNextToken();
+        while (this.token.isPipe()) {
+            this.setNextToken();
+            if (this.token.isColon()) {
+                this.setNextToken();
+            }
+            if (!this.token.isIdentifierOrKeyword()) {
+                throw new Error("Expected relationship type identifier after '|'");
+            }
+            types.push(this.token.value || "");
+            this.setNextToken();
+        }
         const hops: Hops | null = this.parseRelationshipHops();
         const properties: Map<string, Expression> = new Map(this.parseProperties());
         if (!this.token.isClosingBracket()) {
@@ -711,7 +724,7 @@ class Parser extends BaseParser {
         if (hops !== null) {
             relationship.hops = hops;
         }
-        relationship.type = type;
+        relationship.types = types;
         return relationship;
     }