search-input-query-parser 0.1.3 → 0.2.0

package/dist/esm/validate-expression-fields.js

@@ -1,3 +1,4 @@
+import { SearchQueryErrorCode } from "./validator";
 // Helper to validate numeric values
 const validateNumber = (value, position, errors) => {
     if (value === "")
@@ -5,6 +6,7 @@ const validateNumber = (value, position, errors) => {
     if (isNaN(Number(value))) {
         errors.push({
             message: "Invalid numeric value",
+            code: SearchQueryErrorCode.INVALID_NUMERIC_VALUE,
             position,
             length: value.length,
         });
@@ -29,6 +31,7 @@ const validateNumericRange = (start, end, basePosition, errors) => {
         if (startNum > endNum) {
             errors.push({
                 message: "Range start must be less than or equal to range end",
+                code: SearchQueryErrorCode.RANGE_START_GREATER_THAN_END,
                 position: basePosition,
                 length: start.length + 2 + end.length,
             });
@@ -49,6 +52,8 @@ const validateFieldValue = (expr, allowedFields, errors, schemas) => {
             if (!allowedFields.has(expr.field.toLowerCase())) {
                 errors.push({
                     message: `Invalid field: "${expr.field}"`,
+                    code: SearchQueryErrorCode.INVALID_FIELD_NAME,
+                    value: expr.field,
                     position: expr.position,
                     length: expr.field.length,
                 });
@@ -62,6 +67,7 @@ const validateFieldValue = (expr, allowedFields, errors, schemas) => {
                             if (isNaN(Number(value))) {
                                 errors.push({
                                     message: "Invalid numeric value",
+                                    code: SearchQueryErrorCode.INVALID_NUMERIC_VALUE,
                                     position: expr.position +
                                         expr.field.length +
                                         4 +
@@ -74,6 +80,7 @@ const validateFieldValue = (expr, allowedFields, errors, schemas) => {
                             if (!/^\d{4}-\d{2}-\d{2}$/.test(value)) {
                                 errors.push({
                                     message: "Invalid date format",
+                                    code: SearchQueryErrorCode.INVALID_DATE_FORMAT,
                                     position: expr.position +
                                         expr.field.length +
                                         3 +
@@ -92,6 +99,8 @@ const validateFieldValue = (expr, allowedFields, errors, schemas) => {
             const schema = schemas.get(expr.prefix.toLowerCase());
             if ((schema === null || schema === void 0 ? void 0 : schema.type) === "number" || (schema === null || schema === void 0 ? void 0 : schema.type) === "date") {
                 errors.push({
+                    code: SearchQueryErrorCode.WILDCARD_NOT_ALLOWED,
+                    value: schema.type,
                     message: `Wildcards are not allowed for ${schema.type} fields`,
                     position: expr.position,
                     length: expr.length,
@@ -108,6 +117,8 @@ const validateFieldValue = (expr, allowedFields, errors, schemas) => {
             if (!allowedFields.has(fieldName.toLowerCase()) && colonIndex > 0) {
                 errors.push({
                     message: `Invalid field: "${fieldName}"`,
+                    code: SearchQueryErrorCode.INVALID_FIELD_NAME,
+                    value: fieldName,
                     position: expr.position,
                     length: colonIndex,
                 });
@@ -115,6 +126,7 @@ const validateFieldValue = (expr, allowedFields, errors, schemas) => {
             if (!value) {
                 errors.push({
                     message: "Expected field value",
+                    code: SearchQueryErrorCode.EXPECTED_FIELD_VALUE,
                     position: expr.position,
                     length: colonIndex + 1,
                 });
@@ -123,6 +135,7 @@ const validateFieldValue = (expr, allowedFields, errors, schemas) => {
             if (value.startsWith(":")) {
                 errors.push({
                     message: "Missing field name",
+                    code: SearchQueryErrorCode.MISSING_FIELD_NAME,
                     position: expr.position,
                     length: value.length + colonIndex + 1,
                 });
@@ -137,6 +150,7 @@ const validateFieldValue = (expr, allowedFields, errors, schemas) => {
                     if (value === ".." || value.includes("...")) {
                         errors.push({
                             message: "Invalid range format",
+                            code: SearchQueryErrorCode.INVALID_RANGE_FORMAT,
                             position: valueStartPosition,
                             length: value.length,
                         });
@@ -153,6 +167,7 @@ const validateFieldValue = (expr, allowedFields, errors, schemas) => {
                     if (invalidOp.test(value)) {
                         errors.push({
                             message: "Invalid range operator",
+                            code: SearchQueryErrorCode.INVALID_RANGE_OPERATOR,
                             position: valueStartPosition,
                             length: 3,
                         });
@@ -161,6 +176,7 @@ const validateFieldValue = (expr, allowedFields, errors, schemas) => {
                     if (!compValue) {
                         errors.push({
                             message: "Expected range value",
+                            code: SearchQueryErrorCode.EXPECTED_RANGE_VALUE,
                             position: valueStartPosition + operator.length,
                             length: 0,
                         });
@@ -188,6 +204,7 @@ const validateFieldValue = (expr, allowedFields, errors, schemas) => {
                     if (!dateValidator(start) || !dateValidator(end)) {
                         errors.push({
                             message: "Invalid date format",
+                            code: SearchQueryErrorCode.INVALID_DATE_FORMAT,
                             position: valueStartPosition,
                             length: value.length,
                         });
@@ -201,6 +218,7 @@ const validateFieldValue = (expr, allowedFields, errors, schemas) => {
                         if (!dateValidator(dateStr)) {
                             errors.push({
                                 message: "Invalid date format",
+                                code: SearchQueryErrorCode.INVALID_DATE_FORMAT,
                                 position: valueStartPosition,
                                 length: value.length,
                             });
@@ -210,6 +228,7 @@ const validateFieldValue = (expr, allowedFields, errors, schemas) => {
                     else if (!dateValidator(value)) {
                         errors.push({
                             message: "Invalid date format",
+                            code: SearchQueryErrorCode.INVALID_DATE_FORMAT,
                             position: valueStartPosition,
                             length: value.length,
                         });

package/dist/esm/validate-in-expression.js

@@ -1,9 +1,10 @@
-import { reservedWords } from "./validator";
+import { reservedWords, SearchQueryErrorCode } from "./validator";
 export const validateInExpression = (expr, errors) => {
     // Validate field name pattern
     if (!/^[a-zA-Z][a-zA-Z0-9_-]*$/.test(expr.field)) {
         errors.push({
             message: "Invalid characters in field name",
+            code: SearchQueryErrorCode.INVALID_FIELD_CHARS,
             position: expr.position,
             length: expr.field.length,
         });
@@ -12,6 +13,8 @@ export const validateInExpression = (expr, errors) => {
     if (reservedWords.has(expr.field.toUpperCase())) {
         errors.push({
             message: `${expr.field} is a reserved word`,
+            code: SearchQueryErrorCode.RESERVED_WORD_AS_FIELD,
+            value: expr.field,
             position: expr.position,
             length: expr.field.length,
         });
@@ -21,6 +24,7 @@ export const validateInExpression = (expr, errors) => {
         if (value.includes(",")) {
             errors.push({
                 message: "Invalid character in IN value",
+                code: SearchQueryErrorCode.INVALID_IN_VALUE,
                 position: expr.position + expr.field.length + 3 + index * (value.length + 1),
                 length: value.length,
             });

package/dist/esm/validate-string.js

@@ -1,4 +1,4 @@
-import { reservedWords } from "./validator";
+import { reservedWords, SearchQueryErrorCode, } from "./validator";
 import { validateWildcard } from "./validate-wildcard";
 // Validate individual strings (field:value pairs or plain terms)
 export const validateString = (expr, errors) => {
@@ -13,6 +13,7 @@ export const validateString = (expr, errors) => {
     if (expr.value.endsWith(":")) {
         errors.push({
             message: "Expected field value",
+            code: SearchQueryErrorCode.EXPECTED_FIELD_VALUE,
             position: expr.position,
             length: expr.length,
         });
@@ -22,6 +23,7 @@ export const validateString = (expr, errors) => {
     if (expr.value.startsWith(":")) {
         errors.push({
             message: "Missing field name",
+            code: SearchQueryErrorCode.MISSING_FIELD_NAME,
             position: expr.position,
             length: expr.length,
         });
@@ -34,6 +36,8 @@ export const validateString = (expr, errors) => {
         if (reservedWords.has(fieldName.toUpperCase())) {
             errors.push({
                 message: `${fieldName} is a reserved word`,
+                code: SearchQueryErrorCode.RESERVED_WORD_AS_FIELD,
+                value: fieldName,
                 position: expr.position,
                 length: fieldName.length,
             });
@@ -43,6 +47,7 @@ export const validateString = (expr, errors) => {
         if (!/^[a-zA-Z0-9_-]+$/.test(fieldName)) {
             errors.push({
                 message: "Invalid characters in field name",
+                code: SearchQueryErrorCode.INVALID_FIELD_CHARS,
                 position: expr.position,
                 length: fieldName.length,
             });
@@ -54,6 +59,8 @@ export const validateString = (expr, errors) => {
         reservedWords.has(expr.value.toUpperCase())) {
         errors.push({
             message: `${expr.value} is a reserved word`,
+            code: SearchQueryErrorCode.RESERVED_WORD_AS_FIELD,
+            value: expr.value,
             position: expr.position,
             length: expr.length,
         });

package/dist/esm/validate-wildcard.js

@@ -1,3 +1,4 @@
+import { SearchQueryErrorCode } from "./validator";
 // Validates wildcard patterns
 export const validateWildcard = (expr, errors) => {
     const value = expr.type === "STRING" ? expr.value : expr.prefix + "*";
@@ -10,6 +11,7 @@ export const validateWildcard = (expr, errors) => {
             const secondStar = value.indexOf("*", firstStar + 1);
             errors.push({
                 message: "Only one trailing wildcard (*) is allowed",
+                code: SearchQueryErrorCode.MULTIPLE_WILDCARDS,
                 position: expr.position + secondStar,
                 length: 1,
             });
@@ -17,6 +19,7 @@ export const validateWildcard = (expr, errors) => {
         if ((firstStar !== -1 && firstStar !== value.length - 1) && !value.endsWith("**")) {
             errors.push({
                 message: "Wildcard (*) can only appear at the end of a term",
+                code: SearchQueryErrorCode.INVALID_WILDCARD_POSITION,
                 position: expr.position + firstStar,
                 length: 1,
             });
@@ -28,6 +31,7 @@ export const validateWildcard = (expr, errors) => {
         if (value.endsWith("**")) {
             errors.push({
                 message: "Only one trailing wildcard (*) is allowed",
+                code: SearchQueryErrorCode.MULTIPLE_WILDCARDS,
                 position: expr.position + value.length - 1,
                 length: 1,
             });

package/dist/esm/validator.js

@@ -1,5 +1,39 @@
 import { validateInExpression } from "./validate-in-expression";
 import { validateString } from "./validate-string";
+export var SearchQueryErrorCode;
+(function (SearchQueryErrorCode) {
+    // Syntax Errors (1000-1999)
+    SearchQueryErrorCode[SearchQueryErrorCode["UNTERMINATED_QUOTED_STRING"] = 1001] = "UNTERMINATED_QUOTED_STRING";
+    SearchQueryErrorCode[SearchQueryErrorCode["EXPECTED_FIELD_VALUE"] = 1002] = "EXPECTED_FIELD_VALUE";
+    SearchQueryErrorCode[SearchQueryErrorCode["MISSING_FIELD_NAME"] = 1003] = "MISSING_FIELD_NAME";
+    SearchQueryErrorCode[SearchQueryErrorCode["MISSING_FIELD_VALUE"] = 1004] = "MISSING_FIELD_VALUE";
+    SearchQueryErrorCode[SearchQueryErrorCode["UNEXPECTED_RIGHT_PAREN"] = 1005] = "UNEXPECTED_RIGHT_PAREN";
+    SearchQueryErrorCode[SearchQueryErrorCode["EXPECTED_RIGHT_PAREN"] = 1006] = "EXPECTED_RIGHT_PAREN";
+    SearchQueryErrorCode[SearchQueryErrorCode["UNEXPECTED_TOKEN"] = 1007] = "UNEXPECTED_TOKEN";
+    SearchQueryErrorCode[SearchQueryErrorCode["EXPECTED_TOKEN"] = 1008] = "EXPECTED_TOKEN";
+    SearchQueryErrorCode[SearchQueryErrorCode["MISSING_OPERATOR_OR_WHITESPACE"] = 1009] = "MISSING_OPERATOR_OR_WHITESPACE";
+    SearchQueryErrorCode[SearchQueryErrorCode["RESERVED_WORD"] = 1010] = "RESERVED_WORD";
+    // Field Validation Errors (2000-2999)
+    SearchQueryErrorCode[SearchQueryErrorCode["INVALID_FIELD_NAME"] = 2001] = "INVALID_FIELD_NAME";
+    SearchQueryErrorCode[SearchQueryErrorCode["INVALID_FIELD_CHARS"] = 2002] = "INVALID_FIELD_CHARS";
+    SearchQueryErrorCode[SearchQueryErrorCode["RESERVED_WORD_AS_FIELD"] = 2003] = "RESERVED_WORD_AS_FIELD";
+    // Value Validation Errors (3000-3999)
+    SearchQueryErrorCode[SearchQueryErrorCode["INVALID_NUMERIC_VALUE"] = 3001] = "INVALID_NUMERIC_VALUE";
+    SearchQueryErrorCode[SearchQueryErrorCode["INVALID_DATE_FORMAT"] = 3002] = "INVALID_DATE_FORMAT";
+    SearchQueryErrorCode[SearchQueryErrorCode["INVALID_RANGE_FORMAT"] = 3003] = "INVALID_RANGE_FORMAT";
+    SearchQueryErrorCode[SearchQueryErrorCode["INVALID_RANGE_OPERATOR"] = 3004] = "INVALID_RANGE_OPERATOR";
+    SearchQueryErrorCode[SearchQueryErrorCode["EXPECTED_RANGE_VALUE"] = 3005] = "EXPECTED_RANGE_VALUE";
+    SearchQueryErrorCode[SearchQueryErrorCode["RANGE_START_GREATER_THAN_END"] = 3006] = "RANGE_START_GREATER_THAN_END";
+    SearchQueryErrorCode[SearchQueryErrorCode["WILDCARD_NOT_ALLOWED"] = 3007] = "WILDCARD_NOT_ALLOWED";
+    // Wildcard Errors (4000-4999)
+    SearchQueryErrorCode[SearchQueryErrorCode["INVALID_WILDCARD_POSITION"] = 4001] = "INVALID_WILDCARD_POSITION";
+    SearchQueryErrorCode[SearchQueryErrorCode["MULTIPLE_WILDCARDS"] = 4002] = "MULTIPLE_WILDCARDS";
+    // IN Expression Errors (5000-5999)
+    SearchQueryErrorCode[SearchQueryErrorCode["EMPTY_IN_LIST"] = 5001] = "EMPTY_IN_LIST";
+    SearchQueryErrorCode[SearchQueryErrorCode["INVALID_IN_VALUE"] = 5002] = "INVALID_IN_VALUE";
+    SearchQueryErrorCode[SearchQueryErrorCode["EXPECTED_IN_SEPARATOR"] = 5003] = "EXPECTED_IN_SEPARATOR";
+    SearchQueryErrorCode[SearchQueryErrorCode["EXPECTED_LPAREN_AFTER_IN"] = 5004] = "EXPECTED_LPAREN_AFTER_IN";
+})(SearchQueryErrorCode || (SearchQueryErrorCode = {}));
 export const reservedWords = new Set(["AND", "OR"]);
 const walkExpression = (expr, errors) => {
     switch (expr.type) {

package/dist/types/parser.d.ts

@@ -1,5 +1,5 @@
 import { PositionLength } from "./first-pass-parser";
-import { ValidationError } from "./validator";
+import { ValidationError, SearchQueryErrorCode } from "./validator";
 interface FieldSchema {
     name: string;
     type: "string" | "number" | "date" | "boolean";
@@ -65,4 +65,4 @@ type SearchQueryError = {
 };
 declare const stringify: (expr: Expression) => string;
 export declare const parseSearchInputQuery: (input: string, fieldSchemas?: FieldSchema[]) => SearchQuery | SearchQueryError;
-export { type SearchQuery, type SearchQueryError, type Expression, type ValidationError, type FieldSchema, type RangeOperator, type RangeExpression, type WildcardPattern, type Value, stringify, };
+export { type SearchQuery, type SearchQueryError, type Expression, type ValidationError, SearchQueryErrorCode, type FieldSchema, type RangeOperator, type RangeExpression, type WildcardPattern, type Value, stringify, };

package/dist/types/validator.d.ts

@@ -1,6 +1,36 @@
 import { FirstPassExpression } from "./first-pass-parser";
+export declare enum SearchQueryErrorCode {
+    UNTERMINATED_QUOTED_STRING = 1001,
+    EXPECTED_FIELD_VALUE = 1002,
+    MISSING_FIELD_NAME = 1003,
+    MISSING_FIELD_VALUE = 1004,
+    UNEXPECTED_RIGHT_PAREN = 1005,
+    EXPECTED_RIGHT_PAREN = 1006,
+    UNEXPECTED_TOKEN = 1007,
+    EXPECTED_TOKEN = 1008,
+    MISSING_OPERATOR_OR_WHITESPACE = 1009,
+    RESERVED_WORD = 1010,
+    INVALID_FIELD_NAME = 2001,
+    INVALID_FIELD_CHARS = 2002,
+    RESERVED_WORD_AS_FIELD = 2003,
+    INVALID_NUMERIC_VALUE = 3001,
+    INVALID_DATE_FORMAT = 3002,
+    INVALID_RANGE_FORMAT = 3003,
+    INVALID_RANGE_OPERATOR = 3004,
+    EXPECTED_RANGE_VALUE = 3005,
+    RANGE_START_GREATER_THAN_END = 3006,
+    WILDCARD_NOT_ALLOWED = 3007,
+    INVALID_WILDCARD_POSITION = 4001,
+    MULTIPLE_WILDCARDS = 4002,
+    EMPTY_IN_LIST = 5001,
+    INVALID_IN_VALUE = 5002,
+    EXPECTED_IN_SEPARATOR = 5003,
+    EXPECTED_LPAREN_AFTER_IN = 5004
+}
 export type ValidationError = {
     message: string;
+    code: SearchQueryErrorCode;
+    value?: string;
     position: number;
     length: number;
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "search-input-query-parser",
-  "version": "0.1.3",
+  "version": "0.2.0",
   "description": "A parser for advanced search query syntax with field:value support",
   "keywords": [
     "search",
@@ -54,9 +54,10 @@
   "license": "ISC",
   "devDependencies": {
     "@types/jest": "^29.5.14",
-    "@types/node": "^20.11.0",
+    "@types/node": "^22.10.1",
     "jest": "^29.7.0",
+    "npm-check-updates": "^17.1.11",
     "ts-jest": "^29.2.5",
-    "typescript": "^5.3.3"
+    "typescript": "^5.7.2"
   }
-}
+}

package/src/first-pass-parser.ts

@@ -1,5 +1,6 @@
 import { TokenType, TokenStream, currentToken, advanceStream } from "./lexer";
 import { parsePrimary } from "./parse-primary";
+import { SearchQueryErrorCode } from "./validator";
 
 // First Pass AST types (from tokenizer/parser)
 export type PositionLength = {
@@ -94,6 +95,8 @@ export const parseExpression = (
       if (nextToken.type === TokenType.EOF) {
         throw {
           message: `Unexpected token: ${token.value}`,
+          code: SearchQueryErrorCode.UNEXPECTED_TOKEN,
+          value: token.value,
           position: token.position,
           length: token.length,
         };

package/src/lexer.ts

@@ -1,3 +1,5 @@
+import { SearchQueryErrorCode } from "./validator";
+
 // Token types and data structures
 export enum TokenType {
   STRING = "STRING",
@@ -123,7 +125,12 @@ const tokenizeQuotedString = (
     }
   }
 
-  throw { message: "Unterminated quoted string", position, length };
+  throw {
+    message: "Unterminated quoted string",
+    code: SearchQueryErrorCode.UNTERMINATED_QUOTED_STRING,
+    position,
+    length,
+  };
 };
 
 const tokenizeString = (input: string, position: number): [Token, number] => {
@@ -317,6 +324,7 @@ export const tokenize = (input: string): Token[] => {
             throw {
               message:
                 "Invalid syntax: Missing operator or whitespace between terms",
+              code: SearchQueryErrorCode.MISSING_OPERATOR_OR_WHITESPACE,
               position: position,
               length: 1,
             };
@@ -333,6 +341,7 @@ export const tokenize = (input: string): Token[] => {
           throw {
             message:
               "Invalid syntax: Missing operator or whitespace between terms",
+            code: SearchQueryErrorCode.MISSING_OPERATOR_OR_WHITESPACE,
             position: newPos,
             length: 1,
           };

package/src/parse-in-values.ts

@@ -1,6 +1,6 @@
 import { ParseResult } from "./first-pass-parser";
 import { TokenStream, currentToken, TokenType, advanceStream } from "./lexer";
-
+import { SearchQueryErrorCode } from "./validator";
 
 export const parseInValues = (
   stream: TokenStream,
@@ -13,6 +13,7 @@ export const parseInValues = (
   if (currentToken(currentStream).type !== TokenType.LPAREN) {
     throw {
       message: "Expected '(' after IN",
+      code: SearchQueryErrorCode.EXPECTED_LPAREN_AFTER_IN,
       position: inValuePosition, // Use the position passed from the caller
       length: 1,
     };
@@ -26,6 +27,7 @@ export const parseInValues = (
       if (values.length === 0) {
         throw {
           message: "IN operator requires at least one value",
+          code: SearchQueryErrorCode.EMPTY_IN_LIST,
           position: token.position,
           length: 1,
         };
@@ -43,6 +45,7 @@ export const parseInValues = (
         token.type !== TokenType.COMMA)) {
       throw {
         message: "Expected ',' or ')' after IN value",
+        code: SearchQueryErrorCode.EXPECTED_IN_SEPARATOR,
         position: token.position,
         length: 1,
       };
@@ -64,6 +67,7 @@ export const parseInValues = (
       }
       throw {
         message: "Expected ',' or ')' after IN value",
+        code: SearchQueryErrorCode.EXPECTED_IN_SEPARATOR,
         position: nextToken.position,
         length: 1,
       };

package/src/parse-primary.ts

@@ -1,6 +1,7 @@
 import { ParseResult, FirstPassExpression, parseExpression } from "./first-pass-parser";
 import { parseInValues } from "./parse-in-values";
 import { TokenStream, currentToken, TokenType, advanceStream } from "./lexer";
+import { SearchQueryErrorCode } from "./validator";
 
 export const expectToken = (
   stream: TokenStream,
@@ -11,6 +12,8 @@ export const expectToken = (
   if (token.type !== type) {
     throw {
       message: message ? message : `Expected ${type}`,
+      code: SearchQueryErrorCode.EXPECTED_TOKEN,
+      value: type,
       position: token.position,
       length: token.length,
     };
@@ -158,6 +161,8 @@ export const parsePrimary = (
     case TokenType.OR:
       throw {
         message: `${token.value} is a reserved word`,
+        code: SearchQueryErrorCode.RESERVED_WORD,
+        value: token.value,
         position: token.position,
         length: token.length,
       };
@@ -165,6 +170,7 @@ export const parsePrimary = (
     case TokenType.RPAREN:
       throw {
         message: 'Unexpected ")"',
+        code: SearchQueryErrorCode.UNEXPECTED_RIGHT_PAREN,
         position: token.position,
         length: token.length,
       };
@@ -172,6 +178,7 @@ export const parsePrimary = (
     default:
       throw {
         message: "Unexpected token",
+        code: SearchQueryErrorCode.UNEXPECTED_TOKEN,
         position: token.position,
         length: token.length,
       };