reqon-dsl 0.2.0 → 0.4.0

package/src/parser/base.ts

@@ -1,124 +0,0 @@
-import { TokenType, type Token } from 'vague-lang';
-import { ReqonTokenType } from '../lexer/tokens.js';
-import { ParseError, type ErrorContext } from '../errors/index.js';
-
-// Token type can be Vague's TokenType, Reqon's ReqonTokenType, or a plugin string
-type AnyTokenType = TokenType | ReqonTokenType | string;
-
-export class ReqonParserBase {
-  protected tokens: Token[];
-  protected pos = 0;
-  protected source?: string;
-  protected filePath?: string;
-
-  constructor(tokens: Token[], source?: string, filePath?: string) {
-    this.tokens = tokens.filter((t) => t.type !== TokenType.NEWLINE);
-    this.source = source;
-    this.filePath = filePath;
-  }
-
-  protected peek(): Token {
-    return this.tokens[this.pos];
-  }
-
-  protected peekNext(): Token | undefined {
-    return this.tokens[this.pos + 1];
-  }
-
-  protected check(type: AnyTokenType): boolean {
-    return !this.isAtEnd() && this.peek().type === type;
-  }
-
-  protected checkAny(...types: AnyTokenType[]): boolean {
-    return types.some((t) => this.check(t));
-  }
-
-  protected match(type: AnyTokenType): boolean {
-    if (this.check(type)) {
-      this.advance();
-      return true;
-    }
-    return false;
-  }
-
-  protected matchAny(...types: AnyTokenType[]): AnyTokenType | null {
-    for (const type of types) {
-      if (this.check(type)) {
-        this.advance();
-        return type;
-      }
-    }
-    return null;
-  }
-
-  protected advance(): Token {
-    if (!this.isAtEnd()) this.pos++;
-    return this.tokens[this.pos - 1];
-  }
-
-  protected consume(type: AnyTokenType, message: string): Token {
-    if (this.check(type)) return this.advance();
-    throw this.error(message);
-  }
-
-  /**
-   * Consume an identifier, allowing HTTP method tokens to be used as identifiers.
-   * This is needed because 'get', 'post', etc. are valid variable/store names.
-   */
-  protected consumeIdentifier(message: string): Token {
-    const token = this.peek();
-    // Accept both regular identifiers and HTTP method tokens as identifiers
-    if (
-      token.type === TokenType.IDENTIFIER ||
-      token.type === ReqonTokenType.GET ||
-      token.type === ReqonTokenType.POST ||
-      token.type === ReqonTokenType.PUT ||
-      token.type === ReqonTokenType.PATCH ||
-      token.type === ReqonTokenType.DELETE
-    ) {
-      return this.advance();
-    }
-    throw this.error(message);
-  }
-
-  /**
-   * Check if current token is an identifier (including HTTP methods as identifiers)
-   */
-  protected checkIdentifier(): boolean {
-    const type = this.peek().type;
-    return (
-      type === TokenType.IDENTIFIER ||
-      type === ReqonTokenType.GET ||
-      type === ReqonTokenType.POST ||
-      type === ReqonTokenType.PUT ||
-      type === ReqonTokenType.PATCH ||
-      type === ReqonTokenType.DELETE
-    );
-  }
-
-  protected isAtEnd(): boolean {
-    return this.peek().type === TokenType.EOF;
-  }
-
-  protected error(message: string): ParseError {
-    const token = this.peek();
-    const context: ErrorContext | undefined = this.source
-      ? { source: this.source, filePath: this.filePath }
-      : undefined;
-
-    return new ParseError(
-      message,
-      { line: token.line, column: token.column },
-      context,
-      token.value
-    );
-  }
-
-  protected savePosition(): number {
-    return this.pos;
-  }
-
-  protected restorePosition(saved: number): void {
-    this.pos = saved;
-  }
-}

package/src/parser/expressions.test.ts

@@ -1,525 +0,0 @@
-import { describe, it, expect } from 'vitest';
-import { ReqonLexer } from '../lexer/index.js';
-import { ReqonExpressionParser } from './expressions.js';
-import type { ReqonToken } from '../lexer/tokens.js';
-
-describe('ReqonExpressionParser', () => {
-  function parseExpr(source: string) {
-    const lexer = new ReqonLexer(source);
-    const tokens = lexer.tokenize();
-    const parser = new TestableExpressionParser(tokens);
-    return parser.parseExpression();
-  }
-
-  // Create a testable subclass that exposes parseExpression
-  class TestableExpressionParser extends ReqonExpressionParser {
-    constructor(tokens: ReqonToken[]) {
-      super(tokens);
-    }
-  }
-
-  describe('literals', () => {
-    it('parses number literals', () => {
-      const expr = parseExpr('42');
-
-      expect(expr.type).toBe('Literal');
-      if (expr.type === 'Literal') {
-        expect(expr.value).toBe(42);
-        expect(expr.dataType).toBe('number');
-      }
-    });
-
-    it('parses decimal number literals', () => {
-      const expr = parseExpr('3.14');
-
-      expect(expr.type).toBe('Literal');
-      if (expr.type === 'Literal') {
-        expect(expr.value).toBe(3.14);
-      }
-    });
-
-    it('parses string literals', () => {
-      const expr = parseExpr('"hello world"');
-
-      expect(expr.type).toBe('Literal');
-      if (expr.type === 'Literal') {
-        expect(expr.value).toBe('hello world');
-        expect(expr.dataType).toBe('string');
-      }
-    });
-
-    it('parses true literal', () => {
-      const expr = parseExpr('true');
-
-      expect(expr.type).toBe('Literal');
-      if (expr.type === 'Literal') {
-        expect(expr.value).toBe(true);
-        expect(expr.dataType).toBe('boolean');
-      }
-    });
-
-    it('parses false literal', () => {
-      const expr = parseExpr('false');
-
-      expect(expr.type).toBe('Literal');
-      if (expr.type === 'Literal') {
-        expect(expr.value).toBe(false);
-        expect(expr.dataType).toBe('boolean');
-      }
-    });
-
-    it('parses null literal', () => {
-      const expr = parseExpr('null');
-
-      expect(expr.type).toBe('Literal');
-      if (expr.type === 'Literal') {
-        expect(expr.value).toBe(null);
-        expect(expr.dataType).toBe('null');
-      }
-    });
-  });
-
-  describe('identifiers', () => {
-    it('parses simple identifiers', () => {
-      const expr = parseExpr('myVariable');
-
-      expect(expr.type).toBe('Identifier');
-      if (expr.type === 'Identifier') {
-        expect(expr.name).toBe('myVariable');
-      }
-    });
-
-    it('parses dot-prefixed field shorthand', () => {
-      const expr = parseExpr('.fieldName');
-
-      expect(expr.type).toBe('Identifier');
-      if (expr.type === 'Identifier') {
-        expect(expr.name).toBe('fieldName');
-      }
-    });
-  });
-
-  describe('binary arithmetic expressions', () => {
-    it('parses addition', () => {
-      const expr = parseExpr('1 + 2');
-
-      expect(expr.type).toBe('BinaryExpression');
-      if (expr.type === 'BinaryExpression') {
-        expect(expr.operator).toBe('+');
-        expect(expr.left).toMatchObject({ type: 'Literal', value: 1 });
-        expect(expr.right).toMatchObject({ type: 'Literal', value: 2 });
-      }
-    });
-
-    it('parses subtraction', () => {
-      const expr = parseExpr('10 - 5');
-
-      expect(expr.type).toBe('BinaryExpression');
-      if (expr.type === 'BinaryExpression') {
-        expect(expr.operator).toBe('-');
-      }
-    });
-
-    it('parses multiplication', () => {
-      const expr = parseExpr('3 * 4');
-
-      expect(expr.type).toBe('BinaryExpression');
-      if (expr.type === 'BinaryExpression') {
-        expect(expr.operator).toBe('*');
-      }
-    });
-
-    it('parses division', () => {
-      const expr = parseExpr('20 / 4');
-
-      expect(expr.type).toBe('BinaryExpression');
-      if (expr.type === 'BinaryExpression') {
-        expect(expr.operator).toBe('/');
-      }
-    });
-
-    it('respects operator precedence (multiplication before addition)', () => {
-      const expr = parseExpr('1 + 2 * 3');
-
-      expect(expr.type).toBe('BinaryExpression');
-      if (expr.type === 'BinaryExpression') {
-        expect(expr.operator).toBe('+');
-        expect(expr.left).toMatchObject({ type: 'Literal', value: 1 });
-        expect(expr.right.type).toBe('BinaryExpression');
-        if (expr.right.type === 'BinaryExpression') {
-          expect(expr.right.operator).toBe('*');
-        }
-      }
-    });
-
-    it('respects parentheses', () => {
-      const expr = parseExpr('(1 + 2) * 3');
-
-      expect(expr.type).toBe('BinaryExpression');
-      if (expr.type === 'BinaryExpression') {
-        expect(expr.operator).toBe('*');
-        expect(expr.left.type).toBe('BinaryExpression');
-        expect(expr.right).toMatchObject({ type: 'Literal', value: 3 });
-      }
-    });
-  });
-
-  describe('comparison expressions', () => {
-    it('parses equality', () => {
-      const expr = parseExpr('x == 5');
-
-      expect(expr.type).toBe('BinaryExpression');
-      if (expr.type === 'BinaryExpression') {
-        expect(expr.operator).toBe('==');
-      }
-    });
-
-    it('parses less than', () => {
-      const expr = parseExpr('x < 10');
-
-      expect(expr.type).toBe('BinaryExpression');
-      if (expr.type === 'BinaryExpression') {
-        expect(expr.operator).toBe('<');
-      }
-    });
-
-    it('parses greater than', () => {
-      const expr = parseExpr('x > 0');
-
-      expect(expr.type).toBe('BinaryExpression');
-      if (expr.type === 'BinaryExpression') {
-        expect(expr.operator).toBe('>');
-      }
-    });
-
-    it('parses less than or equal', () => {
-      const expr = parseExpr('x <= 100');
-
-      expect(expr.type).toBe('BinaryExpression');
-      if (expr.type === 'BinaryExpression') {
-        expect(expr.operator).toBe('<=');
-      }
-    });
-
-    it('parses greater than or equal', () => {
-      const expr = parseExpr('x >= 0');
-
-      expect(expr.type).toBe('BinaryExpression');
-      if (expr.type === 'BinaryExpression') {
-        expect(expr.operator).toBe('>=');
-      }
-    });
-  });
-
-  describe('logical expressions', () => {
-    it('parses and expression', () => {
-      const expr = parseExpr('a and b');
-
-      expect(expr.type).toBe('LogicalExpression');
-      if (expr.type === 'LogicalExpression') {
-        expect(expr.operator).toBe('and');
-      }
-    });
-
-    it('parses or expression', () => {
-      const expr = parseExpr('a or b');
-
-      expect(expr.type).toBe('LogicalExpression');
-      if (expr.type === 'LogicalExpression') {
-        expect(expr.operator).toBe('or');
-      }
-    });
-
-    it('parses not expression', () => {
-      const expr = parseExpr('not a');
-
-      expect(expr.type).toBe('NotExpression');
-      if (expr.type === 'NotExpression') {
-        expect(expr.operand).toMatchObject({ type: 'Identifier', name: 'a' });
-      }
-    });
-
-    it('parses combined logical expressions', () => {
-      const expr = parseExpr('a and b or c');
-
-      // 'or' has lower precedence, so it's the root
-      expect(expr.type).toBe('LogicalExpression');
-      if (expr.type === 'LogicalExpression') {
-        expect(expr.operator).toBe('or');
-        expect(expr.left.type).toBe('LogicalExpression');
-        if (expr.left.type === 'LogicalExpression') {
-          expect(expr.left.operator).toBe('and');
-        }
-      }
-    });
-
-    it('parses double negation', () => {
-      const expr = parseExpr('not not a');
-
-      expect(expr.type).toBe('NotExpression');
-      if (expr.type === 'NotExpression') {
-        expect(expr.operand.type).toBe('NotExpression');
-      }
-    });
-  });
-
-  describe('ternary expressions', () => {
-    it('parses simple ternary', () => {
-      const expr = parseExpr('true ? 1 : 0');
-
-      expect(expr.type).toBe('TernaryExpression');
-      if (expr.type === 'TernaryExpression') {
-        expect(expr.condition).toMatchObject({ type: 'Literal', value: true });
-        expect(expr.consequent).toMatchObject({ type: 'Literal', value: 1 });
-        expect(expr.alternate).toMatchObject({ type: 'Literal', value: 0 });
-      }
-    });
-
-    it('parses nested ternary', () => {
-      const expr = parseExpr('a ? b ? 1 : 2 : 3');
-
-      expect(expr.type).toBe('TernaryExpression');
-      if (expr.type === 'TernaryExpression') {
-        expect(expr.consequent.type).toBe('TernaryExpression');
-      }
-    });
-  });
-
-  describe('unary expressions', () => {
-    it('parses negative number', () => {
-      const expr = parseExpr('-5');
-
-      expect(expr.type).toBe('UnaryExpression');
-      if (expr.type === 'UnaryExpression') {
-        expect(expr.operator).toBe('-');
-        expect(expr.operand).toMatchObject({ type: 'Literal', value: 5 });
-      }
-    });
-
-    it('parses positive number', () => {
-      const expr = parseExpr('+5');
-
-      expect(expr.type).toBe('UnaryExpression');
-      if (expr.type === 'UnaryExpression') {
-        expect(expr.operator).toBe('+');
-      }
-    });
-
-    it('parses double negative', () => {
-      const expr = parseExpr('--x');
-
-      expect(expr.type).toBe('UnaryExpression');
-      if (expr.type === 'UnaryExpression') {
-        expect(expr.operand.type).toBe('UnaryExpression');
-      }
-    });
-  });
-
-  describe('member access (qualified names)', () => {
-    it('parses single property access', () => {
-      const expr = parseExpr('obj.prop');
-
-      expect(expr.type).toBe('QualifiedName');
-      if (expr.type === 'QualifiedName') {
-        expect(expr.parts).toEqual(['obj', 'prop']);
-      }
-    });
-
-    it('parses chained property access', () => {
-      const expr = parseExpr('a.b.c.d');
-
-      expect(expr.type).toBe('QualifiedName');
-      if (expr.type === 'QualifiedName') {
-        expect(expr.parts).toEqual(['a', 'b', 'c', 'd']);
-      }
-    });
-  });
-
-  describe('function calls', () => {
-    it('parses function call without arguments', () => {
-      const expr = parseExpr('fn()');
-
-      expect(expr.type).toBe('CallExpression');
-      if (expr.type === 'CallExpression') {
-        expect(expr.callee).toBe('fn');
-        expect(expr.arguments).toEqual([]);
-      }
-    });
-
-    it('parses function call with single argument', () => {
-      const expr = parseExpr('length(items)');
-
-      expect(expr.type).toBe('CallExpression');
-      if (expr.type === 'CallExpression') {
-        expect(expr.callee).toBe('length');
-        expect(expr.arguments).toHaveLength(1);
-      }
-    });
-
-    it('parses function call with multiple arguments', () => {
-      const expr = parseExpr('func(1, 2, 3)');
-
-      expect(expr.type).toBe('CallExpression');
-      if (expr.type === 'CallExpression') {
-        expect(expr.arguments).toHaveLength(3);
-      }
-    });
-  });
-
-  describe('match expressions', () => {
-    it('parses simple match expression', () => {
-      const expr = parseExpr('match x { 1 => "one", 2 => "two" }');
-
-      expect(expr.type).toBe('MatchExpression');
-      if (expr.type === 'MatchExpression') {
-        expect(expr.arms).toHaveLength(2);
-        expect(expr.arms[0].pattern).toMatchObject({ type: 'Literal', value: 1 });
-        expect(expr.arms[0].result).toMatchObject({ type: 'Literal', value: 'one' });
-      }
-    });
-
-    it('parses match with wildcard', () => {
-      const expr = parseExpr('match status { "A" => "active", _ => "other" }');
-
-      expect(expr.type).toBe('MatchExpression');
-      if (expr.type === 'MatchExpression') {
-        expect(expr.arms).toHaveLength(2);
-        expect(expr.arms[1].pattern).toMatchObject({ type: 'Identifier', name: '_' });
-      }
-    });
-  });
-
-  describe('any of expressions', () => {
-    it('parses any of expression', () => {
-      const expr = parseExpr('any of items');
-
-      expect(expr.type).toBe('AnyOfExpression');
-      if (expr.type === 'AnyOfExpression') {
-        expect(expr.collection).toMatchObject({ type: 'Identifier', name: 'items' });
-        expect(expr.condition).toBeUndefined();
-      }
-    });
-
-    it('parses any of with where condition', () => {
-      const expr = parseExpr('any of items where active');
-
-      expect(expr.type).toBe('AnyOfExpression');
-      if (expr.type === 'AnyOfExpression') {
-        expect(expr.condition).toBeDefined();
-      }
-    });
-  });
-
-  describe('range expressions', () => {
-    it('parses range expression', () => {
-      const expr = parseExpr('1..10');
-
-      expect(expr.type).toBe('RangeExpression');
-      if (expr.type === 'RangeExpression') {
-        expect(expr.min).toMatchObject({ type: 'Literal', value: 1 });
-        expect(expr.max).toMatchObject({ type: 'Literal', value: 10 });
-      }
-    });
-
-    it('parses open-ended range', () => {
-      const expr = parseExpr('5..');
-
-      expect(expr.type).toBe('RangeExpression');
-      if (expr.type === 'RangeExpression') {
-        expect(expr.min).toMatchObject({ type: 'Literal', value: 5 });
-        expect(expr.max).toBeUndefined();
-      }
-    });
-  });
-
-  describe('is type checking expressions', () => {
-    it('parses is array', () => {
-      const expr = parseExpr('items is array');
-
-      expect(expr.type).toBe('IsExpression');
-      if (expr.type === 'IsExpression') {
-        expect((expr as any).operand).toMatchObject({ type: 'Identifier', name: 'items' });
-        expect((expr as any).typeCheck).toBe('array');
-      }
-    });
-
-    it('parses is string', () => {
-      const expr = parseExpr('.name is string');
-
-      expect(expr.type).toBe('IsExpression');
-      if (expr.type === 'IsExpression') {
-        expect((expr as any).typeCheck).toBe('string');
-      }
-    });
-
-    it('parses is number', () => {
-      const expr = parseExpr('value is number');
-
-      expect(expr.type).toBe('IsExpression');
-      if (expr.type === 'IsExpression') {
-        expect((expr as any).typeCheck).toBe('number');
-      }
-    });
-
-    it('parses is object', () => {
-      const expr = parseExpr('data is object');
-
-      expect(expr.type).toBe('IsExpression');
-      if (expr.type === 'IsExpression') {
-        expect((expr as any).typeCheck).toBe('object');
-      }
-    });
-
-    it('parses is boolean', () => {
-      const expr = parseExpr('flag is boolean');
-
-      expect(expr.type).toBe('IsExpression');
-      if (expr.type === 'IsExpression') {
-        expect((expr as any).typeCheck).toBe('boolean');
-      }
-    });
-
-    it('parses is with property access', () => {
-      const expr = parseExpr('response.items is array');
-
-      expect(expr.type).toBe('IsExpression');
-      if (expr.type === 'IsExpression') {
-        expect((expr as any).operand.type).toBe('QualifiedName');
-        expect((expr as any).typeCheck).toBe('array');
-      }
-    });
-  });
-
-  describe('complex expressions', () => {
-    it('parses complex arithmetic with comparisons', () => {
-      const expr = parseExpr('(a + b) * 2 > 100');
-
-      expect(expr.type).toBe('BinaryExpression');
-      if (expr.type === 'BinaryExpression') {
-        expect(expr.operator).toBe('>');
-      }
-    });
-
-    it('parses logical expression with comparisons', () => {
-      const expr = parseExpr('x > 0 and x < 100');
-
-      expect(expr.type).toBe('LogicalExpression');
-      if (expr.type === 'LogicalExpression') {
-        expect(expr.operator).toBe('and');
-        expect(expr.left.type).toBe('BinaryExpression');
-        expect(expr.right.type).toBe('BinaryExpression');
-      }
-    });
-
-    it('parses ternary with function call', () => {
-      const expr = parseExpr('length(items) > 0 ? first(items) : null');
-
-      expect(expr.type).toBe('TernaryExpression');
-      if (expr.type === 'TernaryExpression') {
-        expect(expr.condition.type).toBe('BinaryExpression');
-        expect(expr.consequent.type).toBe('CallExpression');
-        expect(expr.alternate).toMatchObject({ type: 'Literal', value: null });
-      }
-    });
-  });
-});