search-input-query-parser 0.1.0

package/dist/cjs/transform-to-expression.js

@@ -0,0 +1,130 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.transformToExpression = void 0;
+const parse_range_expression_1 = require("./parse-range-expression");
+// Helper to transform FirstPassExpression into Expression
+const transformToExpression = (expr, schemas) => {
+    switch (expr.type) {
+        case "NOT":
+            return {
+                type: "NOT",
+                expression: (0, exports.transformToExpression)(expr.expression, schemas),
+                position: expr.position,
+                length: expr.length,
+            };
+        case "WILDCARD":
+            // Check if this is part of a field:value pattern by looking at the prefix
+            const colonIndex = expr.prefix.indexOf(":");
+            if (colonIndex !== -1) {
+                const field = expr.prefix.substring(0, colonIndex).trim();
+                const prefix = expr.prefix.substring(colonIndex + 1).trim();
+                return {
+                    type: "FIELD_VALUE",
+                    field: {
+                        type: "FIELD",
+                        value: field,
+                        position: expr.position - colonIndex - 1, // Adjust for the field part
+                        length: colonIndex,
+                    },
+                    value: {
+                        type: "VALUE",
+                        value: prefix + "*", // Preserve the wildcard in the value
+                        position: expr.position,
+                        length: prefix.length + 1,
+                    },
+                };
+            }
+            // If not a field:value pattern, return as a wildcard search term
+            return {
+                type: "WILDCARD",
+                prefix: expr.prefix,
+                quoted: expr.quoted,
+                position: expr.position,
+                length: expr.length,
+            };
+        case "STRING": {
+            // Check if the string is a field:value pattern
+            const colonIndex = expr.value.indexOf(":");
+            if (colonIndex !== -1) {
+                const field = expr.value.substring(0, colonIndex).trim();
+                let value = expr.value.substring(colonIndex + 1).trim();
+                // Remove quotes if present
+                value =
+                    value.startsWith('"') && value.endsWith('"')
+                        ? value.slice(1, -1)
+                        : value;
+                const schema = schemas.get(field.toLowerCase());
+                // Check for range patterns when we have a numeric or date field
+                if (schema && (schema.type === "number" || schema.type === "date")) {
+                    return (0, parse_range_expression_1.parseRangeExpression)(field, value, schema, expr.position, colonIndex);
+                }
+                return {
+                    type: "FIELD_VALUE",
+                    field: {
+                        type: "FIELD",
+                        value: field,
+                        position: expr.position,
+                        length: colonIndex,
+                    },
+                    value: {
+                        type: "VALUE",
+                        value,
+                        position: expr.position + colonIndex + 1,
+                        length: value.length,
+                    },
+                };
+            }
+            return {
+                type: "SEARCH_TERM",
+                value: expr.value,
+                position: expr.position,
+                length: expr.length,
+            };
+        }
+        case "AND":
+            return {
+                type: "AND",
+                left: (0, exports.transformToExpression)(expr.left, schemas),
+                right: (0, exports.transformToExpression)(expr.right, schemas),
+                position: expr.position,
+                length: expr.length,
+            };
+        case "OR":
+            return {
+                type: "OR",
+                left: (0, exports.transformToExpression)(expr.left, schemas),
+                right: (0, exports.transformToExpression)(expr.right, schemas),
+                position: expr.position,
+                length: expr.length,
+            };
+        case "IN": {
+            const schema = schemas.get(expr.field.toLowerCase());
+            const transformedValues = expr.values.map((value, index) => {
+                let transformedValue = value;
+                // Handle type conversion based on schema
+                if ((schema === null || schema === void 0 ? void 0 : schema.type) === "number") {
+                    transformedValue = String(Number(value));
+                }
+                return {
+                    type: "VALUE",
+                    value: transformedValue,
+                    position: expr.position + expr.field.length + 3 + index * (value.length + 1), // +3 for ":IN"
+                    length: value.length,
+                };
+            });
+            return {
+                type: "IN",
+                field: {
+                    type: "FIELD",
+                    value: expr.field,
+                    position: expr.position,
+                    length: expr.field.length,
+                },
+                values: transformedValues,
+                position: expr.position,
+                length: expr.length,
+            };
+        }
+    }
+};
+exports.transformToExpression = transformToExpression;

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

@@ -0,0 +1,244 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.validateExpressionFields = void 0;
+// Helper to validate numeric values
+const validateNumber = (value, position, errors) => {
+    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, end, basePosition, errors) => {
+    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, value, basePosition, errors) => {
+    const valuePosition = basePosition + operator.length;
+    return validateNumber(value, valuePosition, errors);
+};
+// Field validation helpers
+const validateFieldValue = (expr, allowedFields, errors, schemas) => {
+    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 === null || schema === void 0 ? void 0 : schema.type) === "number" || (schema === null || schema === void 0 ? void 0 : 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) => {
+                    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;
+        }
+    }
+};
+const validateExpressionFields = (expr, allowedFields, errors, schemas) => {
+    switch (expr.type) {
+        case "STRING":
+        case "WILDCARD":
+        case "IN":
+            validateFieldValue(expr, allowedFields, errors, schemas);
+            break;
+        case "AND":
+        case "OR":
+            (0, exports.validateExpressionFields)(expr.left, allowedFields, errors, schemas);
+            (0, exports.validateExpressionFields)(expr.right, allowedFields, errors, schemas);
+            break;
+        case "NOT":
+            (0, exports.validateExpressionFields)(expr.expression, allowedFields, errors, schemas);
+            break;
+    }
+};
+exports.validateExpressionFields = validateExpressionFields;

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

@@ -0,0 +1,33 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.validateInExpression = void 0;
+const validator_1 = require("./validator");
+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",
+            position: expr.position,
+            length: expr.field.length,
+        });
+    }
+    // Check for reserved words
+    if (validator_1.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,
+            });
+        }
+    });
+};
+exports.validateInExpression = validateInExpression;

package/dist/cjs/validate-string.js

@@ -0,0 +1,65 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.validateString = void 0;
+const validator_1 = require("./validator");
+const validate_wildcard_1 = require("./validate-wildcard");
+// Validate individual strings (field:value pairs or plain terms)
+const validateString = (expr, errors) => {
+    // Validate wildcard usage
+    (0, validate_wildcard_1.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 (validator_1.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(":") &&
+        validator_1.reservedWords.has(expr.value.toUpperCase())) {
+        errors.push({
+            message: `${expr.value} is a reserved word`,
+            position: expr.position,
+            length: expr.length,
+        });
+    }
+};
+exports.validateString = validateString;

package/dist/cjs/validate-wildcard.js

@@ -0,0 +1,40 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.validateWildcard = void 0;
+// Validates wildcard patterns
+const validateWildcard = (expr, errors) => {
+    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,
+            });
+        }
+    }
+};
+exports.validateWildcard = validateWildcard;

package/dist/cjs/validator.js

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

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

@@ -0,0 +1,73 @@
+import { TokenType, currentToken, advanceStream } from "./lexer";
+import { parsePrimary } from "./parse-primary";
+const getOperatorPrecedence = (type) => type === TokenType.AND ? 2 : type === TokenType.OR ? 1 : 0;
+export const parseExpression = (stream, minPrecedence = 0) => {
+    const token = currentToken(stream);
+    if (token.type === TokenType.STRING && token.value === "*") {
+        return {
+            result: {
+                type: "WILDCARD",
+                prefix: "",
+                quoted: false,
+                position: token.position,
+                length: token.length,
+            },
+            stream: advanceStream(stream),
+        };
+    }
+    let result = parsePrimary(stream);
+    while (true) {
+        const token = currentToken(result.stream);
+        if (token.type === TokenType.EOF)
+            break;
+        if (token.type === TokenType.AND || token.type === TokenType.OR) {
+            const precedence = getOperatorPrecedence(token.type);
+            if (precedence < minPrecedence)
+                break;
+            const operator = token.type;
+            const nextStream = advanceStream(result.stream);
+            const nextToken = currentToken(nextStream);
+            if (nextToken.type === TokenType.EOF) {
+                throw {
+                    message: `Unexpected token: ${token.value}`,
+                    position: token.position,
+                    length: token.length,
+                };
+            }
+            const right = parseExpression(nextStream, precedence + 1);
+            result = {
+                result: {
+                    type: operator,
+                    left: result.result,
+                    right: right.result,
+                    position: token.position,
+                    length: token.length,
+                },
+                stream: right.stream,
+            };
+            continue;
+        }
+        if (token.type === TokenType.STRING ||
+            token.type === TokenType.QUOTED_STRING ||
+            token.type === TokenType.LPAREN ||
+            token.type === TokenType.NOT) {
+            const precedence = getOperatorPrecedence(TokenType.AND);
+            if (precedence < minPrecedence)
+                break;
+            const right = parseExpression(result.stream, precedence + 1);
+            result = {
+                result: {
+                    type: TokenType.AND,
+                    left: result.result,
+                    right: right.result,
+                    position: token.position,
+                    length: token.length,
+                },
+                stream: right.stream,
+            };
+            continue;
+        }
+        break;
+    }
+    return result;
+};