@lowgular/code-graph 0.1.1 → 0.1.2

package/cypher/lib/executor/pattern-matcher.js

@@ -1,86 +0,0 @@
-class PatternMatcher {
-  /**
-   * Check if an edge type matches the relationship pattern's edge type(s)
-   * Supports both single edge type (string) and multiple edge types (array)
-   */
-  matchesEdgeType(edgeType, patternEdgeType) {
-    if (!patternEdgeType) {
-      return true;
-    }
-    if (typeof patternEdgeType === "string") {
-      return edgeType === patternEdgeType;
-    }
-    return patternEdgeType.includes(edgeType);
-  }
-  /**
-   * Deep equality check for arrays
-   */
-  arraysEqual(a, b) {
-    if (a.length !== b.length) {
-      return false;
-    }
-    for (let i = 0; i < a.length; i++) {
-      if (Array.isArray(a[i]) && Array.isArray(b[i])) {
-        if (!this.arraysEqual(a[i], b[i])) {
-          return false;
-        }
-      } else if (a[i] !== b[i]) {
-        return false;
-      }
-    }
-    return true;
-  }
-  /**
-   * Check if two values are equal (handles arrays with deep equality)
-   */
-  valuesEqual(expected, actual) {
-    if (Array.isArray(expected) && Array.isArray(actual)) {
-      return this.arraysEqual(expected, actual);
-    }
-    return expected === actual;
-  }
-  /**
-   * Check if a node matches a pattern (labels and properties)
-   */
-  doesNodeMatchPattern(node, pattern) {
-    if (pattern.labels.length > 0) {
-      const labelOperator = pattern.labelOperator || "AND";
-      if (labelOperator === "AND") {
-        if (!pattern.labels.every((label) => node.labels.includes(label))) {
-          return false;
-        }
-      } else {
-        if (!pattern.labels.some((label) => node.labels.includes(label))) {
-          return false;
-        }
-      }
-    }
-    if (pattern.properties) {
-      const notFound = Object.entries(pattern.properties).find(
-        ([key, expectedValue]) => !this.valuesEqual(expectedValue, node[key])
-      ) !== void 0;
-      if (notFound) {
-        return false;
-      }
-    }
-    return true;
-  }
-  findMatchingNodes(graph, pattern) {
-    return Object.values(graph.nodesById).find(
-      (node) => this.doesNodeMatchPattern(node, pattern)
-    );
-  }
-  /**
-   * Match a single node pattern
-   * Finds all nodes in the graph that match the given pattern
-   * Reuses matchesPattern to avoid code duplication
-   */
-  filterMatchingNodes(graph, pattern) {
-    return Object.values(graph.nodesById).filter(
-      (node) => this.doesNodeMatchPattern(node, pattern)
-    );
-  }
-}
-export {
-  PatternMatcher
-};

package/cypher/lib/executor/relationship-navigator.js

@@ -1,41 +0,0 @@
-class RelationshipNavigator {
-  constructor(patternMatcher) {
-    this.patternMatcher = patternMatcher;
-  }
-  /**
-   * Find nodes and edges connected via a relationship from the given node
-   * Returns both the connected node and the edge that connects them
-   */
-  findConnectedNodesAndEdges(graph, node, relationship) {
-    const connections = [];
-    const seenNodeIds = /* @__PURE__ */ new Set();
-    if (relationship.direction === "outgoing" || relationship.direction === "both") {
-      const outgoingEdges = graph.edgesBySource[node.id] || [];
-      for (const edge of outgoingEdges) {
-        if (this.patternMatcher.matchesEdgeType(edge.type, relationship.edgeType)) {
-          const targetNode = graph.nodesById[edge.target];
-          if (targetNode && !seenNodeIds.has(targetNode.id)) {
-            seenNodeIds.add(targetNode.id);
-            connections.push({ node: targetNode, edge });
-          }
-        }
-      }
-    }
-    if (relationship.direction === "incoming" || relationship.direction === "both") {
-      const incomingEdges = graph.edgesByTarget[node.id] || [];
-      for (const edge of incomingEdges) {
-        if (this.patternMatcher.matchesEdgeType(edge.type, relationship.edgeType)) {
-          const sourceNode = graph.nodesById[edge.source];
-          if (sourceNode && !seenNodeIds.has(sourceNode.id)) {
-            seenNodeIds.add(sourceNode.id);
-            connections.push({ node: sourceNode, edge });
-          }
-        }
-      }
-    }
-    return connections;
-  }
-}
-export {
-  RelationshipNavigator
-};

package/cypher/lib/executor/result-formatter.js

@@ -1,149 +0,0 @@
-import { Annonymizer } from "./utils.js";
-const extractGraphNodesFromResult = (results) => {
-  return Object.values(results).filter(
-    (value) => value !== null && typeof value === "object" && "id" in value && "labels" in value
-  );
-};
-class ResultFormatter {
-  constructor() {
-    this.annonymizer = new Annonymizer();
-  }
-  /**
-   * Format a single match value (node or edge) based on extractData flag
-   */
-  formatValue(value) {
-    if (value === null || value === void 0) {
-      return null;
-    }
-    if ("id" in value && "labels" in value) {
-      const node = value;
-      return node;
-    } else {
-      const edge = value;
-      return edge;
-    }
-  }
-  /**
-   * Sort results based on ORDER BY clause
-   */
-  sortResults(results, orderBy) {
-    return [...results].sort((a, b) => {
-      for (const item of orderBy.items) {
-        const valA = this.getPropertyValue(a[item.variable], item.property);
-        const valB = this.getPropertyValue(b[item.variable], item.property);
-        const comparison = this.compareValues(valA, valB, item.direction);
-        if (comparison !== 0)
-          return comparison;
-      }
-      return 0;
-    });
-  }
-  /**
-   * Get property value from an object, handling nested property access
-   */
-  getPropertyValue(obj, property) {
-    if (obj === null || obj === void 0)
-      return null;
-    return property ? obj[property] : obj;
-  }
-  /**
-   * Compare two values with Neo4j-style NULL handling
-   * ASC: NULLs first, then ascending values
-   * DESC: Values descending, then NULLs last
-   */
-  compareValues(a, b, direction) {
-    const aIsNull = a === null || a === void 0;
-    const bIsNull = b === null || b === void 0;
-    if (aIsNull && bIsNull)
-      return 0;
-    if (aIsNull)
-      return direction === "ASC" ? -1 : 1;
-    if (bIsNull)
-      return direction === "ASC" ? 1 : -1;
-    let result;
-    if (typeof a === "string" && typeof b === "string") {
-      result = a.localeCompare(b);
-    } else {
-      result = a < b ? -1 : a > b ? 1 : 0;
-    }
-    return direction === "DESC" ? -result : result;
-  }
-  /**
-   * Format results with RETURN clause
-   * Only includes variables specified in RETURN clause, with optional aliases
-   * If returnAll is true (RETURN *), returns all variables
-   * If distinct is true, deduplicate results based on returned variables' ids
-   */
-  formatResults(results, returnClause) {
-    let processedResults = returnClause.limit ? results.slice(0, returnClause.limit) : results;
-    if (returnClause.distinct) {
-      processedResults = this.deduplicateResults(processedResults, returnClause);
-    }
-    if (returnClause.returnAll) {
-      return this.formatDefault(processedResults);
-    }
-    return processedResults.map((match) => {
-      const result = {};
-      for (const item of returnClause.items) {
-        const variable = item.expression;
-        if (this.annonymizer.isAnonymous(variable)) {
-          continue;
-        }
-        const alias = item.alias || variable;
-        if (variable in match) {
-          const value = match[variable];
-          result[alias] = this.formatValue(value);
-        } else {
-          throw new Error(`Variable ${variable} not found in match results`);
-        }
-      }
-      return result;
-    });
-  }
-  /**
-   * Deduplicate results based on returned variables' ids
-   */
-  deduplicateResults(results, returnClause) {
-    const seen = /* @__PURE__ */ new Map();
-    for (const match of results) {
-      const key = returnClause.items.map((item) => this.getValueId(match[item.expression])).join("|");
-      if (!seen.has(key)) {
-        seen.set(key, match);
-      }
-    }
-    return Array.from(seen.values());
-  }
-  /**
-   * Get a unique identifier for a match result value
-   */
-  getValueId(value) {
-    if (value === null || value === void 0) {
-      return "null";
-    }
-    if ("id" in value && "labels" in value) {
-      return value.id;
-    }
-    const edge = value;
-    return `edge:${edge.source}|${edge.target}|${edge.type}`;
-  }
-  /**
-   * Format results without RETURN clause (default)
-   * Returns all matched variables keyed by their variable names
-   */
-  formatDefault(matches) {
-    return matches.map((match) => {
-      const result = {};
-      for (const [varName, value] of Object.entries(match)) {
-        if (this.annonymizer.isAnonymous(varName)) {
-          continue;
-        }
-        result[varName] = this.formatValue(value);
-      }
-      return result;
-    });
-  }
-}
-export {
-  ResultFormatter,
-  extractGraphNodesFromResult
-};

package/cypher/lib/executor/traverse-engine.js

@@ -1,141 +0,0 @@
-import { Annonymizer } from "./utils.js";
-class TraverseEngine {
-  constructor(patternMatcher, relationshipNavigator) {
-    this.patternMatcher = patternMatcher;
-    this.relationshipNavigator = relationshipNavigator;
-    this.annonymizer = new Annonymizer();
-  }
-  /**
-   * Recursively traverse relationships to match subsequent patterns
-   * Supports returning edges as variables when relationship variable is specified
-   */
-  traverseRelationships(graph, currentNode, currentVarName, remainingPatterns, relationships) {
-    if (remainingPatterns.length === 0) {
-      return [{ [currentVarName]: currentNode }];
-    }
-    const results = [];
-    const nextPattern = remainingPatterns[0];
-    const nextRelationship = relationships[0];
-    const nextVarName = nextPattern.variable || this.annonymizer.generate(currentNode);
-    const remainingPatterns_ = remainingPatterns.slice(1);
-    const remainingRelationships = relationships.slice(1);
-    if (nextRelationship.variableLength) {
-      return this.traverseVariableLengthPath(
-        graph,
-        currentNode,
-        currentVarName,
-        nextRelationship,
-        nextPattern,
-        nextVarName,
-        remainingPatterns_,
-        remainingRelationships
-      );
-    }
-    const connections = this.relationshipNavigator.findConnectedNodesAndEdges(
-      graph,
-      currentNode,
-      nextRelationship
-    );
-    for (const { node: connectedNode, edge } of connections) {
-      if (this.patternMatcher.doesNodeMatchPattern(connectedNode, nextPattern)) {
-        const subMatches = this.traverseRelationships(
-          graph,
-          connectedNode,
-          nextVarName,
-          remainingPatterns_,
-          remainingRelationships
-        );
-        for (const subMatch of subMatches) {
-          const result = {
-            [currentVarName]: currentNode,
-            [nextVarName]: connectedNode,
-            // Always include the connected node
-            ...subMatch
-          };
-          if (nextRelationship.variable && edge) {
-            result[nextRelationship.variable] = edge;
-          }
-          results.push(result);
-        }
-      }
-    }
-    return results;
-  }
-  /**
-   * Traverse variable-length paths (zero or more edges)
-   * Handles cycles by tracking visited nodes
-   */
-  traverseVariableLengthPath(graph, startNode, startVarName, relationship, targetPattern, targetVarName, remainingPatterns, remainingRelationships) {
-    const results = [];
-    const minLength = relationship.minLength ?? 0;
-    const maxLength = relationship.maxLength ?? Infinity;
-    const traverse = (currentNode, pathLength, visited, pathEdges) => {
-      if (pathLength >= minLength && this.patternMatcher.doesNodeMatchPattern(currentNode, targetPattern)) {
-        const subMatches = this.traverseRelationships(
-          graph,
-          currentNode,
-          targetVarName,
-          remainingPatterns,
-          remainingRelationships
-        );
-        for (const subMatch of subMatches) {
-          const result = {
-            [startVarName]: startNode,
-            [targetVarName]: currentNode,
-            ...subMatch
-          };
-          if (relationship.variable && pathEdges.length > 0) {
-            result[relationship.variable] = pathEdges[pathEdges.length - 1];
-          }
-          results.push(result);
-        }
-      }
-      if (pathLength < maxLength) {
-        const connections2 = this.relationshipNavigator.findConnectedNodesAndEdges(
-          graph,
-          currentNode,
-          relationship
-        );
-        for (const { node: nextNode, edge } of connections2) {
-          if (!visited.has(nextNode.id)) {
-            const newVisited = new Set(visited);
-            newVisited.add(nextNode.id);
-            traverse(nextNode, pathLength + 1, newVisited, [
-              ...pathEdges,
-              edge
-            ]);
-          }
-        }
-      }
-    };
-    if (minLength === 0 && this.patternMatcher.doesNodeMatchPattern(startNode, targetPattern)) {
-      const subMatches = this.traverseRelationships(
-        graph,
-        startNode,
-        targetVarName,
-        remainingPatterns,
-        remainingRelationships
-      );
-      for (const subMatch of subMatches) {
-        const result = {
-          [startVarName]: startNode,
-          [targetVarName]: startNode,
-          ...subMatch
-        };
-        results.push(result);
-      }
-    }
-    const connections = this.relationshipNavigator.findConnectedNodesAndEdges(
-      graph,
-      startNode,
-      relationship
-    );
-    for (const { node: nextNode, edge } of connections) {
-      traverse(nextNode, 1, /* @__PURE__ */ new Set([startNode.id, nextNode.id]), [edge]);
-    }
-    return results;
-  }
-}
-export {
-  TraverseEngine
-};

package/cypher/lib/executor/utils.js

@@ -1,14 +0,0 @@
-class Annonymizer {
-  constructor() {
-    this.anonymousVariablePrefix = "annonymous_";
-  }
-  generate(node) {
-    return this.anonymousVariablePrefix + node.id;
-  }
-  isAnonymous(variable) {
-    return variable.startsWith(this.anonymousVariablePrefix);
-  }
-}
-export {
-  Annonymizer
-};

package/cypher/lib/graph.stub.js

@@ -1,38 +0,0 @@
-class GraphBuilder {
-  constructor() {
-    this.graph = {
-      nodesById: {},
-      edgesBySource: {},
-      edgesByTarget: {}
-    };
-  }
-  addNode(node) {
-    this.graph.nodesById[node.id] = node;
-    return this;
-  }
-  addEdge(edge) {
-    if (!this.graph.edgesBySource[edge.source]) {
-      this.graph.edgesBySource[edge.source] = [];
-    }
-    if (!this.graph.edgesByTarget[edge.target]) {
-      this.graph.edgesByTarget[edge.target] = [];
-    }
-    this.graph.edgesBySource[edge.source].push(edge);
-    this.graph.edgesByTarget[edge.target].push(edge);
-    return this;
-  }
-  build() {
-    return this.graph;
-  }
-}
-const stubNode = (id, label = "A", extras = {}) => ({ id, labels: Array.isArray(label) ? label : [label], ...extras });
-const stubEdge = (source, target, type = "A") => ({
-  source,
-  target,
-  type
-});
-export {
-  GraphBuilder,
-  stubEdge,
-  stubNode
-};

package/cypher/lib/index.js

@@ -1,32 +0,0 @@
-import { CypherExecutor } from "./executor/executor.js";
-import { Lexer } from "./lexer.js";
-import { Parser } from "./parser.js";
-import { validateQuery } from "./validator/query-validator.js";
-const buildQueryObject = (query2) => {
-  const joinedQuery = Array.isArray(query2) ? query2.join(" ") : query2;
-  validateQuery(joinedQuery);
-  const lexer = new Lexer(joinedQuery);
-  const tokens = lexer.tokenize();
-  const parser = new Parser(tokens);
-  return parser.parse();
-};
-const query = (queryStatements, graph) => {
-  const queryObject = buildQueryObject(queryStatements);
-  const executor = new CypherExecutor(graph);
-  return executor.execute(queryObject);
-};
-const matchAll = (query2, graph) => {
-  const queryObject = buildQueryObject(query2);
-  queryObject.statements.push({
-    type: "ReturnStatement",
-    returnAll: true,
-    items: []
-  });
-  const executor = new CypherExecutor(graph);
-  return executor.execute(queryObject);
-};
-export {
-  buildQueryObject,
-  matchAll,
-  query
-};