search-input-query-parser 0.1.0

package/dist/cjs/parse-range-expression.js

@@ -0,0 +1,174 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseRangeExpression = void 0;
+const isRangeOperator = (str) => {
+    return [">=", ">", "<=", "<"].includes(str);
+};
+const parseRangeExpression = (fieldName, value, schema, position, colonIndex) => {
+    // Handle ..20 (less than or equal)
+    if (value.startsWith("..")) {
+        const numValue = value.slice(2);
+        return {
+            type: "RANGE",
+            field: {
+                type: "FIELD",
+                value: fieldName,
+                position,
+                length: colonIndex,
+            },
+            operator: "<=",
+            value: {
+                type: "VALUE",
+                value: numValue,
+                position: position + colonIndex + 3, // after colon and ..
+                length: numValue.length,
+            },
+            position,
+            length: colonIndex + 1 + value.length,
+        };
+    }
+    // Handle 10.. (greater than or equal)
+    if (value.endsWith("..")) {
+        const numValue = value.slice(0, -2);
+        return {
+            type: "RANGE",
+            field: {
+                type: "FIELD",
+                value: fieldName,
+                position,
+                length: colonIndex,
+            },
+            operator: ">=",
+            value: {
+                type: "VALUE",
+                value: numValue,
+                position: position + colonIndex + 1,
+                length: numValue.length,
+            },
+            position,
+            length: colonIndex + 1 + value.length,
+        };
+    }
+    // Handle date ranges with YYYY-MM-DD format
+    if ((schema === null || schema === void 0 ? void 0 : schema.type) === "date") {
+        const betweenMatch = value.match(/^(\d{4}-\d{2}-\d{2})\.\.(\d{4}-\d{2}-\d{2})$/);
+        if (betweenMatch) {
+            const [_, start, end] = betweenMatch;
+            return {
+                type: "RANGE",
+                field: {
+                    type: "FIELD",
+                    value: fieldName,
+                    position,
+                    length: colonIndex,
+                },
+                operator: "BETWEEN",
+                value: {
+                    type: "VALUE",
+                    value: start,
+                    position: position + colonIndex + 1,
+                    length: start.length,
+                },
+                value2: {
+                    type: "VALUE",
+                    value: end,
+                    position: position + colonIndex + start.length + 3,
+                    length: end.length,
+                },
+                position,
+                length: colonIndex + 1 + value.length,
+            };
+        }
+    }
+    // Handle 10..20 (between), handling floats and negative numbers
+    const betweenMatch = value.match(/^(-?\d*\.?\d+)\.\.(-?\d*\.?\d+)$/);
+    if (betweenMatch) {
+        const [_, start, end] = betweenMatch;
+        return {
+            type: "RANGE",
+            field: {
+                type: "FIELD",
+                value: fieldName,
+                position,
+                length: colonIndex,
+            },
+            operator: "BETWEEN",
+            value: {
+                type: "VALUE",
+                value: start,
+                position: position + colonIndex + 1,
+                length: start.length,
+            },
+            value2: {
+                type: "VALUE",
+                value: end,
+                position: position + colonIndex + start.length + 3,
+                length: end.length,
+            },
+            position,
+            length: colonIndex + 1 + value.length,
+        };
+    }
+    // Handle >100, >=100, <100, <=100
+    if (value.length > 1 && isRangeOperator(value.slice(0, 2))) {
+        const operator = value.slice(0, 2);
+        const numValue = value.slice(2);
+        return {
+            type: "RANGE",
+            field: {
+                type: "FIELD",
+                value: fieldName,
+                position,
+                length: colonIndex,
+            },
+            operator,
+            value: {
+                type: "VALUE",
+                value: numValue,
+                position: position + colonIndex + 3,
+                length: numValue.length,
+            },
+            position,
+            length: colonIndex + 1 + value.length,
+        };
+    }
+    if (value.length > 0 && isRangeOperator(value.slice(0, 1))) {
+        const operator = value.slice(0, 1);
+        const numValue = value.slice(1);
+        return {
+            type: "RANGE",
+            field: {
+                type: "FIELD",
+                value: fieldName,
+                position,
+                length: colonIndex,
+            },
+            operator,
+            value: {
+                type: "VALUE",
+                value: numValue,
+                position: position + colonIndex + 2,
+                length: numValue.length,
+            },
+            position,
+            length: colonIndex + 1 + value.length,
+        };
+    }
+    // If no range pattern is matched, return a regular field value
+    return {
+        type: "FIELD_VALUE",
+        field: {
+            type: "FIELD",
+            value: fieldName,
+            position,
+            length: colonIndex,
+        },
+        value: {
+            type: "VALUE",
+            value,
+            position: position + colonIndex + 1,
+            length: value.length,
+        },
+    };
+};
+exports.parseRangeExpression = parseRangeExpression;

package/dist/cjs/parser.js

@@ -0,0 +1,85 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.stringify = exports.parseSearchInputQuery = void 0;
+const lexer_1 = require("./lexer");
+const first_pass_parser_1 = require("./first-pass-parser");
+const validator_1 = require("./validator");
+const validate_expression_fields_1 = require("./validate-expression-fields");
+const transform_to_expression_1 = require("./transform-to-expression");
+// Helper function to stringify expressions
+const stringify = (expr) => {
+    var _a;
+    switch (expr.type) {
+        case "SEARCH_TERM":
+            return expr.value;
+        case "WILDCARD":
+            return `${expr.prefix}*`;
+        case "FIELD_VALUE":
+            return `${expr.field.value}:${expr.value.value}`;
+        case "RANGE":
+            if (expr.operator === "BETWEEN") {
+                return `${expr.field.value}:${expr.value.value}..${(_a = expr.value2) === null || _a === void 0 ? void 0 : _a.value}`;
+            }
+            return `${expr.field.value}:${expr.operator}${expr.value.value}`;
+        case "NOT":
+            return `NOT (${stringify(expr.expression)})`;
+        case "AND":
+            return `(${stringify(expr.left)} AND ${stringify(expr.right)})`;
+        case "OR":
+            return `(${stringify(expr.left)} OR ${stringify(expr.right)})`;
+        case "IN": {
+            const values = expr.values.map((v) => v.value).join(",");
+            return `${expr.field.value}:IN(${values})`;
+        }
+    }
+};
+exports.stringify = stringify;
+// Main parse function
+const parseSearchInputQuery = (input, fieldSchemas = []) => {
+    try {
+        const tokens = (0, lexer_1.tokenize)(input);
+        const stream = (0, lexer_1.createStream)(tokens);
+        if ((0, lexer_1.currentToken)(stream).type === lexer_1.TokenType.EOF) {
+            return { type: "SEARCH_QUERY", expression: null };
+        }
+        const result = (0, first_pass_parser_1.parseExpression)(stream);
+        const finalToken = (0, lexer_1.currentToken)(result.stream);
+        if (finalToken.type !== lexer_1.TokenType.EOF) {
+            throw {
+                message: 'Unexpected ")"',
+                position: finalToken.position,
+                length: finalToken.length,
+            };
+        }
+        const errors = (0, validator_1.validateSearchQuery)(result.result);
+        const fieldErrors = [];
+        const allowedFields = fieldSchemas.map((s) => s.name.toLowerCase());
+        if (allowedFields.length > 0) {
+            const columnSet = new Set(allowedFields.map((col) => col.toLowerCase()));
+            const schemaMap = new Map(fieldSchemas.map((s) => [s.name.toLowerCase(), s]));
+            (0, validate_expression_fields_1.validateExpressionFields)(result.result, columnSet, fieldErrors, schemaMap);
+        }
+        const fieldErrorKeys = fieldErrors.map(({ position, length }) => `${position}-${length}`);
+        const errorsToRemove = errors.filter(({ position, length }) => fieldErrorKeys.includes(`${position}-${length}`));
+        const fieldErrorsFiltered = fieldErrors.filter(({ position, length }) => !errorsToRemove.some((error) => error.position === position && error.length === length));
+        const allErrors = [...errors, ...fieldErrorsFiltered].sort((a, b) => a.position - b.position);
+        if (allErrors.length > 0) {
+            return {
+                type: "SEARCH_QUERY_ERROR",
+                expression: null,
+                errors: allErrors,
+            };
+        }
+        const schemaMap = new Map(fieldSchemas.map((s) => [s.name.toLowerCase(), s]));
+        const expression = (0, transform_to_expression_1.transformToExpression)(result.result, schemaMap);
+        return { type: "SEARCH_QUERY", expression };
+    }
+    catch (error) {
+        return {
+            type: "SEARCH_QUERY_ERROR",
+            expression: null,
+            errors: [error],
+        };
+    }
+};
+exports.parseSearchInputQuery = parseSearchInputQuery;

package/dist/cjs/search-query-to-sql.js

@@ -0,0 +1,346 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.searchStringToSql = exports.searchQueryToSql = void 0;
+const parser_1 = require("./parser");
+// Constants
+const SPECIAL_CHARS = ["%", "_"];
+const ESCAPE_CHAR = "\\";
+// Helper Functions
+const escapeRegExp = (str) => str.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+const escapeSpecialChars = (value) => SPECIAL_CHARS.reduce((escaped, char) => escaped.replace(new RegExp(escapeRegExp(char), "g"), ESCAPE_CHAR + char), value);
+// Helper to escape special characters for ParadeDB query syntax
+const escapeParadeDBChars = (value) => {
+    const specialChars = [
+        "+",
+        "^",
+        "`",
+        ":",
+        "{",
+        "}",
+        '"',
+        "[",
+        "]",
+        "(",
+        ")",
+        "<",
+        ">",
+        "~",
+        "!",
+        "\\",
+        "*",
+    ];
+    return specialChars.reduce((escaped, char) => escaped.replace(new RegExp(escapeRegExp(char), "g"), `\\${char}`), value);
+};
+const stripQuotes = (value) => {
+    if (value.startsWith('"') && value.endsWith('"')) {
+        return value.slice(1, -1);
+    }
+    return value;
+};
+const cleanQuotedString = (value, stripOuterQuotes = true) => {
+    // First strip the outer quotes if requested
+    let cleaned = stripOuterQuotes ? stripQuotes(value) : value;
+    // Replace escaped quotes with regular quotes
+    cleaned = cleaned.replace(/\\"/g, '"');
+    // Clean up any remaining escape characters
+    cleaned = cleaned.replace(/\\\\/g, "\\");
+    return cleaned;
+};
+const isQuotedString = (value) => {
+    return value.startsWith('"') && value.endsWith('"');
+};
+const prepareParadeDBString = (value, includeWildcard = false) => {
+    // First clean up the string
+    const cleaned = cleanQuotedString(value);
+    // For ParadeDB, we need to:
+    // 1. Escape special characters (except wildcards)
+    // 2. Wrap in quotes
+    // 3. Add wildcard if needed
+    const escaped = escapeParadeDBChars(cleaned);
+    const result = `"${escaped}"`;
+    return includeWildcard ? `${result}*` : result;
+};
+// Create a new parameter placeholder and update state
+const nextParam = (state) => {
+    const paramName = `$${state.paramCounter}`;
+    const newState = {
+        ...state,
+        paramCounter: state.paramCounter + 1,
+    };
+    return [paramName, newState];
+};
+// Add a value to the state and return updated state
+const addValue = (state, value) => ({
+    ...state,
+    values: [...state.values, value],
+});
+/**
+ * Convert a wildcard pattern to SQL
+ */
+const wildcardPatternToSql = (expr, state) => {
+    if (expr.prefix === "") {
+        return ["1=1", state];
+    }
+    const [paramName, newState] = nextParam(state);
+    const cleanedPrefix = cleanQuotedString(expr.prefix);
+    switch (state.searchType) {
+        case "paradedb": {
+            const queryValue = prepareParadeDBString(cleanedPrefix, true);
+            const conditions = state.searchableColumns.map((column) => `${column} @@@ ${paramName}`);
+            const sql = conditions.length === 1
+                ? conditions[0]
+                : `(${conditions.join(" OR ")})`;
+            return [sql, addValue(newState, queryValue)];
+        }
+        case "tsvector": {
+            const langConfig = state.language || "english";
+            const conditions = state.searchableColumns.map((column) => `to_tsvector('${langConfig}', ${column})`);
+            const tsvectorCondition = `(${conditions.join(" || ")}) @@ to_tsquery('${langConfig}', ${paramName})`;
+            return [tsvectorCondition, addValue(newState, `${cleanedPrefix}:*`)];
+        }
+        default: {
+            // ILIKE behavior
+            const escapedPrefix = escapeSpecialChars(cleanedPrefix);
+            const conditions = state.searchableColumns.map((column) => `lower(${column}) LIKE lower(${paramName})`);
+            const sql = conditions.length === 1
+                ? conditions[0]
+                : `(${conditions.join(" OR ")})`;
+            return [sql, addValue(newState, `${escapedPrefix}%`)];
+        }
+    }
+};
+/**
+ * Convert a search term to SQL conditions based on search type
+ */
+const searchTermToSql = (value, state) => {
+    const [paramName, newState] = nextParam(state);
+    const hasWildcard = value.endsWith("*");
+    const isQuoted = isQuotedString(value);
+    const cleanedValue = cleanQuotedString(value);
+    const baseValue = hasWildcard ? cleanedValue.slice(0, -1) : cleanedValue;
+    switch (state.searchType) {
+        case "paradedb": {
+            const queryValue = prepareParadeDBString(baseValue, hasWildcard);
+            const conditions = state.searchableColumns.map((column) => `${column} @@@ ${paramName}`);
+            const sql = conditions.length === 1
+                ? conditions[0]
+                : `(${conditions.join(" OR ")})`;
+            return [sql, addValue(newState, queryValue)];
+        }
+        case "tsvector": {
+            const langConfig = state.language || "english";
+            const conditions = state.searchableColumns.map((column) => `to_tsvector('${langConfig}', ${column})`);
+            const tsvectorCondition = `(${conditions.join(" || ")}) @@ ${hasWildcard ? "to_tsquery" : "plainto_tsquery"}('${langConfig}', ${paramName})`;
+            return [
+                tsvectorCondition,
+                addValue(newState, hasWildcard ? `${baseValue}:*` : baseValue),
+            ];
+        }
+        case "ilike": {
+            // Use lower() for case-insensitive search in SQLite
+            const escapedTerm = escapeSpecialChars(baseValue);
+            const conditions = state.searchableColumns.map((column) => `lower(${column}) LIKE lower(${paramName})`);
+            const sql = conditions.length === 1
+                ? conditions[0]
+                : `(${conditions.join(" OR ")})`;
+            if (hasWildcard) {
+                return [sql, addValue(newState, `${escapedTerm}%`)];
+            }
+            else {
+                return [sql, addValue(newState, `%${escapedTerm}%`)];
+            }
+        }
+    }
+};
+/**
+ * Convert a field:value pair to SQL based on search type
+ */
+const fieldValueToSql = (field, value, state) => {
+    const [paramName, newState] = nextParam(state);
+    const schema = state.schemas.get(field.toLowerCase());
+    const hasWildcard = value.endsWith("*");
+    const cleanedValue = cleanQuotedString(value);
+    const baseValue = hasWildcard ? cleanedValue.slice(0, -1) : cleanedValue;
+    if (state.searchType === "paradedb") {
+        switch (schema === null || schema === void 0 ? void 0 : schema.type) {
+            case "date": {
+                // Use parameter binding for dates
+                const [dateParam, dateState] = nextParam(state);
+                return [
+                    `${field} @@@ '"' || ${dateParam} || '"'`,
+                    addValue(dateState, baseValue),
+                ];
+            }
+            case "number":
+                return [`${field} @@@ '${baseValue}'`, newState];
+            default: {
+                const queryValue = prepareParadeDBString(baseValue, hasWildcard);
+                return [`${field} @@@ ${paramName}`, addValue(newState, queryValue)];
+            }
+        }
+    }
+    // Rest of the function remains the same...
+    switch (schema === null || schema === void 0 ? void 0 : schema.type) {
+        case "date":
+            return [
+                `${field} = ${paramName}`,
+                addValue(newState, cleanedValue),
+            ];
+        case "number":
+            return [
+                `${field} = ${paramName}`,
+                addValue(newState, Number(cleanedValue)),
+            ];
+        default:
+            if (state.searchType === "tsvector" &&
+                state.searchableColumns.includes(field)) {
+                const langConfig = state.language || "english";
+                return [
+                    `to_tsvector('${langConfig}', ${field}) @@ ${hasWildcard ? "to_tsquery" : "plainto_tsquery"}('${langConfig}', ${paramName})`,
+                    addValue(newState, hasWildcard ? `${baseValue}:*` : baseValue),
+                ];
+            }
+            else {
+                const escapedValue = escapeSpecialChars(baseValue);
+                return [
+                    `lower(${field}) LIKE lower(${paramName})`,
+                    addValue(newState, hasWildcard ? `${escapedValue}%` : `%${escapedValue}%`),
+                ];
+            }
+    }
+};
+/**
+ * Convert a range expression to SQL
+ */
+const rangeToSql = (field, operator, value, value2, state) => {
+    const schema = state.schemas.get(field.toLowerCase());
+    const isDateField = (schema === null || schema === void 0 ? void 0 : schema.type) === "date";
+    if (state.searchType === "paradedb") {
+        if (operator === "BETWEEN" && value2) {
+            const [param1, state1] = nextParam(state);
+            const [param2, state2] = nextParam(state1);
+            let val1 = isDateField ? value : Number(value);
+            let val2 = isDateField ? value2 : Number(value2);
+            return [
+                `${field} @@@ '[' || ${param1} || ' TO ' || ${param2} || ']'`,
+                addValue(addValue(state2, val1), val2),
+            ];
+        }
+        else {
+            const [paramName, newState] = nextParam(state);
+            const rangeOp = operator.replace(">=", ">=").replace("<=", "<=");
+            const val = isDateField ? value : Number(value);
+            return [
+                `${field} @@@ '${rangeOp}' || ${paramName}`,
+                addValue(newState, val),
+            ];
+        }
+    }
+    if (operator === "BETWEEN" && value2) {
+        const [param1, state1] = nextParam(state);
+        const [param2, state2] = nextParam(state1);
+        let val1 = isDateField ? value : Number(value);
+        let val2 = isDateField ? value2 : Number(value2);
+        return [
+            `${field} BETWEEN ${param1} AND ${param2}`,
+            addValue(addValue(state2, val1), val2),
+        ];
+    }
+    const [paramName, newState] = nextParam(state);
+    const val = isDateField ? value : Number(value);
+    return [
+        `${field} ${operator} ${paramName}`,
+        addValue(newState, val),
+    ];
+};
+const inExpressionToSql = (field, values, state) => {
+    let currentState = state;
+    const cleanedValues = values.map((v) => cleanQuotedString(v));
+    if (state.searchType === "paradedb") {
+        const paramNames = [];
+        for (const value of cleanedValues) {
+            const [paramName, newState] = nextParam(currentState);
+            paramNames.push(paramName);
+            currentState = addValue(newState, value);
+        }
+        const concatExpr = paramNames.join(" || ' ' || ");
+        return [`${field} @@@ 'IN[' || ${concatExpr} || ']'`, currentState];
+    }
+    const paramNames = [];
+    const schema = state.schemas.get(field.toLowerCase());
+    for (const value of cleanedValues) {
+        const [paramName, newState] = nextParam(currentState);
+        paramNames.push(paramName);
+        currentState = addValue(newState, (schema === null || schema === void 0 ? void 0 : schema.type) === "number" ? Number(value) : value);
+    }
+    return [
+        `${field} IN (${paramNames
+            .map((p) => p)
+            .join(", ")})`,
+        currentState,
+    ];
+};
+/**
+ * Convert a binary operation (AND/OR) to SQL
+ */
+const binaryOpToSql = (operator, left, right, state) => {
+    const [leftText, leftState] = expressionToSql(left, state);
+    const [rightText, rightState] = expressionToSql(right, leftState);
+    return [`(${leftText} ${operator} ${rightText})`, rightState];
+};
+/**
+ * Convert a single expression to SQL
+ */
+const expressionToSql = (expr, state) => {
+    var _a;
+    switch (expr.type) {
+        case "SEARCH_TERM":
+            return searchTermToSql(expr.value, state);
+        case "WILDCARD":
+            return wildcardPatternToSql(expr, state);
+        case "IN":
+            return inExpressionToSql(expr.field.value, expr.values.map((v) => v.value), state);
+        case "FIELD_VALUE":
+            return fieldValueToSql(expr.field.value, expr.value.value, state);
+        case "RANGE":
+            return rangeToSql(expr.field.value, expr.operator, expr.value.value, (_a = expr.value2) === null || _a === void 0 ? void 0 : _a.value, state);
+        case "AND":
+            return binaryOpToSql("AND", expr.left, expr.right, state);
+        case "OR":
+            return binaryOpToSql("OR", expr.left, expr.right, state);
+        case "NOT": {
+            const [sqlText, newState] = expressionToSql(expr.expression, state);
+            return [`NOT ${sqlText}`, newState];
+        }
+    }
+};
+/**
+ * Convert a SearchQuery to a SQL WHERE clause with specified search type
+ */
+const searchQueryToSql = (query, searchableColumns, schemas = [], options = {}) => {
+    const initialState = {
+        paramCounter: 1,
+        values: [],
+        searchableColumns,
+        schemas: new Map(schemas.map((s) => [s.name.toLowerCase(), s])),
+        searchType: options.searchType || "ilike",
+        language: options.language,
+    };
+    if (!query.expression) {
+        return { text: "1=1", values: [] };
+    }
+    const [text, finalState] = expressionToSql(query.expression, initialState);
+    return { text, values: finalState.values };
+};
+exports.searchQueryToSql = searchQueryToSql;
+/**
+ * Convert a search string directly to SQL
+ */
+const searchStringToSql = (searchString, searchableColumns, schemas = [], options = {}) => {
+    const query = (0, parser_1.parseSearchInputQuery)(searchString, schemas);
+    if (query.type === "SEARCH_QUERY_ERROR") {
+        throw new Error(`Parse error: ${query.errors[0].message}`);
+    }
+    return (0, exports.searchQueryToSql)(query, searchableColumns, schemas, options);
+};
+exports.searchStringToSql = searchStringToSql;