flowquery 1.0.18 → 1.0.21

package/package.json

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

package/src/graph/data.ts

@@ -27,13 +27,19 @@ class IndexEntry {
 }
 
 class Layer {
-    private _index: Map<string, IndexEntry> = new Map();
+    private _indexes: Map<string, Map<string, IndexEntry>> = new Map();
     private _current: number = -1;
-    constructor(index: Map<string, IndexEntry>) {
-        this._index = index;
+    constructor(indexes: Map<string, Map<string, IndexEntry>>) {
+        this._indexes = indexes;
     }
-    public get index(): Map<string, IndexEntry> {
-        return this._index;
+    public index(name: string): Map<string, IndexEntry> {
+        if (!this._indexes.has(name)) {
+            this._indexes.set(name, new Map());
+        }
+        return this._indexes.get(name)!;
+    }
+    public get indexes(): Map<string, Map<string, IndexEntry>> {
+        return this._indexes;
     }
     public get current(): number {
         return this._current;
@@ -52,33 +58,41 @@ class Data {
         this._layers.set(0, new Layer(new Map()));
     }
     protected _buildIndex(key: string, level: number = 0): void {
-        this.layer(level).index.clear();
-        this._records.forEach((record, idx) => {
+        const idx = this.layer(level).index(key);
+        idx.clear();
+        this._records.forEach((record, i) => {
             if (record.hasOwnProperty(key)) {
-                if (!this.layer(level).index.has(record[key])) {
-                    this.layer(level).index.set(record[key], new IndexEntry());
+                if (!idx.has(record[key])) {
+                    idx.set(record[key], new IndexEntry());
                 }
-                this.layer(level).index.get(record[key])!.add(idx);
+                idx.get(record[key])!.add(i);
             }
         });
     }
     public layer(level: number = 0): Layer {
         if (!this._layers.has(level)) {
             const first = this._layers.get(0)!;
-            const cloned = new Map<string, IndexEntry>();
-            for (const [key, entry] of first.index) {
-                cloned.set(key, entry.clone());
+            const clonedIndexes = new Map<string, Map<string, IndexEntry>>();
+            for (const [name, indexMap] of first.indexes) {
+                const clonedMap = new Map<string, IndexEntry>();
+                for (const [key, entry] of indexMap) {
+                    clonedMap.set(key, entry.clone());
+                }
+                clonedIndexes.set(name, clonedMap);
             }
-            this._layers.set(level, new Layer(cloned));
+            this._layers.set(level, new Layer(clonedIndexes));
         }
         return this._layers.get(level)!;
     }
-    protected _find(key: string, level: number = 0): boolean {
-        if (!this.layer(level).index.has(key)) {
+    protected _find(key: string, level: number = 0, indexName?: string): boolean {
+        const idx = indexName
+            ? this.layer(level).index(indexName)
+            : this.layer(level).indexes.values().next().value;
+        if (!idx || !idx.has(key)) {
             this.layer(level).current = this._records.length; // Move to end
             return false;
         } else {
-            const entry = this.layer(level).index.get(key)!;
+            const entry = idx.get(key)!;
             const more = entry.next();
             if (!more) {
                 this.layer(level).current = this._records.length; // Move to end
@@ -89,9 +103,13 @@ class Data {
         }
     }
     public reset(): void {
-        this.layer(0).current = -1;
-        for (const entry of this.layer(0).index.values()) {
-            entry.reset();
+        for (const layer of this._layers.values()) {
+            layer.current = -1;
+            for (const indexMap of layer.indexes.values()) {
+                for (const entry of indexMap.values()) {
+                    entry.reset();
+                }
+            }
         }
     }
     public next(level: number = 0): boolean {

package/src/graph/node.ts

@@ -41,6 +41,23 @@ class Node extends ASTNode {
     public get properties(): Map<string, Expression> {
         return this._properties;
     }
+    public set properties(properties: Map<string, Expression>) {
+        this._properties = properties;
+    }
+    private _matchesProperties(hop: number = 0): boolean {
+        const data: NodeData = this._data!;
+        for (const [key, expression] of this._properties) {
+            const record: NodeRecord = data.current(hop)!;
+            if (record === null) {
+                throw new Error("No current node data available");
+            }
+            if (!(key in record)) {
+                throw new Error("Node does not have property");
+            }
+            return record[key] === expression.value();
+        }
+        return true;
+    }
     public setProperty(key: string, value: Expression): void {
         this._properties.set(key, value);
     }
@@ -72,6 +89,9 @@ class Node extends ASTNode {
         this._data?.reset();
         while (this._data?.next()) {
             this.setValue(this._data?.current()!);
+            if (!this._matchesProperties()) {
+                continue;
+            }
             await this._outgoing?.find(this._value!.id);
             await this.runTodoNext();
         }
@@ -80,6 +100,9 @@ class Node extends ASTNode {
         this._data?.reset();
         while (this._data?.find(id, hop)) {
             this.setValue(this._data?.current(hop) as NodeRecord);
+            if (!this._matchesProperties(hop)) {
+                continue;
+            }
             this._incoming?.setEndNode(this);
             await this._outgoing?.find(this._value!.id, hop);
             await this.runTodoNext();

package/src/graph/node_data.ts

@@ -8,7 +8,7 @@ class NodeData extends Data {
         super._buildIndex("id");
     }
     public find(id: string, hop: number = 0): boolean {
-        return super._find(id, hop);
+        return super._find(id, hop, "id");
     }
     public current(hop: number = 0): NodeRecord | null {
         return super.current(hop) as NodeRecord | null;

package/src/graph/pattern.ts

@@ -65,17 +65,26 @@ class Pattern extends ASTNode {
         return Array.from(this.values());
     }
     public *values(): Generator<any> {
-        for (const element of this._chain) {
+        for (let i = 0; i < this._chain.length; i++) {
+            const element = this._chain[i];
             if (element instanceof Node) {
+                // Skip node if previous element was a zero-hop relationship (no matches)
+                if (
+                    i > 0 &&
+                    this._chain[i - 1] instanceof Relationship &&
+                    (this._chain[i - 1] as Relationship).matches.length === 0
+                ) {
+                    continue;
+                }
                 yield element.value();
             } else if (element instanceof Relationship) {
-                let i = 0;
+                let j = 0;
                 for (const match of element.matches) {
                     yield match;
-                    if (i < element.matches.length - 1) {
+                    if (j < element.matches.length - 1) {
                         yield match.endNode;
                     }
-                    i++;
+                    j++;
                 }
             }
         }

package/src/graph/relationship.ts

@@ -18,6 +18,7 @@ class Relationship extends ASTNode {
 
     protected _source: Node | null = null;
     protected _target: Node | null = null;
+    protected _direction: "left" | "right" = "right";
 
     private _data: RelationshipData | null = null;
 
@@ -38,8 +39,25 @@ class Relationship extends ASTNode {
     public get type(): string | null {
         return this._type;
     }
-    public get properties(): Record<string, any> {
-        return this._data?.properties() || {};
+    public get properties(): Map<string, Expression> {
+        return this._properties;
+    }
+    public set properties(properties: Map<string, Expression>) {
+        this._properties = properties;
+    }
+    private _matchesProperties(hop: number = 0): boolean {
+        const data: RelationshipData = this._data!;
+        for (const [key, expression] of this._properties) {
+            const record: RelationshipRecord = data.current(hop)!;
+            if (record === null) {
+                throw new Error("No current relationship data available");
+            }
+            if (!(key in record)) {
+                throw new Error("Relationship does not have property");
+            }
+            return record[key] === expression.value();
+        }
+        return true;
     }
     public setProperty(key: string, value: Expression): void {
         this._properties.set(key, value);
@@ -69,6 +87,12 @@ class Relationship extends ASTNode {
     public get target(): Node | null {
         return this._target;
     }
+    public set direction(direction: "left" | "right") {
+        this._direction = direction;
+    }
+    public get direction(): "left" | "right" {
+        return this._direction;
+    }
     public value(): RelationshipMatchRecord | RelationshipMatchRecord[] | null {
         return this._value;
     }
@@ -87,23 +111,39 @@ class Relationship extends ASTNode {
     public async find(left_id: string, hop: number = 0): Promise<void> {
         // Save original source node
         const original = this._source;
+        const isLeft = this._direction === "left";
         if (hop > 0) {
             // For hops greater than 0, the source becomes the target of the previous hop
             this._source = this._target;
         }
         if (hop === 0) {
             this._data?.reset();
+
+            // Handle zero-hop case: when min is 0 on a variable-length relationship,
+            // match source node as target (no traversal)
+            if (this.hops?.multi() && this.hops.min === 0 && this._target) {
+                // For zero-hop, target finds the same node as source (left_id)
+                // No relationship match is pushed since no edge is traversed
+                await this._target.find(left_id, hop);
+            }
         }
-        while (this._data?.find(left_id, hop)) {
+        const findMatch = isLeft
+            ? (id: string, h: number) => this._data!.findReverse(id, h)
+            : (id: string, h: number) => this._data!.find(id, h);
+        const followId = isLeft ? "left_id" : "right_id";
+        while (findMatch(left_id, hop)) {
             const data: RelationshipRecord = this._data?.current(hop) as RelationshipRecord;
             if (hop >= this.hops!.min) {
                 this.setValue(this);
-                await this._target?.find(data.right_id, hop);
+                if (!this._matchesProperties(hop)) {
+                    continue;
+                }
+                await this._target?.find(data[followId], hop);
                 if (this._matches.isCircular()) {
                     throw new Error("Circular relationship detected");
                 }
                 if (hop + 1 < this.hops!.max) {
-                    await this.find(data.right_id, hop + 1);
+                    await this.find(data[followId], hop + 1);
                 }
                 this._matches.pop();
             }

package/src/graph/relationship_data.ts

@@ -6,9 +6,13 @@ class RelationshipData extends Data {
     constructor(records: RelationshipRecord[] = []) {
         super(records);
         super._buildIndex("left_id");
+        super._buildIndex("right_id");
     }
     public find(left_id: string, hop: number = 0): boolean {
-        return super._find(left_id, hop);
+        return super._find(left_id, hop, "left_id");
+    }
+    public findReverse(right_id: string, hop: number = 0): boolean {
+        return super._find(right_id, hop, "right_id");
     }
     /*
     ** Get the properties of the current relationship record
@@ -22,6 +26,9 @@ class RelationshipData extends Data {
         }
         return null;
     }
+    public current(hop: number = 0): RelationshipRecord | null {
+        return super.current(hop) as RelationshipRecord | null;
+    }
 }
 
 export default RelationshipData;

package/src/graph/relationship_match_collector.ts

@@ -16,7 +16,7 @@ class RelationshipMatchCollector {
             type: relationship.type!,
             startNode: relationship.source?.value() || {},
             endNode: null,
-            properties: relationship.properties,
+            properties: relationship.getData()?.properties() as Record<string, any>,
         };
         this._matches.push(match);
         this._nodeIds.push(match.startNode.id);

package/src/graph/relationship_reference.ts

@@ -17,7 +17,8 @@ class RelationshipReference extends Relationship {
         const data: RelationshipRecord = this._reference!.getData()?.current(
             hop
         ) as RelationshipRecord;
-        await this._target?.find(data.right_id, hop);
+        const followId = this._direction === "left" ? "left_id" : "right_id";
+        await this._target?.find(data[followId], hop);
     }
 }
 

package/src/index.ts

@@ -1,12 +1,12 @@
 /**
  * FlowQuery - A declarative query language for data processing pipelines.
- * 
- * This is the main entry point for the FlowQuery command-line interface.
- * 
+ *
+ * Main entry point for the FlowQuery command-line interface.
+ *
  * @packageDocumentation
  */
 
-import CommandLine from './io/command_line';
+import CommandLine from "./io/command_line";
 
 const commandLine = new CommandLine();
-commandLine.loop();
+commandLine.loop();

package/src/parsing/parser.ts

@@ -431,6 +431,7 @@ class Parser extends BaseParser {
         }
         this.skipWhitespaceAndComments();
         let node = new Node();
+        node.properties = new Map(this.parseProperties());
         node.label = label!;
         if (label !== null && identifier !== null) {
             node.identifier = identifier;
@@ -449,6 +450,47 @@ class Parser extends BaseParser {
         return node;
     }
 
+    private *parseProperties(): Iterable<[string, Expression]> {
+        let parts: number = 0;
+        while (true) {
+            this.skipWhitespaceAndComments();
+            if (!this.token.isOpeningBrace() && parts == 0) {
+                return;
+            } else if (!this.token.isOpeningBrace() && parts > 0) {
+                throw new Error("Expected opening brace");
+            }
+            this.setNextToken();
+            this.skipWhitespaceAndComments();
+            if (!this.token.isIdentifier()) {
+                throw new Error("Expected identifier");
+            }
+            const key: string = this.token.value!;
+            this.setNextToken();
+            this.skipWhitespaceAndComments();
+            if (!this.token.isColon()) {
+                throw new Error("Expected colon");
+            }
+            this.setNextToken();
+            this.skipWhitespaceAndComments();
+            const expression: Expression | null = this.parseExpression();
+            if (expression === null) {
+                throw new Error("Expected expression");
+            }
+            this.skipWhitespaceAndComments();
+            if (!this.token.isClosingBrace()) {
+                throw new Error("Expected closing brace");
+            }
+            this.setNextToken();
+            yield [key, expression];
+            this.skipWhitespaceAndComments();
+            if (!this.token.isComma()) {
+                break;
+            }
+            this.setNextToken();
+            parts++;
+        }
+    }
+
     private *parsePatterns(): IterableIterator<Pattern> {
         while (true) {
             let identifier: string | null = null;
@@ -538,7 +580,9 @@ class Parser extends BaseParser {
     }
 
     private parseRelationship(): Relationship | null {
+        let direction: "left" | "right" = "right";
         if (this.token.isLessThan() && this.peek()?.isSubtract()) {
+            direction = "left";
             this.setNextToken();
             this.setNextToken();
         } else if (this.token.isSubtract()) {
@@ -565,6 +609,7 @@ class Parser extends BaseParser {
         const type: string = this.token.value || "";
         this.setNextToken();
         const hops: Hops | null = this.parseRelationshipHops();
+        const properties: Map<string, Expression> = new Map(this.parseProperties());
         if (!this.token.isClosingBracket()) {
             throw new Error("Expected closing bracket for relationship definition");
         }
@@ -577,6 +622,8 @@ class Parser extends BaseParser {
             this.setNextToken();
         }
         let relationship = new Relationship();
+        relationship.direction = direction;
+        relationship.properties = properties;
         if (type !== null && variable !== null) {
             relationship.identifier = variable;
             this.variables.set(variable, relationship);
@@ -610,10 +657,11 @@ class Parser extends BaseParser {
                 }
                 this.setNextToken();
                 if (!this.token.isNumber()) {
-                    throw new Error("Expected number for relationship hops");
+                    hops.max = Number.MAX_SAFE_INTEGER;
+                } else {
+                    hops.max = parseInt(this.token.value || "0");
+                    this.setNextToken();
                 }
-                hops.max = parseInt(this.token.value || "0");
-                this.setNextToken();
             }
         } else {
             hops.min = 0;
@@ -691,77 +739,97 @@ class Parser extends BaseParser {
         }
     }
 
+    /**
+     * Parse a single operand (without operators).
+     * @returns True if an operand was parsed, false otherwise.
+     */
+    private parseOperand(expression: Expression): boolean {
+        this.skipWhitespaceAndComments();
+        if (this.token.isIdentifier() && !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()) {
+            const func = this.parsePredicateFunction() || this.parseFunction();
+            if (func !== null) {
+                const lookup = this.parseLookup(func);
+                expression.addNode(lookup);
+                return true;
+            }
+        } else if (
+            this.token.isLeftParenthesis() &&
+            (this.peek()?.isIdentifier() ||
+                this.peek()?.isColon() ||
+                this.peek()?.isRightParenthesis())
+        ) {
+            // Possible graph pattern expression
+            const pattern = this.parsePatternExpression();
+            if (pattern !== null) {
+                expression.addNode(pattern);
+                return true;
+            }
+        } else if (this.token.isOperand()) {
+            expression.addNode(this.token.node);
+            this.setNextToken();
+            return true;
+        } else if (this.token.isFString()) {
+            const f_string = this.parseFString();
+            if (f_string === null) {
+                throw new Error("Expected f-string");
+            }
+            expression.addNode(f_string);
+            return true;
+        } else if (this.token.isLeftParenthesis()) {
+            this.setNextToken();
+            const sub = this.parseExpression();
+            if (sub === null) {
+                throw new Error("Expected expression");
+            }
+            if (!this.token.isRightParenthesis()) {
+                throw new Error("Expected right parenthesis");
+            }
+            this.setNextToken();
+            const lookup = this.parseLookup(sub);
+            expression.addNode(lookup);
+            return true;
+        } else if (this.token.isOpeningBrace() || this.token.isOpeningBracket()) {
+            const json = this.parseJSON();
+            if (json === null) {
+                throw new Error("Expected JSON object");
+            }
+            const lookup = this.parseLookup(json);
+            expression.addNode(lookup);
+            return true;
+        } else if (this.token.isCase()) {
+            const _case = this.parseCase();
+            if (_case === null) {
+                throw new Error("Expected CASE statement");
+            }
+            expression.addNode(_case);
+            return true;
+        } else if (this.token.isNot()) {
+            const not = new Not();
+            this.setNextToken();
+            // NOT should only bind to the next operand, not the entire expression
+            const tempExpr = new Expression();
+            if (!this.parseOperand(tempExpr)) {
+                throw new Error("Expected expression after NOT");
+            }
+            tempExpr.finish();
+            not.addChild(tempExpr);
+            expression.addNode(not);
+            return true;
+        }
+        return false;
+    }
+
     private parseExpression(): Expression | null {
         const expression = new Expression();
         while (true) {
-            this.skipWhitespaceAndComments();
-            if (this.token.isIdentifier() && !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);
-            } else if (this.token.isIdentifier() && this.peek()?.isLeftParenthesis()) {
-                const func = this.parsePredicateFunction() || this.parseFunction();
-                if (func !== null) {
-                    const lookup = this.parseLookup(func);
-                    expression.addNode(lookup);
-                }
-            } else if (
-                this.token.isLeftParenthesis() &&
-                (this.peek()?.isIdentifier() ||
-                    this.peek()?.isColon() ||
-                    this.peek()?.isRightParenthesis())
-            ) {
-                // Possible graph pattern expression
-                const pattern = this.parsePatternExpression();
-                if (pattern !== null) {
-                    expression.addNode(pattern);
-                }
-            } else if (this.token.isOperand()) {
-                expression.addNode(this.token.node);
-                this.setNextToken();
-            } else if (this.token.isFString()) {
-                const f_string = this.parseFString();
-                if (f_string === null) {
-                    throw new Error("Expected f-string");
-                }
-                expression.addNode(f_string);
-            } else if (this.token.isLeftParenthesis()) {
-                this.setNextToken();
-                const sub = this.parseExpression();
-                if (sub === null) {
-                    throw new Error("Expected expression");
-                }
-                if (!this.token.isRightParenthesis()) {
-                    throw new Error("Expected right parenthesis");
-                }
-                this.setNextToken();
-                const lookup = this.parseLookup(sub);
-                expression.addNode(lookup);
-            } else if (this.token.isOpeningBrace() || this.token.isOpeningBracket()) {
-                const json = this.parseJSON();
-                if (json === null) {
-                    throw new Error("Expected JSON object");
-                }
-                const lookup = this.parseLookup(json);
-                expression.addNode(lookup);
-            } else if (this.token.isCase()) {
-                const _case = this.parseCase();
-                if (_case === null) {
-                    throw new Error("Expected CASE statement");
-                }
-                expression.addNode(_case);
-            } else if (this.token.isNot()) {
-                const not = new Not();
-                this.setNextToken();
-                const sub = this.parseExpression();
-                if (sub === null) {
-                    throw new Error("Expected expression");
-                }
-                not.addChild(sub);
-                expression.addNode(not);
-            } else {
+            if (!this.parseOperand(expression)) {
                 if (expression.nodesAdded()) {
                     throw new Error("Expected operand or left parenthesis");
                 } else {