@gblikas/querykit 0.1.0 → 0.3.0

package/src/parser/parse-with-context.test.ts

@@ -0,0 +1,325 @@
+import { QueryParser } from './parser';
+
+describe('QueryParser.parseWithContext', () => {
+  let parser: QueryParser;
+
+  beforeEach(() => {
+    parser = new QueryParser();
+  });
+
+  describe('successful parsing', () => {
+    it('should return success=true for valid query', () => {
+      const result = parser.parseWithContext('status:done');
+
+      expect(result.success).toBe(true);
+      expect(result.ast).toBeDefined();
+      expect(result.error).toBeUndefined();
+    });
+
+    it('should include AST for valid query', () => {
+      const result = parser.parseWithContext('status:done');
+
+      expect(result.ast).toMatchObject({
+        type: 'comparison',
+        field: 'status',
+        value: 'done'
+      });
+    });
+
+    it('should parse complex valid query', () => {
+      const result = parser.parseWithContext('status:done AND priority:high');
+
+      expect(result.success).toBe(true);
+      expect(result.ast?.type).toBe('logical');
+    });
+  });
+
+  describe('failed parsing', () => {
+    it('should return success=false for invalid query', () => {
+      const result = parser.parseWithContext('status:');
+
+      expect(result.success).toBe(false);
+      expect(result.ast).toBeUndefined();
+      expect(result.error).toBeDefined();
+    });
+
+    it('should include error message', () => {
+      const result = parser.parseWithContext('status:');
+
+      expect(result.error?.message).toBeDefined();
+      expect(result.error?.message.length).toBeGreaterThan(0);
+    });
+
+    it('should still return tokens for invalid query', () => {
+      const result = parser.parseWithContext('status:');
+
+      expect(result.tokens).toHaveLength(1);
+      expect(result.tokens[0]).toMatchObject({
+        type: 'term',
+        key: 'status',
+        value: null
+      });
+    });
+
+    it('should handle trailing operator', () => {
+      const result = parser.parseWithContext('status:done AND');
+
+      expect(result.success).toBe(false);
+      expect(result.tokens.length).toBeGreaterThanOrEqual(2);
+    });
+  });
+
+  describe('tokens', () => {
+    it('should always return tokens array', () => {
+      const validResult = parser.parseWithContext('status:done');
+      const invalidResult = parser.parseWithContext('status:');
+
+      expect(Array.isArray(validResult.tokens)).toBe(true);
+      expect(Array.isArray(invalidResult.tokens)).toBe(true);
+    });
+
+    it('should return interleaved tokens for compound query', () => {
+      const result = parser.parseWithContext('a:1 AND b:2 OR c:3');
+
+      expect(result.tokens).toHaveLength(5);
+      expect(result.tokens.map(t => t.type)).toEqual([
+        'term',
+        'operator',
+        'term',
+        'operator',
+        'term'
+      ]);
+    });
+
+    it('should include position information', () => {
+      const result = parser.parseWithContext('status:done');
+
+      expect(result.tokens[0].startPosition).toBe(0);
+      expect(result.tokens[0].endPosition).toBe(11);
+      expect(result.tokens[0].raw).toBe('status:done');
+    });
+  });
+
+  describe('active token (cursor awareness)', () => {
+    it('should identify active token when cursor position provided', () => {
+      const result = parser.parseWithContext('status:done AND priority:high', {
+        cursorPosition: 5
+      });
+
+      expect(result.activeToken).toBeDefined();
+      expect(result.activeToken?.type).toBe('term');
+      expect(result.activeTokenIndex).toBe(0);
+    });
+
+    it('should identify cursor in operator', () => {
+      const result = parser.parseWithContext('status:done AND priority:high', {
+        cursorPosition: 13 // in "AND"
+      });
+
+      expect(result.activeToken?.type).toBe('operator');
+      expect(result.activeTokenIndex).toBe(1);
+    });
+
+    it('should return activeTokenIndex=-1 when no cursor provided', () => {
+      const result = parser.parseWithContext('status:done');
+
+      expect(result.activeTokenIndex).toBe(-1);
+    });
+  });
+
+  describe('structure analysis', () => {
+    it('should analyze simple query structure', () => {
+      const result = parser.parseWithContext('status:done');
+
+      expect(result.structure).toMatchObject({
+        depth: 1,
+        clauseCount: 1,
+        operatorCount: 0,
+        hasBalancedParentheses: true,
+        hasBalancedQuotes: true,
+        isComplete: true,
+        complexity: 'simple'
+      });
+    });
+
+    it('should count clauses correctly', () => {
+      const result = parser.parseWithContext('a:1 AND b:2 AND c:3');
+
+      expect(result.structure.clauseCount).toBe(3);
+      expect(result.structure.operatorCount).toBe(2);
+    });
+
+    it('should detect unbalanced parentheses', () => {
+      const result = parser.parseWithContext('(status:done');
+
+      expect(result.structure.hasBalancedParentheses).toBe(false);
+      expect(result.structure.isComplete).toBe(false);
+    });
+
+    it('should detect unbalanced quotes', () => {
+      const result = parser.parseWithContext('name:"John');
+
+      expect(result.structure.hasBalancedQuotes).toBe(false);
+      expect(result.structure.isComplete).toBe(false);
+    });
+
+    it('should calculate depth for nested query', () => {
+      const result = parser.parseWithContext('(a:1 AND (b:2 OR c:3))');
+
+      expect(result.structure.depth).toBe(2);
+    });
+
+    it('should extract referenced fields', () => {
+      const result = parser.parseWithContext('status:done AND priority:high');
+
+      expect(result.structure.referencedFields).toContain('status');
+      expect(result.structure.referencedFields).toContain('priority');
+      expect(result.structure.referencedFields).toHaveLength(2);
+    });
+
+    it('should not duplicate fields in referencedFields', () => {
+      const result = parser.parseWithContext('status:done OR status:pending');
+
+      expect(result.structure.referencedFields).toEqual(['status']);
+    });
+
+    it('should classify simple queries', () => {
+      expect(parser.parseWithContext('a:1').structure.complexity).toBe(
+        'simple'
+      );
+      expect(parser.parseWithContext('a:1 AND b:2').structure.complexity).toBe(
+        'simple'
+      );
+    });
+
+    it('should classify moderate queries', () => {
+      const result = parser.parseWithContext('a:1 AND b:2 AND c:3');
+
+      expect(result.structure.complexity).toBe('moderate');
+    });
+
+    it('should classify complex queries', () => {
+      const result = parser.parseWithContext(
+        'a:1 AND b:2 AND c:3 AND d:4 AND e:5 AND f:6'
+      );
+
+      expect(result.structure.complexity).toBe('complex');
+    });
+
+    it('should classify deeply nested as complex', () => {
+      const result = parser.parseWithContext(
+        '(((a:1 AND b:2) OR c:3) AND d:4)'
+      );
+
+      // Depth > 3 should be complex
+      expect(result.structure.depth).toBeGreaterThanOrEqual(3);
+    });
+  });
+
+  describe('input preservation', () => {
+    it('should preserve original input', () => {
+      const input = 'status:done AND priority:high';
+      const result = parser.parseWithContext(input);
+
+      expect(result.input).toBe(input);
+    });
+  });
+
+  describe('edge cases', () => {
+    it('should handle empty input', () => {
+      const result = parser.parseWithContext('');
+
+      expect(result.success).toBe(false);
+      expect(result.tokens).toHaveLength(0);
+      expect(result.structure.clauseCount).toBe(0);
+      expect(result.structure.depth).toBe(0);
+    });
+
+    it('should handle whitespace-only input', () => {
+      const result = parser.parseWithContext('   ');
+
+      expect(result.success).toBe(false);
+      expect(result.tokens).toHaveLength(0);
+    });
+
+    it('should handle query with only logical operators', () => {
+      const result = parser.parseWithContext('AND OR');
+
+      expect(result.success).toBe(false);
+      // Should still tokenize the operators
+      expect(result.tokens.length).toBeGreaterThanOrEqual(1);
+    });
+
+    it('should handle very long query', () => {
+      const clauses = Array.from(
+        { length: 20 },
+        (_, i) => `field${i}:value${i}`
+      );
+      const query = clauses.join(' AND ');
+      const result = parser.parseWithContext(query);
+
+      expect(result.success).toBe(true);
+      expect(result.structure.clauseCount).toBe(20);
+      expect(result.structure.complexity).toBe('complex');
+    });
+  });
+
+  describe('integration with parser options', () => {
+    it('should respect caseInsensitiveFields option', () => {
+      const caseInsensitiveParser = new QueryParser({
+        caseInsensitiveFields: true
+      });
+
+      const result = caseInsensitiveParser.parseWithContext('STATUS:done');
+
+      expect(result.success).toBe(true);
+      expect(result.ast).toMatchObject({
+        field: 'status' // lowercased
+      });
+    });
+
+    it('should respect fieldMappings option', () => {
+      const mappedParser = new QueryParser({
+        fieldMappings: { s: 'status' }
+      });
+
+      const result = mappedParser.parseWithContext('s:done');
+
+      expect(result.success).toBe(true);
+      expect(result.ast).toMatchObject({
+        field: 'status' // mapped
+      });
+    });
+  });
+
+  describe('never throws', () => {
+    it('should never throw, even for malformed input', () => {
+      const badInputs = [
+        '',
+        '   ',
+        ':::',
+        '(((',
+        '))))',
+        'AND AND AND',
+        '""""""',
+        '\n\t\r',
+        'field:>>>>>',
+        'a'.repeat(10000)
+      ];
+
+      for (const input of badInputs) {
+        expect(() => parser.parseWithContext(input)).not.toThrow();
+      }
+    });
+
+    it('should return a valid result object for any input', () => {
+      const result = parser.parseWithContext('totally {{invalid}} query!!!');
+
+      expect(result).toHaveProperty('success');
+      expect(result).toHaveProperty('input');
+      expect(result).toHaveProperty('tokens');
+      expect(result).toHaveProperty('structure');
+      expect(result).toHaveProperty('activeTokenIndex');
+    });
+  });
+});

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', () => {