@lowgular/code-graph 0.0.1 → 0.1.1

package/libs/cli/cypher/src/lib/docs/features/advanced-optional-match.feature.js

@@ -1,277 +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 advanced_optional_match_feature_exports = {};
-__export(advanced_optional_match_feature_exports, {
-  ADVANCED_OPTIONAL_MATCH_FEATURES: () => ADVANCED_OPTIONAL_MATCH_FEATURES
-});
-module.exports = __toCommonJS(advanced_optional_match_feature_exports);
-var import_graph2 = require("../../graph.stub");
-const ADVANCED_OPTIONAL_MATCH_FEATURES = [
-  {
-    name: "Filter optional matches with WHERE IS NOT NULL",
-    description: "Use WHERE IS NOT NULL to filter out results where optional matches failed, keeping only results with successful optional matches.",
-    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")).addNode((0, import_graph2.stubNode)("3", "A")).build(),
-    queries: [
-      [
-        "MATCH (a:A)",
-        "OPTIONAL MATCH (a)-[:R1]->(b:B)",
-        "WHERE b IS NOT NULL",
-        "RETURN a, b"
-      ]
-    ],
-    results: [
-      {
-        a: {
-          id: "1"
-        },
-        b: {
-          id: "2"
-        }
-      }
-    ]
-  },
-  {
-    name: "Filter optional matches with WHERE IS NULL",
-    description: "Use WHERE IS NULL to find results where optional matches failed, filtering out successful optional matches.",
-    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")).addNode((0, import_graph2.stubNode)("3", "A")).build(),
-    queries: [
-      [
-        "MATCH (a:A)",
-        "OPTIONAL MATCH (a)-[:R1]->(b:B)",
-        "WHERE b IS NULL",
-        "RETURN a, b"
-      ]
-    ],
-    results: [
-      {
-        a: {
-          id: "3"
-        },
-        b: null
-      }
-    ]
-  },
-  {
-    name: "Multiple optional matches sequentially",
-    description: "Multiple OPTIONAL MATCH statements can be chained sequentially, each building on previous results.",
-    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")).addNode((0, import_graph2.stubNode)("3", "C")).addEdge((0, import_graph2.stubEdge)("1", "3", "R2")).addNode((0, import_graph2.stubNode)("4", "A")).build(),
-    queries: [
-      [
-        "MATCH (a:A)",
-        "OPTIONAL MATCH (a)-[:R1]->(b:B)",
-        "OPTIONAL MATCH (a)-[:R2]->(c:C)",
-        "RETURN a, b, c"
-      ]
-    ],
-    results: [
-      {
-        a: {
-          id: "1"
-        },
-        b: {
-          id: "2"
-        },
-        c: {
-          id: "3"
-        }
-      },
-      {
-        a: {
-          id: "4"
-        },
-        b: null,
-        c: null
-      }
-    ]
-  },
-  {
-    name: "Optional match with comma-separated patterns",
-    description: "OPTIONAL MATCH supports comma-separated patterns in a single statement, creating a Cartesian product of optional matches.",
-    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")).addNode((0, import_graph2.stubNode)("3", "C")).build(),
-    queries: [
-      [
-        "MATCH (a:A)",
-        "OPTIONAL MATCH (a)-[:R1]->(b:B), (c:C)",
-        "RETURN a, b, c"
-      ]
-    ],
-    results: [
-      {
-        a: {
-          id: "1"
-        },
-        b: {
-          id: "2"
-        },
-        c: {
-          id: "3"
-        }
-      }
-    ]
-  },
-  {
-    name: "Bind optional relationship variable when match exists",
-    description: "When an optional relationship is bound to a variable and the match succeeds, the relationship object is included in results.",
-    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")).addNode((0, import_graph2.stubNode)("3", "A")).build(),
-    queries: [
-      ["MATCH (a:A)", "OPTIONAL MATCH (a)-[rel:R1]->(b:B)", "RETURN a, rel, b"]
-    ],
-    results: [
-      {
-        a: {
-          id: "1"
-        },
-        rel: {
-          source: "1",
-          target: "2",
-          type: "R1"
-        },
-        b: {
-          id: "2"
-        }
-      },
-      {
-        a: {
-          id: "3"
-        },
-        rel: null,
-        b: null
-      }
-    ]
-  },
-  {
-    name: "Set optional relationship variable to null when no match",
-    description: "When an optional relationship variable is bound but no match exists, both the relationship and target node variables are set to null.",
-    graphFactory: () => new import_graph2.GraphBuilder().addNode((0, import_graph2.stubNode)("1", "A")).build(),
-    queries: [
-      ["MATCH (a:A)", "OPTIONAL MATCH (a)-[rel:R1]->(b:B)", "RETURN a, rel, b"]
-    ],
-    results: [
-      {
-        a: {
-          id: "1"
-        },
-        rel: null,
-        b: null
-      }
-    ]
-  },
-  {
-    name: "Optional incoming relationship",
-    description: "OPTIONAL MATCH works with incoming relationships (reverse direction), matching relationships where the optional node is the source.",
-    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")).addNode((0, import_graph2.stubNode)("3", "A")).build(),
-    queries: [
-      ["MATCH (a:A)", "OPTIONAL MATCH (a)<-[:R1]-(b:B)", "RETURN a, b"]
-    ],
-    results: [
-      {
-        a: {
-          id: "1"
-        },
-        b: {
-          id: "2"
-        }
-      },
-      {
-        a: {
-          id: "3"
-        },
-        b: null
-      }
-    ]
-  },
-  {
-    name: "Optional undirected relationship",
-    description: "OPTIONAL MATCH works with undirected relationships, matching relationships in either 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)("1", "2", "R1")).addNode((0, import_graph2.stubNode)("3", "A")).build(),
-    queries: [["MATCH (a:A)", "OPTIONAL MATCH (a)-[:R1]-(b:B)", "RETURN a, b"]],
-    results: [
-      {
-        a: {
-          id: "1"
-        },
-        b: {
-          id: "2"
-        }
-      },
-      {
-        a: {
-          id: "3"
-        },
-        b: null
-      }
-    ]
-  },
-  {
-    name: "Optional match starting from empty graph",
-    description: "When OPTIONAL MATCH is used without a required MATCH and the graph is empty, it returns no results.",
-    graphFactory: () => new import_graph2.GraphBuilder().build(),
-    queries: [["OPTIONAL MATCH (a:A)", "RETURN a"]],
-    results: []
-  },
-  {
-    name: "Optional match with nodes in graph",
-    description: "When OPTIONAL MATCH is used without a required MATCH and nodes exist, it matches all nodes like a regular MATCH.",
-    graphFactory: () => new import_graph2.GraphBuilder().addNode((0, import_graph2.stubNode)("1", "A")).addNode((0, import_graph2.stubNode)("2", "A")).build(),
-    queries: [["OPTIONAL MATCH (a:A)", "RETURN a"]],
-    results: [
-      {
-        a: {
-          id: "1"
-        }
-      },
-      {
-        a: {
-          id: "2"
-        }
-      }
-    ]
-  },
-  {
-    name: "Optional match with property filter on optional node",
-    description: "Property filters can be applied to optional nodes in the OPTIONAL MATCH pattern, filtering which optional matches succeed.",
-    graphFactory: () => new import_graph2.GraphBuilder().addNode((0, import_graph2.stubNode)("1", "A")).addNode((0, import_graph2.stubNode)("2", "B", { id: "2" })).addNode((0, import_graph2.stubNode)("3", "B", { id: "3" })).addEdge((0, import_graph2.stubEdge)("1", "2", "R1")).addEdge((0, import_graph2.stubEdge)("1", "3", "R1")).addNode((0, import_graph2.stubNode)("4", "A")).build(),
-    queries: [
-      [
-        "MATCH (a:A)",
-        'OPTIONAL MATCH (a)-[:R1]->(b:B {id: "2"})',
-        "RETURN a, b"
-      ]
-    ],
-    results: [
-      {
-        a: {
-          id: "1"
-        },
-        b: {
-          id: "2"
-        }
-      },
-      {
-        a: {
-          id: "4"
-        },
-        b: null
-      }
-    ]
-  }
-];
-// Annotate the CommonJS export names for ESM import in node:
-0 && (module.exports = {
-  ADVANCED_OPTIONAL_MATCH_FEATURES
-});

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

@@ -1,69 +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 anonymous_relationship_feature_exports = {};
-__export(anonymous_relationship_feature_exports, {
-  ANONYMOUS_RELATIONSHIP_FEATURES: () => ANONYMOUS_RELATIONSHIP_FEATURES
-});
-module.exports = __toCommonJS(anonymous_relationship_feature_exports);
-var import_graph2 = require("../../graph.stub");
-const ANONYMOUS_RELATIONSHIP_FEATURES = [
-  {
-    name: "Match any relationship type",
-    description: "Empty relationship type specification [] matches any relationship 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", "ANY_TYPE")).build(),
-    queries: [["MATCH (a:A)-[]->(b:B)", "RETURN a, b"]],
-    results: [
-      {
-        a: {
-          id: "1"
-        },
-        b: {
-          id: "2"
-        }
-      }
-    ]
-  },
-  {
-    name: "Match different relationship types",
-    description: "Empty relationship type matches relationships of any type, including different types in the same graph.",
-    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")).addNode((0, import_graph2.stubNode)("3", "A")).addNode((0, import_graph2.stubNode)("4", "B")).addEdge((0, import_graph2.stubEdge)("3", "4", "R2")).build(),
-    queries: [["MATCH (a:A)-[]->(b:B)", "RETURN a, b"]],
-    results: [
-      {
-        a: {
-          id: "1"
-        },
-        b: {
-          id: "2"
-        }
-      },
-      {
-        a: {
-          id: "3"
-        },
-        b: {
-          id: "4"
-        }
-      }
-    ]
-  }
-];
-// Annotate the CommonJS export names for ESM import in node:
-0 && (module.exports = {
-  ANONYMOUS_RELATIONSHIP_FEATURES
-});

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

@@ -1,105 +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 anonymous_variable_length_feature_exports = {};
-__export(anonymous_variable_length_feature_exports, {
-  ANONYMOUS_VARIABLE_LENGTH_FEATURES: () => ANONYMOUS_VARIABLE_LENGTH_FEATURES
-});
-module.exports = __toCommonJS(anonymous_variable_length_feature_exports);
-var import_graph2 = require("../../graph.stub");
-const ANONYMOUS_VARIABLE_LENGTH_FEATURES = [
-  {
-    name: "Match any relationship type with variable length",
-    description: "Anonymous variable-length paths [*] match paths of any relationship type with zero or more edges.",
-    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", "R1")).addEdge((0, import_graph2.stubEdge)("2", "3", "R2")).build(),
-    queries: [["MATCH (a:A)-[*]->(b:B)", "RETURN a, b"]],
-    results: [
-      {
-        a: {
-          id: "1"
-        },
-        b: {
-          id: "3"
-        }
-      }
-    ]
-  },
-  {
-    name: "Match pattern with anonymous variable-length at edges and specific type in middle",
-    description: "Variable-length paths can mix anonymous types [*] with specific types in complex patterns.",
-    graphFactory: () => new import_graph2.GraphBuilder().addNode((0, import_graph2.stubNode)("1", "A")).addNode((0, import_graph2.stubNode)("2", "B")).addNode((0, import_graph2.stubNode)("3", "C")).addNode((0, import_graph2.stubNode)("4", "D")).addEdge((0, import_graph2.stubEdge)("1", "2", "R1")).addEdge((0, import_graph2.stubEdge)("2", "3", "R2")).addEdge((0, import_graph2.stubEdge)("3", "4", "R3")).build(),
-    queries: [
-      ["MATCH (a:A)-[*]->(b:B)-[:R2*]->(c:C)-[*]->(d:D)", "RETURN a, b, c, d"]
-    ],
-    results: [
-      {
-        a: {
-          id: "1"
-        },
-        b: {
-          id: "2"
-        },
-        c: {
-          id: "3"
-        },
-        d: {
-          id: "4"
-        }
-      }
-    ]
-  },
-  {
-    name: "Match zero-length path (same node) with anonymous variable-length",
-    description: "Anonymous variable-length paths support zero-length paths when source and target are different nodes (no path).",
-    graphFactory: () => new import_graph2.GraphBuilder().addNode((0, import_graph2.stubNode)("1", "A")).addNode((0, import_graph2.stubNode)("2", "B")).build(),
-    queries: [["MATCH (a:A)-[*]->(b:B)", "RETURN a, b"]],
-    results: []
-  },
-  {
-    name: "Match zero-length path when source and target are same node",
-    description: "Anonymous variable-length paths match zero-length paths when source and target variables refer to the same node.",
-    graphFactory: () => new import_graph2.GraphBuilder().addNode((0, import_graph2.stubNode)("1", "A")).build(),
-    queries: [["MATCH (a:A)-[*]->(a:A)", "RETURN a"]],
-    results: [
-      {
-        a: {
-          id: "1"
-        }
-      }
-    ]
-  },
-  {
-    name: "Traverse multiple hops with different relationship types",
-    description: "Anonymous variable-length paths can traverse multiple hops with different relationship types.",
-    graphFactory: () => new import_graph2.GraphBuilder().addNode((0, import_graph2.stubNode)("1", "A")).addNode((0, import_graph2.stubNode)("2", "X")).addNode((0, import_graph2.stubNode)("3", "Y")).addNode((0, import_graph2.stubNode)("4", "B")).addEdge((0, import_graph2.stubEdge)("1", "2", "TYPE1")).addEdge((0, import_graph2.stubEdge)("2", "3", "TYPE2")).addEdge((0, import_graph2.stubEdge)("3", "4", "TYPE3")).build(),
-    queries: [["MATCH (a:A)-[*]->(b:B)", "RETURN a, b"]],
-    results: [
-      {
-        a: {
-          id: "1"
-        },
-        b: {
-          id: "4"
-        }
-      }
-    ]
-  }
-];
-// Annotate the CommonJS export names for ESM import in node:
-0 && (module.exports = {
-  ANONYMOUS_VARIABLE_LENGTH_FEATURES
-});

package/libs/cli/cypher/src/lib/docs/features/basic-filtering.feature.js

@@ -1,70 +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 basic_filtering_feature_exports = {};
-__export(basic_filtering_feature_exports, {
-  BASIC_FILTERING_FEATURES: () => BASIC_FILTERING_FEATURES
-});
-module.exports = __toCommonJS(basic_filtering_feature_exports);
-var import_graph2 = require("../../graph.stub");
-const BASIC_FILTERING_FEATURES = [
-  {
-    name: "Filter single node with property in pattern",
-    description: "Filter nodes by property directly in the MATCH pattern. Equivalent to using WHERE clause.",
-    graphFactory: () => new import_graph2.GraphBuilder().addNode((0, import_graph2.stubNode)("1")).addNode((0, import_graph2.stubNode)("2")).addNode((0, import_graph2.stubNode)("3")).build(),
-    queries: [
-      ['MATCH (a:A {id: "1"})', "RETURN a"],
-      ["MATCH (a:A)", 'WHERE a.id = "1"', "RETURN a"]
-    ],
-    results: [
-      {
-        a: {
-          id: "1"
-        }
-      }
-    ]
-  },
-  {
-    name: "Filter multiple nodes with properties in pattern",
-    description: "Filter multiple nodes by properties directly in the MATCH pattern.",
-    graphFactory: () => new import_graph2.GraphBuilder().addNode((0, import_graph2.stubNode)("1", "A")).addNode((0, import_graph2.stubNode)("2", "B")).addNode((0, import_graph2.stubNode)("3", "A")).addNode((0, import_graph2.stubNode)("4", "B")).build(),
-    queries: [
-      ['MATCH (a:A {id: "1"}), (b:B {id: "2"})', "RETURN a, b"],
-      ['MATCH (a:A {id: "1"}), (b:B)', 'WHERE b.id = "2"', "RETURN a, b"],
-      [
-        "MATCH (a:A)",
-        "MATCH (b:B)",
-        'WHERE a.id = "1" AND b.id = "2"',
-        "RETURN a, b"
-      ]
-    ],
-    results: [
-      {
-        a: {
-          id: "1"
-        },
-        b: {
-          id: "2"
-        }
-      }
-    ]
-  }
-];
-// Annotate the CommonJS export names for ESM import in node:
-0 && (module.exports = {
-  BASIC_FILTERING_FEATURES
-});

package/libs/cli/cypher/src/lib/docs/features/basic-optional-match.feature.js

@@ -1,99 +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 basic_optional_match_feature_exports = {};
-__export(basic_optional_match_feature_exports, {
-  BASIC_OPTIONAL_MATCH_FEATURES: () => BASIC_OPTIONAL_MATCH_FEATURES
-});
-module.exports = __toCommonJS(basic_optional_match_feature_exports);
-var import_graph2 = require("../../graph.stub");
-const BASIC_OPTIONAL_MATCH_FEATURES = [
-  {
-    name: "Left outer join - all required nodes preserved",
-    description: "OPTIONAL MATCH performs a left outer join. All required MATCH results are preserved, even if optional matches fail.",
-    graphFactory: () => new import_graph2.GraphBuilder().addNode((0, import_graph2.stubNode)("1", "A")).addNode((0, import_graph2.stubNode)("2", "A")).addNode((0, import_graph2.stubNode)("3", "B")).addEdge((0, import_graph2.stubEdge)("1", "3", "R1")).build(),
-    queries: [
-      ["MATCH (a:A)", "OPTIONAL MATCH (a)-[:R1]->(b:B)", "RETURN a, b"]
-    ],
-    results: [
-      {
-        a: {
-          id: "1"
-        },
-        b: {
-          id: "3"
-        }
-      },
-      {
-        a: {
-          id: "2"
-        },
-        b: null
-      }
-    ]
-  },
-  {
-    name: "Optional variable set to null when no match exists",
-    description: "When an optional match fails, the optional variable is set to null in the result.",
-    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")).addNode((0, import_graph2.stubNode)("3", "A")).build(),
-    queries: [
-      ["MATCH (a:A)", "OPTIONAL MATCH (a)-[:R1]->(b:B)", "RETURN a, b"]
-    ],
-    results: [
-      {
-        a: {
-          id: "1"
-        },
-        b: {
-          id: "2"
-        }
-      },
-      {
-        a: {
-          id: "3"
-        },
-        b: null
-      }
-    ]
-  },
-  {
-    name: "Set optional variable to null when no match exists",
-    description: "When all optional matches fail (no connections exist), all optional variables are set to null for all required matches.",
-    graphFactory: () => new import_graph2.GraphBuilder().addNode((0, import_graph2.stubNode)("1", "A")).addNode((0, import_graph2.stubNode)("2", "A")).build(),
-    queries: [
-      ["MATCH (a:A)", "OPTIONAL MATCH (a)-[:R1]->(b:B)", "RETURN a, b"]
-    ],
-    results: [
-      {
-        a: {
-          id: "1"
-        },
-        b: null
-      },
-      {
-        a: {
-          id: "2"
-        },
-        b: null
-      }
-    ]
-  }
-];
-// Annotate the CommonJS export names for ESM import in node:
-0 && (module.exports = {
-  BASIC_OPTIONAL_MATCH_FEATURES
-});