@lowgular/code-graph 0.0.1 → 0.1.2

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
-});

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
-});