@gblikas/querykit 0.1.0 → 0.2.0

package/dist/parser/parser.d.ts

@@ -15,6 +15,35 @@ export declare class QueryParser implements IQueryParser {
      * Parse a query string into a QueryKit AST
      */
     parse(query: string): QueryExpression;
+    /**
+     * Pre-process a query string to convert non-standard syntax to Liqe-compatible syntax.
+     * Supports:
+     * - `field:[val1, val2, val3]` → `(field:val1 OR field:val2 OR field:val3)`
+     *
+     * This keeps the syntax consistent with the `key:value` pattern used throughout QueryKit:
+     * - `priority:>2` (comparison)
+     * - `status:active` (equality)
+     * - `status:[todo, doing, done]` (IN / multiple values)
+     */
+    private preprocessQuery;
+    /**
+     * Convert a field and comma-separated values to an OR expression string
+     */
+    private convertToOrExpression;
+    /**
+     * Parse a comma-separated string into values, respecting quoted strings.
+     * Commas inside quoted strings are preserved as part of the value.
+     *
+     * Examples:
+     * - `a, b, c` → ['a', 'b', 'c']
+     * - `"John, Jr.", Jane` → ['"John, Jr."', 'Jane']
+     * - `'hello, world', test` → ["'hello, world'", 'test']
+     */
+    private parseCommaSeparatedValues;
+    /**
+     * Format a field:value pair, quoting the value if necessary
+     */
+    private formatFieldValue;
     /**
      * Validate a query string
      */
@@ -35,6 +64,11 @@ export declare class QueryParser implements IQueryParser {
      * Create a comparison expression
      */
     private createComparisonExpression;
+    /**
+     * Convert a Liqe RangeExpression to a QueryKit logical AND expression
+     * E.g., `field:[2 TO 5]` becomes `(field >= 2 AND field <= 5)`
+     */
+    private convertRangeExpression;
     /**
      * Convert a Liqe operator to a QueryKit operator
      */

package/dist/parser/parser.js

@@ -27,19 +27,142 @@ class QueryParser {
      */
     parse(query) {
         try {
-            const liqeAst = (0, liqe_1.parse)(query);
+            // Pre-process the query to handle IN operator syntax
+            const preprocessedQuery = this.preprocessQuery(query);
+            const liqeAst = (0, liqe_1.parse)(preprocessedQuery);
             return this.convertLiqeAst(liqeAst);
         }
         catch (error) {
             throw new QueryParseError(`Failed to parse query: ${error instanceof Error ? error.message : String(error)}`);
         }
     }
+    /**
+     * Pre-process a query string to convert non-standard syntax to Liqe-compatible syntax.
+     * Supports:
+     * - `field:[val1, val2, val3]` → `(field:val1 OR field:val2 OR field:val3)`
+     *
+     * This keeps the syntax consistent with the `key:value` pattern used throughout QueryKit:
+     * - `priority:>2` (comparison)
+     * - `status:active` (equality)
+     * - `status:[todo, doing, done]` (IN / multiple values)
+     */
+    preprocessQuery(query) {
+        let result = query;
+        // Handle `field:[val1, val2, ...]` syntax (array-like, not range)
+        // Pattern: fieldName:[value1, value2, ...]
+        // We distinguish from range by checking for commas without "TO"
+        const bracketArrayPattern = /(\w+):\[([^\]]+)\]/g;
+        result = result.replace(bracketArrayPattern, (fullMatch, field, values) => {
+            // Check if this looks like a range expression (contains " TO ")
+            if (/\s+TO\s+/i.test(values)) {
+                // This is a range expression, keep as-is
+                return fullMatch;
+            }
+            // This is an array-like expression, convert to OR
+            return this.convertToOrExpression(field, values);
+        });
+        return result;
+    }
+    /**
+     * Convert a field and comma-separated values to an OR expression string
+     */
+    convertToOrExpression(field, valuesStr) {
+        // Parse values respecting quoted strings (commas inside quotes are preserved)
+        const values = this.parseCommaSeparatedValues(valuesStr);
+        if (values.length === 0) {
+            return `${field}:""`;
+        }
+        if (values.length === 1) {
+            return this.formatFieldValue(field, values[0]);
+        }
+        // Build OR expression: (field:val1 OR field:val2 OR ...)
+        const orClauses = values.map((v) => this.formatFieldValue(field, v));
+        return `(${orClauses.join(' OR ')})`;
+    }
+    /**
+     * Parse a comma-separated string into values, respecting quoted strings.
+     * Commas inside quoted strings are preserved as part of the value.
+     *
+     * Examples:
+     * - `a, b, c` → ['a', 'b', 'c']
+     * - `"John, Jr.", Jane` → ['"John, Jr."', 'Jane']
+     * - `'hello, world', test` → ["'hello, world'", 'test']
+     */
+    parseCommaSeparatedValues(input) {
+        const values = [];
+        let current = '';
+        let inDoubleQuotes = false;
+        let inSingleQuotes = false;
+        let i = 0;
+        while (i < input.length) {
+            const char = input[i];
+            const nextChar = input[i + 1];
+            // Handle escape sequences inside quotes
+            if ((inDoubleQuotes || inSingleQuotes) && char === '\\' && nextChar) {
+                // Include both the backslash and the escaped character
+                current += char + nextChar;
+                i += 2;
+                continue;
+            }
+            // Toggle double quote state
+            if (char === '"' && !inSingleQuotes) {
+                inDoubleQuotes = !inDoubleQuotes;
+                current += char;
+                i++;
+                continue;
+            }
+            // Toggle single quote state
+            if (char === "'" && !inDoubleQuotes) {
+                inSingleQuotes = !inSingleQuotes;
+                current += char;
+                i++;
+                continue;
+            }
+            // Handle comma as separator (only when not inside quotes)
+            if (char === ',' && !inDoubleQuotes && !inSingleQuotes) {
+                const trimmed = current.trim();
+                if (trimmed.length > 0) {
+                    values.push(trimmed);
+                }
+                current = '';
+                i++;
+                continue;
+            }
+            // Regular character
+            current += char;
+            i++;
+        }
+        // Don't forget the last value
+        const trimmed = current.trim();
+        if (trimmed.length > 0) {
+            values.push(trimmed);
+        }
+        return values;
+    }
+    /**
+     * Format a field:value pair, quoting the value if necessary
+     */
+    formatFieldValue(field, value) {
+        // If the value is already quoted, use it as-is
+        if ((value.startsWith('"') && value.endsWith('"')) ||
+            (value.startsWith("'") && value.endsWith("'"))) {
+            return `${field}:${value}`;
+        }
+        // If value contains spaces or special characters, quote it
+        if (/\s|[():]/.test(value)) {
+            // Escape quotes within the value
+            const escapedValue = value.replace(/"/g, '\\"');
+            return `${field}:"${escapedValue}"`;
+        }
+        return `${field}:${value}`;
+    }
     /**
      * Validate a query string
      */
     validate(query) {
         try {
-            const ast = (0, liqe_1.parse)(query);
+            const preprocessedQuery = this.preprocessQuery(query);
+            const ast = (0, liqe_1.parse)(preprocessedQuery);
             this.convertLiqeAst(ast);
             return true;
         }
@@ -72,10 +195,16 @@ class QueryParser {
                     throw new QueryParseError('Invalid field or expression in Tag node');
                 }
                 const fieldName = this.normalizeFieldName(field.name);
+                // Handle RangeExpression (e.g., field:[min TO max])
+                if (expression.type === 'RangeExpression') {
+                    return this.convertRangeExpression(fieldName, expression);
+                }
                 const operator = this.convertLiqeOperator(tagNode.operator.operator);
                 const value = this.convertLiqeValue(expression.value);
                 // Check for wildcard patterns in string values
-                if (operator === '==' && typeof value === 'string' && (value.includes('*') || value.includes('?'))) {
+                if (operator === '==' &&
+                    typeof value === 'string' &&
+                    (value.includes('*') || value.includes('?'))) {
                     return this.createComparisonExpression(fieldName, 'LIKE', value);
                 }
                 return this.createComparisonExpression(fieldName, operator, value);
@@ -133,6 +262,31 @@ class QueryParser {
             value
         };
     }
+    /**
+     * Convert a Liqe RangeExpression to a QueryKit logical AND expression
+     * E.g., `field:[2 TO 5]` becomes `(field >= 2 AND field <= 5)`
+     */
+    convertRangeExpression(fieldName, expression) {
+        const range = expression.range;
+        // Handle null/undefined range values
+        if (range === null || range === undefined) {
+            throw new QueryParseError('Invalid range expression: missing range data');
+        }
+        const { min, max, minInclusive, maxInclusive } = range;
+        // Determine the operators based on inclusivity
+        const minOperator = minInclusive ? '>=' : '>';
+        const maxOperator = maxInclusive ? '<=' : '<';
+        // Create comparison expressions for min and max
+        const minComparison = this.createComparisonExpression(fieldName, minOperator, min);
+        const maxComparison = this.createComparisonExpression(fieldName, maxOperator, max);
+        // Combine with AND
+        return {
+            type: 'logical',
+            operator: 'AND',
+            left: minComparison,
+            right: maxComparison
+        };
+    }
     /**
      * Convert a Liqe operator to a QueryKit operator
      */
@@ -142,7 +296,9 @@ class QueryParser {
             return '==';
         }
         // Check if the operator is prefixed with a colon
-        const actualOperator = operator.startsWith(':') ? operator.substring(1) : operator;
+        const actualOperator = operator.startsWith(':')
+            ? operator.substring(1)
+            : operator;
         // Map Liqe operators to QueryKit operators
         const operatorMap = {
             '=': '==',
@@ -151,7 +307,7 @@ class QueryParser {
             '>=': '>=',
             '<': '<',
             '<=': '<=',
-            'in': 'IN',
+            in: 'IN',
             'not in': 'NOT IN'
         };
         const queryKitOperator = operatorMap[actualOperator.toLowerCase()];
@@ -169,7 +325,9 @@ class QueryParser {
         if (value === null) {
             return null;
         }
-        if (typeof value === 'string' || typeof value === 'number' || typeof value === 'boolean') {
+        if (typeof value === 'string' ||
+            typeof value === 'number' ||
+            typeof value === 'boolean') {
             return value;
         }
         if (Array.isArray(value)) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@gblikas/querykit",
-  "version": "0.1.0",
+  "version": "0.2.0",
   "description": "A comprehensive query toolkit for TypeScript that simplifies building and executing data queries across different environments",
   "repository": {
     "type": "git",

package/src/parser/parser.test.ts

@@ -1,5 +1,9 @@
 import { QueryParser, QueryParseError } from './parser';
-import { QueryExpression } from './types';
+import {
+  IComparisonExpression,
+  ILogicalExpression,
+  QueryExpression
+} from './types';
 
 // Replace the type definition with this approach
 type QueryParserPrivate = {
@@ -863,6 +867,210 @@ describe('QueryParser', () => {
 
       expect(parser.parse(query)).toEqual(expected);
     });
+
+    // IN operator syntax tests using consistent key:[values] pattern
+    describe('IN operator syntax (key:[values])', () => {
+      it('should parse "field:[val1, val2, val3]" bracket array syntax', () => {
+        const query = 'status:[todo, doing, done]';
+        const expected: QueryExpression = {
+          type: 'logical',
+          operator: 'OR',
+          left: {
+            type: 'logical',
+            operator: 'OR',
+            left: {
+              type: 'comparison',
+              field: 'status',
+              operator: '==',
+              value: 'todo'
+            },
+            right: {
+              type: 'comparison',
+              field: 'status',
+              operator: '==',
+              value: 'doing'
+            }
+          },
+          right: {
+            type: 'comparison',
+            field: 'status',
+            operator: '==',
+            value: 'done'
+          }
+        };
+
+        expect(parser.parse(query)).toEqual(expected);
+      });
+
+      it('should parse numeric values in bracket syntax', () => {
+        const query = 'id:[2, 3]';
+        const expected: QueryExpression = {
+          type: 'logical',
+          operator: 'OR',
+          left: {
+            type: 'comparison',
+            field: 'id',
+            operator: '==',
+            value: 2
+          },
+          right: {
+            type: 'comparison',
+            field: 'id',
+            operator: '==',
+            value: 3
+          }
+        };
+
+        expect(parser.parse(query)).toEqual(expected);
+      });
+
+      it('should parse single value in bracket syntax', () => {
+        const query = 'status:[active]';
+        const expected: QueryExpression = {
+          type: 'comparison',
+          field: 'status',
+          operator: '==',
+          value: 'active'
+        };
+
+        expect(parser.parse(query)).toEqual(expected);
+      });
+
+      it('should preserve range syntax "field:[min TO max]"', () => {
+        const query = 'id:[2 TO 5]';
+        const expected: QueryExpression = {
+          type: 'logical',
+          operator: 'AND',
+          left: {
+            type: 'comparison',
+            field: 'id',
+            operator: '>=',
+            value: 2
+          },
+          right: {
+            type: 'comparison',
+            field: 'id',
+            operator: '<=',
+            value: 5
+          }
+        };
+
+        expect(parser.parse(query)).toEqual(expected);
+      });
+
+      it('should parse exclusive range syntax "field:{min TO max}"', () => {
+        const query = 'id:{2 TO 5}';
+        const expected: QueryExpression = {
+          type: 'logical',
+          operator: 'AND',
+          left: {
+            type: 'comparison',
+            field: 'id',
+            operator: '>',
+            value: 2
+          },
+          right: {
+            type: 'comparison',
+            field: 'id',
+            operator: '<',
+            value: 5
+          }
+        };
+
+        expect(parser.parse(query)).toEqual(expected);
+      });
+
+      it('should parse bracket syntax combined with other expressions', () => {
+        const query = 'status:[todo, doing] AND priority:>2';
+        const parsed = parser.parse(query);
+
+        // Verify it's a logical AND at the top level
+        expect(parsed.type).toBe('logical');
+        expect((parsed as ILogicalExpression).operator).toBe('AND');
+
+        // Left side should be OR of status values
+        const left = (parsed as ILogicalExpression).left as ILogicalExpression;
+        expect(left.type).toBe('logical');
+        expect(left.operator).toBe('OR');
+      });
+
+      it('should handle values with spaces using quotes', () => {
+        const query = 'name:[John, "Jane Doe"]';
+        const parsed = parser.parse(query);
+
+        expect(parsed.type).toBe('logical');
+        expect((parsed as ILogicalExpression).operator).toBe('OR');
+
+        const right = (parsed as ILogicalExpression)
+          .right as IComparisonExpression;
+        expect(right.value).toBe('Jane Doe');
+      });
+
+      it('should validate bracket syntax queries', () => {
+        expect(parser.validate('status:[todo, doing, done]')).toBe(true);
+        expect(parser.validate('id:[1, 2, 3]')).toBe(true);
+        expect(parser.validate('id:[1 TO 10]')).toBe(true);
+      });
+
+      it('should handle mixed types in bracket syntax', () => {
+        const query = 'priority:[1, 2, 3]';
+        const parsed = parser.parse(query);
+
+        expect(parsed.type).toBe('logical');
+        // All values should be numbers
+        const getLeftmost = (expr: QueryExpression): IComparisonExpression => {
+          if (expr.type === 'comparison') return expr;
+          return getLeftmost((expr as ILogicalExpression).left);
+        };
+        expect(typeof getLeftmost(parsed).value).toBe('number');
+      });
+
+      it('should handle quoted values with commas inside', () => {
+        const query = 'name:["John, Jr.", "Jane"]';
+        const parsed = parser.parse(query);
+
+        expect(parsed.type).toBe('logical');
+        expect((parsed as ILogicalExpression).operator).toBe('OR');
+
+        const left = (parsed as ILogicalExpression)
+          .left as IComparisonExpression;
+        const right = (parsed as ILogicalExpression)
+          .right as IComparisonExpression;
+
+        expect(left.value).toBe('John, Jr.');
+        expect(right.value).toBe('Jane');
+      });
+
+      it('should handle single-quoted values with commas inside', () => {
+        const query = "name:['Hello, World', 'test']";
+        const parsed = parser.parse(query);
+
+        expect(parsed.type).toBe('logical');
+        const left = (parsed as ILogicalExpression)
+          .left as IComparisonExpression;
+        expect(left.value).toBe('Hello, World');
+      });
+
+      it('should handle mixed quoted and unquoted values with commas', () => {
+        const query = 'tags:["a,b,c", simple, "x,y"]';
+        const parsed = parser.parse(query);
+
+        expect(parsed.type).toBe('logical');
+        // Should have 3 values: "a,b,c", "simple", "x,y"
+        const getValues = (expr: QueryExpression): string[] => {
+          if (expr.type === 'comparison') {
+            return [String(expr.value)];
+          }
+          const logical = expr as ILogicalExpression;
+          return [...getValues(logical.left), ...getValues(logical.right!)];
+        };
+
+        const values = getValues(parsed);
+        expect(values).toContain('a,b,c');
+        expect(values).toContain('simple');
+        expect(values).toContain('x,y');
+      });
+    });
   });
 
   describe('validate', () => {

package/src/parser/parser.ts

@@ -7,6 +7,7 @@ import type {
   LiqeQuery,
   LogicalExpressionToken,
   ParenthesizedExpressionToken,
+  RangeExpressionToken,
   TagToken,
   UnaryOperatorToken
 } from 'liqe';
@@ -48,7 +49,9 @@ export class QueryParser implements IQueryParser {
    */
   public parse(query: string): QueryExpression {
     try {
-      const liqeAst = liqeParse(query);
+      // Pre-process the query to handle IN operator syntax
+      const preprocessedQuery = this.preprocessQuery(query);
+      const liqeAst = liqeParse(preprocessedQuery);
       return this.convertLiqeAst(liqeAst);
     } catch (error) {
       throw new QueryParseError(
@@ -57,12 +60,155 @@ export class QueryParser implements IQueryParser {
     }
   }
 
+  /**
+   * Pre-process a query string to convert non-standard syntax to Liqe-compatible syntax.
+   * Supports:
+   * - `field:[val1, val2, val3]` → `(field:val1 OR field:val2 OR field:val3)`
+   *
+   * This keeps the syntax consistent with the `key:value` pattern used throughout QueryKit:
+   * - `priority:>2` (comparison)
+   * - `status:active` (equality)
+   * - `status:[todo, doing, done]` (IN / multiple values)
+   */
+  private preprocessQuery(query: string): string {
+    let result = query;
+
+    // Handle `field:[val1, val2, ...]` syntax (array-like, not range)
+    // Pattern: fieldName:[value1, value2, ...]
+    // We distinguish from range by checking for commas without "TO"
+    const bracketArrayPattern = /(\w+):\[([^\]]+)\]/g;
+    result = result.replace(bracketArrayPattern, (fullMatch, field, values) => {
+      // Check if this looks like a range expression (contains " TO ")
+      if (/\s+TO\s+/i.test(values)) {
+        // This is a range expression, keep as-is
+        return fullMatch;
+      }
+      // This is an array-like expression, convert to OR
+      return this.convertToOrExpression(field, values);
+    });
+
+    return result;
+  }
+
+  /**
+   * Convert a field and comma-separated values to an OR expression string
+   */
+  private convertToOrExpression(field: string, valuesStr: string): string {
+    // Parse values respecting quoted strings (commas inside quotes are preserved)
+    const values = this.parseCommaSeparatedValues(valuesStr);
+
+    if (values.length === 0) {
+      return `${field}:""`;
+    }
+
+    if (values.length === 1) {
+      return this.formatFieldValue(field, values[0]);
+    }
+
+    // Build OR expression: (field:val1 OR field:val2 OR ...)
+    const orClauses = values.map((v: string) =>
+      this.formatFieldValue(field, v)
+    );
+    return `(${orClauses.join(' OR ')})`;
+  }
+
+  /**
+   * Parse a comma-separated string into values, respecting quoted strings.
+   * Commas inside quoted strings are preserved as part of the value.
+   *
+   * Examples:
+   * - `a, b, c` → ['a', 'b', 'c']
+   * - `"John, Jr.", Jane` → ['"John, Jr."', 'Jane']
+   * - `'hello, world', test` → ["'hello, world'", 'test']
+   */
+  private parseCommaSeparatedValues(input: string): string[] {
+    const values: string[] = [];
+    let current = '';
+    let inDoubleQuotes = false;
+    let inSingleQuotes = false;
+    let i = 0;
+
+    while (i < input.length) {
+      const char = input[i];
+      const nextChar = input[i + 1];
+
+      // Handle escape sequences inside quotes
+      if ((inDoubleQuotes || inSingleQuotes) && char === '\\' && nextChar) {
+        // Include both the backslash and the escaped character
+        current += char + nextChar;
+        i += 2;
+        continue;
+      }
+
+      // Toggle double quote state
+      if (char === '"' && !inSingleQuotes) {
+        inDoubleQuotes = !inDoubleQuotes;
+        current += char;
+        i++;
+        continue;
+      }
+
+      // Toggle single quote state
+      if (char === "'" && !inDoubleQuotes) {
+        inSingleQuotes = !inSingleQuotes;
+        current += char;
+        i++;
+        continue;
+      }
+
+      // Handle comma as separator (only when not inside quotes)
+      if (char === ',' && !inDoubleQuotes && !inSingleQuotes) {
+        const trimmed = current.trim();
+        if (trimmed.length > 0) {
+          values.push(trimmed);
+        }
+        current = '';
+        i++;
+        continue;
+      }
+
+      // Regular character
+      current += char;
+      i++;
+    }
+
+    // Don't forget the last value
+    const trimmed = current.trim();
+    if (trimmed.length > 0) {
+      values.push(trimmed);
+    }
+
+    return values;
+  }
+
+  /**
+   * Format a field:value pair, quoting the value if necessary
+   */
+  private formatFieldValue(field: string, value: string): string {
+    // If the value is already quoted, use it as-is
+    if (
+      (value.startsWith('"') && value.endsWith('"')) ||
+      (value.startsWith("'") && value.endsWith("'"))
+    ) {
+      return `${field}:${value}`;
+    }
+
+    // If value contains spaces or special characters, quote it
+    if (/\s|[():]/.test(value)) {
+      // Escape quotes within the value
+      const escapedValue = value.replace(/"/g, '\\"');
+      return `${field}:"${escapedValue}"`;
+    }
+    return `${field}:${value}`;
+  }
+
   /**
    * Validate a query string
    */
   public validate(query: string): boolean {
     try {
-      const ast = liqeParse(query);
+      const preprocessedQuery = this.preprocessQuery(query);
+      const ast = liqeParse(preprocessedQuery);
       this.convertLiqeAst(ast);
       return true;
     } catch {
@@ -81,7 +227,11 @@ export class QueryParser implements IQueryParser {
     switch (node.type) {
       case 'LogicalExpression': {
         const logicalNode = node as LogicalExpressionToken;
-        const operator = (logicalNode.operator as BooleanOperatorToken | ImplicitBooleanOperatorToken).operator;
+        const operator = (
+          logicalNode.operator as
+            | BooleanOperatorToken
+            | ImplicitBooleanOperatorToken
+        ).operator;
         return this.createLogicalExpression(
           this.convertLogicalOperator(operator),
           logicalNode.left,
@@ -97,30 +247,37 @@ export class QueryParser implements IQueryParser {
       case 'Tag': {
         const tagNode = node as TagToken;
         const field = tagNode.field as FieldToken;
-        const expression = tagNode.expression as ExpressionToken & { value: QueryValue };
-        
+        const expression = tagNode.expression as ExpressionToken & {
+          value: QueryValue;
+        };
+
         if (!field || !expression) {
           throw new QueryParseError('Invalid field or expression in Tag node');
         }
 
         const fieldName = this.normalizeFieldName(field.name);
+
+        // Handle RangeExpression (e.g., field:[min TO max])
+        if (expression.type === 'RangeExpression') {
+          return this.convertRangeExpression(
+            fieldName,
+            expression as unknown as RangeExpressionToken
+          );
+        }
+
         const operator = this.convertLiqeOperator(tagNode.operator.operator);
         const value = this.convertLiqeValue(expression.value);
 
         // Check for wildcard patterns in string values
-        if (operator === '==' && typeof value === 'string' && (value.includes('*') || value.includes('?'))) {
-          return this.createComparisonExpression(
-            fieldName,
-            'LIKE',
-            value
-          );
+        if (
+          operator === '==' &&
+          typeof value === 'string' &&
+          (value.includes('*') || value.includes('?'))
+        ) {
+          return this.createComparisonExpression(fieldName, 'LIKE', value);
         }
 
-        return this.createComparisonExpression(
-          fieldName,
-          operator,
-          value
-        );
+        return this.createComparisonExpression(fieldName, operator, value);
       }
 
       case 'EmptyExpression':
@@ -138,7 +295,9 @@ export class QueryParser implements IQueryParser {
       }
 
       default:
-        throw new QueryParseError(`Unsupported node type: ${(node as { type: string }).type}`);
+        throw new QueryParseError(
+          `Unsupported node type: ${(node as { type: string }).type}`
+        );
     }
   }
 
@@ -190,6 +349,48 @@ export class QueryParser implements IQueryParser {
     };
   }
 
+  /**
+   * Convert a Liqe RangeExpression to a QueryKit logical AND expression
+   * E.g., `field:[2 TO 5]` becomes `(field >= 2 AND field <= 5)`
+   */
+  private convertRangeExpression(
+    fieldName: string,
+    expression: RangeExpressionToken
+  ): QueryExpression {
+    const range = expression.range;
+
+    // Handle null/undefined range values
+    if (range === null || range === undefined) {
+      throw new QueryParseError('Invalid range expression: missing range data');
+    }
+
+    const { min, max, minInclusive, maxInclusive } = range;
+
+    // Determine the operators based on inclusivity
+    const minOperator: ComparisonOperator = minInclusive ? '>=' : '>';
+    const maxOperator: ComparisonOperator = maxInclusive ? '<=' : '<';
+
+    // Create comparison expressions for min and max
+    const minComparison = this.createComparisonExpression(
+      fieldName,
+      minOperator,
+      min
+    );
+    const maxComparison = this.createComparisonExpression(
+      fieldName,
+      maxOperator,
+      max
+    );
+
+    // Combine with AND
+    return {
+      type: 'logical',
+      operator: 'AND',
+      left: minComparison,
+      right: maxComparison
+    };
+  }
+
   /**
    * Convert a Liqe operator to a QueryKit operator
    */
@@ -200,7 +401,9 @@ export class QueryParser implements IQueryParser {
     }
 
     // Check if the operator is prefixed with a colon
-    const actualOperator = operator.startsWith(':') ? operator.substring(1) : operator;
+    const actualOperator = operator.startsWith(':')
+      ? operator.substring(1)
+      : operator;
 
     // Map Liqe operators to QueryKit operators
     const operatorMap: Record<string, ComparisonOperator> = {
@@ -210,7 +413,7 @@ export class QueryParser implements IQueryParser {
       '>=': '>=',
       '<': '<',
       '<=': '<=',
-      'in': 'IN',
+      in: 'IN',
       'not in': 'NOT IN'
     };
 
@@ -231,11 +434,15 @@ export class QueryParser implements IQueryParser {
     if (value === null) {
       return null;
     }
-    
-    if (typeof value === 'string' || typeof value === 'number' || typeof value === 'boolean') {
+
+    if (
+      typeof value === 'string' ||
+      typeof value === 'number' ||
+      typeof value === 'boolean'
+    ) {
       return value as QueryValue;
     }
-    
+
     if (Array.isArray(value)) {
       // Security fix: Recursively validate array elements
       const validatedArray = value.map(item => {
@@ -246,10 +453,12 @@ export class QueryParser implements IQueryParser {
       });
       return validatedArray as QueryValue;
     }
-    
+
     // Security fix: Reject all object types to prevent NoSQL injection
     if (typeof value === 'object') {
-      throw new QueryParseError('Object values are not supported for security reasons');
+      throw new QueryParseError(
+        'Object values are not supported for security reasons'
+      );
     }
 
     throw new QueryParseError(`Unsupported value type: ${typeof value}`);
@@ -265,4 +474,4 @@ export class QueryParser implements IQueryParser {
 
     return this.options.fieldMappings[normalizedField] ?? normalizedField;
   }
-} 
+}