@lowgular/code-graph 0.0.1 → 0.1.1

package/libs/cli/cypher/src/lib/docs/features/property-matching.feature.js

@@ -1,152 +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 property_matching_feature_exports = {};
-__export(property_matching_feature_exports, {
-  PROPERTY_MATCHING_FEATURES: () => PROPERTY_MATCHING_FEATURES
-});
-module.exports = __toCommonJS(property_matching_feature_exports);
-var import_graph2 = require("../../graph.stub");
-const PROPERTY_MATCHING_FEATURES = [
-  {
-    name: "Match node with single property",
-    description: "Filter nodes by a single property value in the pattern. Properties are matched exactly.",
-    graphFactory: () => new import_graph2.GraphBuilder().addNode((0, import_graph2.stubNode)("1", "A", { id: "1" })).addNode((0, import_graph2.stubNode)("2", "A", { id: "2" })).build(),
-    queries: [['MATCH (n:A {id: "1"})', "RETURN n"]],
-    results: [
-      {
-        n: {
-          id: "1"
-        }
-      }
-    ]
-  },
-  {
-    name: "Match node with number property",
-    description: "Properties can be numbers (integers or floats).",
-    graphFactory: () => new import_graph2.GraphBuilder().addNode((0, import_graph2.stubNode)("1", "A", { count: 42 })).addNode((0, import_graph2.stubNode)("2", "A", { count: 10 })).build(),
-    queries: [["MATCH (n:A {count: 42})", "RETURN n"]],
-    results: [
-      {
-        n: {
-          id: "1"
-        }
-      }
-    ]
-  },
-  {
-    name: "Match node with boolean property",
-    description: "Properties can be boolean values (true/false).",
-    graphFactory: () => new import_graph2.GraphBuilder().addNode((0, import_graph2.stubNode)("1", "A", { active: true })).addNode((0, import_graph2.stubNode)("2", "A", { active: false })).build(),
-    queries: [["MATCH (n:A {active: true})", "RETURN n"]],
-    results: [
-      {
-        n: {
-          id: "1"
-        }
-      }
-    ]
-  },
-  {
-    name: "Match node with multiple properties",
-    description: "Filter nodes by multiple property values. All properties must match exactly.",
-    graphFactory: () => new import_graph2.GraphBuilder().addNode((0, import_graph2.stubNode)("1", "A", { count: 5 })).addNode((0, import_graph2.stubNode)("2", "A", { count: 5 })).addNode((0, import_graph2.stubNode)("3", "A", { count: 3 })).build(),
-    queries: [['MATCH (n:A {id: "1", count: 5})', "RETURN n"]],
-    results: [
-      {
-        n: {
-          id: "1"
-        }
-      }
-    ]
-  },
-  {
-    name: "Match node with empty property map",
-    description: "Empty property map `{}` matches all nodes with the specified label, regardless of their properties.",
-    graphFactory: () => new import_graph2.GraphBuilder().addNode((0, import_graph2.stubNode)("1", "A")).addNode((0, import_graph2.stubNode)("2", "A")).build(),
-    queries: [["MATCH (n:A {})", "RETURN n"]],
-    results: [
-      {
-        n: {
-          id: "1"
-        }
-      },
-      {
-        n: {
-          id: "2"
-        }
-      }
-    ]
-  },
-  {
-    name: "Match node with array property",
-    description: "Properties can be arrays. Arrays are matched exactly (same elements in same order).",
-    graphFactory: () => new import_graph2.GraphBuilder().addNode((0, import_graph2.stubNode)("1", "A", { tags: ["a", "b"] })).addNode((0, import_graph2.stubNode)("2", "A", { tags: ["a"] })).addNode((0, import_graph2.stubNode)("3", "A", { tags: ["a", "b", "c"] })).build(),
-    queries: [['MATCH (n:A {tags: ["a", "b"]})', "RETURN n"]],
-    results: [
-      {
-        n: {
-          id: "1"
-        }
-      }
-    ]
-  },
-  {
-    name: "Match node with array of numbers property",
-    description: "Array properties can contain numbers.",
-    graphFactory: () => new import_graph2.GraphBuilder().addNode((0, import_graph2.stubNode)("1", "A", { tags: [1, 2, 3] })).addNode((0, import_graph2.stubNode)("2", "A", { tags: [1, 2] })).build(),
-    queries: [["MATCH (n:A {tags: [1, 2, 3]})", "RETURN n"]],
-    results: [
-      {
-        n: {
-          id: "1"
-        }
-      }
-    ]
-  },
-  {
-    name: "Match node with mixed property types including array",
-    description: "Multiple properties of different types (boolean, array, etc.) can be combined in a single pattern.",
-    graphFactory: () => new import_graph2.GraphBuilder().addNode((0, import_graph2.stubNode)("1", "A", { active: true, tags: ["a"] })).addNode((0, import_graph2.stubNode)("2", "A", { active: true, tags: ["b"] })).addNode((0, import_graph2.stubNode)("3", "A", { active: false, tags: ["a"] })).build(),
-    queries: [['MATCH (n:A {active: true, tags: ["a"]})', "RETURN n"]],
-    results: [
-      {
-        n: {
-          id: "1"
-        }
-      }
-    ]
-  },
-  {
-    name: "Return empty when matching non-existent property",
-    description: "If a property specified in the pattern does not exist on any nodes, the query returns no results.",
-    graphFactory: () => new import_graph2.GraphBuilder().addNode((0, import_graph2.stubNode)("1", "A")).addNode((0, import_graph2.stubNode)("2", "A")).build(),
-    queries: [['MATCH (n:A {missing: "value"})', "RETURN n"]],
-    results: []
-  },
-  {
-    name: "Return empty when one property exists but other does not",
-    description: "All properties in the pattern must exist and match. If any property is missing, no results are returned.",
-    graphFactory: () => new import_graph2.GraphBuilder().addNode((0, import_graph2.stubNode)("1", "A")).addNode((0, import_graph2.stubNode)("2", "A")).build(),
-    queries: [['MATCH (n:A {id: "1", missing: "value"})', "RETURN n"]],
-    results: []
-  }
-];
-// Annotate the CommonJS export names for ESM import in node:
-0 && (module.exports = {
-  PROPERTY_MATCHING_FEATURES
-});

package/libs/cli/cypher/src/lib/docs/features/relationship-without-variable.feature.js

@@ -1,48 +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 relationship_without_variable_feature_exports = {};
-__export(relationship_without_variable_feature_exports, {
-  RELATIONSHIP_WITHOUT_VARIABLE_FEATURES: () => RELATIONSHIP_WITHOUT_VARIABLE_FEATURES
-});
-module.exports = __toCommonJS(relationship_without_variable_feature_exports);
-var import_graph2 = require("../../graph.stub");
-const RELATIONSHIP_WITHOUT_VARIABLE_FEATURES = [
-  {
-    name: "Not include edge in results when no variable",
-    description: "When relationship variable is not bound (e.g., -[:TYPE]->), edge is not included in results. Only nodes are returned.",
-    graphFactory: () => new import_graph2.GraphBuilder().addNode((0, import_graph2.stubNode)("1", "A")).addNode((0, import_graph2.stubNode)("2", "B")).addEdge((0, import_graph2.stubEdge)("1", "2", "R1")).build(),
-    queries: [
-      ["MATCH (a:A)-[:R1]->(b:B)", "RETURN a, b"],
-      ["MATCH (b:B)<-[:R1]-(a:A)", "RETURN a, b"]
-    ],
-    results: [
-      {
-        a: {
-          id: "1"
-        },
-        b: {
-          id: "2"
-        }
-      }
-    ]
-  }
-];
-// Annotate the CommonJS export names for ESM import in node:
-0 && (module.exports = {
-  RELATIONSHIP_WITHOUT_VARIABLE_FEATURES
-});

package/libs/cli/cypher/src/lib/docs/features/return-statement.feature.js

@@ -1,65 +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 return_statement_feature_exports = {};
-__export(return_statement_feature_exports, {
-  RETURN_STATEMENT_FEATURES: () => RETURN_STATEMENT_FEATURES
-});
-module.exports = __toCommonJS(return_statement_feature_exports);
-var import_graph2 = require("../../graph.stub");
-const RETURN_STATEMENT_FEATURES = [
-  {
-    name: "Return all nodes",
-    description: "The default behavior is to return all nodes.",
-    graphFactory: () => new import_graph2.GraphBuilder().addNode((0, import_graph2.stubNode)("1")).addNode((0, import_graph2.stubNode)("2")).build(),
-    queries: [["MATCH (n) RETURN *"]],
-    results: [
-      {
-        n: {
-          id: "1"
-        }
-      },
-      {
-        n: {
-          id: "2"
-        }
-      }
-    ]
-  },
-  {
-    name: "Return aliased nodes",
-    description: "Return aliased nodes by using the AS keyword.",
-    graphFactory: () => new import_graph2.GraphBuilder().addNode((0, import_graph2.stubNode)("1")).addNode((0, import_graph2.stubNode)("2")).build(),
-    queries: [["MATCH (n) RETURN n AS node"]],
-    results: [
-      {
-        node: {
-          id: "1"
-        }
-      },
-      {
-        node: {
-          id: "2"
-        }
-      }
-    ]
-  }
-];
-// Annotate the CommonJS export names for ESM import in node:
-0 && (module.exports = {
-  RETURN_STATEMENT_FEATURES
-});

package/libs/cli/cypher/src/lib/docs/features/unidirected-relationship.feature.js

@@ -1,82 +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 unidirected_relationship_feature_exports = {};
-__export(unidirected_relationship_feature_exports, {
-  UNDIRECTED_RELATIONSHIP_FEATURES: () => UNDIRECTED_RELATIONSHIP_FEATURES
-});
-module.exports = __toCommonJS(unidirected_relationship_feature_exports);
-var import_graph2 = require("../../graph.stub");
-const UNDIRECTED_RELATIONSHIP_FEATURES = [
-  {
-    name: "Match undirected relationship (both directions)",
-    description: "Undirected relationships match edges in either direction. Use -[:TYPE]- syntax.",
-    graphFactory: () => new import_graph2.GraphBuilder().addNode((0, import_graph2.stubNode)("1", "A")).addNode((0, import_graph2.stubNode)("2", "B")).addEdge((0, import_graph2.stubEdge)("1", "2", "R1")).build(),
-    queries: [["MATCH (a:A)-[:R1]-(b:B)", "RETURN a, b"]],
-    results: [
-      {
-        a: {
-          id: "1"
-        },
-        b: {
-          id: "2"
-        }
-      }
-    ]
-  },
-  {
-    name: "Match undirected relationship in reverse direction",
-    description: "Undirected relationships match edges regardless of their stored direction.",
-    graphFactory: () => new import_graph2.GraphBuilder().addNode((0, import_graph2.stubNode)("1", "A")).addNode((0, import_graph2.stubNode)("2", "B")).addEdge((0, import_graph2.stubEdge)("2", "1", "R1")).build(),
-    queries: [["MATCH (a:A)-[:R1]-(b:B)", "RETURN a, b"]],
-    results: [
-      {
-        a: {
-          id: "1"
-        },
-        b: {
-          id: "2"
-        }
-      }
-    ]
-  },
-  {
-    name: "Bind relationship variable in undirected relationship",
-    description: "When relationship variable is bound in undirected relationship, edge object is included in results with source, target, and type.",
-    graphFactory: () => new import_graph2.GraphBuilder().addNode((0, import_graph2.stubNode)("1", "A")).addNode((0, import_graph2.stubNode)("2", "B")).addEdge((0, import_graph2.stubEdge)("1", "2", "R1")).build(),
-    queries: [["MATCH (a:A)-[rel:R1]-(b:B)", "RETURN a, rel, b"]],
-    results: [
-      {
-        a: {
-          id: "1"
-        },
-        rel: {
-          source: "1",
-          target: "2",
-          type: "R1"
-        },
-        b: {
-          id: "2"
-        }
-      }
-    ]
-  }
-];
-// Annotate the CommonJS export names for ESM import in node:
-0 && (module.exports = {
-  UNDIRECTED_RELATIONSHIP_FEATURES
-});

package/libs/cli/cypher/src/lib/docs/features/variable-length-path.feature.js

@@ -1,136 +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 variable_length_path_feature_exports = {};
-__export(variable_length_path_feature_exports, {
-  VARIABLE_LENGTH_PATH_FEATURES: () => VARIABLE_LENGTH_PATH_FEATURES
-});
-module.exports = __toCommonJS(variable_length_path_feature_exports);
-var import_graph2 = require("../../graph.stub");
-const VARIABLE_LENGTH_PATH_FEATURES = [
-  {
-    name: "Match zero-length path (same node)",
-    description: "Variable-length paths with * support zero-length paths, matching when source and target are the same node.",
-    graphFactory: () => new import_graph2.GraphBuilder().addNode((0, import_graph2.stubNode)("1", "A")).build(),
-    queries: [["MATCH (a:A)-[:R*]->(a)", "RETURN a"]],
-    results: [
-      {
-        a: {
-          id: "1"
-        }
-      }
-    ]
-  },
-  {
-    name: "Return empty when no path exists",
-    description: "When no path exists between source and target nodes, variable-length path returns no results.",
-    graphFactory: () => new import_graph2.GraphBuilder().addNode((0, import_graph2.stubNode)("1", "A")).addNode((0, import_graph2.stubNode)("2", "B")).build(),
-    queries: [["MATCH (a:A)-[:R*]->(b:B)", "RETURN a, b"]],
-    results: []
-  },
-  {
-    name: "Handle multiple valid paths",
-    description: "Variable-length paths find all valid paths between source and target nodes.",
-    graphFactory: () => new import_graph2.GraphBuilder().addNode((0, import_graph2.stubNode)("1", "A")).addNode((0, import_graph2.stubNode)("2", "C")).addNode((0, import_graph2.stubNode)("3", "C")).addNode((0, import_graph2.stubNode)("4", "B")).addEdge((0, import_graph2.stubEdge)("1", "2", "R")).addEdge((0, import_graph2.stubEdge)("1", "3", "R")).addEdge((0, import_graph2.stubEdge)("2", "4", "R")).addEdge((0, import_graph2.stubEdge)("3", "4", "R")).build(),
-    queries: [["MATCH (a:A)-[r:R*]->(b:B)", "RETURN a, r, b"]],
-    results: [
-      {
-        a: {
-          id: "1"
-        },
-        r: {
-          source: "2",
-          target: "4",
-          type: "R"
-        },
-        b: {
-          id: "4"
-        }
-      },
-      {
-        a: {
-          id: "1"
-        },
-        r: {
-          source: "3",
-          target: "4",
-          type: "R"
-        },
-        b: {
-          id: "4"
-        }
-      }
-    ]
-  },
-  {
-    name: "Prevent infinite loops with cycles",
-    description: "Variable-length paths handle cycles correctly, preventing infinite loops while still finding valid paths.",
-    graphFactory: () => new import_graph2.GraphBuilder().addNode((0, import_graph2.stubNode)("1", "A")).addNode((0, import_graph2.stubNode)("2", "C")).addNode((0, import_graph2.stubNode)("3", "B")).addEdge((0, import_graph2.stubEdge)("1", "2", "R")).addEdge((0, import_graph2.stubEdge)("2", "2", "R")).addEdge((0, import_graph2.stubEdge)("2", "3", "R")).build(),
-    queries: [["MATCH (a:A)-[:R*]->(b:B)", "RETURN a, b"]],
-    results: [
-      {
-        a: {
-          id: "1"
-        },
-        b: {
-          id: "3"
-        }
-      }
-    ]
-  },
-  {
-    name: "Handle cycle in path but still reach target",
-    description: "Variable-length paths can traverse through cycles but still reach the target node without getting stuck.",
-    graphFactory: () => new import_graph2.GraphBuilder().addNode((0, import_graph2.stubNode)("1", "A")).addNode((0, import_graph2.stubNode)("2", "C")).addNode((0, import_graph2.stubNode)("3", "C")).addNode((0, import_graph2.stubNode)("4", "B")).addEdge((0, import_graph2.stubEdge)("1", "2", "R")).addEdge((0, import_graph2.stubEdge)("2", "3", "R")).addEdge((0, import_graph2.stubEdge)("3", "2", "R")).addEdge((0, import_graph2.stubEdge)("2", "4", "R")).build(),
-    queries: [["MATCH (a:A)-[:R*]->(b:B)", "RETURN a, b"]],
-    results: [
-      {
-        a: {
-          id: "1"
-        },
-        b: {
-          id: "4"
-        }
-      }
-    ]
-  },
-  {
-    name: "Bind relationship variable in variable-length path",
-    description: "When relationship variable is bound in variable-length path, it binds to the last edge in the path.",
-    graphFactory: () => new import_graph2.GraphBuilder().addNode((0, import_graph2.stubNode)("1", "A")).addNode((0, import_graph2.stubNode)("2", "C")).addNode((0, import_graph2.stubNode)("3", "B")).addEdge((0, import_graph2.stubEdge)("1", "2", "R")).addEdge((0, import_graph2.stubEdge)("2", "3", "R")).build(),
-    queries: [["MATCH (a:A)-[rel:R*]->(b:B)", "RETURN a, rel, b"]],
-    results: [
-      {
-        a: {
-          id: "1"
-        },
-        rel: {
-          source: "2",
-          target: "3",
-          type: "R"
-        },
-        b: {
-          id: "3"
-        }
-      }
-    ]
-  }
-];
-// Annotate the CommonJS export names for ESM import in node:
-0 && (module.exports = {
-  VARIABLE_LENGTH_PATH_FEATURES
-});

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

@@ -1,187 +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_conditional_feature_exports = {};
-__export(where_conditional_feature_exports, {
-  WHERE_CONDITIONAL_LOGIC_FEATURES: () => WHERE_CONDITIONAL_LOGIC_FEATURES
-});
-module.exports = __toCommonJS(where_conditional_feature_exports);
-var import_graph2 = require("../../graph.stub");
-const WHERE_CONDITIONAL_LOGIC_FEATURES = [
-  {
-    name: "Filter with OR logic (strings)",
-    description: "Use OR operator to filter nodes where property matches any of multiple string values.",
-    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 = "X" OR a.type = "Y"', "RETURN a"]
-    ],
-    results: [
-      {
-        a: {
-          id: "1"
-        }
-      },
-      {
-        a: {
-          id: "2"
-        }
-      }
-    ]
-  },
-  {
-    name: "Filter with OR logic (numbers)",
-    description: "Use OR operator to filter nodes where property matches any of multiple number values.",
-    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 = 3 OR a.count = 7", "RETURN a"]],
-    results: [
-      {
-        a: {
-          id: "1"
-        }
-      },
-      {
-        a: {
-          id: "3"
-        }
-      }
-    ]
-  },
-  {
-    name: "Filter with multiple OR conditions",
-    description: "Use multiple OR conditions to filter nodes matching any of three or more values.",
-    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" })).addNode((0, import_graph2.stubNode)("4", "A", { type: "W" })).build(),
-    queries: [
-      [
-        "MATCH (a:A)",
-        'WHERE a.type = "X" OR a.type = "Y" OR a.type = "Z"',
-        "RETURN a"
-      ]
-    ],
-    results: [
-      {
-        a: {
-          id: "1"
-        }
-      },
-      {
-        a: {
-          id: "2"
-        }
-      },
-      {
-        a: {
-          id: "3"
-        }
-      }
-    ]
-  },
-  {
-    name: "Filter with multiple AND conditions",
-    description: "Use multiple AND conditions to filter nodes where all specified properties match.",
-    graphFactory: () => new import_graph2.GraphBuilder().addNode((0, import_graph2.stubNode)("1", "A", { type: "X", count: 5 })).addNode((0, import_graph2.stubNode)("2", "A", { type: "X", count: 3 })).addNode((0, import_graph2.stubNode)("3", "A", { type: "Y", count: 5 })).build(),
-    queries: [
-      ["MATCH (a:A)", 'WHERE a.type = "X" AND a.count = 5', "RETURN a"]
-    ],
-    results: [
-      {
-        a: {
-          id: "1"
-        }
-      }
-    ]
-  },
-  {
-    name: "Filter with AND using comparison operators",
-    description: "Use AND with comparison operators to filter nodes within a range of values.",
-    graphFactory: () => new import_graph2.GraphBuilder().addNode((0, import_graph2.stubNode)("1", "A", { count: 2 })).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: 12 })).build(),
-    queries: [
-      ["MATCH (a:A)", "WHERE a.count > 3 AND a.count < 10", "RETURN a"]
-    ],
-    results: [
-      {
-        a: {
-          id: "2"
-        }
-      },
-      {
-        a: {
-          id: "3"
-        }
-      }
-    ]
-  },
-  {
-    name: "Filter with WHERE on relationship pattern (source node)",
-    description: "Apply WHERE clause to filter relationship matches based on source node properties.",
-    graphFactory: () => new import_graph2.GraphBuilder().addNode((0, import_graph2.stubNode)("1", "A", { count: 3 })).addNode((0, import_graph2.stubNode)("2", "A", { count: 7 })).addNode((0, import_graph2.stubNode)("3", "B")).addEdge((0, import_graph2.stubEdge)("1", "3", "R1")).addEdge((0, import_graph2.stubEdge)("2", "3", "R1")).build(),
-    queries: [["MATCH (a:A)-[r:R1]->(:B)", "WHERE a.count > 5", "RETURN a"]],
-    results: [
-      {
-        a: {
-          id: "2"
-        }
-      }
-    ]
-  },
-  {
-    name: "Filter with WHERE on relationship pattern (target node)",
-    description: "Apply WHERE clause to filter relationship matches based on target node properties.",
-    graphFactory: () => new import_graph2.GraphBuilder().addNode((0, import_graph2.stubNode)("1", "A")).addNode((0, import_graph2.stubNode)("2", "B", { type: "X" })).addNode((0, import_graph2.stubNode)("3", "B", { type: "Y" })).addEdge((0, import_graph2.stubEdge)("1", "2", "R1")).addEdge((0, import_graph2.stubEdge)("1", "3", "R1")).build(),
-    queries: [
-      ["MATCH (a:A)-[:R1]->(b:B)", 'WHERE b.type = "X"', "RETURN a, b"]
-    ],
-    results: [
-      {
-        a: {
-          id: "1"
-        },
-        b: {
-          id: "2"
-        }
-      }
-    ]
-  },
-  {
-    name: "Filter with WHERE on 2-hop relationship pattern",
-    description: "Apply WHERE clause to filter multi-hop relationship matches based on properties of nodes at different hops.",
-    graphFactory: () => new import_graph2.GraphBuilder().addNode((0, import_graph2.stubNode)("1", "A", { count: 5 })).addNode((0, import_graph2.stubNode)("2", "A", { count: 3 })).addNode((0, import_graph2.stubNode)("3", "B")).addNode((0, import_graph2.stubNode)("4", "C", { type: "X" })).addNode((0, import_graph2.stubNode)("5", "C", { type: "Y" })).addEdge((0, import_graph2.stubEdge)("1", "3", "R1")).addEdge((0, import_graph2.stubEdge)("2", "3", "R1")).addEdge((0, import_graph2.stubEdge)("3", "4", "R2")).addEdge((0, import_graph2.stubEdge)("3", "5", "R2")).build(),
-    queries: [
-      [
-        "MATCH (a:A)-[:R1]->(b:B)-[:R2]->(c:C)",
-        'WHERE a.count = 5 AND c.type = "X"',
-        "RETURN a, b, c"
-      ]
-    ],
-    results: [
-      {
-        a: {
-          id: "1"
-        },
-        b: {
-          id: "3"
-        },
-        c: {
-          id: "4"
-        }
-      }
-    ]
-  }
-];
-// Annotate the CommonJS export names for ESM import in node:
-0 && (module.exports = {
-  WHERE_CONDITIONAL_LOGIC_FEATURES
-});