@lowgular/code-graph 0.0.1 → 0.1.1

package/libs/cli/cypher/src/lib/docs/features/where-operators.feature.js

@@ -1,302 +0,0 @@
-var __defProp = Object.defineProperty;
-var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
-var __getOwnPropNames = Object.getOwnPropertyNames;
-var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __export = (target, all) => {
-  for (var name in all)
-    __defProp(target, name, { get: all[name], enumerable: true });
-};
-var __copyProps = (to, from, except, desc) => {
-  if (from && typeof from === "object" || typeof from === "function") {
-    for (let key of __getOwnPropNames(from))
-      if (!__hasOwnProp.call(to, key) && key !== except)
-        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
-  }
-  return to;
-};
-var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
-var where_operators_feature_exports = {};
-__export(where_operators_feature_exports, {
-  WHERE_OPERATORS_FEATURES: () => WHERE_OPERATORS_FEATURES
-});
-module.exports = __toCommonJS(where_operators_feature_exports);
-var import_graph2 = require("../../graph.stub");
-const WHERE_OPERATORS_FEATURES = [
-  {
-    name: "Filter with != operator",
-    description: "Use != operator to filter nodes where property is not equal to a value.",
-    graphFactory: () => new import_graph2.GraphBuilder().addNode((0, import_graph2.stubNode)("1", "A", { count: 3 })).addNode((0, import_graph2.stubNode)("2", "A", { count: 5 })).addNode((0, import_graph2.stubNode)("3", "A", { count: 7 })).build(),
-    queries: [["MATCH (a:A)", "WHERE a.count != 5", "RETURN a"]],
-    results: [
-      {
-        a: {
-          id: "1"
-        }
-      },
-      {
-        a: {
-          id: "3"
-        }
-      }
-    ]
-  },
-  {
-    name: "Filter with > operator",
-    description: "Use > operator to filter nodes where property is greater than a value.",
-    graphFactory: () => new import_graph2.GraphBuilder().addNode((0, import_graph2.stubNode)("1", "A", { count: 3 })).addNode((0, import_graph2.stubNode)("2", "A", { count: 5 })).addNode((0, import_graph2.stubNode)("3", "A", { count: 7 })).addNode((0, import_graph2.stubNode)("4", "A", { count: 10 })).build(),
-    queries: [["MATCH (a:A)", "WHERE a.count > 5", "RETURN a"]],
-    results: [
-      {
-        a: {
-          id: "3"
-        }
-      },
-      {
-        a: {
-          id: "4"
-        }
-      }
-    ]
-  },
-  {
-    name: "Filter with < operator",
-    description: "Use < operator to filter nodes where property is less than a value.",
-    graphFactory: () => new import_graph2.GraphBuilder().addNode((0, import_graph2.stubNode)("1", "A", { count: 3 })).addNode((0, import_graph2.stubNode)("2", "A", { count: 5 })).addNode((0, import_graph2.stubNode)("3", "A", { count: 7 })).build(),
-    queries: [["MATCH (a:A)", "WHERE a.count < 5", "RETURN a"]],
-    results: [
-      {
-        a: {
-          id: "1"
-        }
-      }
-    ]
-  },
-  {
-    name: "Filter with >= operator",
-    description: "Use >= operator to filter nodes where property is greater than or equal to a value.",
-    graphFactory: () => new import_graph2.GraphBuilder().addNode((0, import_graph2.stubNode)("1", "A", { count: 3 })).addNode((0, import_graph2.stubNode)("2", "A", { count: 5 })).addNode((0, import_graph2.stubNode)("3", "A", { count: 7 })).build(),
-    queries: [["MATCH (a:A)", "WHERE a.count >= 5", "RETURN a"]],
-    results: [
-      {
-        a: {
-          id: "2"
-        }
-      },
-      {
-        a: {
-          id: "3"
-        }
-      }
-    ]
-  },
-  {
-    name: "Filter with <= operator",
-    description: "Use <= operator to filter nodes where property is less than or equal to a value.",
-    graphFactory: () => new import_graph2.GraphBuilder().addNode((0, import_graph2.stubNode)("1", "A", { count: 3 })).addNode((0, import_graph2.stubNode)("2", "A", { count: 5 })).addNode((0, import_graph2.stubNode)("3", "A", { count: 7 })).build(),
-    queries: [["MATCH (a:A)", "WHERE a.count <= 5", "RETURN a"]],
-    results: [
-      {
-        a: {
-          id: "1"
-        }
-      },
-      {
-        a: {
-          id: "2"
-        }
-      }
-    ]
-  },
-  {
-    name: "Filter with IN operator (strings)",
-    description: "Use IN operator to filter nodes where property value is in a list of strings.",
-    graphFactory: () => new import_graph2.GraphBuilder().addNode((0, import_graph2.stubNode)("1", "A", { type: "X" })).addNode((0, import_graph2.stubNode)("2", "A", { type: "Y" })).addNode((0, import_graph2.stubNode)("3", "A", { type: "Z" })).build(),
-    queries: [["MATCH (a:A)", 'WHERE a.type IN ["X", "Y"]', "RETURN a"]],
-    results: [
-      {
-        a: {
-          id: "1"
-        }
-      },
-      {
-        a: {
-          id: "2"
-        }
-      }
-    ]
-  },
-  {
-    name: "Filter with IN operator (numbers)",
-    description: "Use IN operator to filter nodes where property value is in a list of numbers.",
-    graphFactory: () => new import_graph2.GraphBuilder().addNode((0, import_graph2.stubNode)("1", "A", { count: 3 })).addNode((0, import_graph2.stubNode)("2", "A", { count: 5 })).addNode((0, import_graph2.stubNode)("3", "A", { count: 7 })).addNode((0, import_graph2.stubNode)("4", "A", { count: 9 })).build(),
-    queries: [["MATCH (a:A)", "WHERE a.count IN [5, 7, 10]", "RETURN a"]],
-    results: [
-      {
-        a: {
-          id: "2"
-        }
-      },
-      {
-        a: {
-          id: "3"
-        }
-      }
-    ]
-  },
-  {
-    name: "Filter with NOT IN operator (strings)",
-    description: "Use NOT IN operator to filter nodes where property value is not in a list of strings.",
-    graphFactory: () => new import_graph2.GraphBuilder().addNode((0, import_graph2.stubNode)("1", "A", { type: "X" })).addNode((0, import_graph2.stubNode)("2", "A", { type: "Y" })).addNode((0, import_graph2.stubNode)("3", "A", { type: "Z" })).build(),
-    queries: [["MATCH (a:A)", 'WHERE a.type NOT IN ["X", "Y"]', "RETURN a"]],
-    results: [
-      {
-        a: {
-          id: "3"
-        }
-      }
-    ]
-  },
-  {
-    name: "Filter with NOT IN operator (numbers)",
-    description: "Use NOT IN operator to filter nodes where property value is not in a list of numbers.",
-    graphFactory: () => new import_graph2.GraphBuilder().addNode((0, import_graph2.stubNode)("1", "A", { count: 3 })).addNode((0, import_graph2.stubNode)("2", "A", { count: 5 })).addNode((0, import_graph2.stubNode)("3", "A", { count: 7 })).addNode((0, import_graph2.stubNode)("4", "A", { count: 10 })).build(),
-    queries: [["MATCH (a:A)", "WHERE a.count NOT IN [5, 7]", "RETURN a"]],
-    results: [
-      {
-        a: {
-          id: "1"
-        }
-      },
-      {
-        a: {
-          id: "4"
-        }
-      }
-    ]
-  },
-  {
-    name: "Filter with IS NULL operator",
-    description: "Use IS NULL to filter nodes where a property is null or does not exist.",
-    graphFactory: () => new import_graph2.GraphBuilder().addNode((0, import_graph2.stubNode)("1", "A", { value: null })).addNode((0, import_graph2.stubNode)("2", "A", { value: "test" })).addNode((0, import_graph2.stubNode)("3", "A", {})).build(),
-    queries: [["MATCH (a:A)", "WHERE a.value IS NULL", "RETURN a"]],
-    results: [
-      {
-        a: {
-          id: "1"
-        }
-      },
-      {
-        a: {
-          id: "3"
-        }
-      }
-    ]
-  },
-  {
-    name: "Filter with IS NOT NULL operator",
-    description: "Use IS NOT NULL to filter nodes where a property exists and is not null.",
-    graphFactory: () => new import_graph2.GraphBuilder().addNode((0, import_graph2.stubNode)("1", "A", { value: null })).addNode((0, import_graph2.stubNode)("2", "A", { value: "test" })).addNode((0, import_graph2.stubNode)("3", "A", {})).build(),
-    queries: [["MATCH (a:A)", "WHERE a.value IS NOT NULL", "RETURN a"]],
-    results: [
-      {
-        a: {
-          id: "2"
-        }
-      }
-    ]
-  },
-  {
-    name: "Filter with STARTS WITH operator",
-    description: "Use STARTS WITH operator to filter nodes where a string property starts with a specific value.",
-    graphFactory: () => new import_graph2.GraphBuilder().addNode((0, import_graph2.stubNode)("1", "A", { name: "apple" })).addNode((0, import_graph2.stubNode)("2", "A", { name: "application" })).addNode((0, import_graph2.stubNode)("3", "A", { name: "banana" })).addNode((0, import_graph2.stubNode)("4", "A", { name: "cherry" })).build(),
-    queries: [["MATCH (a:A)", "WHERE a.name STARTS WITH 'app'", "RETURN a"]],
-    results: [
-      {
-        a: {
-          id: "1"
-        }
-      },
-      {
-        a: {
-          id: "2"
-        }
-      }
-    ]
-  },
-  {
-    name: "Filter with ENDS WITH operator",
-    description: "Use ENDS WITH operator to filter nodes where a string property ends with a specific value.",
-    graphFactory: () => new import_graph2.GraphBuilder().addNode((0, import_graph2.stubNode)("1", "A", { name: "apple" })).addNode((0, import_graph2.stubNode)("2", "A", { name: "pineapple" })).addNode((0, import_graph2.stubNode)("3", "A", { name: "banana" })).addNode((0, import_graph2.stubNode)("4", "A", { name: "cherry" })).build(),
-    queries: [["MATCH (a:A)", "WHERE a.name ENDS WITH 'le'", "RETURN a"]],
-    results: [
-      {
-        a: {
-          id: "1"
-        }
-      },
-      {
-        a: {
-          id: "2"
-        }
-      }
-    ]
-  },
-  {
-    name: "Filter with CONTAINS operator",
-    description: "Use CONTAINS operator to filter nodes where a string property contains a specific value.",
-    graphFactory: () => new import_graph2.GraphBuilder().addNode((0, import_graph2.stubNode)("1", "A", { name: "apple" })).addNode((0, import_graph2.stubNode)("2", "A", { name: "pineapple" })).addNode((0, import_graph2.stubNode)("3", "A", { name: "banana" })).addNode((0, import_graph2.stubNode)("4", "A", { name: "cherry" })).build(),
-    queries: [["MATCH (a:A)", "WHERE a.name CONTAINS 'pp'", "RETURN a"]],
-    results: [
-      {
-        a: {
-          id: "1"
-        }
-      },
-      {
-        a: {
-          id: "2"
-        }
-      }
-    ]
-  },
-  {
-    name: "Filter with =~ regex operator (letters only)",
-    description: "Use =~ operator to filter nodes where a string property matches a regex pattern. This example matches strings containing only lowercase letters.",
-    graphFactory: () => new import_graph2.GraphBuilder().addNode((0, import_graph2.stubNode)("1", "A", { name: "apple" })).addNode((0, import_graph2.stubNode)("2", "A", { name: "application" })).addNode((0, import_graph2.stubNode)("3", "A", { name: "banana" })).addNode((0, import_graph2.stubNode)("4", "A", { name: "cherry123" })).build(),
-    queries: [["MATCH (a:A)", "WHERE a.name =~ '^[a-z]+$'", "RETURN a"]],
-    results: [
-      {
-        a: {
-          id: "1"
-        }
-      },
-      {
-        a: {
-          id: "2"
-        }
-      },
-      {
-        a: {
-          id: "3"
-        }
-      }
-    ]
-  },
-  {
-    name: "Filter with =~ regex operator (ends with pattern)",
-    description: 'Use =~ operator to filter nodes where a string property matches a regex pattern. This example matches strings ending with "123".',
-    graphFactory: () => new import_graph2.GraphBuilder().addNode((0, import_graph2.stubNode)("1", "A", { name: "apple" })).addNode((0, import_graph2.stubNode)("2", "A", { name: "application" })).addNode((0, import_graph2.stubNode)("3", "A", { name: "banana" })).addNode((0, import_graph2.stubNode)("4", "A", { name: "cherry123" })).build(),
-    queries: [["MATCH (a:A)", "WHERE a.name =~ '.*123$'", "RETURN a"]],
-    results: [
-      {
-        a: {
-          id: "4"
-        }
-      }
-    ]
-  }
-];
-// Annotate the CommonJS export names for ESM import in node:
-0 && (module.exports = {
-  WHERE_OPERATORS_FEATURES
-});

package/libs/cli/cypher/src/lib/docs/prompts.js

@@ -1,36 +0,0 @@
-var __defProp = Object.defineProperty;
-var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
-var __getOwnPropNames = Object.getOwnPropertyNames;
-var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __export = (target, all) => {
-  for (var name in all)
-    __defProp(target, name, { get: all[name], enumerable: true });
-};
-var __copyProps = (to, from, except, desc) => {
-  if (from && typeof from === "object" || typeof from === "function") {
-    for (let key of __getOwnPropNames(from))
-      if (!__hasOwnProp.call(to, key) && key !== except)
-        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
-  }
-  return to;
-};
-var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
-var prompts_exports = {};
-__export(prompts_exports, {
-  FUNCTIONALITY_RESEARCH: () => FUNCTIONALITY_RESEARCH
-});
-module.exports = __toCommonJS(prompts_exports);
-const FUNCTIONALITY_RESEARCH = `you are a cypher expert that needs to implement the cypher query language from neo4j.
-
-There is a project that has a lot of it already done and is located in libs/cli/cypher.
-Follow this step by step:
-
-- read the docs in libs/cli/cypher/src/lib/docs: that will explain you current supported and unsupported features as well as contrains and limitations
-- read the .spec.ts test files to understand how it works in real life
-- read the source files: index.ts, lexer.ts, parser.ts, validator.ts, executor.ts - this is the core of the project and you will need to understand how it works
-
-`;
-// Annotate the CommonJS export names for ESM import in node:
-0 && (module.exports = {
-  FUNCTIONALITY_RESEARCH
-});

package/libs/cli/cypher/src/lib/docs/specs.js

@@ -1,181 +0,0 @@
-var __defProp = Object.defineProperty;
-var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
-var __getOwnPropNames = Object.getOwnPropertyNames;
-var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __export = (target, all) => {
-  for (var name in all)
-    __defProp(target, name, { get: all[name], enumerable: true });
-};
-var __copyProps = (to, from, except, desc) => {
-  if (from && typeof from === "object" || typeof from === "function") {
-    for (let key of __getOwnPropNames(from))
-      if (!__hasOwnProp.call(to, key) && key !== except)
-        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
-  }
-  return to;
-};
-var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
-var specs_exports = {};
-__export(specs_exports, {
-  CYPHER_CONSTRAINTS: () => CYPHER_CONSTRAINTS,
-  CYPHER_FORBIDDEN_FEATURES: () => CYPHER_FORBIDDEN_FEATURES,
-  MATCH_BASICS: () => MATCH_BASICS,
-  RELATIONSHIP_ADVANCED: () => RELATIONSHIP_ADVANCED,
-  RELATIONSHIP_BASICS: () => RELATIONSHIP_BASICS,
-  WHERE_BASICS: () => WHERE_BASICS,
-  mb: () => mb
-});
-module.exports = __toCommonJS(specs_exports);
-var import_supported_features = require("../validator/supported-features.config");
-var import_unsupported_features = require("../validator/unsupported-features.config");
-var import_features = require("./features");
-var import_basic_optional_match = require("./features/basic-optional-match.feature");
-var import_return_statement = require("./features/return-statement.feature");
-const mb = (content, type) => `\`\`\`${type}
-${content}
-\`\`\``;
-function generateFeatureList(depth, features) {
-  return features.map((feature) => {
-    const lines = [];
-    lines.push(`${mh(depth)} ${feature.name}`);
-    lines.push(feature.description);
-    if (feature.queries) {
-      lines.push(`Allowed queries:`);
-      feature.queries.forEach((query) => {
-        lines.push(mb(query.join("\n"), "cypher"));
-      });
-    }
-    return lines.join("\n\n");
-  }).join("\n");
-}
-function generateConstraintList(constraints) {
-  return constraints.map((constraint) => `- ${constraint.description}`).join("\n");
-}
-function generateForbiddenFeaturesList(data) {
-  return data.map((feature) => {
-    let line = `- **${feature.name}** - ${feature.errorMessage}`;
-    if (feature.alternative) {
-      line += ` ${feature.alternative}`;
-    }
-    return line;
-  }).join("\n");
-}
-const mh = (depth) => `${"#".repeat(depth)}`;
-const MATCH_BASICS = (depth) => `
-${mh(depth)} MATCH Nodes
-
-${generateFeatureList(depth + 1, import_features.MATCH_NODES_FEATURES)}
-
-${mh(depth)} MATCH Nodes by Properties
-
-${generateFeatureList(depth + 1, import_features.PROPERTY_MATCHING_FEATURES)}
-
-${mh(depth)} Optional Match
-
-${generateFeatureList(depth + 1, import_basic_optional_match.BASIC_OPTIONAL_MATCH_FEATURES)}
-
-${mh(depth)} Return Statement
-
-${generateFeatureList(depth + 1, import_return_statement.RETURN_STATEMENT_FEATURES)}
-
-${mh(depth)} LIMIT Clause
-
-${generateFeatureList(depth + 1, import_features.LIMIT_FEATURES)}
-
-${mh(depth)} ORDER BY Clause
-
-Without ORDER BY, results are returned in graph insertion order:
-- Files: Order from TypeScript's program.getSourceFiles() (typically alphabetical by file path based on tsconfig include patterns)
-- Within files: Top-to-bottom AST traversal order (position in SourceFile)
-
-${generateFeatureList(depth + 1, import_features.ORDER_BY_FEATURES)}
-`;
-const WHERE_BASICS = (depth) => `
-${mh(depth)} Filtering Nodes
-
-${generateFeatureList(depth + 1, import_features.BASIC_FILTERING_FEATURES)}
-
-${mh(depth)} WHERE Clause Operators
-
-${generateFeatureList(depth + 1, import_features.WHERE_OPERATORS_FEATURES)}
-
-${mh(depth)} WHERE Conditional Logic
-
-${generateFeatureList(depth + 1, import_features.WHERE_CONDITIONAL_LOGIC_FEATURES)}
-
-${mh(depth)} Advanced Optional Match
-
-${generateFeatureList(depth + 1, import_features.ADVANCED_OPTIONAL_MATCH_FEATURES)}
-`;
-const RELATIONSHIP_BASICS = (depth) => `
-${mh(depth)} Basic Relationships
-
-${generateFeatureList(depth + 1, import_features.BASIC_RELATIONSHIP_FEATURES)}
-
-${mh(depth)} Undirected Relationships
-
-${generateFeatureList(depth + 1, import_features.UNDIRECTED_RELATIONSHIP_FEATURES)}
-
-${mh(depth)} Multiple Relationship Types
-
-${generateFeatureList(depth + 1, import_features.MULTIPLE_RELATIONSHIP_TYPES_FEATURES)}
-
-${mh(depth)} Anonymous Relationships
-
-${generateFeatureList(depth + 1, import_features.ANONYMOUS_RELATIONSHIP_FEATURES)}
-
-${mh(depth)} Relationship Without Variable
-
-${generateFeatureList(depth + 1, import_features.RELATIONSHIP_WITHOUT_VARIABLE_FEATURES)}
-`;
-const RELATIONSHIP_ADVANCED = (depth) => `
-${mh(depth)} Variable-Length Paths
-
-${generateFeatureList(depth + 1, import_features.VARIABLE_LENGTH_PATH_FEATURES)}
-
-${mh(depth)} Anonymous Variable-Length Paths
-
-${generateFeatureList(depth + 1, import_features.ANONYMOUS_VARIABLE_LENGTH_FEATURES)}
-`;
-const CYPHER_CONSTRAINTS = (depth) => `${mh(depth)} Node Constraints
-
-${generateConstraintList(import_supported_features.NODE_CONSTRAINTS)}
-
-${mh(depth)} Relationship Constraints
-
-${generateConstraintList(import_supported_features.RELATIONSHIP_CONSTRAINTS)}
-
-${mh(depth)} Query Constraints
-
-${generateConstraintList(import_supported_features.QUERY_CONSTRAINTS)}
-
-${mh(depth)} Pattern Constraints
-
-${generateConstraintList(import_supported_features.PATTERN_CONSTRAINTS)}`;
-const CYPHER_FORBIDDEN_FEATURES = (depth) => `${mh(depth)} Forbidden Keywords
-
-${generateForbiddenFeaturesList(import_unsupported_features.FORBIDDEN_KEYWORDS)}
-
-${mh(depth)} Forbidden Aggregations
-
-${generateForbiddenFeaturesList(import_unsupported_features.FORBIDDEN_AGGREGATIONS)}
-
-${mh(depth)} Forbidden Modifiers
-
-${generateForbiddenFeaturesList(import_unsupported_features.FORBIDDEN_MODIFIERS)}
-
-${mh(depth)} Forbidden Patterns
-
-${generateForbiddenFeaturesList(import_unsupported_features.FORBIDDEN_PATTERNS)}
-
-`;
-// Annotate the CommonJS export names for ESM import in node:
-0 && (module.exports = {
-  CYPHER_CONSTRAINTS,
-  CYPHER_FORBIDDEN_FEATURES,
-  MATCH_BASICS,
-  RELATIONSHIP_ADVANCED,
-  RELATIONSHIP_BASICS,
-  WHERE_BASICS,
-  mb
-});

package/libs/cli/cypher/src/lib/executor/executor.js

@@ -1,83 +0,0 @@
-var __defProp = Object.defineProperty;
-var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
-var __getOwnPropNames = Object.getOwnPropertyNames;
-var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __export = (target, all) => {
-  for (var name in all)
-    __defProp(target, name, { get: all[name], enumerable: true });
-};
-var __copyProps = (to, from, except, desc) => {
-  if (from && typeof from === "object" || typeof from === "function") {
-    for (let key of __getOwnPropNames(from))
-      if (!__hasOwnProp.call(to, key) && key !== except)
-        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
-  }
-  return to;
-};
-var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
-var executor_exports = {};
-__export(executor_exports, {
-  CypherExecutor: () => CypherExecutor
-});
-module.exports = __toCommonJS(executor_exports);
-var import_condition_evaluator = require("./condition-evaluator");
-var import_match_engine = require("./match-engine");
-var import_pattern_matcher = require("./pattern-matcher");
-var import_relationship_navigator = require("./relationship-navigator");
-var import_result_formatter = require("./result-formatter");
-var import_traverse_engine = require("./traverse-engine");
-class CypherExecutor {
-  constructor(graph) {
-    this.graph = graph;
-    this.conditionEvaluator = new import_condition_evaluator.ConditionEvaluator();
-    const patternMatcher = new import_pattern_matcher.PatternMatcher();
-    const relationshipNavigator = new import_relationship_navigator.RelationshipNavigator(patternMatcher);
-    const traverseEngine = new import_traverse_engine.TraverseEngine(
-      patternMatcher,
-      relationshipNavigator
-    );
-    this.matchEngine = new import_match_engine.MatchEngine(patternMatcher, traverseEngine);
-    this.resultFormatter = new import_result_formatter.ResultFormatter();
-  }
-  /**
-   * Execute a parsed Cypher query
-   * @param extractData - If true (default), returns node.data. If false, returns full GraphNode objects.
-   * For edges, always returns the full GraphEdge object (edges have no data property).
-   * Returns results where keys are variable names and values are either node data or edge objects
-   */
-  execute(query) {
-    if (query.statements.length === 0) {
-      throw new Error("Query must have at least one statement");
-    }
-    if (query.statements[query.statements.length - 1].type !== "ReturnStatement") {
-      throw new Error("MATCH Query must have a RETURN statement");
-    }
-    let results = [];
-    for (const statement of query.statements) {
-      if (statement.type === "MatchStatement") {
-        results = this.matchEngine.processMatchStatement(
-          this.graph,
-          statement,
-          results
-        );
-      } else if (statement.type === "WhereStatement") {
-        results = this.conditionEvaluator.applyWhereClauseIfNeeded(
-          results,
-          statement
-        );
-      } else if (statement.type === "OrderByStatement") {
-        results = this.resultFormatter.sortResults(results, statement);
-      }
-    }
-    const returnStatement = query.statements[query.statements.length - 1];
-    let formattedResults = this.resultFormatter.formatResults(
-      results,
-      returnStatement
-    );
-    return formattedResults;
-  }
-}
-// Annotate the CommonJS export names for ESM import in node:
-0 && (module.exports = {
-  CypherExecutor
-});

package/libs/cli/cypher/src/lib/executor/graph.js

@@ -1,15 +0,0 @@
-var __defProp = Object.defineProperty;
-var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
-var __getOwnPropNames = Object.getOwnPropertyNames;
-var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __copyProps = (to, from, except, desc) => {
-  if (from && typeof from === "object" || typeof from === "function") {
-    for (let key of __getOwnPropNames(from))
-      if (!__hasOwnProp.call(to, key) && key !== except)
-        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
-  }
-  return to;
-};
-var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
-var graph_exports = {};
-module.exports = __toCommonJS(graph_exports);

package/libs/cli/cypher/src/lib/executor/utils.js

@@ -1,37 +0,0 @@
-var __defProp = Object.defineProperty;
-var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
-var __getOwnPropNames = Object.getOwnPropertyNames;
-var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __export = (target, all) => {
-  for (var name in all)
-    __defProp(target, name, { get: all[name], enumerable: true });
-};
-var __copyProps = (to, from, except, desc) => {
-  if (from && typeof from === "object" || typeof from === "function") {
-    for (let key of __getOwnPropNames(from))
-      if (!__hasOwnProp.call(to, key) && key !== except)
-        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
-  }
-  return to;
-};
-var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
-var utils_exports = {};
-__export(utils_exports, {
-  Annonymizer: () => Annonymizer
-});
-module.exports = __toCommonJS(utils_exports);
-class Annonymizer {
-  constructor() {
-    this.anonymousVariablePrefix = "annonymous_";
-  }
-  generate(node) {
-    return this.anonymousVariablePrefix + node.id;
-  }
-  isAnonymous(variable) {
-    return variable.startsWith(this.anonymousVariablePrefix);
-  }
-}
-// Annotate the CommonJS export names for ESM import in node:
-0 && (module.exports = {
-  Annonymizer
-});