@lowgular/code-graph 0.0.1

package/libs/cli/code-graph/src/lib/v2/graph-builder/type.processor.js

@@ -0,0 +1,45 @@
+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 type_processor_exports = {};
+__export(type_processor_exports, {
+  processType: () => processType
+});
+module.exports = __toCommonJS(type_processor_exports);
+var import_typescript = require("@cli/typescript");
+var import_extractors = require("../extractors");
+var import_relationship = require("./relationship.processor");
+const ts = require("typescript");
+const processType = (context, nodeExtractors, codeGraph) => {
+  const nodeId = context.args.typeChecker.typeToString(
+    context.args.current
+  );
+  const kindName = "Type";
+  const nodeConfig = nodeExtractors[kindName];
+  const graphNode = {
+    ...nodeConfig && nodeConfig.properties ? (0, import_extractors.extractNodeProperties)(context, nodeConfig.properties) : {},
+    id: nodeId,
+    labels: [kindName]
+  };
+  (0, import_typescript.addNode)(codeGraph, graphNode);
+  (0, import_relationship.processRelationships)(nodeId, context, nodeConfig, codeGraph);
+  return graphNode;
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  processType
+});

package/libs/cli/code-graph/src/lib/v2/index.js

@@ -0,0 +1,37 @@
+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 __reExport = (target, mod, secondTarget) => (__copyProps(target, mod, "default"), secondTarget && __copyProps(secondTarget, mod, "default"));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var v2_exports = {};
+__export(v2_exports, {
+  TOOLSV2: () => TOOLSV2
+});
+module.exports = __toCommonJS(v2_exports);
+var import_build_code_graph = require("./tools/build-code-graph.tool");
+__reExport(v2_exports, require("./extractors"), module.exports);
+__reExport(v2_exports, require("./graph-builder"), module.exports);
+__reExport(v2_exports, require("./tools/build-code-graph.doc"), module.exports);
+const TOOLSV2 = {
+  buildCodeGraph: import_build_code_graph.buildCodeGraphTool
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  TOOLSV2,
+  ...require("./extractors"),
+  ...require("./graph-builder"),
+  ...require("./tools/build-code-graph.doc")
+});

package/libs/cli/code-graph/src/lib/v2/tools/build-code-graph.doc.js

@@ -0,0 +1,220 @@
+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 build_code_graph_doc_exports = {};
+__export(build_code_graph_doc_exports, {
+  BUILD_CODE_GRAPH_DOC: () => BUILD_CODE_GRAPH_DOC
+});
+module.exports = __toCommonJS(build_code_graph_doc_exports);
+var import_cypher = require("@cli/cypher");
+var import_core = require("../../core/core");
+const BUILD_CODE_GRAPH_DOC = `# Build Code Graph
+
+Tool for building a code graph from TypeScript source files using AST-based extraction and relationship configuration.
+
+## Overview
+
+The \`build_code_graph\` tool allows you to:
+- Extract nodes from TypeScript AST
+- Extract properties from nodes using extractor functions code that you provide
+- Create relationships between nodes using AST traversal functions code that you provide
+- Build a graph structure that will be saved to a file
+
+## Graph Structure
+
+The tool creates a graph with:
+
+### Nodes
+- **id**: Unique identifier (filePath + range)
+- **labels**: Array of SyntaxKind names
+- **properties**: Custom properties defined in configuration
+
+### Edges
+- **source**: Source node ID
+- **target**: Target node ID
+- **type**: Relationship type name (from configuration)
+
+### Graph File
+- Saved to \`code-graph.json\` (or path specified in \`graphPath\`)
+- Structure: \`{ nodesById, edgesBySource, edgesByTarget }\`
+
+The extractor loops through the SourceFiles in the project (does not include node_modules) and extracts the nodes based on the nodeExtractors configuration.
+
+## ExtractorGraphConfig
+
+${(0, import_cypher.mb)(
+  `
+export type ExtractorGraphConfig = {
+  nodeExtractors: NodeExtractors;
+};
+
+export type NodeExtractors = Record<string, NodeExtractorConfig>;
+
+export type NodeExtractorConfig = {
+  properties: Record<string, string>; // property name -> Extractor function code that you provide to extract the property
+  relationships?: Record<
+    string, // name of relationship: HAS_PARAMETER, HAS_CHILD, HAS_DESCENDANT, etc.
+    {
+      extractorCode: string; // Extractor function code that you provide to extract the relationship
+      nodeExtractors: NodeExtractors;
+    }
+  >;
+};
+
+`,
+  "typescript"
+)}
+
+### Extracting Nodes
+
+For each node, the extractor will execute the properties extractor code and create a node with the properties.
+
+${(0, import_cypher.mb)(
+  `{
+  "ClassDeclaration": {
+    "properties": {
+      "name": "args.current.name.getText();", // this will map ClassDeclaration name text to property 'name'
+      "filePath": "args.sourceFile.fileName;" // this will map current SourceFile path to property 'filePath'
+    }
+  }
+}
+`,
+  "json"
+)}
+
+This will create ClassDeclaration nodes with \`name\` and \`filePath\` properties.
+
+### Property Configuration
+
+Properties are defined as a map where:
+- **Key**: Property name (can be anything you want)
+- **Value**: Extractor function name (must be a predefined function from the propertyExtractorContents map)
+
+${(0, import_cypher.mb)(
+  `{
+  "properties": {
+    "name": "args.current.name?.getText();",
+    "filePath": "args.sourceFile.fileName;",
+    "hasDecorators": "args.ts.getDecorators(args.current)?.length > 0 || false;"
+  }
+}
+`,
+  "json"
+)}
+
+**Return Types for Properties:**
+- Primitive types: \`string\`, \`number\`, \`boolean\`
+- Arrays of primitives: \`string[]\`, \`number[]\`, \`boolean[]\`
+- \`null\` and \`undefined\` are allowed but will be ignored (property won't be set)
+
+Related resource:
+${(0, import_core.ml)({
+  name: "Extractors",
+  id: "build-code-graph-extractors"
+})}
+
+## Relationships
+
+If the extractor config has relationships property, then you must strictly follow the following example:
+
+${(0, import_cypher.mb)(
+  JSON.stringify(
+    {
+      ClassDeclaration: {
+        properties: {
+          name: "args.current.name?.getText();"
+        },
+        relationships: {
+          HAS_METHOD: {
+            extractorCode: "helpers.getDescendantsBy(args.current, (node) => node.kind === args.ts.SyntaxKind.MethodDeclaration);",
+            nodeExtractors: {
+              MethodDeclaration: {
+                properties: {
+                  name: "args.current.name?.getText();"
+                }
+              }
+            }
+          }
+        }
+      }
+    },
+    null,
+    2
+  ),
+  "json"
+)}
+
+This example will create:
+- **nodes**: ClassDeclaration and MethodDeclarations
+- **edges**: HAS_METHOD relationship linking ClassDeclaration to MethodDeclaration
+
+**Important Notes:**
+- The relationship extractor code must return an array of nodes (\`ts.Node[]\` or \`ts.Type[]\`)
+- Each returned node will be processed according to the nested \`nodeExtractors\` configuration
+- Relationships can be nested to create multi-level graphs
+
+### Nested Relationships
+
+Relationships can be nested to create chains:
+
+${(0, import_cypher.mb)(
+  JSON.stringify(
+    {
+      ClassDeclaration: {
+        relationships: {
+          HAS_METHOD: {
+            extractorCode: "helpers.getDescendantsBy(args.current, (node) => node.kind === args.ts.SyntaxKind.MethodDeclaration);",
+            nodeExtractors: {
+              MethodDeclaration: {
+                relationships: {
+                  HAS_PARAMETER: {
+                    extractorCode: "helpers.getDescendantsBy(args.current, (node) => node.kind === args.ts.SyntaxKind.Parameter);",
+                    nodeExtractors: {
+                      Parameter: {
+                        properties: {
+                          name: "args.current.name?.getText();"
+                        }
+                      }
+                    }
+                  }
+                }
+              }
+            }
+          }
+        }
+      }
+    },
+    null,
+    2
+  ),
+  "json"
+)}
+
+This creates:
+- \`ClassDeclaration -[:HAS_METHOD]-> MethodDeclaration\`
+- \`MethodDeclaration -[:HAS_PARAMETER]-> Parameter\`
+
+Related resource:
+${(0, import_core.ml)({
+  name: "Extractors",
+  id: "build-code-graph-extractors"
+})}
+`;
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  BUILD_CODE_GRAPH_DOC
+});

package/libs/cli/code-graph/src/lib/v2/tools/build-code-graph.tool.js

@@ -0,0 +1,42 @@
+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 build_code_graph_tool_exports = {};
+__export(build_code_graph_tool_exports, {
+  buildCodeGraphTool: () => buildCodeGraphTool
+});
+module.exports = __toCommonJS(build_code_graph_tool_exports);
+var import_codegular = require("@core/codegular");
+var import_fs = require("fs");
+var import_graph_builder = require("../graph-builder");
+async function buildCodeGraphTool(tsConfigPath, config) {
+  const program = (0, import_codegular.createProgramFromTsConfig)(tsConfigPath);
+  const graph = (0, import_graph_builder.buildCodeGraph)(program, config);
+  const nodeCount = Object.keys(graph.nodesById).length;
+  const edgeCount = Object.values(graph.edgesBySource).flat().length;
+  const graphPath = tsConfigPath.replace("tsconfig.json", "code-graph.json");
+  (0, import_fs.writeFileSync)(graphPath, JSON.stringify(graph, null, 2));
+  return {
+    graphPath,
+    nodeCount,
+    edgeCount
+  };
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  buildCodeGraphTool
+});

package/libs/cli/cypher/src/index.js

@@ -0,0 +1,25 @@
+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 __reExport = (target, mod, secondTarget) => (__copyProps(target, mod, "default"), secondTarget && __copyProps(secondTarget, mod, "default"));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var src_exports = {};
+module.exports = __toCommonJS(src_exports);
+__reExport(src_exports, require("./lib/docs/features"), module.exports);
+__reExport(src_exports, require("./lib/docs/specs"), module.exports);
+__reExport(src_exports, require("./lib/index"), module.exports);
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  ...require("./lib/docs/features"),
+  ...require("./lib/docs/specs"),
+  ...require("./lib/index")
+});

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

@@ -0,0 +1,277 @@
+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
+});