Skip to content

armgit / papra

Public Imported from GitHub
0

The minimalistic document archiving platform.

25.6 KB
Raw Blame
import { describe, expect, test } from 'vitest';
import { parseSearchQuery } from './parser';

describe('parseSearchQuery', () => {
  describe('when parsing simple queries', () => {
    test('returns empty expression and no search terms for empty query', () => {
      expect(parseSearchQuery({ query: '' })).toEqual({
        expression: { type: 'empty' },
        issues: [],
      });

      expect(parseSearchQuery({ query: '  ' })).toEqual({
        expression: { type: 'empty' },
        issues: [],
      });

      expect(parseSearchQuery({ query: ' \n \t ' })).toEqual({
        expression: { type: 'empty' },
        issues: [],
      });
    });

    test('extracts full-text search terms when no filters present', () => {
      expect(parseSearchQuery({ query: 'my invoice' })).toEqual({
        expression: {
          type: 'and',
          operands: [
            { type: 'text', value: 'my' },
            { type: 'text', value: 'invoice' },
          ],
        },
        issues: [],
      });
    });

    test('handles quoted search terms', () => {
      expect(parseSearchQuery({ query: '"my special invoice"' })).toEqual({
        expression: { type: 'text', value: 'my special invoice' },
        issues: [],
      });
    });

    test('handles escaped quotes in search terms', () => {
      expect(parseSearchQuery({ query: '"my \\"special\\" invoice"' })).toEqual({
        expression: { type: 'text', value: 'my "special" invoice' },
        issues: [],
      });
    });

    test('handles escaped colons to prevent filter parsing', () => {
      expect(parseSearchQuery({ query: 'tag\\:invoice' })).toEqual({
        expression: { type: 'text', value: 'tag:invoice' },
        issues: [],
      });
    });
  });

  describe('when parsing filter expressions', () => {
    test('parses simple filter with equality operator', () => {
      expect(parseSearchQuery({ query: 'tag:invoice' })).toEqual({
        expression: {
          type: 'filter',
          field: 'tag',
          operator: '=',
          value: 'invoice',
        },
        issues: [],
      });
    });

    test('parses filter with explicit equality operator', () => {
      expect(parseSearchQuery({ query: 'tag:=invoice' })).toEqual({
        expression: {
          type: 'filter',
          field: 'tag',
          operator: '=',
          value: 'invoice',
        },
        issues: [],
      });
    });

    test('parses filter with quoted value containing spaces', () => {
      expect(parseSearchQuery({ query: 'tag:"my invoices"' })).toEqual({
        expression: {
          type: 'filter',
          field: 'tag',
          operator: '=',
          value: 'my invoices',
        },
        issues: [],
      });
    });

    test('parses filter with escaped quotes in value', () => {
      expect(parseSearchQuery({ query: 'tag:"my \\"special\\" invoices"' })).toEqual({
        expression: {
          type: 'filter',
          field: 'tag',
          operator: '=',
          value: 'my "special" invoices',
        },
        issues: [],
      });
    });

    test('parses filter with escaped colons in value', () => {
      expect(parseSearchQuery({ query: 'tag:my\\:\\:special\\:\\:tag' })).toEqual({
        expression: {
          type: 'filter',
          field: 'tag',
          operator: '=',
          value: 'my::special::tag',
        },
        issues: [],
      });
    });

    test('parses filter with escaped colons in field name', () => {
      expect(parseSearchQuery({ query: 'my\\:field:value' })).toEqual({
        expression: {
          type: 'filter',
          field: 'my:field',
          operator: '=',
          value: 'value',
        },
        issues: [],
      });
    });

    test('parses filter with quoted field name containing spaces', () => {
      expect(parseSearchQuery({ query: '"foo bar":buz' })).toEqual({
        expression: {
          type: 'filter',
          field: 'foo bar',
          operator: '=',
          value: 'buz',
        },
        issues: [],
      });
    });

    test('parses filter with quoted field name and quoted value', () => {
      expect(parseSearchQuery({ query: '"foo bar":"hello world"' })).toEqual({
        expression: {
          type: 'filter',
          field: 'foo bar',
          operator: '=',
          value: 'hello world',
        },
        issues: [],
      });
    });

    test('parses filter with quoted field name and comparison operator', () => {
      expect(parseSearchQuery({ query: '"my field":>=42' })).toEqual({
        expression: {
          type: 'filter',
          field: 'my field',
          operator: '>=',
          value: '42',
        },
        issues: [],
      });
    });

    test('parses filter with quoted keyword field names without treating them as operators', () => {
      expect(parseSearchQuery({ query: '"or":foo' })).toEqual({
        expression: {
          type: 'filter',
          field: 'or',
          operator: '=',
          value: 'foo',
        },
        issues: [],
      });

      expect(parseSearchQuery({ query: '"NOT":value' })).toEqual({
        expression: {
          type: 'filter',
          field: 'NOT',
          operator: '=',
          value: 'value',
        },
        issues: [],
      });

      expect(parseSearchQuery({ query: '"AND":>=42' })).toEqual({
        expression: {
          type: 'filter',
          field: 'AND',
          operator: '>=',
          value: '42',
        },
        issues: [],
      });
    });

    test('treats quoted keyword strings as text, not operators', () => {
      expect(parseSearchQuery({ query: '"AND"' })).toEqual({
        expression: { type: 'text', value: 'AND' },
        issues: [],
      });

      expect(parseSearchQuery({ query: '"OR"' })).toEqual({
        expression: { type: 'text', value: 'OR' },
        issues: [],
      });

      expect(parseSearchQuery({ query: '"NOT"' })).toEqual({
        expression: { type: 'text', value: 'NOT' },
        issues: [],
      });
    });

    test('parses negated filter with quoted field name', () => {
      expect(parseSearchQuery({ query: '-"foo bar":buz' })).toEqual({
        expression: {
          type: 'not',
          operand: {
            type: 'filter',
            field: 'foo bar',
            operator: '=',
            value: 'buz',
          },
        },
        issues: [],
      });
    });

    test('parses filter with escaped quotes in quoted field name', () => {
      expect(parseSearchQuery({ query: '"foo \\"bar\\"":buz' })).toEqual({
        expression: {
          type: 'filter',
          field: 'foo "bar"',
          operator: '=',
          value: 'buz',
        },
        issues: [],
      });
    });

    test('parses filters with quotes containing colons', () => {
      expect(parseSearchQuery({ query: '"field:with:colons":value' })).toEqual({
        expression: {
          type: 'filter',
          field: 'field:with:colons',
          operator: '=',
          value: 'value',
        },
        issues: [],
      });
    });

    test('parses filter with comparison operators', () => {
      expect(parseSearchQuery({ query: 'createdAt:>2024-01-01' })).toEqual({
        expression: {
          type: 'filter',
          field: 'createdAt',
          operator: '>',
          value: '2024-01-01',
        },
        issues: [],
      });

      expect(parseSearchQuery({ query: 'createdAt:<2024-01-01' })).toEqual({
        expression: {
          type: 'filter',
          field: 'createdAt',
          operator: '<',
          value: '2024-01-01',
        },
        issues: [],
      });

      expect(parseSearchQuery({ query: 'createdAt:>=2024-01-01' })).toEqual({
        expression: {
          type: 'filter',
          field: 'createdAt',
          operator: '>=',
          value: '2024-01-01',
        },
        issues: [],
      });

      expect(parseSearchQuery({ query: 'createdAt:<=2024-01-01' })).toEqual({
        expression: {
          type: 'filter',
          field: 'createdAt',
          operator: '<=',
          value: '2024-01-01',
        },
        issues: [],
      });
    });

    test('parses negated filter with minus prefix', () => {
      expect(parseSearchQuery({ query: '-tag:personal' })).toEqual({
        expression: {
          type: 'not',
          operand: {
            type: 'filter',
            field: 'tag',
            operator: '=',
            value: 'personal',
          },
        },
        issues: [],
      });
    });
  });

  describe('when combining filters and search terms', () => {
    test('combines filter with search terms', () => {
      expect(parseSearchQuery({ query: 'tag:invoice my invoice' })).toEqual({
        expression: {
          type: 'and',
          operands: [
            { type: 'filter', field: 'tag', operator: '=', value: 'invoice' },
            { type: 'text', value: 'my' },
            { type: 'text', value: 'invoice' },
          ],
        },
        issues: [],
      });
    });

    test('extracts search terms before and after filters', () => {
      expect(parseSearchQuery({ query: 'foo tag:invoice bar' })).toEqual({
        expression: {
          type: 'and',
          operands: [
            { type: 'text', value: 'foo' },
            { type: 'filter', field: 'tag', operator: '=', value: 'invoice' },
            { type: 'text', value: 'bar' },
          ],
        },
        issues: [],
      });
    });
  });

  describe('when using AND operator', () => {
    test('combines filters with explicit AND', () => {
      expect(parseSearchQuery({ query: 'tag:invoice AND tag:receipt' })).toEqual({
        expression: {
          type: 'and',
          operands: [
            { type: 'filter', field: 'tag', operator: '=', value: 'invoice' },
            { type: 'filter', field: 'tag', operator: '=', value: 'receipt' },
          ],
        },
        issues: [],
      });
    });

    test('combines filters with implicit AND', () => {
      expect(parseSearchQuery({ query: 'tag:invoice tag:receipt' })).toEqual({
        expression: {
          type: 'and',
          operands: [
            { type: 'filter', field: 'tag', operator: '=', value: 'invoice' },
            { type: 'filter', field: 'tag', operator: '=', value: 'receipt' },
          ],
        },
        issues: [],
      });
    });

    test('combines multiple filters with AND', () => {
      expect(
        parseSearchQuery({ query: 'tag:invoice createdAt:>2024-01-01 status:active' }),
      ).toEqual({
        expression: {
          type: 'and',
          operands: [
            { type: 'filter', field: 'tag', operator: '=', value: 'invoice' },
            { type: 'filter', field: 'createdAt', operator: '>', value: '2024-01-01' },
            { type: 'filter', field: 'status', operator: '=', value: 'active' },
          ],
        },
        issues: [],
      });
    });
  });

  describe('when using OR operator', () => {
    test('combines filters with OR', () => {
      expect(parseSearchQuery({ query: 'tag:invoice OR tag:receipt' })).toEqual({
        expression: {
          type: 'or',
          operands: [
            { type: 'filter', field: 'tag', operator: '=', value: 'invoice' },
            { type: 'filter', field: 'tag', operator: '=', value: 'receipt' },
          ],
        },
        issues: [],
      });
    });

    test('combines multiple filters with OR', () => {
      expect(parseSearchQuery({ query: 'tag:invoice OR tag:receipt OR tag:bill' })).toEqual({
        expression: {
          type: 'or',
          operands: [
            { type: 'filter', field: 'tag', operator: '=', value: 'invoice' },
            { type: 'filter', field: 'tag', operator: '=', value: 'receipt' },
            { type: 'filter', field: 'tag', operator: '=', value: 'bill' },
          ],
        },
        issues: [],
      });
    });
  });

  describe('when using NOT operator', () => {
    test('negates filter with NOT keyword', () => {
      expect(parseSearchQuery({ query: 'NOT tag:personal' })).toEqual({
        expression: {
          type: 'not',
          operand: {
            type: 'filter',
            field: 'tag',
            operator: '=',
            value: 'personal',
          },
        },
        issues: [],
      });
    });

    test('negates grouped expression', () => {
      expect(parseSearchQuery({ query: 'NOT (tag:personal OR tag:private)' })).toEqual({
        expression: {
          type: 'not',
          operand: {
            type: 'or',
            operands: [
              { type: 'filter', field: 'tag', operator: '=', value: 'personal' },
              { type: 'filter', field: 'tag', operator: '=', value: 'private' },
            ],
          },
        },
        issues: [],
      });
    });
  });

  describe('when using grouping with parentheses', () => {
    test('groups expressions with parentheses', () => {
      expect(parseSearchQuery({ query: '(tag:invoice OR tag:receipt)' })).toEqual({
        expression: {
          type: 'or',
          operands: [
            { type: 'filter', field: 'tag', operator: '=', value: 'invoice' },
            { type: 'filter', field: 'tag', operator: '=', value: 'receipt' },
          ],
        },
        issues: [],
      });
    });

    test('combines grouped expressions with AND', () => {
      expect(
        parseSearchQuery({ query: '(tag:invoice OR tag:receipt) AND createdAt:>2024-01-01' }),
      ).toEqual({
        expression: {
          type: 'and',
          operands: [
            {
              type: 'or',
              operands: [
                { type: 'filter', field: 'tag', operator: '=', value: 'invoice' },
                { type: 'filter', field: 'tag', operator: '=', value: 'receipt' },
              ],
            },
            { type: 'filter', field: 'createdAt', operator: '>', value: '2024-01-01' },
          ],
        },
        issues: [],
      });
    });

    test('handles nested grouping', () => {
      expect(
        parseSearchQuery({ query: '((tag:invoice OR tag:receipt) AND status:active)' }),
      ).toEqual({
        expression: {
          type: 'and',
          operands: [
            {
              type: 'or',
              operands: [
                { type: 'filter', field: 'tag', operator: '=', value: 'invoice' },
                { type: 'filter', field: 'tag', operator: '=', value: 'receipt' },
              ],
            },
            { type: 'filter', field: 'status', operator: '=', value: 'active' },
          ],
        },
        issues: [],
      });
    });
  });

  describe('when respecting operator precedence', () => {
    test('aND binds tighter than OR', () => {
      expect(parseSearchQuery({ query: 'tag:invoice OR tag:receipt AND tag:company' })).toEqual({
        expression: {
          type: 'or',
          operands: [
            { type: 'filter', field: 'tag', operator: '=', value: 'invoice' },
            {
              type: 'and',
              operands: [
                { type: 'filter', field: 'tag', operator: '=', value: 'receipt' },
                { type: 'filter', field: 'tag', operator: '=', value: 'company' },
              ],
            },
          ],
        },
        issues: [],
      });
    });

    test('nOT binds tighter than AND', () => {
      expect(parseSearchQuery({ query: 'NOT tag:invoice AND tag:receipt' })).toEqual({
        expression: {
          type: 'and',
          operands: [
            {
              type: 'not',
              operand: { type: 'filter', field: 'tag', operator: '=', value: 'invoice' },
            },
            { type: 'filter', field: 'tag', operator: '=', value: 'receipt' },
          ],
        },
        issues: [],
      });
    });

    test('parentheses override precedence', () => {
      expect(parseSearchQuery({ query: '(tag:invoice OR tag:receipt) AND tag:company' })).toEqual({
        expression: {
          type: 'and',
          operands: [
            {
              type: 'or',
              operands: [
                { type: 'filter', field: 'tag', operator: '=', value: 'invoice' },
                { type: 'filter', field: 'tag', operator: '=', value: 'receipt' },
              ],
            },
            { type: 'filter', field: 'tag', operator: '=', value: 'company' },
          ],
        },
        issues: [],
      });
    });
  });

  describe('when handling malformed queries', () => {
    test('handles unclosed quoted string gracefully', () => {
      const result = parseSearchQuery({ query: '"unclosed string' });
      expect(result.expression).toEqual({
        type: 'text',
        value: 'unclosed string',
      });
      expect(result.issues).toContainEqual({
        code: 'unclosed-quoted-string',
        message: 'Unclosed quoted string',
      });
    });

    test('handles unmatched opening parenthesis gracefully', () => {
      const result = parseSearchQuery({ query: '(tag:invoice' });
      expect(result.expression).toEqual({
        type: 'filter',
        field: 'tag',
        operator: '=',
        value: 'invoice',
      });
      expect(result.issues).toContainEqual({
        code: 'unmatched-opening-parenthesis',
        message: 'Unmatched opening parenthesis',
      });
    });

    test('handles unmatched closing parenthesis gracefully', () => {
      const result = parseSearchQuery({ query: 'tag:invoice)' });
      expect(result.expression).toEqual({
        type: 'filter',
        field: 'tag',
        operator: '=',
        value: 'invoice',
      });
      expect(result.issues).toContainEqual({
        code: 'unmatched-closing-parenthesis',
        message: 'Unmatched closing parenthesis',
      });
    });

    test('handles NOT without operand gracefully', () => {
      const result = parseSearchQuery({ query: 'tag:invoice AND NOT' });
      expect(result.expression).toEqual({
        type: 'filter',
        field: 'tag',
        operator: '=',
        value: 'invoice',
      });
      expect(result.issues).toContainEqual({
        code: 'missing-operand-for-not',
        message: 'NOT operator requires an operand',
      });
    });
  });

  describe('when enforcing limits', () => {
    test('respects maximum token limit', () => {
      const longQuery = Array.from({ length: 50 })
        .map((_, i) => `tag${i}:value${i}`)
        .join(' ');
      const result = parseSearchQuery({ query: longQuery, maxTokens: 10 });
      expect(result.issues).toContainEqual({
        code: 'max-tokens-exceeded',
        message: 'Maximum token limit of 10 exceeded',
      });
    });

    test('respects maximum depth limit', () => {
      const deepQuery = '((((((((((tag:invoice))))))))))';
      const result = parseSearchQuery({ query: deepQuery, maxDepth: 5 });
      expect(result.issues).toContainEqual({
        code: 'max-nesting-depth-exceeded',
        message: 'Maximum nesting depth of 5 exceeded',
      });
    });
  });

  describe('when handling complex real-world queries', () => {
    test('parses complex query with multiple operators and grouping', () => {
      expect(
        parseSearchQuery({
          query:
            '(tag:invoice OR tag:receipt) AND createdAt:>2024-01-01 AND NOT tag:personal my document',
        }),
      ).toEqual({
        expression: {
          type: 'and',
          operands: [
            {
              type: 'or',
              operands: [
                { type: 'filter', field: 'tag', operator: '=', value: 'invoice' },
                { type: 'filter', field: 'tag', operator: '=', value: 'receipt' },
              ],
            },
            { type: 'filter', field: 'createdAt', operator: '>', value: '2024-01-01' },
            {
              type: 'not',
              operand: { type: 'filter', field: 'tag', operator: '=', value: 'personal' },
            },
            { type: 'text', value: 'my' },
            { type: 'text', value: 'document' },
          ],
        },
        issues: [],
      });
    });

    test('parses query with multiple negations', () => {
      expect(parseSearchQuery({ query: '-tag:personal -tag:private -tag:confidential' })).toEqual({
        expression: {
          type: 'and',
          operands: [
            {
              type: 'not',
              operand: { type: 'filter', field: 'tag', operator: '=', value: 'personal' },
            },
            {
              type: 'not',
              operand: { type: 'filter', field: 'tag', operator: '=', value: 'private' },
            },
            {
              type: 'not',
              operand: { type: 'filter', field: 'tag', operator: '=', value: 'confidential' },
            },
          ],
        },
        issues: [],
      });
    });
  });

  describe('when parsing text with boolean operators', () => {
    test('parses text OR text as OR expression', () => {
      expect(parseSearchQuery({ query: 'foo OR bar' })).toEqual({
        expression: {
          type: 'or',
          operands: [
            { type: 'text', value: 'foo' },
            { type: 'text', value: 'bar' },
          ],
        },
        issues: [],
      });
    });

    test('parses text with implicit AND correctly', () => {
      expect(parseSearchQuery({ query: 'foo bar baz' })).toEqual({
        expression: {
          type: 'and',
          operands: [
            { type: 'text', value: 'foo' },
            { type: 'text', value: 'bar' },
            { type: 'text', value: 'baz' },
          ],
        },
        issues: [],
      });
    });

    test('negated text creates NOT expression', () => {
      expect(parseSearchQuery({ query: '-foo' })).toEqual({
        expression: {
          type: 'not',
          operand: { type: 'text', value: 'foo' },
        },
        issues: [],
      });
    });

    test('handles complex text with operators', () => {
      expect(
        parseSearchQuery({
          query: '(tag:invoice foo) OR (tag:receipt bar)',
        }),
      ).toEqual({
        expression: {
          type: 'or',
          operands: [
            {
              type: 'and',
              operands: [
                { type: 'filter', field: 'tag', operator: '=', value: 'invoice' },
                { type: 'text', value: 'foo' },
              ],
            },
            {
              type: 'and',
              operands: [
                { type: 'filter', field: 'tag', operator: '=', value: 'receipt' },
                { type: 'text', value: 'bar' },
              ],
            },
          ],
        },
        issues: [],
      });
    });

    test('parses multiple ORs with text and filters', () => {
      expect(parseSearchQuery({ query: 'foo OR bar OR baz' })).toEqual({
        expression: {
          type: 'or',
          operands: [
            { type: 'text', value: 'foo' },
            { type: 'text', value: 'bar' },
            { type: 'text', value: 'baz' },
          ],
        },
        issues: [],
      });
    });

    test('parses quoted text with spaces', () => {
      expect(parseSearchQuery({ query: '"hello world"' })).toEqual({
        expression: { type: 'text', value: 'hello world' },
        issues: [],
      });
    });

    test('parses negated quoted text', () => {
      expect(parseSearchQuery({ query: '-"hello world"' })).toEqual({
        expression: {
          type: 'not',
          operand: { type: 'text', value: 'hello world' },
        },
        issues: [],
      });
    });

    test('parses text mixed with explicit NOT operator', () => {
      expect(parseSearchQuery({ query: 'NOT foo' })).toEqual({
        expression: {
          type: 'not',
          operand: { type: 'text', value: 'foo' },
        },
        issues: [],
      });
    });

    test('respects AND precedence over OR in text expressions', () => {
      expect(parseSearchQuery({ query: 'foo OR bar AND baz' })).toEqual({
        expression: {
          type: 'or',
          operands: [
            { type: 'text', value: 'foo' },
            {
              type: 'and',
              operands: [
                { type: 'text', value: 'bar' },
                { type: 'text', value: 'baz' },
              ],
            },
          ],
        },
        issues: [],
      });
    });
  });

  describe('when using optimization', () => {
    test('applies optimization when optimize flag is true', () => {
      // Query that creates nested AND that can be flattened
      const result = parseSearchQuery({
        query: 'foo foo bar',
        optimize: true,
      });

      // Should remove duplicate 'foo' through optimization
      expect(result.expression).toEqual({
        type: 'and',
        operands: [
          { type: 'text', value: 'foo' },
          { type: 'text', value: 'bar' },
        ],
      });
      expect(result.issues).toEqual([]);
    });

    test('does not apply optimization when optimize flag is false', () => {
      const result = parseSearchQuery({
        query: 'foo foo bar',
        optimize: false,
      });

      // Should keep duplicates without optimization
      expect(result.expression).toEqual({
        type: 'and',
        operands: [
          { type: 'text', value: 'foo' },
          { type: 'text', value: 'foo' },
          { type: 'text', value: 'bar' },
        ],
      });
      expect(result.issues).toEqual([]);
    });

    test('does apply optimization by default', () => {
      const result = parseSearchQuery({ query: 'foo foo bar' });

      expect(result.expression).toEqual({
        type: 'and',
        operands: [
          { type: 'text', value: 'foo' },
          { type: 'text', value: 'bar' },
        ],
      });
      expect(result.issues).toEqual([]);
    });

    test('applies optimization to complex queries', () => {
      // Query with double negation and duplicates
      const result = parseSearchQuery({
        query: '(tag:invoice OR tag:invoice) AND NOT NOT tag:receipt',
        optimize: true,
      });

      expect(result.expression).toEqual({
        type: 'and',
        operands: [
          { type: 'filter', field: 'tag', operator: '=', value: 'invoice' },
          { type: 'filter', field: 'tag', operator: '=', value: 'receipt' },
        ],
      });
      expect(result.issues).toEqual([]);
    });
  });
});