search-input-query-parser 0.1.0

package/src/validate-expression-fields.ts

@@ -0,0 +1,296 @@
+import { FieldSchema } from "./parser";
+import { FirstPassExpression } from "./first-pass-parser";
+import { ValidationError } from "./validator";
+
+// Helper to validate numeric values
+const validateNumber = (
+  value: string,
+  position: number,
+  errors: ValidationError[]
+): boolean => {
+  if (value === "") return false;
+  if (isNaN(Number(value))) {
+    errors.push({
+      message: "Invalid numeric value",
+      position,
+      length: value.length,
+    });
+    return false;
+  }
+  return true;
+};
+
+// Helper to validate range values for numeric fields
+const validateNumericRange = (
+  start: string,
+  end: string,
+  basePosition: number,
+  errors: ValidationError[]
+): boolean => {
+  let isValid = true;
+  const startPos = basePosition;
+  const endPos = basePosition + start.length + 2; // +2 for the '..'
+
+  if (start && !validateNumber(start, startPos, errors)) {
+    isValid = false;
+  }
+  if (end && !validateNumber(end, endPos, errors)) {
+    isValid = false;
+  }
+
+  if (isValid && start && end) {
+    const startNum = Number(start);
+    const endNum = Number(end);
+    if (startNum > endNum) {
+      errors.push({
+        message: "Range start must be less than or equal to range end",
+        position: basePosition,
+        length: start.length + 2 + end.length,
+      });
+      isValid = false;
+    }
+  }
+
+  return isValid;
+};
+
+// Helper to validate numeric comparison operators
+const validateNumericComparison = (
+  operator: string,
+  value: string,
+  basePosition: number,
+  errors: ValidationError[]
+): boolean => {
+  const valuePosition = basePosition + operator.length;
+  return validateNumber(value, valuePosition, errors);
+};
+
+// Field validation helpers
+const validateFieldValue = (
+  expr: FirstPassExpression,
+  allowedFields: Set<string>,
+  errors: ValidationError[],
+  schemas: Map<string, FieldSchema>
+): void => {
+  switch (expr.type) {
+    case "IN": {
+      if (!allowedFields.has(expr.field.toLowerCase())) {
+        errors.push({
+          message: `Invalid field: "${expr.field}"`,
+          position: expr.position,
+          length: expr.field.length,
+        });
+      }
+
+      // Get schema for type validation
+      const schema = schemas.get(expr.field.toLowerCase());
+      if (schema) {
+        expr.values.forEach((value, index) => {
+          switch (schema.type) {
+            case "number":
+              if (isNaN(Number(value))) {
+                errors.push({
+                  message: "Invalid numeric value",
+                  position:
+                    expr.position +
+                    expr.field.length +
+                    4 +
+                    index * (value.length + 1),
+                  length: value.length,
+                });
+              }
+              break;
+            case "date":
+              if (!/^\d{4}-\d{2}-\d{2}$/.test(value)) {
+                errors.push({
+                  message: "Invalid date format",
+                  position:
+                    expr.position +
+                    expr.field.length +
+                    3 +
+                    index * (value.length + 1),
+                  length: value.length,
+                });
+              }
+              break;
+          }
+        });
+      }
+      break;
+    }
+
+    case "WILDCARD": {
+      // For wildcard patterns, validate against field type constraints
+      const schema = schemas.get(expr.prefix.toLowerCase());
+      if (schema?.type === "number" || schema?.type === "date") {
+        errors.push({
+          message: `Wildcards are not allowed for ${schema.type} fields`,
+          position: expr.position,
+          length: expr.length,
+        });
+      }
+      break;
+    }
+
+    case "STRING": {
+      const colonIndex = expr.value.indexOf(":");
+      if (colonIndex === -1) return;
+
+      const fieldName = expr.value.substring(0, colonIndex).trim();
+      const value = expr.value.substring(colonIndex + 1).trim();
+
+      if (!allowedFields.has(fieldName.toLowerCase()) && colonIndex > 0) {
+        errors.push({
+          message: `Invalid field: "${fieldName}"`,
+          position: expr.position,
+          length: colonIndex,
+        });
+      }
+
+      if (!value) {
+        errors.push({
+          message: "Expected field value",
+          position: expr.position,
+          length: colonIndex + 1,
+        });
+        return;
+      }
+
+      if (value.startsWith(":")) {
+        errors.push({
+          message: "Missing field name",
+          position: expr.position,
+          length: value.length + colonIndex + 1,
+        });
+        return;
+      }
+
+      const schema = schemas.get(fieldName.toLowerCase());
+      if (!schema) return;
+
+      const valueStartPosition = expr.position + colonIndex + 1;
+
+      if (schema.type === "number") {
+        if (value.includes("..")) {
+          if (value === ".." || value.includes("...")) {
+            errors.push({
+              message: "Invalid range format",
+              position: valueStartPosition,
+              length: value.length,
+            });
+            return;
+          }
+
+          const [start, end] = value.split("..");
+          validateNumericRange(start, end, valueStartPosition, errors);
+          return;
+        }
+
+        const comparisonMatch = value.match(/^(>=|>|<=|<)(.*)$/);
+        if (comparisonMatch) {
+          const [, operator, compValue] = comparisonMatch;
+
+          const invalidOp = /^[<>]{2,}|>=>/;
+          if (invalidOp.test(value)) {
+            errors.push({
+              message: "Invalid range operator",
+              position: valueStartPosition,
+              length: 3,
+            });
+            return;
+          }
+
+          if (!compValue) {
+            errors.push({
+              message: "Expected range value",
+              position: valueStartPosition + operator.length,
+              length: 0,
+            });
+            return;
+          }
+
+          validateNumericComparison(
+            operator,
+            compValue,
+            valueStartPosition,
+            errors
+          );
+          return;
+        }
+
+        validateNumber(value, valueStartPosition, errors);
+        return;
+      }
+
+      if (schema.type === "date") {
+        const dateValidator = (dateStr: string) => {
+          if (!dateStr) return true;
+          if (!/^\d{4}-\d{2}-\d{2}$/.test(dateStr)) {
+            return false;
+          }
+          const date = new Date(dateStr);
+          return (
+            !isNaN(date.getTime()) &&
+            dateStr === date.toISOString().split("T")[0]
+          );
+        };
+
+        if (value.includes("..")) {
+          const [start, end] = value.split("..");
+          if (!dateValidator(start) || !dateValidator(end)) {
+            errors.push({
+              message: "Invalid date format",
+              position: valueStartPosition,
+              length: value.length,
+            });
+            return;
+          }
+        } else {
+          const comparisonMatch = value.match(/^(>=|>|<=|<)(.*)$/);
+          if (comparisonMatch) {
+            const [, , dateStr] = comparisonMatch;
+            if (!dateValidator(dateStr)) {
+              errors.push({
+                message: "Invalid date format",
+                position: valueStartPosition,
+                length: value.length,
+              });
+              return;
+            }
+          } else if (!dateValidator(value)) {
+            errors.push({
+              message: "Invalid date format",
+              position: valueStartPosition,
+              length: value.length,
+            });
+            return;
+          }
+        }
+      }
+      break;
+    }
+  }
+};
+
+export const validateExpressionFields = (
+  expr: FirstPassExpression,
+  allowedFields: Set<string>,
+  errors: ValidationError[],
+  schemas: Map<string, FieldSchema>
+): void => {
+  switch (expr.type) {
+    case "STRING":
+    case "WILDCARD":
+    case "IN":
+      validateFieldValue(expr, allowedFields, errors, schemas);
+      break;
+    case "AND":
+    case "OR":
+      validateExpressionFields(expr.left, allowedFields, errors, schemas);
+      validateExpressionFields(expr.right, allowedFields, errors, schemas);
+      break;
+    case "NOT":
+      validateExpressionFields(expr.expression, allowedFields, errors, schemas);
+      break;
+  }
+};

package/src/validate-in-expression.ts

@@ -0,0 +1,36 @@
+import { InExpression } from "./first-pass-parser";
+import { ValidationError, reservedWords } from "./validator";
+
+export const validateInExpression = (
+  expr: InExpression,
+  errors: ValidationError[]
+): void => {
+  // Validate field name pattern
+  if (!/^[a-zA-Z][a-zA-Z0-9_-]*$/.test(expr.field)) {
+    errors.push({
+      message: "Invalid characters in field name",
+      position: expr.position,
+      length: expr.field.length,
+    });
+  }
+
+  // Check for reserved words
+  if (reservedWords.has(expr.field.toUpperCase())) {
+    errors.push({
+      message: `${expr.field} is a reserved word`,
+      position: expr.position,
+      length: expr.field.length,
+    });
+  }
+
+  // Validate value format based on field type
+  expr.values.forEach((value, index) => {
+    if (value.includes(",")) {
+      errors.push({
+        message: "Invalid character in IN value",
+        position: expr.position + expr.field.length + 3 + index * (value.length + 1),
+        length: value.length,
+      });
+    }
+  });
+};

package/src/validate-string.ts

@@ -0,0 +1,73 @@
+import { StringLiteral, WildcardPattern } from "./first-pass-parser";
+import { ValidationError, reservedWords } from "./validator";
+import { validateWildcard } from "./validate-wildcard";
+
+// Validate individual strings (field:value pairs or plain terms)
+export const validateString = (
+  expr: StringLiteral | WildcardPattern,
+  errors: ValidationError[]
+) => {
+  // Validate wildcard usage
+  validateWildcard(expr, errors);
+
+  // For wildcard patterns, no additional validation needed
+  if (expr.type === "WILDCARD") {
+    return;
+  }
+
+  // Handle STRING type
+  // Check for empty field values
+  if (expr.value.endsWith(":")) {
+    errors.push({
+      message: "Expected field value",
+      position: expr.position,
+      length: expr.length,
+    });
+    return;
+  }
+
+  // Check for field values that start with colon
+  if (expr.value.startsWith(":")) {
+    errors.push({
+      message: "Missing field name",
+      position: expr.position,
+      length: expr.length,
+    });
+    return;
+  }
+
+  // For field:value patterns, validate the field name
+  if (expr.value.includes(":")) {
+    const [fieldName] = expr.value.split(":");
+
+    // Check for reserved words used as field names
+    if (reservedWords.has(fieldName.toUpperCase())) {
+      errors.push({
+        message: `${fieldName} is a reserved word`,
+        position: expr.position,
+        length: fieldName.length,
+      });
+      return;
+    }
+
+    // Check for invalid characters in field names
+    if (!/^[a-zA-Z0-9_-]+$/.test(fieldName)) {
+      errors.push({
+        message: "Invalid characters in field name",
+        position: expr.position,
+        length: fieldName.length,
+      });
+      return;
+    }
+  }
+
+  // Handle standalone reserved words (not in field:value pattern)
+  if (!expr.value.includes(":") &&
+    reservedWords.has(expr.value.toUpperCase())) {
+    errors.push({
+      message: `${expr.value} is a reserved word`,
+      position: expr.position,
+      length: expr.length,
+    });
+  }
+};

package/src/validate-wildcard.ts

@@ -0,0 +1,45 @@
+import { StringLiteral, WildcardPattern } from "./first-pass-parser";
+import { ValidationError } from "./validator";
+
+// Validates wildcard patterns
+
+export const validateWildcard = (
+  expr: StringLiteral | WildcardPattern,
+  errors: ValidationError[]
+) => {
+  const value = expr.type === "STRING" ? expr.value : expr.prefix + "*";
+  const starCount = (value.match(/\*/g) || []).length;
+  const isQuoted = expr.quoted;
+
+  // For unquoted strings
+  if (!isQuoted) {
+    const firstStar = value.indexOf("*");
+    if (starCount > 1) {
+      const secondStar = value.indexOf("*", firstStar + 1);
+      errors.push({
+        message: "Only one trailing wildcard (*) is allowed",
+        position: expr.position + secondStar,
+        length: 1,
+      });
+    }
+    if ((firstStar !== -1 && firstStar !== value.length - 1) && !value.endsWith("**")) {
+      errors.push({
+        message: "Wildcard (*) can only appear at the end of a term",
+        position: expr.position + firstStar,
+        length: 1,
+      });
+    }
+  }
+
+  // For quoted strings
+  else {
+    // Handle multiple wildcards or internal wildcards in quoted strings
+    if (value.endsWith("**")) {
+      errors.push({
+        message: "Only one trailing wildcard (*) is allowed",
+        position: expr.position + value.length - 1,
+        length: 1,
+      });
+    }
+  }
+};

package/src/validator.test.ts

@@ -0,0 +1,192 @@
+import { describe, expect, test } from "@jest/globals";
+import { validateSearchQuery, ValidationError } from "./validator";
+import { tokenize, createStream } from "./lexer";
+import { parseExpression } from "./first-pass-parser";
+
+describe("Search Query Validator", () => {
+  const validateQuery = (input: string): ValidationError[] => {
+    const tokens = tokenize(input);
+    const stream = createStream(tokens);
+    const result = parseExpression(stream);
+    return validateSearchQuery(result.result);
+  };
+
+  describe("Field Name Validation", () => {
+    test("accepts valid field names", () => {
+      expect(validateQuery("simple:value")).toEqual([]);
+      expect(validateQuery("field123:value")).toEqual([]);
+      expect(validateQuery("field_name:value")).toEqual([]);
+      expect(validateQuery("field-name:value")).toEqual([]);
+    });
+
+    test("handles field names with special characters", () => {
+      expect(validateQuery("special@field:value")).toEqual([
+        {
+          message: "Invalid characters in field name",
+          position: 0,
+          length: 13,
+        },
+      ]);
+    });
+
+    test("validates multiple field:value pairs", () => {
+      expect(validateQuery("valid:value special!:value")).toEqual([
+        {
+          message: "Invalid characters in field name",
+          position: 12,
+          length: 8,
+        },
+      ]);
+    });
+  });
+
+  describe("Field Value Validation", () => {
+    test("detects missing field values", () => {
+      expect(validateQuery("field:")).toEqual([
+        {
+          message: "Expected field value",
+          position: 0,
+          length: 6,
+        },
+      ]);
+    });
+
+    test("validates field values with spaces", () => {
+      expect(validateQuery('field:"value with spaces"')).toEqual([]);
+      expect(validateQuery("field:value with spaces")).toEqual([]);
+    });
+
+    test("validates empty colon patterns", () => {
+      expect(validateQuery(":value")).toEqual([
+        {
+          message: "Missing field name",
+          position: 0,
+          length: 6,
+        },
+      ]);
+    });
+  });
+
+  describe("Reserved Word Validation", () => {
+    test("detects reserved words as field names", () => {
+      expect(validateQuery("AND:value")).toEqual([
+        {
+          message: "AND is a reserved word",
+          position: 0,
+          length: 3,
+        },
+      ]);
+
+      expect(validateQuery("OR:value")).toEqual([
+        {
+          message: "OR is a reserved word",
+          position: 0,
+          length: 2,
+        },
+      ]);
+    });
+
+    test("detects reserved words as standalone terms", () => {
+      // This will throw because it's handled by the parser
+      expect(() => validateQuery("AND")).toThrow("AND is a reserved word");
+      expect(() => validateQuery("OR")).toThrow("OR is a reserved word");
+    });
+
+    test("allows reserved words as field values", () => {
+      expect(validateQuery("field:AND")).toEqual([]);
+      expect(validateQuery("field:OR")).toEqual([]);
+      expect(validateQuery('field:"AND OR"')).toEqual([]);
+    });
+  });
+
+  describe("Complex Expression Validation", () => {
+    test("validates nested expressions", () => {
+      expect(validateQuery("(field:value AND invalid!:value)")).toEqual([
+        {
+          message: "Invalid characters in field name",
+          position: 17,
+          length: 8,
+        },
+      ]);
+    });
+
+    test("validates multiple errors in one expression", () => {
+      expect(validateQuery("AND:test OR invalid!:value")).toEqual([
+        {
+          message: "AND is a reserved word",
+          position: 0,
+          length: 3,
+        },
+        {
+          message: "Invalid characters in field name",
+          position: 12,
+          length: 8,
+        },
+      ]);
+    });
+
+    test("validates complex nested expressions", () => {
+      expect(
+        validateQuery("(field:value AND (OR:test OR valid:value))")
+      ).toEqual([
+        {
+          message: "OR is a reserved word",
+          position: 18,
+          length: 2,
+        },
+      ]);
+    });
+  });
+
+  describe("Edge Cases", () => {
+    test("handles empty input", () => {
+      expect(() => validateQuery("")).toThrow("Unexpected token");
+    });
+
+    test("handles whitespace-only input", () => {
+      expect(() => validateQuery("   ")).toThrow("Unexpected token");
+    });
+
+    test("invalidates consecutive colons", () => {
+      expect(validateQuery("field::value")).toEqual([
+        {
+          message: "Expected field value",
+          position: 0,
+          length: 6,
+        },
+        {
+          message: "Missing field name",
+          position: 6,
+          length: 6,
+        }
+      ]);
+    });
+
+    test("validates field names with only special characters", () => {
+      expect(validateQuery("@#$:value")).toEqual([
+        {
+          message: "Invalid characters in field name",
+          position: 0,
+          length: 3,
+        },
+      ]);
+    });
+
+    test("validates mixed valid and invalid patterns", () => {
+      const complexQuery =
+        'valid:value AND field:"test" OR @invalid:value AND OR:test';
+      expect(validateQuery(complexQuery)).toEqual([
+        {
+          message: "Invalid characters in field name",
+          position: 32,
+          length: 8,
+        },
+        {
+          message: "OR is a reserved word",
+          position: 51,
+          length: 2,
+        },
+      ]);
+    });
+  });
+});

package/src/validator.ts

@@ -0,0 +1,53 @@
+import {
+  FirstPassExpression,
+} from "./first-pass-parser";
+
+import { FieldSchema } from "./parser";
+import { validateInExpression } from "./validate-in-expression";
+import { validateString } from "./validate-string";
+
+// Validation error type
+export type ValidationError = {
+  message: string;
+  position: number;
+  length: number;
+};
+
+export const reservedWords = new Set(["AND", "OR"]);
+
+const walkExpression = (
+  expr: FirstPassExpression,
+  errors: ValidationError[]
+) => {
+  switch (expr.type) {
+    case "STRING":
+    case "WILDCARD":
+      validateString(expr, errors);
+      break;
+    case "AND":
+    case "OR":
+      walkExpression(expr.left, errors);
+      walkExpression(expr.right, errors);
+      break;
+    case "NOT":
+      walkExpression(expr.expression, errors);
+      break;
+    case "IN":
+      validateInExpression(expr, errors);
+      break;
+  }
+};
+
+export const validateSearchQuery = (
+  expression: FirstPassExpression
+): ValidationError[] => {
+  const errors: ValidationError[] = [];
+
+  if (expression === null) {
+    return errors;
+  }
+
+  walkExpression(expression, errors);
+
+  return errors;
+};