leangraph 1.0.0

package/dist/executor.d.ts

@@ -0,0 +1,663 @@
+import { GraphDatabase } from "./db.js";
+/**
+ * Phase execution context - carries variable values between phases
+ *
+ * Cypher is inherently sequential. Each clause operates on variables from
+ * previous clauses. This context tracks:
+ * - nodeIds: Map variable names to node IDs (for nodes we've created/matched)
+ * - edgeIds: Map variable names to edge IDs (for edges we've created/matched)
+ * - values: Map variable names to arbitrary values (scalars, lists, aggregates)
+ * - rows: The current "row set" - multiple rows from MATCH or UNWIND
+ */
+export interface PhaseContext {
+    nodeIds: Map<string, string>;
+    edgeIds: Map<string, string>;
+    values: Map<string, unknown>;
+    rows: Array<Map<string, unknown>>;
+}
+export interface ExecutionResult {
+    success: true;
+    data: Record<string, unknown>[];
+    meta: {
+        count: number;
+        time_ms: number;
+    };
+}
+export interface ExecutionError {
+    success: false;
+    error: {
+        message: string;
+        position?: number;
+        line?: number;
+        column?: number;
+    };
+}
+export type QueryResponse = ExecutionResult | ExecutionError;
+export declare class Executor {
+    private db;
+    constructor(db: GraphDatabase);
+    /**
+     * Execute a Cypher query and return formatted results
+     */
+    execute(cypher: string, params?: Record<string, unknown>): QueryResponse;
+    /**
+     * Check if a query needs phase-based execution and execute it if so.
+     *
+     * Phase boundaries are detected when:
+     * 1. A WITH clause contains an aggregate function (collect, count, sum, etc.)
+     * 2. An UNWIND clause references a variable that doesn't exist yet (from previous phase)
+     * 3. A clause references a variable computed from aggregation
+     *
+     * Returns null if the query can be handled by standard SQL translation.
+     */
+    private tryPhasedExecution;
+    /**
+     * Validate MERGE variables - cannot MERGE a variable that's already bound by MATCH
+     *
+     * The rule is: you cannot MERGE a node pattern that is just a variable already
+     * bound by MATCH. MATCH guarantees the node exists, so MERGE would be meaningless.
+     *
+     * However, you CAN use already-bound variables in:
+     * - Relationship MERGE endpoints: MATCH (a), (b) MERGE (a)-[:REL]->(b) is valid
+     * - Subsequent MERGE clauses: MERGE (c) MERGE (c) is valid (second one just matches)
+     *
+     * Additionally: you cannot impose new predicates (labels/properties) on a variable
+     * that is already bound. E.g., CREATE (a:Foo) MERGE (a)-[:R]->(a:Bar) is invalid
+     * because it tries to impose label :Bar on variable 'a' which is already bound.
+     */
+    private validateMergeVariables;
+    /**
+     * Validate that SET assignment values do not reference undefined variables.
+     *
+     * Example (invalid):
+     *   MATCH (a) SET a.name = missing RETURN a
+     */
+    private validateSetClauseValueVariables;
+    /**
+     * Validate that ORDER BY expressions do not reference undefined or out-of-scope variables.
+     *
+     * Examples (invalid):
+     *   MATCH (a), (b) WITH a ORDER BY b RETURN a
+     *   MATCH (a) RETURN a.name AS name ORDER BY missing
+     */
+    private validateOrderByVariables;
+    private validateOrderByVariablesInQuery;
+    private validateSetClauseValueVariablesInQuery;
+    private validateExpressionVariablesInScope;
+    private validateWhereConditionVariablesInScope;
+    /**
+     * Collect all node and relationship variables from a pattern
+     */
+    private collectPatternVariables;
+    /**
+     * Check if a MERGE pattern tries to use an already-bound variable
+     */
+    private checkMergePatternForBoundVariables;
+    /**
+     * Check if a MERGE pattern tries to impose new labels/properties on an already-bound variable.
+     * E.g., CREATE (a:Foo) MERGE (a)-[:R]->(a:Bar) is invalid because :Bar conflicts with :Foo
+     */
+    private checkMergePatternForLabelConflicts;
+    /**
+     * Validate that MERGE properties in the AST don't contain explicit null values.
+     * MERGE cannot use null property values because null = null is undefined in Cypher.
+     * This validates the original AST properties, not the resolved values,
+     * to distinguish between explicit null (invalid) and variable references that may resolve to null.
+     */
+    private validateMergeAstPropertiesNotNull;
+    /**
+     * Detect phase boundaries in a query.
+     *
+     * A phase boundary occurs when:
+     * - A WITH clause contains aggregate functions (collect, count, sum, avg, min, max)
+     * - An UNWIND clause references a variable from a previous WITH aggregate
+     */
+    private detectPhases;
+    /**
+     * Get all variable names referenced in an expression
+     */
+    private getExpressionVariables;
+    /**
+     * Get all variable names referenced in a WHERE condition
+     */
+    private getWhereVariables;
+    /**
+     * Get all variables referenced by a clause (not defined, just referenced)
+     */
+    private getClauseReferencedVariables;
+    /**
+     * Track variables defined by a clause
+     */
+    private trackClauseVariables;
+    /**
+     * Check if an expression contains aggregate functions
+     */
+    private expressionHasAggregate;
+    /**
+     * Check if a WhereCondition contains non-deterministic functions
+     */
+    private whereConditionHasNonDeterministic;
+    /**
+     * Check if an expression contains non-deterministic functions (like rand())
+     * These expressions cannot be safely inlined by the translator and require
+     * phased execution to materialize intermediate results.
+     */
+    private expressionHasNonDeterministic;
+    /**
+     * Execute a single phase with the given context
+     */
+    private executePhase;
+    /**
+     * Execute a single clause and update context
+     */
+    private executeClause;
+    /**
+     * Execute CREATE clause
+     */
+    private executeCreateClause;
+    /**
+     * Execute MERGE clause
+     *
+     * MERGE semantics:
+     * - For each input row, find nodes/edges matching the MERGE pattern
+     * - If match found, bind to existing nodes (creating Cartesian product with all matches)
+     * - If no match, create new nodes/edges
+     *
+     * For MERGE (b) with no label/properties after MATCH (a):
+     * - If ANY nodes exist, match ALL of them → Cartesian product with input rows
+     * - If NO nodes exist, create one node per input row
+     */
+    private executeMergeClause;
+    /**
+     * Build a path object from relationship patterns.
+     * Returns an array alternating [nodeProps, edgeProps, nodeProps, ...]
+     * or null if the path cannot be constructed.
+     */
+    private buildPathFromPatterns;
+    /**
+     * Execute MERGE for a node pattern within a row context
+     * Returns multiple rows if multiple nodes match (Cartesian product)
+     */
+    private executeMergeNodeInContext;
+    /**
+     * Execute MERGE for a relationship pattern within a row context
+     * Returns multiple rows if multiple matches found
+     */
+    private executeMergeRelationshipInContext;
+    /**
+     * Execute CREATE for a single node pattern within a row context
+     */
+    private executeCreateNodeInContext;
+    /**
+     * Extract a node ID from a value that could be:
+     * - A raw UUID string
+     * - A JSON string like '{"name":"Alice","_nf_id":"uuid"}'
+     * - An object with _nf_id property
+     */
+    private extractNodeId;
+    /**
+     * Execute CREATE for a relationship pattern within a row context
+     */
+    private executeCreateRelationshipInContext;
+    /**
+     * Execute WITH clause
+     */
+    private executeWithClause;
+    /**
+     * Sort rows by ORDER BY expressions
+     */
+    private sortRowsByOrderBy;
+    /**
+     * Compare two values for sorting (Cypher ordering semantics)
+     */
+    private compareValues;
+    /**
+     * Evaluate a literal expression (for SKIP/LIMIT)
+     */
+    private evaluateLiteralExpression;
+    /**
+     * Execute UNWIND clause
+     */
+    private executeUnwindClause;
+    /**
+     * Execute MATCH clause
+     */
+    private executeMatchClause;
+    /**
+     * Execute a MATCH clause for a single input row, using bound variable values as constraints
+     */
+    private executeMatchForRow;
+    /**
+     * Execute a MATCH clause for a single input row using SQL translation.
+     * This handles complex patterns (multi-hop, anonymous nodes) by:
+     * 1. Translating the MATCH to SQL
+     * 2. Adding WHERE constraints for bound variables (matching by node ID)
+     * 3. Executing and returning results
+     */
+    private executeMatchWithSqlForRow;
+    /**
+     * Transform a MATCH clause to substitute context variable references with parameter references.
+     * This converts WHERE conditions like `n.id = foo` (where foo is from context)
+     * to `n.id = $_ctx_foo` so the translator can handle it.
+     */
+    private transformClauseForContext;
+    /**
+     * Transform a WHERE condition to substitute context variable references with parameter references
+     */
+    private transformWhereForContext;
+    /**
+     * Transform an expression to substitute context variable references with parameter references
+     */
+    private transformExpressionForContext;
+    /**
+     * Check if a WHERE condition references context variables
+     */
+    private whereReferencesContextVars;
+    /**
+     * Check if an expression references a context variable (not a pattern variable)
+     */
+    private expressionReferencesContextVar;
+    /**
+     * Find a pattern with a variable-length edge where the edge variable is bound to a list
+     * Returns the pattern info if found, null otherwise
+     */
+    private findBoundRelationshipListPattern;
+    /**
+     * Execute MATCH with a pre-bound relationship list
+     * e.g., MATCH (first)-[rs*]->(second) where rs = [r1, r2, ...]
+     * This finds the path by following the exact sequence of relationships in rs
+     */
+    private executeMatchWithBoundRelList;
+    /**
+     * Build RETURN items for all variables in a MATCH pattern
+     */
+    private buildReturnItemsForMatch;
+    /**
+     * Execute RETURN clause
+     */
+    private executeReturnClause;
+    /**
+     * Execute SET clause
+     */
+    private executeSetClause;
+    /**
+     * Execute DELETE clause
+     */
+    private executeDeleteClause;
+    /**
+     * Evaluate an expression in the context of a single row
+     */
+    private evaluateExpressionInRow;
+    /**
+     * Evaluate a function expression in a row context
+     */
+    private evaluateFunctionInRow;
+    /**
+     * Evaluate a binary expression in a row context
+     */
+    private evaluateBinaryInRow;
+    /**
+     * Evaluate an aggregate expression across all rows
+     */
+    private evaluateAggregateExpression;
+    /**
+     * Evaluate a WHERE condition in a row context
+     */
+    private evaluateWhereInRow;
+    /**
+     * Resolve properties with row context
+     */
+    private resolvePropertiesInContext;
+    /**
+     * Resolve a property value with row context
+     */
+    private resolvePropertyValueInContext;
+    /**
+     * Convert context to result format
+     */
+    private contextToResults;
+    /**
+     * Handle UNWIND with CREATE pattern
+     * UNWIND expands an array and executes CREATE for each element
+     */
+    private tryUnwindCreateExecution;
+    /**
+     * Evaluate a WITH clause WHERE condition against created nodes
+     */
+    private evaluateWithWhereCondition;
+    /**
+     * Evaluate a WITH clause WHERE condition using captured property values
+     * This is used for patterns like: WITH n.num AS num ... DELETE n ... WITH num WHERE num % 2 = 0
+     */
+    private evaluateWithWhereConditionWithPropertyAliases;
+    /**
+     * Evaluate an expression using captured property values (for property alias references)
+     */
+    private evaluateExpressionWithPropertyAliases;
+    /**
+     * Evaluate an expression for filtering in UNWIND+CREATE+WITH context
+     */
+    private evaluateExpressionForFilter;
+    /**
+     * Handle UNWIND + MERGE pattern (optionally with WITH clauses between)
+     * This requires special handling to resolve UNWIND variables in MERGE patterns
+     */
+    private tryUnwindMergeExecution;
+    /**
+     * Apply a WITH clause to transform rows
+     */
+    private applyWithClauseToRows;
+    /**
+     * Evaluate a WHERE condition on a row context
+     */
+    private evaluateWhereConditionOnRow;
+    /**
+     * Evaluate an expression in the context of a row
+     */
+    private evaluateExpressionOnRow;
+    /**
+     * Check if a value is a parameter reference
+     */
+    private isParamRef;
+    /**
+     * Check if a value is a variable reference
+     */
+    private isVarRef;
+    /**
+     * Resolve MERGE pattern properties from a row context
+     */
+    private resolvePropertiesFromRow;
+    /**
+     * Convert expression to string for alias/key purposes
+     */
+    private expressionToString;
+    /**
+     * Compare two values with operator
+     */
+    private evaluateComparison;
+    /**
+     * Handle MATCH+WITH(COLLECT)+UNWIND+RETURN pattern
+     * This requires a subquery for the aggregate function because SQLite doesn't
+     * allow aggregate functions directly inside json_each()
+     */
+    private tryCollectUnwindExecution;
+    /**
+     * Handle MATCH+WITH(COLLECT)+DELETE[expr] pattern
+     * This handles queries like:
+     *   MATCH (:User)-[:FRIEND]->(n)
+     *   WITH collect(n) AS friends
+     *   DETACH DELETE friends[$friendIndex]
+     */
+    private tryCollectDeleteExecution;
+    /**
+     * Evaluate a DELETE expression (like friends[$index]) with collected context
+     */
+    private evaluateDeleteExpression;
+    /**
+     * Evaluate UNWIND expressions to get the arrays to iterate over
+     */
+    private evaluateUnwindExpressions;
+    /**
+     * Evaluate a SKIP or LIMIT expression to a number
+     */
+    private evaluateSkipLimitExpression;
+    /**
+     * Evaluate an expression that should return a list
+     */
+    private evaluateListExpression;
+    /**
+     * Evaluate a simple expression (literals, parameters, basic arithmetic)
+     */
+    private evaluateSimpleExpression;
+    /**
+     * Generate cartesian product of arrays
+     */
+    private generateCartesianProduct;
+    /**
+     * Resolve properties, including unwind variable references and binary expressions
+     */
+    private resolvePropertiesWithUnwind;
+    /**
+     * Resolve a single property value, handling binary expressions recursively
+     */
+    private resolvePropertyValueWithUnwind;
+    /**
+     * Evaluate a function call within a property value context
+     */
+    private evaluateFunctionInProperty;
+    /**
+     * Execute CREATE relationship pattern with unwind context
+     */
+    private executeCreateRelationshipPatternWithUnwind;
+    /**
+     * Handle CREATE...RETURN pattern by creating nodes/edges and then querying them back
+     */
+    private tryCreateReturnExecution;
+    /**
+     * Handle MATCH...WITH...MATCH patterns where the second MATCH has a variable-length
+     * pattern with a bound relationship list from the WITH clause.
+     *
+     * Example: MATCH ()-[r1]->()-[r2]->() WITH [r1, r2] AS rs MATCH (a)-[rs*]->(b) RETURN a, b
+     *
+     * The second MATCH should follow the exact sequence of relationships in rs.
+     * Returns null if this pattern is not detected.
+     */
+    private tryBoundRelationshipListExecution;
+    /**
+     * Handle MERGE clauses that need special execution (relationship patterns or ON CREATE/MATCH SET)
+     * Returns null if this is not a MERGE pattern that needs special handling
+     */
+    private tryMergeExecution;
+    /**
+     * Execute multiple MERGE clauses in sequence, handling path expressions
+     */
+    private executeMultipleMergeClauses;
+    /**
+     * Execute a MERGE for a node pattern, tracking the result
+     */
+    private executeMergeNodeWithTracking;
+    /**
+     * Execute a MERGE for a relationship pattern, tracking the result
+     */
+    private executeMergeRelationshipWithTracking;
+    /**
+     * Build a path from patterns using tracked nodes and edges
+     */
+    private buildPathFromPatternsWithTracking;
+    /**
+     * Process RETURN clause with paths support
+     */
+    private processReturnClauseWithPaths;
+    /**
+     * Execute a MERGE clause with ON CREATE SET and/or ON MATCH SET
+     *
+     * This needs to handle the case where MATCH returns multiple rows.
+     * For each MATCH row, we execute the MERGE (with its ON CREATE SET / ON MATCH SET)
+     * and collect results for RETURN.
+     */
+    private executeMergeWithSetClauses;
+    /**
+     * Execute a simple node MERGE for a single input row
+     * Used when there's a MATCH before MERGE - this handles one row at a time
+     */
+    private executeMergeNodeForRow;
+    /**
+     * Execute a relationship MERGE for a single input row
+     */
+    private executeMergeRelationshipForRow;
+    /**
+     * Execute a relationship MERGE for a single input row, tracking edges for aggregation
+     * This version doesn't process RETURN - it just executes the MERGE and captures the edge info
+     */
+    private executeMergeRelationshipForRowWithTracking;
+    /**
+     * Process RETURN clause with aggregate functions over multiple rows of matched nodes/edges
+     */
+    private processAggregateReturn;
+    /**
+     * Resolve properties with access to matched nodes for property references
+     */
+    private resolvePropertiesWithMatchedNodes;
+    /**
+     * Resolve a single property value with matched nodes context
+     */
+    private resolvePropertyValueWithMatchedNodes;
+    /**
+     * Evaluate an expression with matched nodes context
+     */
+    private evaluateExpressionWithMatchedNodes;
+    /**
+     * Execute a simple node MERGE
+     */
+    private executeMergeNode;
+    /**
+     * Execute a relationship MERGE: MERGE (a)-[:TYPE]->(b)
+     * Handles multiple scenarios:
+     * 1. MATCH (a), (b) MERGE (a)-[:REL]->(b) - both nodes already matched
+     * 2. MATCH (a) MERGE (a)-[:REL]->(b:Label {props}) - source matched, target to find/create
+     * 3. MERGE (a:Label)-[:REL]->(b:Label) - entire pattern to find/create
+     */
+    private executeMergeRelationship;
+    /**
+     * Find an existing node matching the pattern, or create a new one
+     */
+    private findOrCreateNode;
+    /**
+     * Process a RETURN clause using matched nodes and edges
+     */
+    private processReturnClauseWithEdges;
+    /**
+     * Process a RETURN clause using matched nodes
+     */
+    private processReturnClause;
+    /**
+     * Evaluate an expression for RETURN clause
+     */
+    private evaluateReturnExpression;
+    /**
+     * Execute a CREATE relationship pattern, tracking created IDs
+     */
+    private executeCreateRelationshipPattern;
+    /**
+     * Get a name for an expression (for default aliases)
+     */
+    private getExpressionName;
+    /**
+     * Detect and handle patterns that need multi-phase execution:
+     * - MATCH...CREATE that references matched variables
+     * - MATCH...SET that updates matched nodes/edges via relationships
+     * - MATCH...DELETE that deletes matched nodes/edges via relationships
+     * Returns null if this is not a multi-phase pattern, otherwise returns the result data.
+     */
+    private tryMultiPhaseExecution;
+    /**
+     * Collect variable names from a pattern
+     */
+    private collectVariablesFromPattern;
+    /**
+     * Find variables in CREATE that reference MATCH variables (with alias support)
+     */
+    private findReferencedVariablesWithAliases;
+    /**
+     * Validate that all variable references in CREATE clause properties are defined.
+     * Throws an error if an undefined variable is referenced.
+     */
+    private validateCreatePropertyVariables;
+    /**
+     * Check a properties object for undefined variable references.
+     * Throws an error if found.
+     */
+    private validatePropertiesForUndefinedVariables;
+    /**
+     * Recursively check a value for undefined variable references.
+     */
+    private validateValueForUndefinedVariables;
+    /**
+     * Execute a complex pattern with MATCH...CREATE/SET/DELETE in multiple phases
+     */
+    private executeMultiPhaseGeneral;
+    /**
+     * Collect variable names referenced in a RETURN clause
+     */
+    private collectReturnVariables;
+    /**
+     * Collect variable names from an expression
+     */
+    private collectExpressionVariables;
+    /**
+     * Build RETURN results from resolved node/edge IDs
+     */
+    private buildReturnResults;
+    /**
+     * Execute SET clause with pre-resolved node IDs
+     */
+    private executeSetWithResolvedIds;
+    /**
+     * Evaluate an object expression to get its key-value pairs
+     */
+    private evaluateObjectExpression;
+    /**
+     * Execute DELETE clause with pre-resolved node/edge IDs
+     * Returns the set of variables that were deleted
+     */
+    private executeDeleteWithResolvedIds;
+    /**
+     * Evaluate an expression to get its value
+     * Note: For property and binary expressions that reference nodes, use evaluateExpressionWithContext
+     */
+    private evaluateExpression;
+    /**
+     * Evaluate an expression with access to node/edge context for property lookups
+     */
+    private evaluateExpressionWithContext;
+    /**
+     * Execute a CREATE clause with pre-resolved node IDs for referenced variables
+     * The resolvedIds map is mutated to include newly created node IDs
+     */
+    private executeCreateWithResolvedIds;
+    /**
+     * Create a relationship where some endpoints reference pre-existing nodes.
+     * The resolvedIds map is mutated to include newly created node IDs.
+     */
+    private createRelationshipWithResolvedIds;
+    /**
+     * Resolve parameter references and binary expressions in properties
+     */
+    private resolveProperties;
+    /**
+     * Type guard for relationship patterns
+     */
+    private isRelationshipPattern;
+    /**
+     * Format raw database results into a more usable structure
+     */
+    private formatResults;
+    /**
+     * Recursively parse JSON strings in a value
+     * Also normalizes labels (single-element arrays become strings)
+     */
+    private deepParseJson;
+    /**
+     * Normalize label to JSON string for storage
+     * Handles both single labels and multiple labels
+     */
+    private normalizeLabelToJson;
+    /**
+     * Normalize label for output (from database JSON to user-friendly format)
+     * Single label: return string, multiple labels: return array
+     */
+    private normalizeLabelForOutput;
+    /**
+     * Generate SQL condition for label matching
+     * Supports both single and multiple labels
+     */
+    private generateLabelCondition;
+    /**
+     * Extract id() function conditions from a WHERE clause
+     * For conditions like: WHERE id(n) = $id
+     * Populates the idConditions map with variable -> id value mappings
+     */
+    private extractIdConditions;
+}
+export declare function executeQuery(db: GraphDatabase, cypher: string, params?: Record<string, unknown>): QueryResponse;
+//# sourceMappingURL=executor.d.ts.map

package/dist/executor.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"executor.d.ts","sourceRoot":"","sources":["../src/executor.ts"],"names":[],"mappings":"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"}