@lowgular/code-graph 0.1.1 → 0.1.2

package/cypher/lib/parser.js

@@ -1,586 +0,0 @@
-import { TokenType } from "./lexer.js";
-class Parser {
-  constructor(tokens) {
-    this.tokens = [];
-    this.position = 0;
-    this.tokens = tokens;
-  }
-  current() {
-    return this.tokens[this.position];
-  }
-  advance() {
-    const token = this.current();
-    if (this.position < this.tokens.length - 1) {
-      this.position++;
-    }
-    return token;
-  }
-  peek() {
-    return this.tokens[this.position + 1] || this.tokens[this.tokens.length - 1];
-  }
-  expect(type) {
-    const token = this.current();
-    if (token.type !== type) {
-      throw new Error(
-        `Expected ${type}, got ${token.type} at position ${token.position}`
-      );
-    }
-    return this.advance();
-  }
-  isKeyword(keyword) {
-    return this.current().type === keyword;
-  }
-  /**
-   * Parse a property object: { key: value, ... }
-   * Note: Cypher uses colon (:) for properties in node patterns, not equals (=)
-   */
-  parseProperties() {
-    this.expect(TokenType.LBRACE);
-    const properties = {};
-    if (this.current().type === TokenType.RBRACE) {
-      this.advance();
-      return properties;
-    }
-    while (true) {
-      const key = this.expect(TokenType.IDENTIFIER).value;
-      this.expect(TokenType.LABEL);
-      let value;
-      if (this.current().type === TokenType.LBRACKET) {
-        value = this.parseArrayLiteral();
-      } else if (this.current().type === TokenType.STRING) {
-        value = this.advance().value;
-      } else if (this.current().type === TokenType.NUMBER) {
-        value = parseFloat(this.advance().value);
-      } else if (this.current().type === TokenType.TRUE) {
-        value = true;
-        this.advance();
-      } else if (this.current().type === TokenType.FALSE) {
-        value = false;
-        this.advance();
-      } else if (this.current().type === TokenType.IDENTIFIER) {
-        value = this.advance().value;
-      } else {
-        throw new Error(
-          `Unexpected token type for property value: ${this.current().type}`
-        );
-      }
-      properties[key] = value;
-      if (this.current().type === TokenType.RBRACE) {
-        this.advance();
-        break;
-      }
-      this.expect(TokenType.COMMA);
-    }
-    return properties;
-  }
-  /**
-   * Parse a node pattern: (var:Label {prop: value}) or (:Label {prop: value})
-   */
-  parseNodePattern() {
-    this.expect(TokenType.LPAREN);
-    const pattern = {
-      type: "NodePattern",
-      labels: []
-    };
-    if (this.current().type === TokenType.IDENTIFIER) {
-      const nextToken = this.peek();
-      if (nextToken.type === TokenType.LABEL || nextToken.type === TokenType.LBRACE || nextToken.type === TokenType.RPAREN) {
-        pattern.variable = this.advance().value;
-      }
-    }
-    if (this.current().type === TokenType.LABEL) {
-      this.advance();
-      if (this.current().type !== TokenType.IDENTIFIER) {
-        throw new Error(
-          `Expected identifier after :, got ${this.current().type}`
-        );
-      }
-      pattern.labels.push(this.advance().value);
-      if (this.current().type === TokenType.LABEL) {
-        pattern.labelOperator = "AND";
-        while (this.current().type === TokenType.LABEL) {
-          this.advance();
-          if (this.current().type === TokenType.IDENTIFIER) {
-            pattern.labels.push(this.advance().value);
-          } else {
-            throw new Error(
-              `Expected identifier after :, got ${this.current().type}`
-            );
-          }
-        }
-      } else if (this.current().type === TokenType.PIPE) {
-        pattern.labelOperator = "OR";
-        while (this.current().type === TokenType.PIPE) {
-          this.advance();
-          if (this.current().type === TokenType.IDENTIFIER) {
-            pattern.labels.push(this.advance().value);
-          } else {
-            throw new Error(
-              `Expected identifier after |, got ${this.current().type}`
-            );
-          }
-        }
-      } else {
-        pattern.labelOperator = "AND";
-      }
-    }
-    if (this.current().type === TokenType.LBRACE) {
-      pattern.properties = this.parseProperties();
-    }
-    this.expect(TokenType.RPAREN);
-    return pattern;
-  }
-  /**
-   * Parse relationship pattern: -[:RELATIONSHIP_TYPE]-> or <-[:RELATIONSHIP_TYPE]- or -[r:RELATIONSHIP_TYPE]->
-   */
-  parseRelationship() {
-    const relationship = {
-      type: "RelationshipPattern",
-      direction: "outgoing"
-    };
-    if (this.current().type === TokenType.ARROW && this.current().value === "<-") {
-      relationship.direction = "incoming";
-      this.advance();
-    } else {
-      this.expect(TokenType.DASH);
-    }
-    if (this.current().type === TokenType.LBRACKET) {
-      this.advance();
-      if (this.current().type === TokenType.IDENTIFIER) {
-        const nextToken = this.peek();
-        if (nextToken.type === TokenType.LABEL || nextToken.type === TokenType.ASTERISK) {
-          relationship.variable = this.advance().value;
-        }
-      }
-      if (this.current().type === TokenType.ASTERISK) {
-        this.advance();
-        relationship.variableLength = true;
-        relationship.minLength = 0;
-        relationship.maxLength = void 0;
-      } else if (this.current().type === TokenType.LABEL) {
-        this.advance();
-        const edgeTypes = [];
-        edgeTypes.push(this.expect(TokenType.IDENTIFIER).value);
-        while (this.current().type === TokenType.PIPE) {
-          this.advance();
-          edgeTypes.push(this.expect(TokenType.IDENTIFIER).value);
-        }
-        relationship.edgeType = edgeTypes.length === 1 ? edgeTypes[0] : edgeTypes;
-        if (this.current().type === TokenType.ASTERISK) {
-          this.advance();
-          relationship.variableLength = true;
-          relationship.minLength = 0;
-          relationship.maxLength = void 0;
-        }
-      }
-      this.expect(TokenType.RBRACKET);
-    }
-    if (relationship.direction === "incoming") {
-      this.expect(TokenType.DASH);
-    } else {
-      if (this.current().type === TokenType.ARROW && this.current().value === "->") {
-        this.advance();
-      } else if (this.current().type === TokenType.DASH) {
-        relationship.direction = "both";
-        this.advance();
-      }
-    }
-    return relationship;
-  }
-  /**
-   * Parse MATCH clause (supports OPTIONAL MATCH)
-   */
-  parseMatch() {
-    const isOptional = this.isKeyword(TokenType.OPTIONAL);
-    if (isOptional) {
-      this.advance();
-    }
-    this.expect(TokenType.MATCH);
-    const firstPattern = this.parsePatternChain();
-    const matchClause = {
-      type: "MatchClause",
-      patterns: firstPattern.patterns,
-      relationships: firstPattern.relationships,
-      additionalMatches: []
-    };
-    while (this.current().type === TokenType.COMMA) {
-      this.advance();
-      const additionalPattern = this.parsePatternChain();
-      matchClause.additionalMatches.push(additionalPattern);
-    }
-    if (isOptional) {
-      matchClause.optionalMatches = [
-        {
-          type: "MatchStatement",
-          patterns: firstPattern.patterns,
-          relationships: firstPattern.relationships
-        },
-        ...matchClause.additionalMatches || []
-      ];
-      matchClause.patterns = [];
-      matchClause.relationships = void 0;
-      matchClause.additionalMatches = void 0;
-    }
-    return matchClause;
-  }
-  /**
-   * Parse a pattern chain: (node)-[:rel]->(node)-[:rel]->(node)...
-   * Returns patterns and relationships for a single connected pattern
-   */
-  parsePatternChain() {
-    const patterns = [];
-    const relationships = [];
-    patterns.push(this.parseNodePattern());
-    while (this.current().type === TokenType.DASH || this.current().type === TokenType.ARROW) {
-      relationships.push(this.parseRelationship());
-      patterns.push(this.parseNodePattern());
-    }
-    return {
-      type: "MatchStatement",
-      patterns,
-      relationships: relationships.length > 0 ? relationships : void 0
-    };
-  }
-  /**
-   * Parse WHERE clause
-   * Example: WHERE m.type = "Command" AND "param" IN m.parameters
-   * Note: Flat properties only (no nesting, like Neo4j Cypher)
-   */
-  parseWhere() {
-    this.expect(TokenType.WHERE);
-    const conditions = [];
-    let logic;
-    while (true) {
-      const variable = this.expect(TokenType.IDENTIFIER).value;
-      let property;
-      if (this.current().type === TokenType.DOT) {
-        this.advance();
-        property = this.expect(TokenType.IDENTIFIER).value;
-      }
-      let operator = "=";
-      if (this.current().type === TokenType.EQUALS) {
-        operator = "=";
-        this.advance();
-      } else if (this.current().type === TokenType.NOT_EQUALS) {
-        operator = "!=";
-        this.advance();
-      } else if (this.current().type === TokenType.GT) {
-        operator = ">";
-        this.advance();
-      } else if (this.current().type === TokenType.LT) {
-        operator = "<";
-        this.advance();
-      } else if (this.current().type === TokenType.GTE) {
-        operator = ">=";
-        this.advance();
-      } else if (this.current().type === TokenType.LTE) {
-        operator = "<=";
-        this.advance();
-      } else if (this.current().type === TokenType.NOT) {
-        this.advance();
-        this.expect(TokenType.IN);
-        operator = "NOT IN";
-      } else if (this.current().type === TokenType.IN) {
-        this.advance();
-        operator = "IN";
-      } else if (this.current().type === TokenType.IS) {
-        this.advance();
-        if (this.isKeyword(TokenType.NULL)) {
-          this.advance();
-          operator = "IS NULL";
-        } else if (this.isKeyword(TokenType.NOT)) {
-          this.advance();
-          this.expect(TokenType.NULL);
-          operator = "IS NOT NULL";
-        } else {
-          throw new Error(
-            `Expected NULL or NOT NULL after IS at position ${this.current().position}`
-          );
-        }
-      } else if (this.current().type === TokenType.STARTS) {
-        this.advance();
-        this.expect(TokenType.WITH);
-        operator = "STARTS WITH";
-      } else if (this.current().type === TokenType.ENDS) {
-        this.advance();
-        this.expect(TokenType.WITH);
-        operator = "ENDS WITH";
-      } else if (this.current().type === TokenType.CONTAINS) {
-        operator = "CONTAINS";
-        this.advance();
-      } else if (this.current().type === TokenType.REGEX_MATCH) {
-        operator = "=~";
-        this.advance();
-      } else {
-        throw new Error(
-          `Unsupported operator at position ${this.current().position}.`
-        );
-      }
-      let value = null;
-      if (operator === "IS NULL" || operator === "IS NOT NULL") {
-      } else if (operator === "STARTS WITH" || operator === "ENDS WITH" || operator === "CONTAINS" || operator === "=~") {
-        if (this.current().type === TokenType.STRING) {
-          value = this.advance().value;
-        } else {
-          throw new Error(
-            `String matching operators (${operator}) require a string value at position ${this.current().position}`
-          );
-        }
-      } else if (this.current().type === TokenType.LBRACKET) {
-        value = this.parseArrayLiteral();
-      } else if (this.current().type === TokenType.STRING) {
-        value = this.advance().value;
-      } else if (this.current().type === TokenType.NUMBER) {
-        value = parseFloat(this.advance().value);
-      } else if (this.current().type === TokenType.TRUE) {
-        value = true;
-        this.advance();
-      } else if (this.current().type === TokenType.FALSE) {
-        value = false;
-        this.advance();
-      } else if (this.current().type === TokenType.IDENTIFIER) {
-        value = this.advance().value;
-      } else {
-        throw new Error(
-          `Unexpected token type for WHERE value: ${this.current().type}`
-        );
-      }
-      conditions.push({ variable, property, operator, value });
-      if (this.isKeyword(TokenType.AND)) {
-        if (logic === void 0) {
-          logic = "AND";
-        } else if (logic !== "AND") {
-          throw new Error("Cannot mix AND and OR in WHERE clause");
-        }
-        this.advance();
-        continue;
-      } else if (this.isKeyword(TokenType.OR)) {
-        if (logic === void 0) {
-          logic = "OR";
-        } else if (logic !== "OR") {
-          throw new Error("Cannot mix AND and OR in WHERE clause");
-        }
-        this.advance();
-        continue;
-      }
-      break;
-    }
-    return {
-      type: "WhereClause",
-      conditions,
-      logic
-    };
-  }
-  /**
-   * Parse array literal: [value1, value2, ...]
-   */
-  parseArrayLiteral() {
-    this.expect(TokenType.LBRACKET);
-    const array = [];
-    if (this.current().type === TokenType.RBRACKET) {
-      this.advance();
-      return array;
-    }
-    while (true) {
-      if (this.current().type === TokenType.STRING) {
-        array.push(this.advance().value);
-      } else if (this.current().type === TokenType.NUMBER) {
-        array.push(parseFloat(this.advance().value));
-      } else if (this.current().type === TokenType.TRUE) {
-        array.push(true);
-        this.advance();
-      } else if (this.current().type === TokenType.FALSE) {
-        array.push(false);
-        this.advance();
-      } else if (this.current().type === TokenType.IDENTIFIER) {
-        array.push(this.advance().value);
-      } else {
-        throw new Error(
-          `Unexpected token type in array literal: ${this.current().type}`
-        );
-      }
-      if (this.current().type === TokenType.COMMA) {
-        this.advance();
-      } else if (this.current().type === TokenType.RBRACKET) {
-        this.advance();
-        break;
-      } else {
-        throw new Error(
-          `Expected comma or closing bracket in array literal at position ${this.current().position}`
-        );
-      }
-    }
-    return array;
-  }
-  /**
-   * Parse RETURN clause
-   * Supports: RETURN *, RETURN DISTINCT, RETURN var1, var2, RETURN var AS alias, LIMIT n
-   */
-  parseReturn() {
-    this.expect(TokenType.RETURN);
-    const distinct = this.isKeyword(TokenType.DISTINCT);
-    if (distinct) {
-      this.advance();
-    }
-    if (this.current().type === TokenType.ASTERISK) {
-      this.advance();
-      const limit2 = this.parseOptionalLimit();
-      return {
-        type: "ReturnClause",
-        distinct,
-        returnAll: true,
-        items: [],
-        limit: limit2
-      };
-    }
-    const items = [];
-    while (true) {
-      const expression = this.expect(TokenType.IDENTIFIER).value;
-      let alias;
-      if (this.isKeyword(TokenType.AS)) {
-        this.advance();
-        alias = this.expect(TokenType.IDENTIFIER).value;
-      }
-      items.push({ expression, alias });
-      if (this.current().type === TokenType.COMMA) {
-        this.advance();
-        continue;
-      }
-      break;
-    }
-    const limit = this.parseOptionalLimit();
-    return {
-      type: "ReturnClause",
-      distinct,
-      returnAll: false,
-      items,
-      limit
-    };
-  }
-  /**
-   * Parse optional LIMIT clause
-   * Returns the limit number or undefined if not present
-   */
-  parseOptionalLimit() {
-    if (this.isKeyword(TokenType.LIMIT)) {
-      this.advance();
-      const limitToken = this.expect(TokenType.NUMBER);
-      return parseInt(limitToken.value, 10);
-    }
-    return void 0;
-  }
-  /**
-   * Parse ORDER BY clause
-   * Supports: ORDER BY n.name, ORDER BY n.name ASC, ORDER BY n.name DESC
-   * Also supports multiple fields: ORDER BY n.type DESC, n.name ASC
-   */
-  parseOrderBy() {
-    this.expect(TokenType.ORDER);
-    this.expect(TokenType.BY);
-    const items = [];
-    while (true) {
-      const variable = this.expect(TokenType.IDENTIFIER).value;
-      let property;
-      if (this.current().type === TokenType.DOT) {
-        this.advance();
-        property = this.expect(TokenType.IDENTIFIER).value;
-      }
-      let direction = "ASC";
-      if (this.isKeyword(TokenType.ASC)) {
-        this.advance();
-        direction = "ASC";
-      } else if (this.isKeyword(TokenType.DESC)) {
-        this.advance();
-        direction = "DESC";
-      }
-      items.push({ variable, property, direction });
-      if (this.current().type === TokenType.COMMA) {
-        this.advance();
-        continue;
-      }
-      break;
-    }
-    return { type: "OrderByStatement", items };
-  }
-  /**
-   * Parse entire Cypher query
-   * Returns statements in execution order
-   */
-  parse() {
-    const statements = [];
-    while (this.current().type !== TokenType.EOF) {
-      if (this.isKeyword(TokenType.MATCH) || this.isKeyword(TokenType.OPTIONAL)) {
-        const isOptional = this.isKeyword(TokenType.OPTIONAL);
-        const matchClause = this.parseMatch();
-        if (matchClause.optionalMatches) {
-          for (const optionalMatch of matchClause.optionalMatches) {
-            statements.push({
-              type: "MatchStatement",
-              patterns: optionalMatch.patterns,
-              relationships: optionalMatch.relationships,
-              optional: true
-            });
-          }
-        } else {
-          if (matchClause.patterns.length > 0) {
-            statements.push({
-              type: "MatchStatement",
-              patterns: matchClause.patterns,
-              relationships: matchClause.relationships,
-              optional: false
-            });
-          }
-          if (matchClause.additionalMatches) {
-            for (const additionalMatch of matchClause.additionalMatches) {
-              statements.push({
-                type: "MatchStatement",
-                patterns: additionalMatch.patterns,
-                relationships: additionalMatch.relationships,
-                optional: false
-              });
-            }
-          }
-        }
-        continue;
-      }
-      if (this.isKeyword(TokenType.WHERE)) {
-        const whereClause = this.parseWhere();
-        statements.push({
-          type: "WhereStatement",
-          conditions: whereClause.conditions,
-          logic: whereClause.logic
-        });
-        continue;
-      }
-      if (this.isKeyword(TokenType.ORDER)) {
-        const orderByStatement = this.parseOrderBy();
-        statements.push(orderByStatement);
-        continue;
-      }
-      if (this.isKeyword(TokenType.RETURN)) {
-        const returnClause = this.parseReturn();
-        statements.push({
-          type: "ReturnStatement",
-          distinct: returnClause.distinct,
-          returnAll: returnClause.returnAll,
-          items: returnClause.items,
-          limit: returnClause.limit
-        });
-        continue;
-      }
-      break;
-    }
-    if (this.current().type !== TokenType.EOF) {
-      throw new Error(
-        `Unexpected token: ${this.current().type} at position ${this.current().position}`
-      );
-    }
-    return {
-      type: "CypherQuery",
-      statements
-    };
-  }
-}
-export {
-  Parser
-};

package/cypher/lib/validator/query-validator.js

@@ -1,75 +0,0 @@
-import {
-  FORBIDDEN_AGGREGATIONS,
-  FORBIDDEN_KEYWORDS,
-  FORBIDDEN_MODIFIERS,
-  FORBIDDEN_PATTERNS
-} from "./unsupported-features.config.js";
-const UNSUPPORTED_FEATURES = [
-  ...FORBIDDEN_KEYWORDS,
-  ...FORBIDDEN_AGGREGATIONS,
-  ...FORBIDDEN_MODIFIERS,
-  ...FORBIDDEN_PATTERNS
-];
-class UnsupportedFeatureError extends Error {
-  constructor(feature, query) {
-    const message = `Unsupported Cypher feature detected: ${feature.name}
-
-${feature.errorMessage}${feature.alternative ? `
-
-Alternative: ${feature.alternative}` : ""}
-
-Query: ${query}`;
-    super(message);
-    this.feature = feature;
-    this.query = query;
-    this.name = "UnsupportedFeatureError";
-  }
-}
-function validateQuery(query) {
-  if (!query || typeof query !== "string") {
-    throw new Error("Query must be a non-empty string");
-  }
-  const normalizedQuery = query.trim();
-  if (normalizedQuery.length === 0) {
-    throw new Error("Query cannot be empty");
-  }
-  for (const feature of UNSUPPORTED_FEATURES) {
-    const pattern = typeof feature.pattern === "string" ? new RegExp(feature.pattern, "i") : feature.pattern;
-    if (pattern.test(normalizedQuery)) {
-      if (feature.name === "WITH clause") {
-        const withMatches = normalizedQuery.matchAll(/\bWITH\b/gi);
-        let isAllowed = false;
-        for (const match of withMatches) {
-          const beforeMatch = normalizedQuery.substring(
-            Math.max(0, match.index - 10),
-            match.index
-          );
-          if (/\bSTARTS\s+$/i.test(beforeMatch) || /\bENDS\s+$/i.test(beforeMatch)) {
-            isAllowed = true;
-            break;
-          }
-        }
-        if (isAllowed) {
-          continue;
-        }
-      }
-      throw new UnsupportedFeatureError(feature, normalizedQuery);
-    }
-  }
-}
-function validateQuerySafe(query) {
-  try {
-    validateQuery(query);
-    return { valid: true };
-  } catch (error) {
-    if (error instanceof UnsupportedFeatureError) {
-      return { valid: false, error };
-    }
-    throw error;
-  }
-}
-export {
-  UnsupportedFeatureError,
-  validateQuery,
-  validateQuerySafe
-};