@lowgular/code-graph 0.1.1 → 0.1.2

package/codegular/utils.js

@@ -1,335 +0,0 @@
-import * as path from "path";
-import * as ts from "typescript";
-import { getNameByIdentifier } from "./string.js";
-const { forEachChild, SyntaxKind } = ts;
-function escapeValue(value) {
-  return value.replace(/^['"`]+/i, "").replace(/['"`]+$/i, "");
-}
-const parseObjectLiteralString = (objectLiteralString) => {
-  const result = {};
-  if (!objectLiteralString || typeof objectLiteralString !== "string") {
-    return result;
-  }
-  const code = `const _ = ${objectLiteralString}`;
-  const sourceFile = ts.createSourceFile(
-    "temp.ts",
-    code,
-    ts.ScriptTarget.Latest,
-    true
-  );
-  const findObjectLiteral = (node) => {
-    if (ts.isObjectLiteralExpression(node)) {
-      return node;
-    }
-    return ts.forEachChild(node, findObjectLiteral);
-  };
-  const objectLiteral = findObjectLiteral(sourceFile);
-  if (!objectLiteral) {
-    return result;
-  }
-  for (const property of objectLiteral.properties) {
-    if (ts.isPropertyAssignment(property)) {
-      let key;
-      if (ts.isIdentifier(property.name)) {
-        key = property.name.text;
-      } else if (ts.isStringLiteral(property.name)) {
-        key = property.name.text;
-      } else if (ts.isComputedPropertyName(property.name)) {
-        key = property.name.getText(sourceFile);
-      } else {
-        continue;
-      }
-      const value = property.initializer.getText(sourceFile);
-      result[key] = value;
-    } else if (ts.isShorthandPropertyAssignment(property)) {
-      const key = property.name.text;
-      result[key] = key;
-    }
-  }
-  return result;
-};
-function findFirstChildByKind(node, kind) {
-  let element;
-  forEachChild(node, (child) => {
-    if (child.kind !== kind || !!element) {
-      return;
-    }
-    element = child;
-  });
-  return element;
-}
-function peelCallTarget(expr) {
-  const chain = [];
-  let hasOptional = false;
-  let e = expr;
-  let baseAccess;
-  while (true) {
-    if (ts.isPropertyAccessExpression(e)) {
-      chain.unshift(e.name.text);
-      hasOptional = hasOptional || !!e.questionDotToken;
-      baseAccess = e;
-      e = e.expression;
-      continue;
-    }
-    if (ts.isElementAccessExpression(e)) {
-      const arg = e.argumentExpression;
-      const key = ts.isStringLiteral(arg) || ts.isIdentifier(arg) ? arg.text : "<computed>";
-      chain.unshift(key);
-      hasOptional = hasOptional || !!e.questionDotToken;
-      baseAccess = e;
-      e = e.expression;
-      continue;
-    }
-    break;
-  }
-  return {
-    root: e,
-    basePropAccess: baseAccess,
-    chain,
-    invoked: chain.length ? chain[chain.length - 1] : void 0,
-    hasOptional
-  };
-}
-function getAncestorsBy(node, predicate) {
-  let currentNode = node;
-  const nodes = [];
-  while (currentNode) {
-    if (predicate(currentNode)) {
-      nodes.push(currentNode);
-    }
-    const parent = currentNode?.parent;
-    if (!parent) {
-      break;
-    }
-    currentNode = parent;
-  }
-  return nodes;
-}
-function getAncestorsByKind(node, kind) {
-  return getAncestorsBy(node, (node2) => node2.kind === kind);
-}
-function getAncestorByKind(node, kinds) {
-  let currentNode = node;
-  while (currentNode) {
-    if (kinds.includes(currentNode.kind)) {
-      return currentNode;
-    }
-    currentNode = currentNode.parent;
-  }
-  return void 0;
-}
-function getAllExpressions(node) {
-  const expressions = [];
-  function visit(currentNode) {
-    if (!currentNode)
-      return;
-    if (ts.isExpression(currentNode)) {
-      expressions.push(currentNode);
-    }
-    ts.forEachChild(currentNode, visit);
-  }
-  visit(node);
-  return expressions;
-}
-function getDescendantsBy(node, predicate) {
-  let foundElements = [];
-  let queue = [node];
-  while (queue.length > 0) {
-    const currentNode = queue.shift();
-    const children = Array.from(
-      currentNode?.getChildren(node.getSourceFile()) || []
-    );
-    foundElements = [
-      ...foundElements,
-      ...children.filter((node2) => predicate(node2))
-    ];
-    queue = [...queue, ...children];
-  }
-  return foundElements;
-}
-function getDescendantsByKind(node, kind) {
-  return getDescendantsBy(node, (node2) => node2.kind === kind);
-}
-function getDescendantsByKinds(node, kinds) {
-  return getDescendantsBy(node, (node2) => kinds.includes(node2.kind));
-}
-function getDescendantByName(node, name) {
-  return getDescendantsBy(
-    node,
-    (node2) => getNameByIdentifier(node2) === name
-  );
-}
-function findFirstChildByKinds(node, kinds) {
-  let element;
-  forEachChild(node, (child) => {
-    if (!kinds.includes(child.kind) || !!element) {
-      return;
-    }
-    element = child;
-  });
-  return element;
-}
-function findChildrenByKinds(node, kinds) {
-  const elements = [];
-  forEachChild(node, (child) => {
-    if (!kinds.includes(child.kind)) {
-      return;
-    }
-    elements.push(child);
-  });
-  return elements;
-}
-function findChildrenByKind(node, kind) {
-  return findChildrenByKinds(node, [kind]);
-}
-function findChildrenByName(sourceFile, node, name) {
-  const elements = [];
-  forEachChild(node, (child) => {
-    const [nameNode] = findChildrenByKind(child, SyntaxKind.Identifier);
-    if (nameNode?.getText(sourceFile) !== name) {
-      return;
-    }
-    elements.push(child);
-  });
-  return elements;
-}
-function findChildByName(sourceFile, node, name) {
-  let element;
-  forEachChild(node, (child) => {
-    const [nameNode] = findChildrenByKind(child, SyntaxKind.Identifier);
-    if (nameNode?.getText(sourceFile) !== name) {
-      return;
-    }
-    element = child;
-  });
-  return element;
-}
-function findChildByIndex(node, index) {
-  let element;
-  let i = 0;
-  forEachChild(node, (child) => {
-    if (i !== index) {
-      i++;
-      return;
-    }
-    element = child;
-  });
-  return element;
-}
-function consoleAllChildren(sourceFile, node) {
-  forEachChild(node, (child) => {
-    console.log(child.kind, child.getText(sourceFile));
-  });
-}
-function parseArrayLiteralExpression(sourceFile, node) {
-  return findChildrenByKind(node, SyntaxKind.ObjectLiteralExpression).map(
-    (obj) => {
-      return parseObjectLiteralExpression(sourceFile, obj);
-    }
-  );
-}
-function parseObjectLiteralExpression(sourceFile, node) {
-  return findChildrenByKind(node, SyntaxKind.PropertyAssignment).reduce(
-    (state, currentNode) => {
-      const [property, _, value] = Array.from(
-        currentNode?.getChildren(sourceFile) || []
-      );
-      if (value.kind === SyntaxKind.ObjectLiteralExpression) {
-        const obj = parseObjectLiteralExpression(sourceFile, value);
-        return {
-          ...state,
-          ...Object.keys(obj).reduce((s, k) => {
-            return {
-              ...s,
-              [property.getText(sourceFile) + "." + k]: escapeValue(obj[k])
-            };
-          }, {})
-        };
-      }
-      return {
-        ...state,
-        [property.getText(sourceFile)]: escapeValue(value.getText(sourceFile))
-      };
-    },
-    {}
-  );
-}
-const isComment = (content) => content.match(/^\s*\/\/.*/) !== null;
-const extractCommentContent = (content) => content.replace(/^\s*\/\/\s*/, "");
-const getComments = (nodeContent) => {
-  const blockLines = nodeContent.split("\r\n");
-  const comments = blockLines.filter(isComment).map(extractCommentContent);
-  return comments;
-};
-function findTypeDeclarationByName(sourceFile, typeName) {
-  let result;
-  function visit(node) {
-    if (ts.isInterfaceDeclaration(node) || ts.isClassDeclaration(node) || ts.isTypeAliasDeclaration(node)) {
-      const name = node.name?.getText(sourceFile);
-      if (name === typeName) {
-        result = node;
-        return;
-      }
-    }
-    ts.forEachChild(node, visit);
-  }
-  visit(sourceFile);
-  return result;
-}
-const getSolutionSourceFiles = (program) => {
-  const allSourceFiles = program.getSourceFiles();
-  const sourceFiles = allSourceFiles.filter((sourceFile) => {
-    const fileName = sourceFile.fileName;
-    if (fileName.includes("node_modules")) {
-      return false;
-    }
-    if (fileName.endsWith(".d.ts")) {
-      return false;
-    }
-    return true;
-  });
-  return sourceFiles;
-};
-function readSourceFiles(tsConfigPath) {
-  const configFile = ts.readConfigFile(tsConfigPath, ts.sys.readFile);
-  if (configFile.error) {
-    throw new Error("Error reading tsconfig at " + tsConfigPath);
-  }
-  const parsedConfig = ts.parseJsonConfigFileContent(
-    configFile.config,
-    ts.sys,
-    path.dirname(tsConfigPath)
-  );
-  const program = ts.createProgram(
-    parsedConfig.fileNames,
-    parsedConfig.options
-  );
-  return { sourceFiles: getSolutionSourceFiles(program), program };
-}
-export {
-  consoleAllChildren,
-  escapeValue,
-  findChildByIndex,
-  findChildByName,
-  findChildrenByKind,
-  findChildrenByKinds,
-  findChildrenByName,
-  findFirstChildByKind,
-  findFirstChildByKinds,
-  findTypeDeclarationByName,
-  getAllExpressions,
-  getAncestorByKind,
-  getAncestorsBy,
-  getAncestorsByKind,
-  getComments,
-  getDescendantByName,
-  getDescendantsBy,
-  getDescendantsByKind,
-  getDescendantsByKinds,
-  getSolutionSourceFiles,
-  parseArrayLiteralExpression,
-  parseObjectLiteralExpression,
-  parseObjectLiteralString,
-  peelCallTarget,
-  readSourceFiles
-};

package/cypher/index.js

@@ -1 +0,0 @@
-export * from "./lib/index.js";

package/cypher/lib/executor/condition-evaluator.js

@@ -1,135 +0,0 @@
-class ConditionEvaluator {
-  // @TODO: apply where at match level
-  /**
-   * Apply WHERE clause filtering to matches
-   */
-  applyWhereClauseIfNeeded(matches, where) {
-    return matches.filter((match) => {
-      const conditionResults = where.conditions.map(
-        (condition) => this.evaluateCondition(match, condition)
-      );
-      const logic = where.logic || "AND";
-      if (logic === "AND") {
-        return conditionResults.every((result) => result === true);
-      } else {
-        return conditionResults.some((result) => result === true);
-      }
-    });
-  }
-  // @fixme move to utils
-  /**
-   * Escape special regex characters in a string
-   */
-  escapeRegex(str) {
-    return str.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
-  }
-  /**
-   * Evaluate a single WHERE condition
-   * Supports flat properties only (no nesting, like Neo4j Cypher)
-   * Handles null values from optional matches (null values fail the condition)
-   */
-  evaluateCondition(match, condition) {
-    const value = match[condition.variable];
-    if ((condition.operator === "IS NULL" || condition.operator === "IS NOT NULL") && !condition.property) {
-      const isNull = value === null || value === void 0;
-      return condition.operator === "IS NULL" ? isNull : !isNull;
-    }
-    if (!value || value === null) {
-      return false;
-    }
-    let baseObject;
-    if ("id" in value) {
-      baseObject = value;
-    } else if ("type" in value && "source" in value) {
-      baseObject = value;
-    } else {
-      return false;
-    }
-    let actualValue;
-    if (!condition.property) {
-      actualValue = baseObject;
-    } else {
-      actualValue = baseObject[condition.property];
-      if (actualValue === void 0) {
-        if (condition.operator === "IS NULL" || condition.operator === "IS NOT NULL") {
-          actualValue = void 0;
-        } else {
-          return false;
-        }
-      }
-    }
-    const conditionValue = condition.value;
-    switch (condition.operator) {
-      case "=":
-        return actualValue === conditionValue;
-      case "!=":
-        return actualValue !== conditionValue;
-      case ">":
-        return actualValue > conditionValue;
-      case "<":
-        return actualValue < conditionValue;
-      case ">=":
-        return actualValue >= conditionValue;
-      case "<=":
-        return actualValue <= conditionValue;
-      case "IS NULL":
-        return actualValue === null || actualValue === void 0;
-      case "IS NOT NULL":
-        return actualValue !== null && actualValue !== void 0;
-      case "IN":
-        if (Array.isArray(conditionValue)) {
-          if (conditionValue.length > 0 && typeof conditionValue[0] === "object" && conditionValue[0] !== null) {
-            const extractedValues = conditionValue.map((item) => item?.name).filter((name) => name !== void 0);
-            return extractedValues.includes(actualValue);
-          }
-          return conditionValue.includes(actualValue);
-        }
-        return false;
-      case "NOT IN":
-        if (Array.isArray(conditionValue)) {
-          if (conditionValue.length > 0 && typeof conditionValue[0] === "object" && conditionValue[0] !== null) {
-            const extractedValues = conditionValue.map((item) => item?.name).filter((name) => name !== void 0);
-            return !extractedValues.includes(actualValue);
-          }
-          return !conditionValue.includes(actualValue);
-        }
-        return true;
-      case "STARTS WITH":
-        return this.testRegex(
-          new RegExp(`^${this.escapeRegex(conditionValue)}`),
-          actualValue
-        );
-      case "ENDS WITH":
-        return this.testRegex(
-          new RegExp(`${this.escapeRegex(conditionValue)}$`),
-          actualValue
-        );
-      case "CONTAINS":
-        return this.testRegex(
-          new RegExp(this.escapeRegex(conditionValue)),
-          actualValue
-        );
-      case "=~":
-        return this.testRegex(new RegExp(conditionValue), actualValue);
-      default:
-        throw new Error(`Unsupported operator: ${condition.operator}`);
-    }
-  }
-  testRegex(regexp, actualValue) {
-    if (actualValue === null || actualValue === void 0) {
-      return false;
-    }
-    if (typeof actualValue !== "string" && typeof actualValue !== "number" && typeof actualValue !== "boolean") {
-      return false;
-    }
-    const regexStr = typeof actualValue === "string" ? actualValue : String(actualValue);
-    try {
-      return regexp.test(regexStr);
-    } catch {
-      return false;
-    }
-  }
-}
-export {
-  ConditionEvaluator
-};

package/cypher/lib/executor/executor.js

@@ -1,60 +0,0 @@
-import { ConditionEvaluator } from "./condition-evaluator.js";
-import { MatchEngine } from "./match-engine.js";
-import { PatternMatcher } from "./pattern-matcher.js";
-import { RelationshipNavigator } from "./relationship-navigator.js";
-import { ResultFormatter } from "./result-formatter.js";
-import { TraverseEngine } from "./traverse-engine.js";
-class CypherExecutor {
-  constructor(graph) {
-    this.graph = graph;
-    this.conditionEvaluator = new ConditionEvaluator();
-    const patternMatcher = new PatternMatcher();
-    const relationshipNavigator = new RelationshipNavigator(patternMatcher);
-    const traverseEngine = new TraverseEngine(
-      patternMatcher,
-      relationshipNavigator
-    );
-    this.matchEngine = new MatchEngine(patternMatcher, traverseEngine);
-    this.resultFormatter = new ResultFormatter();
-  }
-  /**
-   * Execute a parsed Cypher query
-   * @param extractData - If true (default), returns node.data. If false, returns full GraphNode objects.
-   * For edges, always returns the full GraphEdge object (edges have no data property).
-   * Returns results where keys are variable names and values are either node data or edge objects
-   */
-  execute(query) {
-    if (query.statements.length === 0) {
-      throw new Error("Query must have at least one statement");
-    }
-    if (query.statements[query.statements.length - 1].type !== "ReturnStatement") {
-      throw new Error("MATCH Query must have a RETURN statement");
-    }
-    let results = [];
-    for (const statement of query.statements) {
-      if (statement.type === "MatchStatement") {
-        results = this.matchEngine.processMatchStatement(
-          this.graph,
-          statement,
-          results
-        );
-      } else if (statement.type === "WhereStatement") {
-        results = this.conditionEvaluator.applyWhereClauseIfNeeded(
-          results,
-          statement
-        );
-      } else if (statement.type === "OrderByStatement") {
-        results = this.resultFormatter.sortResults(results, statement);
-      }
-    }
-    const returnStatement = query.statements[query.statements.length - 1];
-    let formattedResults = this.resultFormatter.formatResults(
-      results,
-      returnStatement
-    );
-    return formattedResults;
-  }
-}
-export {
-  CypherExecutor
-};

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

@@ -1,130 +0,0 @@
-import { Annonymizer } from "./utils.js";
-class MatchEngine {
-  constructor(patternMatcher, traverseEngine) {
-    this.patternMatcher = patternMatcher;
-    this.traverseEngine = traverseEngine;
-    this.annonymizer = new Annonymizer();
-  }
-  processMatchStatement(graph, match, existingResults = []) {
-    if (match.patterns.length === 0)
-      return existingResults;
-    const starting = match.patterns[0];
-    const allResults = [];
-    this.patternMatcher.filterMatchingNodes(graph, starting).forEach((node) => {
-      const matches = this.traverseEngine.traverseRelationships(
-        graph,
-        node,
-        starting.variable || this.annonymizer.generate(node),
-        match.patterns.slice(1),
-        match.relationships
-      );
-      allResults.push(...matches);
-    });
-    if (existingResults.length > 0) {
-      if (match.optional) {
-        return this.mergeOptionalResults(existingResults, allResults, match);
-      } else {
-        return this.mergeResults(existingResults, allResults);
-      }
-    }
-    return allResults;
-  }
-  mergeResults(existingResults, newResults) {
-    if (existingResults.length === 0) {
-      return newResults;
-    }
-    const mergedResults = [];
-    for (const existingResult of existingResults) {
-      for (const newResult of newResults) {
-        if (this.canMergeResult(existingResult, newResult)) {
-          mergedResults.push({ ...existingResult, ...newResult });
-        }
-      }
-    }
-    return mergedResults;
-  }
-  /**
-   * Merge optional match results with existing results (left outer join)
-   * - Keeps all existing results
-   * - Merges optional results where variables overlap
-   * - Adds nulls for optional variables when no match is found
-   */
-  mergeOptionalResults(existingResults, optionalResults, match) {
-    if (existingResults.length === 0) {
-      return optionalResults;
-    }
-    const optionalVarNames = /* @__PURE__ */ new Set();
-    for (const pattern of match.patterns) {
-      if (pattern.variable) {
-        optionalVarNames.add(pattern.variable);
-      }
-    }
-    if (match.relationships) {
-      for (const rel of match.relationships) {
-        if (rel.variable) {
-          optionalVarNames.add(rel.variable);
-        }
-      }
-    }
-    if (optionalResults.length === 0) {
-      return existingResults.map((result) => {
-        const resultWithNulls = { ...result };
-        for (const varName of optionalVarNames) {
-          if (!(varName in resultWithNulls)) {
-            resultWithNulls[varName] = null;
-          }
-        }
-        return resultWithNulls;
-      });
-    }
-    for (const optionalResult of optionalResults) {
-      for (const key in optionalResult) {
-        optionalVarNames.add(key);
-      }
-    }
-    const mergedResults = [];
-    for (const existingResult of existingResults) {
-      let hasMatch = false;
-      for (const optionalResult of optionalResults) {
-        if (this.canMergeResult(existingResult, optionalResult)) {
-          mergedResults.push({ ...existingResult, ...optionalResult });
-          hasMatch = true;
-        }
-      }
-      if (!hasMatch) {
-        const resultWithNulls = { ...existingResult };
-        for (const varName of optionalVarNames) {
-          if (!(varName in resultWithNulls)) {
-            resultWithNulls[varName] = null;
-          }
-        }
-        mergedResults.push(resultWithNulls);
-      }
-    }
-    return mergedResults;
-  }
-  /**
-   * Check if additionalResult can be merged with existingResult
-   * Returns true if shared variables match (same node/edge) or if there are no conflicts
-   * Does NOT mutate any parameters
-   */
-  canMergeResult(additionalResult, existingResult) {
-    for (const key in additionalResult) {
-      if (key in existingResult) {
-        const existing = existingResult[key];
-        const additional = additionalResult[key];
-        if (existing !== null && additional !== null) {
-          if ("id" in existing && "id" in additional && existing.id !== additional.id) {
-            return false;
-          }
-        } else if (existing !== additional) {
-          return false;
-        }
-      }
-    }
-    return true;
-  }
-}
-export {
-  MatchEngine
-};