search-input-query-parser 0.1.4 → 0.2.0

package/dist/cjs/first-pass-parser.js

@@ -3,6 +3,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.parseExpression = void 0;
 const lexer_1 = require("./lexer");
 const parse_primary_1 = require("./parse-primary");
+const validator_1 = require("./validator");
 const getOperatorPrecedence = (type) => type === lexer_1.TokenType.AND ? 2 : type === lexer_1.TokenType.OR ? 1 : 0;
 const parseExpression = (stream, minPrecedence = 0) => {
     const token = (0, lexer_1.currentToken)(stream);
@@ -33,6 +34,8 @@ const parseExpression = (stream, minPrecedence = 0) => {
             if (nextToken.type === lexer_1.TokenType.EOF) {
                 throw {
                     message: `Unexpected token: ${token.value}`,
+                    code: validator_1.SearchQueryErrorCode.UNEXPECTED_TOKEN,
+                    value: token.value,
                     position: token.position,
                     length: token.length,
                 };

package/dist/cjs/lexer.js

@@ -1,6 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.tokenize = exports.advanceStream = exports.currentToken = exports.createStream = exports.TokenType = void 0;
+const validator_1 = require("./validator");
 // Token types and data structures
 var TokenType;
 (function (TokenType) {
@@ -96,7 +97,12 @@ const tokenizeQuotedString = (input, position) => {
             pos++;
         }
     }
-    throw { message: "Unterminated quoted string", position, length };
+    throw {
+        message: "Unterminated quoted string",
+        code: validator_1.SearchQueryErrorCode.UNTERMINATED_QUOTED_STRING,
+        position,
+        length,
+    };
 };
 const tokenizeString = (input, position) => {
     let pos = position;
@@ -260,6 +266,7 @@ const tokenize = (input) => {
                             prevToken.type === TokenType.STRING)) {
                         throw {
                             message: "Invalid syntax: Missing operator or whitespace between terms",
+                            code: validator_1.SearchQueryErrorCode.MISSING_OPERATOR_OR_WHITESPACE,
                             position: position,
                             length: 1,
                         };
@@ -272,6 +279,7 @@ const tokenize = (input) => {
                     !isSpecialChar(input[newPos])) {
                     throw {
                         message: "Invalid syntax: Missing operator or whitespace between terms",
+                        code: validator_1.SearchQueryErrorCode.MISSING_OPERATOR_OR_WHITESPACE,
                         position: newPos,
                         length: 1,
                     };

package/dist/cjs/parse-in-values.js

@@ -2,6 +2,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.parseInValues = void 0;
 const lexer_1 = require("./lexer");
+const validator_1 = require("./validator");
 const parseInValues = (stream, inValuePosition) => {
     const values = [];
     let currentStream = stream;
@@ -9,6 +10,7 @@ const parseInValues = (stream, inValuePosition) => {
     if ((0, lexer_1.currentToken)(currentStream).type !== lexer_1.TokenType.LPAREN) {
         throw {
             message: "Expected '(' after IN",
+            code: validator_1.SearchQueryErrorCode.EXPECTED_LPAREN_AFTER_IN,
             position: inValuePosition, // Use the position passed from the caller
             length: 1,
         };
@@ -20,6 +22,7 @@ const parseInValues = (stream, inValuePosition) => {
             if (values.length === 0) {
                 throw {
                     message: "IN operator requires at least one value",
+                    code: validator_1.SearchQueryErrorCode.EMPTY_IN_LIST,
                     position: token.position,
                     length: 1,
                 };
@@ -36,6 +39,7 @@ const parseInValues = (stream, inValuePosition) => {
                 token.type !== lexer_1.TokenType.COMMA)) {
             throw {
                 message: "Expected ',' or ')' after IN value",
+                code: validator_1.SearchQueryErrorCode.EXPECTED_IN_SEPARATOR,
                 position: token.position,
                 length: 1,
             };
@@ -55,6 +59,7 @@ const parseInValues = (stream, inValuePosition) => {
             }
             throw {
                 message: "Expected ',' or ')' after IN value",
+                code: validator_1.SearchQueryErrorCode.EXPECTED_IN_SEPARATOR,
                 position: nextToken.position,
                 length: 1,
             };

package/dist/cjs/parse-primary.js

@@ -4,11 +4,14 @@ exports.parsePrimary = exports.extractFieldValue = exports.isFieldValuePattern =
 const first_pass_parser_1 = require("./first-pass-parser");
 const parse_in_values_1 = require("./parse-in-values");
 const lexer_1 = require("./lexer");
+const validator_1 = require("./validator");
 const expectToken = (stream, type, message) => {
     const token = (0, lexer_1.currentToken)(stream);
     if (token.type !== type) {
         throw {
             message: message ? message : `Expected ${type}`,
+            code: validator_1.SearchQueryErrorCode.EXPECTED_TOKEN,
+            value: type,
             position: token.position,
             length: token.length,
         };
@@ -134,18 +137,22 @@ const parsePrimary = (stream) => {
         case lexer_1.TokenType.OR:
             throw {
                 message: `${token.value} is a reserved word`,
+                code: validator_1.SearchQueryErrorCode.RESERVED_WORD,
+                value: token.value,
                 position: token.position,
                 length: token.length,
             };
         case lexer_1.TokenType.RPAREN:
             throw {
                 message: 'Unexpected ")"',
+                code: validator_1.SearchQueryErrorCode.UNEXPECTED_RIGHT_PAREN,
                 position: token.position,
                 length: token.length,
             };
         default:
             throw {
                 message: "Unexpected token",
+                code: validator_1.SearchQueryErrorCode.UNEXPECTED_TOKEN,
                 position: token.position,
                 length: token.length,
             };

package/dist/cjs/parser.js

@@ -1,9 +1,10 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.stringify = exports.parseSearchInputQuery = void 0;
+exports.stringify = exports.SearchQueryErrorCode = exports.parseSearchInputQuery = void 0;
 const lexer_1 = require("./lexer");
 const first_pass_parser_1 = require("./first-pass-parser");
 const validator_1 = require("./validator");
+Object.defineProperty(exports, "SearchQueryErrorCode", { enumerable: true, get: function () { return validator_1.SearchQueryErrorCode; } });
 const validate_expression_fields_1 = require("./validate-expression-fields");
 const transform_to_expression_1 = require("./transform-to-expression");
 // Helper function to stringify expressions
@@ -47,6 +48,7 @@ const parseSearchInputQuery = (input, fieldSchemas = []) => {
         if (finalToken.type !== lexer_1.TokenType.EOF) {
             throw {
                 message: 'Unexpected ")"',
+                code: validator_1.SearchQueryErrorCode.UNEXPECTED_RIGHT_PAREN,
                 position: finalToken.position,
                 length: finalToken.length,
             };

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

@@ -1,6 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.validateExpressionFields = void 0;
+const validator_1 = require("./validator");
 // Helper to validate numeric values
 const validateNumber = (value, position, errors) => {
     if (value === "")
@@ -8,6 +9,7 @@ const validateNumber = (value, position, errors) => {
     if (isNaN(Number(value))) {
         errors.push({
             message: "Invalid numeric value",
+            code: validator_1.SearchQueryErrorCode.INVALID_NUMERIC_VALUE,
             position,
             length: value.length,
         });
@@ -32,6 +34,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: validator_1.SearchQueryErrorCode.RANGE_START_GREATER_THAN_END,
                 position: basePosition,
                 length: start.length + 2 + end.length,
             });
@@ -52,6 +55,8 @@ const validateFieldValue = (expr, allowedFields, errors, schemas) => {
             if (!allowedFields.has(expr.field.toLowerCase())) {
                 errors.push({
                     message: `Invalid field: "${expr.field}"`,
+                    code: validator_1.SearchQueryErrorCode.INVALID_FIELD_NAME,
+                    value: expr.field,
                     position: expr.position,
                     length: expr.field.length,
                 });
@@ -65,6 +70,7 @@ const validateFieldValue = (expr, allowedFields, errors, schemas) => {
                             if (isNaN(Number(value))) {
                                 errors.push({
                                     message: "Invalid numeric value",
+                                    code: validator_1.SearchQueryErrorCode.INVALID_NUMERIC_VALUE,
                                     position: expr.position +
                                         expr.field.length +
                                         4 +
@@ -77,6 +83,7 @@ const validateFieldValue = (expr, allowedFields, errors, schemas) => {
                             if (!/^\d{4}-\d{2}-\d{2}$/.test(value)) {
                                 errors.push({
                                     message: "Invalid date format",
+                                    code: validator_1.SearchQueryErrorCode.INVALID_DATE_FORMAT,
                                     position: expr.position +
                                         expr.field.length +
                                         3 +
@@ -95,6 +102,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: validator_1.SearchQueryErrorCode.WILDCARD_NOT_ALLOWED,
+                    value: schema.type,
                     message: `Wildcards are not allowed for ${schema.type} fields`,
                     position: expr.position,
                     length: expr.length,
@@ -111,6 +120,8 @@ const validateFieldValue = (expr, allowedFields, errors, schemas) => {
             if (!allowedFields.has(fieldName.toLowerCase()) && colonIndex > 0) {
                 errors.push({
                     message: `Invalid field: "${fieldName}"`,
+                    code: validator_1.SearchQueryErrorCode.INVALID_FIELD_NAME,
+                    value: fieldName,
                     position: expr.position,
                     length: colonIndex,
                 });
@@ -118,6 +129,7 @@ const validateFieldValue = (expr, allowedFields, errors, schemas) => {
             if (!value) {
                 errors.push({
                     message: "Expected field value",
+                    code: validator_1.SearchQueryErrorCode.EXPECTED_FIELD_VALUE,
                     position: expr.position,
                     length: colonIndex + 1,
                 });
@@ -126,6 +138,7 @@ const validateFieldValue = (expr, allowedFields, errors, schemas) => {
             if (value.startsWith(":")) {
                 errors.push({
                     message: "Missing field name",
+                    code: validator_1.SearchQueryErrorCode.MISSING_FIELD_NAME,
                     position: expr.position,
                     length: value.length + colonIndex + 1,
                 });
@@ -140,6 +153,7 @@ const validateFieldValue = (expr, allowedFields, errors, schemas) => {
                     if (value === ".." || value.includes("...")) {
                         errors.push({
                             message: "Invalid range format",
+                            code: validator_1.SearchQueryErrorCode.INVALID_RANGE_FORMAT,
                             position: valueStartPosition,
                             length: value.length,
                         });
@@ -156,6 +170,7 @@ const validateFieldValue = (expr, allowedFields, errors, schemas) => {
                     if (invalidOp.test(value)) {
                         errors.push({
                             message: "Invalid range operator",
+                            code: validator_1.SearchQueryErrorCode.INVALID_RANGE_OPERATOR,
                             position: valueStartPosition,
                             length: 3,
                         });
@@ -164,6 +179,7 @@ const validateFieldValue = (expr, allowedFields, errors, schemas) => {
                     if (!compValue) {
                         errors.push({
                             message: "Expected range value",
+                            code: validator_1.SearchQueryErrorCode.EXPECTED_RANGE_VALUE,
                             position: valueStartPosition + operator.length,
                             length: 0,
                         });
@@ -191,6 +207,7 @@ const validateFieldValue = (expr, allowedFields, errors, schemas) => {
                     if (!dateValidator(start) || !dateValidator(end)) {
                         errors.push({
                             message: "Invalid date format",
+                            code: validator_1.SearchQueryErrorCode.INVALID_DATE_FORMAT,
                             position: valueStartPosition,
                             length: value.length,
                         });
@@ -204,6 +221,7 @@ const validateFieldValue = (expr, allowedFields, errors, schemas) => {
                         if (!dateValidator(dateStr)) {
                             errors.push({
                                 message: "Invalid date format",
+                                code: validator_1.SearchQueryErrorCode.INVALID_DATE_FORMAT,
                                 position: valueStartPosition,
                                 length: value.length,
                             });
@@ -213,6 +231,7 @@ const validateFieldValue = (expr, allowedFields, errors, schemas) => {
                     else if (!dateValidator(value)) {
                         errors.push({
                             message: "Invalid date format",
+                            code: validator_1.SearchQueryErrorCode.INVALID_DATE_FORMAT,
                             position: valueStartPosition,
                             length: value.length,
                         });

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

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

package/dist/cjs/validate-string.js

@@ -16,6 +16,7 @@ const validateString = (expr, errors) => {
     if (expr.value.endsWith(":")) {
         errors.push({
             message: "Expected field value",
+            code: validator_1.SearchQueryErrorCode.EXPECTED_FIELD_VALUE,
             position: expr.position,
             length: expr.length,
         });
@@ -25,6 +26,7 @@ const validateString = (expr, errors) => {
     if (expr.value.startsWith(":")) {
         errors.push({
             message: "Missing field name",
+            code: validator_1.SearchQueryErrorCode.MISSING_FIELD_NAME,
             position: expr.position,
             length: expr.length,
         });
@@ -37,6 +39,8 @@ const validateString = (expr, errors) => {
         if (validator_1.reservedWords.has(fieldName.toUpperCase())) {
             errors.push({
                 message: `${fieldName} is a reserved word`,
+                code: validator_1.SearchQueryErrorCode.RESERVED_WORD_AS_FIELD,
+                value: fieldName,
                 position: expr.position,
                 length: fieldName.length,
             });
@@ -46,6 +50,7 @@ const validateString = (expr, errors) => {
         if (!/^[a-zA-Z0-9_-]+$/.test(fieldName)) {
             errors.push({
                 message: "Invalid characters in field name",
+                code: validator_1.SearchQueryErrorCode.INVALID_FIELD_CHARS,
                 position: expr.position,
                 length: fieldName.length,
             });
@@ -57,6 +62,8 @@ const validateString = (expr, errors) => {
         validator_1.reservedWords.has(expr.value.toUpperCase())) {
         errors.push({
             message: `${expr.value} is a reserved word`,
+            code: validator_1.SearchQueryErrorCode.RESERVED_WORD_AS_FIELD,
+            value: expr.value,
             position: expr.position,
             length: expr.length,
         });

package/dist/cjs/validate-wildcard.js

@@ -1,6 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.validateWildcard = void 0;
+const validator_1 = require("./validator");
 // Validates wildcard patterns
 const validateWildcard = (expr, errors) => {
     const value = expr.type === "STRING" ? expr.value : expr.prefix + "*";
@@ -13,6 +14,7 @@ const validateWildcard = (expr, errors) => {
             const secondStar = value.indexOf("*", firstStar + 1);
             errors.push({
                 message: "Only one trailing wildcard (*) is allowed",
+                code: validator_1.SearchQueryErrorCode.MULTIPLE_WILDCARDS,
                 position: expr.position + secondStar,
                 length: 1,
             });
@@ -20,6 +22,7 @@ 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: validator_1.SearchQueryErrorCode.INVALID_WILDCARD_POSITION,
                 position: expr.position + firstStar,
                 length: 1,
             });
@@ -31,6 +34,7 @@ const validateWildcard = (expr, errors) => {
         if (value.endsWith("**")) {
             errors.push({
                 message: "Only one trailing wildcard (*) is allowed",
+                code: validator_1.SearchQueryErrorCode.MULTIPLE_WILDCARDS,
                 position: expr.position + value.length - 1,
                 length: 1,
             });

package/dist/cjs/validator.js

@@ -1,8 +1,42 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.validateSearchQuery = exports.reservedWords = void 0;
+exports.validateSearchQuery = exports.reservedWords = exports.SearchQueryErrorCode = void 0;
 const validate_in_expression_1 = require("./validate-in-expression");
 const validate_string_1 = require("./validate-string");
+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 || (exports.SearchQueryErrorCode = SearchQueryErrorCode = {}));
 exports.reservedWords = new Set(["AND", "OR"]);
 const walkExpression = (expr, errors) => {
     switch (expr.type) {

package/dist/esm/first-pass-parser.js

@@ -1,5 +1,6 @@
 import { TokenType, currentToken, advanceStream } from "./lexer";
 import { parsePrimary } from "./parse-primary";
+import { SearchQueryErrorCode } from "./validator";
 const getOperatorPrecedence = (type) => type === TokenType.AND ? 2 : type === TokenType.OR ? 1 : 0;
 export const parseExpression = (stream, minPrecedence = 0) => {
     const token = currentToken(stream);
@@ -30,6 +31,8 @@ export const parseExpression = (stream, minPrecedence = 0) => {
             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/dist/esm/lexer.js

@@ -1,3 +1,4 @@
+import { SearchQueryErrorCode } from "./validator";
 // Token types and data structures
 export var TokenType;
 (function (TokenType) {
@@ -90,7 +91,12 @@ const tokenizeQuotedString = (input, position) => {
             pos++;
         }
     }
-    throw { message: "Unterminated quoted string", position, length };
+    throw {
+        message: "Unterminated quoted string",
+        code: SearchQueryErrorCode.UNTERMINATED_QUOTED_STRING,
+        position,
+        length,
+    };
 };
 const tokenizeString = (input, position) => {
     let pos = position;
@@ -254,6 +260,7 @@ export const tokenize = (input) => {
                             prevToken.type === TokenType.STRING)) {
                         throw {
                             message: "Invalid syntax: Missing operator or whitespace between terms",
+                            code: SearchQueryErrorCode.MISSING_OPERATOR_OR_WHITESPACE,
                             position: position,
                             length: 1,
                         };
@@ -266,6 +273,7 @@ export const tokenize = (input) => {
                     !isSpecialChar(input[newPos])) {
                     throw {
                         message: "Invalid syntax: Missing operator or whitespace between terms",
+                        code: SearchQueryErrorCode.MISSING_OPERATOR_OR_WHITESPACE,
                         position: newPos,
                         length: 1,
                     };

package/dist/esm/parse-in-values.js

@@ -1,4 +1,5 @@
 import { currentToken, TokenType, advanceStream } from "./lexer";
+import { SearchQueryErrorCode } from "./validator";
 export const parseInValues = (stream, inValuePosition) => {
     const values = [];
     let currentStream = stream;
@@ -6,6 +7,7 @@ export const parseInValues = (stream, inValuePosition) => {
     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,
         };
@@ -17,6 +19,7 @@ export const parseInValues = (stream, inValuePosition) => {
             if (values.length === 0) {
                 throw {
                     message: "IN operator requires at least one value",
+                    code: SearchQueryErrorCode.EMPTY_IN_LIST,
                     position: token.position,
                     length: 1,
                 };
@@ -33,6 +36,7 @@ export const parseInValues = (stream, inValuePosition) => {
                 token.type !== TokenType.COMMA)) {
             throw {
                 message: "Expected ',' or ')' after IN value",
+                code: SearchQueryErrorCode.EXPECTED_IN_SEPARATOR,
                 position: token.position,
                 length: 1,
             };
@@ -52,6 +56,7 @@ export const parseInValues = (stream, inValuePosition) => {
             }
             throw {
                 message: "Expected ',' or ')' after IN value",
+                code: SearchQueryErrorCode.EXPECTED_IN_SEPARATOR,
                 position: nextToken.position,
                 length: 1,
             };

package/dist/esm/parse-primary.js

@@ -1,11 +1,14 @@
 import { parseExpression } from "./first-pass-parser";
 import { parseInValues } from "./parse-in-values";
 import { currentToken, TokenType, advanceStream } from "./lexer";
+import { SearchQueryErrorCode } from "./validator";
 export const expectToken = (stream, type, message) => {
     const token = currentToken(stream);
     if (token.type !== type) {
         throw {
             message: message ? message : `Expected ${type}`,
+            code: SearchQueryErrorCode.EXPECTED_TOKEN,
+            value: type,
             position: token.position,
             length: token.length,
         };
@@ -128,18 +131,22 @@ export const parsePrimary = (stream) => {
         case TokenType.OR:
             throw {
                 message: `${token.value} is a reserved word`,
+                code: SearchQueryErrorCode.RESERVED_WORD,
+                value: token.value,
                 position: token.position,
                 length: token.length,
             };
         case TokenType.RPAREN:
             throw {
                 message: 'Unexpected ")"',
+                code: SearchQueryErrorCode.UNEXPECTED_RIGHT_PAREN,
                 position: token.position,
                 length: token.length,
             };
         default:
             throw {
                 message: "Unexpected token",
+                code: SearchQueryErrorCode.UNEXPECTED_TOKEN,
                 position: token.position,
                 length: token.length,
             };

package/dist/esm/parser.js

@@ -1,6 +1,6 @@
 import { tokenize, createStream, currentToken, TokenType } from "./lexer";
 import { parseExpression, } from "./first-pass-parser";
-import { validateSearchQuery } from "./validator";
+import { validateSearchQuery, SearchQueryErrorCode, } from "./validator";
 import { validateExpressionFields } from "./validate-expression-fields";
 import { transformToExpression } from "./transform-to-expression";
 // Helper function to stringify expressions
@@ -43,6 +43,7 @@ export const parseSearchInputQuery = (input, fieldSchemas = []) => {
         if (finalToken.type !== TokenType.EOF) {
             throw {
                 message: 'Unexpected ")"',
+                code: SearchQueryErrorCode.UNEXPECTED_RIGHT_PAREN,
                 position: finalToken.position,
                 length: finalToken.length,
             };
@@ -78,4 +79,4 @@ export const parseSearchInputQuery = (input, fieldSchemas = []) => {
         };
     }
 };
-export { stringify, };
+export { SearchQueryErrorCode, stringify, };