flowquery 1.0.15 → 1.0.17

package/src/parsing/base_parser.ts

@@ -3,7 +3,7 @@ import Tokenizer from "../tokenization/tokenizer";
 
 /**
  * Base class for parsers providing common token manipulation functionality.
- * 
+ *
  * This class handles tokenization and provides utility methods for navigating
  * through tokens, peeking ahead, and checking token sequences.
  */
@@ -11,9 +11,15 @@ class BaseParser {
     private tokens: Token[] = <Token[]>[];
     private tokenIndex: number = 0;
 
+    constructor(tokens: Token[] | null = null) {
+        if (tokens !== null) {
+            this.tokens = tokens;
+        }
+    }
+
     /**
      * Tokenizes a statement and initializes the token array.
-     * 
+     *
      * @param statement - The input statement to tokenize
      */
     protected tokenize(statement: string): void {
@@ -30,11 +36,11 @@ class BaseParser {
 
     /**
      * Peeks at the next token without advancing the current position.
-     * 
+     *
      * @returns The next token, or null if at the end of the token stream
      */
     protected peek(): Token | null {
-        if(this.tokenIndex + 1 >= this.tokens.length) {
+        if (this.tokenIndex + 1 >= this.tokens.length) {
             return null;
         }
         return this.tokens[this.tokenIndex + 1];
@@ -42,22 +48,22 @@ class BaseParser {
 
     /**
      * Checks if a sequence of tokens appears ahead in the token stream.
-     * 
+     *
      * @param tokens - The sequence of tokens to look for
      * @param skipWhitespaceAndComments - Whether to skip whitespace and comments when matching
      * @returns True if the token sequence is found ahead, false otherwise
      */
     protected ahead(tokens: Token[], skipWhitespaceAndComments: boolean = true): boolean {
         let j = 0;
-        for(let i=this.tokenIndex; i<this.tokens.length; i++) {
-            if(skipWhitespaceAndComments && this.tokens[i].isWhitespaceOrComment()) {
+        for (let i = this.tokenIndex; i < this.tokens.length; i++) {
+            if (skipWhitespaceAndComments && this.tokens[i].isWhitespaceOrComment()) {
                 continue;
             }
-            if(!this.tokens[i].equals(tokens[j])) {
+            if (!this.tokens[i].equals(tokens[j])) {
                 return false;
             }
             j++;
-            if(j === tokens.length) {
+            if (j === tokens.length) {
                 break;
             }
         }
@@ -66,11 +72,11 @@ class BaseParser {
 
     /**
      * Gets the current token.
-     * 
+     *
      * @returns The current token, or EOF if at the end
      */
     protected get token(): Token {
-        if(this.tokenIndex >= this.tokens.length) {
+        if (this.tokenIndex >= this.tokens.length) {
             return Token.EOF;
         }
         return this.tokens[this.tokenIndex];
@@ -78,15 +84,15 @@ class BaseParser {
 
     /**
      * Gets the previous token.
-     * 
+     *
      * @returns The previous token, or EOF if at the beginning
      */
     protected get previousToken(): Token {
-        if(this.tokenIndex - 1 < 0) {
+        if (this.tokenIndex - 1 < 0) {
             return Token.EOF;
         }
         return this.tokens[this.tokenIndex - 1];
     }
 }
 
-export default BaseParser;
+export default BaseParser;

package/src/parsing/context.ts

@@ -2,10 +2,10 @@ import ASTNode from "./ast_node";
 
 /**
  * Maintains a stack of AST nodes to track parsing context.
- * 
+ *
  * Used during parsing to maintain the current context and check for specific node types
  * in the parsing hierarchy, which helps with context-sensitive parsing decisions.
- * 
+ *
  * @example
  * ```typescript
  * const context = new Context();
@@ -14,35 +14,35 @@ import ASTNode from "./ast_node";
  * ```
  */
 class Context {
-    private stack: ASTNode[] = [];
-    
+    private nodes: ASTNode[] = [];
+
     /**
      * Pushes a node onto the context stack.
-     * 
+     *
      * @param node - The AST node to push
      */
     public push(node: ASTNode): void {
-        this.stack.push(node);
+        this.nodes.push(node);
     }
-    
+
     /**
      * Pops the top node from the context stack.
-     * 
+     *
      * @returns The popped node, or undefined if the stack is empty
      */
     public pop(): ASTNode | undefined {
-        return this.stack.pop();
+        return this.nodes.pop();
     }
-    
+
     /**
-     * Checks if the stack contains a node of the specified type.
-     * 
+     * Checks if the nodes stack contains a node of the specified type.
+     *
      * @param type - The constructor of the node type to search for
      * @returns True if a node of the specified type is found in the stack, false otherwise
      */
     public containsType(type: new (...args: any[]) => ASTNode): boolean {
-        return this.stack.some((v) => v instanceof type);
+        return this.nodes.some((v) => v instanceof type);
     }
 }
 
-export default Context;
+export default Context;

package/src/parsing/expressions/boolean.ts

@@ -0,0 +1,21 @@
+import ASTNode from "../ast_node";
+
+class Boolean extends ASTNode {
+    private _value: boolean;
+    constructor(value: string) {
+        super();
+        const _value = value.toUpperCase();
+        if (_value === "TRUE") {
+            this._value = true;
+        } else if (_value === "FALSE") {
+            this._value = false;
+        } else {
+            throw new Error(`Invalid boolean value: ${value}`);
+        }
+    }
+    public value(): boolean {
+        return this._value;
+    }
+}
+
+export default Boolean;

package/src/parsing/expressions/expression.ts

@@ -1,14 +1,15 @@
+import PatternExpression from "../../graph/pattern_expression";
 import ASTNode from "../ast_node";
 import AggregateFunction from "../functions/aggregate_function";
 import Reference from "./reference";
 
 /**
  * Represents an expression in the FlowQuery AST.
- * 
+ *
  * Expressions are built using the Shunting Yard algorithm to handle operator
  * precedence and associativity. They can contain operands (numbers, strings, identifiers)
  * and operators (arithmetic, logical, comparison).
- * 
+ *
  * @example
  * ```typescript
  * const expr = new Expression();
@@ -24,23 +25,24 @@ class Expression extends ASTNode {
     private _alias: string | null = null;
     private _overridden: any | null = null;
     private _reducers: AggregateFunction[] | null = null;
+    private _patterns: PatternExpression[] | null = null;
 
     /**
      * Adds a node (operand or operator) to the expression.
-     * 
+     *
      * Uses the Shunting Yard algorithm to maintain correct operator precedence.
-     * 
+     *
      * @param node - The AST node to add (operand or operator)
      */
     public addNode(node: ASTNode): void {
         /* Implements the Shunting Yard algorithm */
-        if(node.isOperand()) {
+        if (node.isOperand()) {
             this.output.push(node);
-        } else if(node.isOperator()) {
+        } else if (node.isOperator()) {
             const operator1: ASTNode = node;
-            while(this.operators.length > 0) {
+            while (this.operators.length > 0) {
                 let operator2 = this.operators[this.operators.length - 1];
-                if(
+                if (
                     operator2.precedence > operator1.precedence ||
                     (operator2.precedence === operator1.precedence && operator1.leftAssociative)
                 ) {
@@ -56,25 +58,25 @@ class Expression extends ASTNode {
 
     /**
      * Finalizes the expression by converting it to a tree structure.
-     * 
+     *
      * Should be called after all nodes have been added.
      */
     public finish(): void {
         let last: ASTNode | undefined;
-        while(last = this.operators.pop()) {
+        while ((last = this.operators.pop())) {
             this.output.push(last);
-        };
+        }
         this.addChild(this.toTree());
     }
 
     private toTree(): ASTNode {
         const node = this.output.pop() || new ASTNode();
-        if(node.isOperator()) {
+        if (node.isOperator()) {
             const rhs = this.toTree();
             const lhs = this.toTree();
             node.addChild(lhs);
             node.addChild(rhs);
-        } 
+        }
         return node;
     }
 
@@ -83,11 +85,11 @@ class Expression extends ASTNode {
     }
 
     public value(): any {
-        if(this._overridden !== null) {
+        if (this._overridden !== null) {
             return this._overridden;
         }
-        if(this.childCount() !== 1) {
-            throw new Error('Expected one child');
+        if (this.childCount() !== 1) {
+            throw new Error("Expected one child");
         }
         return this.children[0].value();
     }
@@ -101,31 +103,37 @@ class Expression extends ASTNode {
     }
 
     public get alias(): string | null {
-        if(this.firstChild() instanceof Reference && this._alias === null) {
+        if (this.firstChild() instanceof Reference && this._alias === null) {
             return (<Reference>this.firstChild()).identifier;
         }
         return this._alias;
     }
 
     public toString(): string {
-        if(this._alias !== null) {
+        if (this._alias !== null) {
             return `Expression (${this._alias})`;
         } else {
-            return 'Expression';
+            return "Expression";
         }
     }
     public reducers(): AggregateFunction[] {
-        if(this._reducers === null) {
-            this._reducers = [...this._extract_reducers()];
+        if (this._reducers === null) {
+            this._reducers = [...this._extract(this, AggregateFunction)];
         }
         return this._reducers;
     }
-    private *_extract_reducers(node: ASTNode = this): Generator<AggregateFunction> {
-        if(node instanceof AggregateFunction) {
+    public patterns(): PatternExpression[] {
+        if (this._patterns === null) {
+            this._patterns = [...this._extract(this, PatternExpression)];
+        }
+        return this._patterns;
+    }
+    private *_extract(node: ASTNode = this, of_type: any): Generator<any> {
+        if (node instanceof of_type) {
             yield node;
         }
-        for(const child of node.getChildren()) {
-            yield* this._extract_reducers(child);
+        for (const child of node.getChildren()) {
+            yield* this._extract(child, of_type);
         }
     }
     public mappable(): boolean {
@@ -139,4 +147,4 @@ class Expression extends ASTNode {
     }
 }
 
-export default Expression;
+export default Expression;

package/src/parsing/expressions/expression_map.ts

@@ -5,6 +5,9 @@ class ExpressionMap {
     public get(alias: string): Expression | undefined {
         return this._map.get(alias);
     }
+    public has(alias: string): boolean {
+        return this._map.has(alias);
+    }
     public set map(expressions: Expression[]) {
         this._map.clear();
         for (const expr of expressions) {

package/src/parsing/expressions/operator.ts

@@ -176,4 +176,22 @@ class Is extends Operator {
     }
 }
 
-export { Operator, Add, Subtract, Multiply, Divide, Modulo, Power, Equals, NotEquals, GreaterThan, LessThan, GreaterThanOrEqual, LessThanOrEqual, And, Or, Not, Is };
+export {
+    Operator,
+    Add,
+    Subtract,
+    Multiply,
+    Divide,
+    Modulo,
+    Power,
+    Equals,
+    NotEquals,
+    GreaterThan,
+    LessThan,
+    GreaterThanOrEqual,
+    LessThanOrEqual,
+    And,
+    Or,
+    Not,
+    Is,
+};

package/src/parsing/functions/function_factory.ts

@@ -1,42 +1,41 @@
+import AsyncFunction from "./async_function";
+import "./avg";
+import "./collect";
 import Function from "./function";
+import {
+    AsyncDataProvider,
+    FunctionMetadata,
+    getFunctionMetadata,
+    getRegisteredFunctionFactory,
+    getRegisteredFunctionMetadata,
+} from "./function_metadata";
+import "./functions";
+import "./join";
+import "./keys";
 import PredicateFunction from "./predicate_function";
-// Import built-in functions to ensure their @FunctionDef decorators run
-import "./sum";
-import "./collect";
-import "./avg";
-import "./range";
+import "./predicate_sum";
 import "./rand";
+import "./range";
+import "./replace";
 import "./round";
+import "./size";
 import "./split";
-import "./join";
-import "./keys";
-import "./to_json";
-import "./replace";
 import "./stringify";
-import "./size";
-import "./functions";
-import "./predicate_sum";
+// Import built-in functions to ensure their @FunctionDef decorators run
+import "./sum";
+import "./to_json";
 import "./type";
-import { 
-    FunctionMetadata, 
-    getRegisteredFunctionMetadata,
-    getFunctionMetadata,
-    getRegisteredFunctionFactory,
-    AsyncDataProvider
-} from "./function_metadata";
-import AsyncFunction from "./async_function";
-import { get } from "node:http";
 
 // Re-export AsyncDataProvider for backwards compatibility
 export { AsyncDataProvider };
 
 /**
  * Factory for creating function instances by name.
- * 
+ *
  * All functions are registered via the @FunctionDef decorator.
  * Maps function names (case-insensitive) to their corresponding implementation classes.
  * Supports built-in functions like sum, avg, collect, range, split, join, etc.
- * 
+ *
  * @example
  * ```typescript
  * const sumFunc = FunctionFactory.create("sum");
@@ -46,7 +45,7 @@ export { AsyncDataProvider };
 class FunctionFactory {
     /**
      * Gets an async data provider by name.
-     * 
+     *
      * @param name - The function name (case-insensitive)
      * @returns The async data provider, or undefined if not found
      */
@@ -56,7 +55,7 @@ class FunctionFactory {
 
     /**
      * Checks if a function name is registered as an async data provider.
-     * 
+     *
      * @param name - The function name (case-insensitive)
      * @returns True if the function is an async data provider
      */
@@ -66,7 +65,7 @@ class FunctionFactory {
 
     /**
      * Gets metadata for a specific function.
-     * 
+     *
      * @param name - The function name (case-insensitive)
      * @returns The function metadata, or undefined if not found
      */
@@ -76,56 +75,58 @@ class FunctionFactory {
 
     /**
      * Lists all registered functions with their metadata.
-     * 
+     *
      * @param options - Optional filter options
      * @returns Array of function metadata
      */
-    public static listFunctions(options?: { 
-        category?: string; 
+    public static listFunctions(options?: {
+        category?: string;
         asyncOnly?: boolean;
         syncOnly?: boolean;
     }): FunctionMetadata[] {
         const result: FunctionMetadata[] = [];
-        
+
         for (const meta of getRegisteredFunctionMetadata()) {
             if (options?.category && meta.category !== options.category) continue;
-            if (options?.asyncOnly && meta.category !== 'async') continue;
-            if (options?.syncOnly && meta.category === 'async') continue;
+            if (options?.asyncOnly && meta.category !== "async") continue;
+            if (options?.syncOnly && meta.category === "async") continue;
             result.push(meta);
         }
-        
+
         return result;
     }
 
     /**
      * Lists all registered function names.
-     * 
+     *
      * @returns Array of function names
      */
     public static listFunctionNames(): string[] {
-        return getRegisteredFunctionMetadata().map(m => m.name);
+        return getRegisteredFunctionMetadata().map((m) => m.name);
     }
 
     /**
      * Gets all function metadata as a JSON-serializable object for LLM consumption.
-     * 
+     *
      * @returns Object with functions grouped by category
      */
     public static toJSON(): { functions: FunctionMetadata[]; categories: string[] } {
         const functions = FunctionFactory.listFunctions();
-        const categories = [...new Set(functions.map(f => f.category).filter(Boolean))] as string[];
+        const categories = [
+            ...new Set(functions.map((f) => f.category).filter(Boolean)),
+        ] as string[];
         return { functions, categories };
     }
 
     /**
      * Creates a function instance by name.
-     * 
+     *
      * @param name - The function name (case-insensitive)
      * @returns A Function instance of the appropriate type
      */
     public static create(name: string): Function {
         const lowerName: string = name.toLowerCase();
-        
+
         // Check decorator-registered functions (built-ins use @FunctionDef)
         const decoratorFactory = getRegisteredFunctionFactory(lowerName);
         if (decoratorFactory) {
@@ -138,15 +139,15 @@ class FunctionFactory {
     /**
      * Creates a predicate function instance by name.
      * Predicate functions are used in WHERE clauses with quantifiers (e.g., ANY, ALL).
-     * 
+     *
      * @param name - The function name (case-insensitive)
      * @returns A PredicateFunction instance of the appropriate type
      */
     public static createPredicate(name: string): PredicateFunction {
         const lowerName: string = name.toLowerCase();
-        
+
         // Check decorator-registered predicate functions
-        const decoratorFactory = getRegisteredFunctionFactory(lowerName, 'predicate');
+        const decoratorFactory = getRegisteredFunctionFactory(lowerName, "predicate");
         if (decoratorFactory) {
             return decoratorFactory();
         }
@@ -156,13 +157,12 @@ class FunctionFactory {
 
     public static createAsync(name: string): AsyncFunction {
         const lowerName: string = name.toLowerCase();
-        const decoratorFactory = getRegisteredFunctionFactory(lowerName, 'async');
+        const decoratorFactory = getRegisteredFunctionFactory(lowerName, "async");
         if (decoratorFactory) {
             return decoratorFactory() as AsyncFunction;
         }
         throw new Error(`Unknown async function: ${name}`);
     }
-
 }
 
-export default FunctionFactory;
+export default FunctionFactory;

package/src/parsing/operations/call.ts

@@ -50,7 +50,9 @@ class Call extends Projection {
                 const record: Map<string, any> = new Map();
                 if (typeof item == "object" && !Array.isArray(item)) {
                     for (const [key, value] of Object.entries(item)) {
-                        record.set(key, value);
+                        if (this._map.has(key) || !this.hasYield) {
+                            record.set(key, value);
+                        }
                     }
                 } else {
                     record.set(DEFAULT_VARIABLE_NAME, item);

package/src/parsing/operations/create_node.ts

@@ -0,0 +1,39 @@
+import Database from "../../graph/database";
+import Node from "../../graph/node";
+import ASTNode from "../ast_node";
+import Operation from "./operation";
+
+class CreateNode extends Operation {
+    private _node: Node | null = null;
+    private _statement: ASTNode | null = null;
+    constructor(node: Node, statement: ASTNode) {
+        super();
+        this._node = node;
+        this._statement = statement;
+    }
+    public get node(): Node | null {
+        return this._node;
+    }
+    public get statement(): ASTNode | null {
+        return this._statement;
+    }
+    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.addNode(this._node, this._statement!);
+                resolve();
+            } catch (error) {
+                reject(error);
+            }
+        });
+    }
+    public get results(): Record<string, any>[] {
+        return [];
+    }
+}
+
+export default CreateNode;

package/src/parsing/operations/create_relationship.ts

@@ -0,0 +1,38 @@
+import Database from "../../graph/database";
+import Relationship from "../../graph/relationship";
+import ASTNode from "../ast_node";
+import Operation from "./operation";
+
+class CreateRelationship extends Operation {
+    private _relationship: Relationship | null = null;
+    private _statement: ASTNode | null = null;
+    constructor(relationship: Relationship, statement: ASTNode) {
+        super();
+        this._relationship = relationship;
+        this._statement = statement;
+    }
+    public get relationship(): Relationship | null {
+        return this._relationship;
+    }
+    public get statement(): ASTNode | null {
+        return this._statement;
+    }
+    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.addRelationship(this._relationship, this._statement!);
+                resolve();
+            } catch (error) {
+                reject(error);
+            }
+        });
+    }
+    public get results(): Record<string, any>[] {
+        return [];
+    }
+}
+export default CreateRelationship;

package/src/parsing/operations/match.ts

@@ -0,0 +1,31 @@
+import Pattern from "../../graph/pattern";
+import Patterns from "../../graph/patterns";
+import Operation from "./operation";
+
+class Match extends Operation {
+    private _patterns: Patterns | null = null;
+
+    constructor(patterns: Pattern[] = []) {
+        super();
+        this._patterns = new Patterns(patterns);
+    }
+    public get patterns(): Pattern[] {
+        return this._patterns ? this._patterns.patterns : [];
+    }
+    /**
+     * Executes the match operation by chaining the patterns together.
+     * After each pattern match, it continues to the next operation in the chain.
+     * @return Promise<void>
+     */
+    public async run(): Promise<void> {
+        await this._patterns!.initialize();
+        this._patterns!.toDoNext = async () => {
+            // Continue to the next operation after all patterns are matched
+            await this.next?.run();
+        };
+        // Kick off the graph pattern traversal
+        await this._patterns!.traverse();
+    }
+}
+
+export default Match;