reqon-dsl 0.2.0 → 0.4.0

package/src/parser/expressions.ts

@@ -1,314 +0,0 @@
-import { TokenType, type Expression, type QualifiedName, type MatchArm, type Token } from 'vague-lang';
-import { ReqonTokenType } from '../lexer/tokens.js';
-import { ReqonParserBase } from './base.js';
-
-// Extended expression type for Reqon's 'is' type checking
-export interface IsExpression {
-  type: 'IsExpression';
-  operand: Expression;
-  typeCheck: string; // 'array', 'object', 'string', 'number', 'boolean', 'null', 'undefined'
-}
-
-export class ReqonExpressionParser extends ReqonParserBase {
-  parseExpression(): Expression {
-    return this.parseTernary();
-  }
-
-  parseLogicalExpression(): Expression {
-    return this.parseOr();
-  }
-
-  private parseTernary(): Expression {
-    const condition = this.parseOr();
-
-    if (this.match(TokenType.QUESTION)) {
-      const consequent = this.parseTernary();
-      this.consume(TokenType.COLON, "Expected ':' in ternary expression");
-      const alternate = this.parseTernary();
-      return {
-        type: 'TernaryExpression',
-        condition,
-        consequent,
-        alternate,
-      };
-    }
-
-    return condition;
-  }
-
-  private parseOr(): Expression {
-    let left = this.parseAnd();
-
-    while (this.match(TokenType.OR)) {
-      const right = this.parseAnd();
-      left = { type: 'LogicalExpression', operator: 'or', left, right };
-    }
-
-    return left;
-  }
-
-  private parseAnd(): Expression {
-    let left = this.parseNot();
-
-    while (this.match(TokenType.AND)) {
-      const right = this.parseNot();
-      left = { type: 'LogicalExpression', operator: 'and', left, right };
-    }
-
-    return left;
-  }
-
-  private parseNot(): Expression {
-    if (this.match(TokenType.NOT)) {
-      const operand = this.parseNot();
-      return { type: 'NotExpression', operand };
-    }
-
-    return this.parseSuperposition();
-  }
-
-  private parseSuperposition(): Expression {
-    const first = this.parseSuperpositionOption();
-
-    if (this.check(TokenType.PIPE)) {
-      const options = [first];
-
-      while (this.match(TokenType.PIPE)) {
-        options.push(this.parseSuperpositionOption());
-      }
-
-      return { type: 'SuperpositionExpression', options };
-    }
-
-    return first.value;
-  }
-
-  private parseSuperpositionOption(): { weight?: number; value: Expression } {
-    const expr = this.parseComparison();
-
-    if (expr.type === 'Literal' && expr.dataType === 'number' && this.check(TokenType.COLON)) {
-      this.advance();
-      const value = this.parseComparison();
-      return { weight: expr.value as number, value };
-    }
-
-    return { value: expr };
-  }
-
-  parseComparison(): Expression {
-    let left = this.parseRange();
-
-    while (this.checkAny(TokenType.LT, TokenType.GT, TokenType.LTE, TokenType.GTE, TokenType.DOUBLE_EQUALS, ReqonTokenType.NOT_EQUALS)) {
-      const token = this.advance();
-      // Normalize the operator value for NOT_EQUALS
-      const operator = token.type === ReqonTokenType.NOT_EQUALS ? '!=' : token.value;
-      const right = this.parseRange();
-      left = { type: 'BinaryExpression', operator, left, right };
-    }
-
-    // Check for 'is' type checking: expr is array, expr is string, etc.
-    if (this.check(ReqonTokenType.IS)) {
-      this.advance(); // consume 'is'
-      const typeCheck = this.consume(TokenType.IDENTIFIER, "Expected type name after 'is'").value;
-      return { type: 'IsExpression', operand: left, typeCheck } as unknown as Expression;
-    }
-
-    return left;
-  }
-
-  parseRange(): Expression {
-    const left = this.parseAdditive();
-
-    if (this.match(TokenType.DOTDOT)) {
-      const right = this.check(TokenType.NUMBER) ? this.parseAdditive() : undefined;
-      return { type: 'RangeExpression', min: left, max: right };
-    }
-
-    return left;
-  }
-
-  parseAdditive(): Expression {
-    let left = this.parseMultiplicative();
-
-    while (this.checkAny(TokenType.PLUS, TokenType.MINUS)) {
-      const operator = this.advance().value;
-      const right = this.parseMultiplicative();
-      left = { type: 'BinaryExpression', operator, left, right };
-    }
-
-    return left;
-  }
-
-  private parseMultiplicative(): Expression {
-    let left = this.parseUnary();
-
-    while (this.checkAny(TokenType.STAR, TokenType.SLASH)) {
-      const operator = this.advance().value;
-      const right = this.parseUnary();
-      left = { type: 'BinaryExpression', operator, left, right };
-    }
-
-    return left;
-  }
-
-  private parseUnary(): Expression {
-    if (this.match(TokenType.CARET)) {
-      const path = this.parseQualifiedName();
-      return { type: 'ParentReference', path };
-    }
-
-    if (this.checkAny(TokenType.MINUS, TokenType.PLUS)) {
-      const operator = this.advance().value;
-      const operand = this.parseUnary();
-      return { type: 'UnaryExpression', operator, operand };
-    }
-
-    return this.parseCall();
-  }
-
-  private parseCall(): Expression {
-    let expr = this.parsePrimary();
-
-    while (true) {
-      if (this.match(TokenType.LPAREN)) {
-        const args: Expression[] = [];
-        if (!this.check(TokenType.RPAREN)) {
-          do {
-            args.push(this.parseExpression());
-          } while (this.match(TokenType.COMMA));
-        }
-        this.consume(TokenType.RPAREN, "Expected ')'");
-
-        if (expr.type === 'Identifier') {
-          expr = { type: 'CallExpression', callee: expr.name, arguments: args };
-        } else if (expr.type === 'QualifiedName') {
-          expr = { type: 'CallExpression', callee: expr.parts.join('.'), arguments: args };
-        }
-      } else if (this.match(TokenType.DOT)) {
-        const name = this.consume(TokenType.IDENTIFIER, 'Expected property name').value;
-        if (expr.type === 'Identifier') {
-          expr = { type: 'QualifiedName', parts: [expr.name, name] };
-        } else if (expr.type === 'QualifiedName') {
-          expr.parts.push(name);
-        }
-      } else {
-        break;
-      }
-    }
-
-    return expr;
-  }
-
-  parsePrimary(): Expression {
-    // Match expression
-    if (this.match(TokenType.MATCH)) {
-      return this.parseMatchExpression();
-    }
-
-    // Ordered sequence
-    if (this.match(TokenType.LBRACKET)) {
-      return this.parseOrderedSequence();
-    }
-
-    // Any of expression
-    if (this.match(TokenType.ANY)) {
-      this.consume(TokenType.OF, "Expected 'of'");
-      const collection = this.parseExpression();
-      let condition: Expression | undefined;
-      if (this.match(TokenType.WHERE)) {
-        condition = this.parseExpression();
-      }
-      return { type: 'AnyOfExpression', collection, condition };
-    }
-
-    // Parenthesized expression
-    if (this.match(TokenType.LPAREN)) {
-      const expr = this.parseExpression();
-      this.consume(TokenType.RPAREN, "Expected ')'");
-      return expr;
-    }
-
-    // Number literal
-    if (this.check(TokenType.NUMBER)) {
-      const value = parseFloat(this.advance().value);
-      return { type: 'Literal', value, dataType: 'number' };
-    }
-
-    // String literal
-    if (this.check(TokenType.STRING)) {
-      const value = this.advance().value;
-      return { type: 'Literal', value, dataType: 'string' };
-    }
-
-    // Null literal
-    if (this.match(TokenType.NULL)) {
-      return { type: 'Literal', value: null, dataType: 'null' };
-    }
-
-    // Boolean literals
-    if (this.match(TokenType.TRUE)) {
-      return { type: 'Literal', value: true, dataType: 'boolean' };
-    }
-    if (this.match(TokenType.FALSE)) {
-      return { type: 'Literal', value: false, dataType: 'boolean' };
-    }
-
-    // Identifier (including HTTP method tokens that can be used as identifiers)
-    if (this.checkIdentifier()) {
-      const name = this.advance().value;
-      return { type: 'Identifier', name };
-    }
-
-    // .field shorthand
-    if (this.match(TokenType.DOT)) {
-      const name = this.consumeIdentifier("Expected field name after '.'").value;
-      return { type: 'Identifier', name };
-    }
-
-    throw this.error(`Unexpected token: ${this.peek().value}`);
-  }
-
-  private parseMatchExpression(): Expression {
-    const value = this.parsePrimary();
-    this.consume(TokenType.LBRACE, "Expected '{'");
-
-    const arms: MatchArm[] = [];
-    while (!this.check(TokenType.RBRACE) && !this.isAtEnd()) {
-      const pattern = this.parseExpression();
-      this.consume(TokenType.ARROW, "Expected '=>'");
-      const result = this.parseExpression();
-      arms.push({ pattern, result });
-      this.match(TokenType.COMMA);
-    }
-
-    this.consume(TokenType.RBRACE, "Expected '}'");
-    return { type: 'MatchExpression', value, arms };
-  }
-
-  private parseOrderedSequence(): Expression {
-    const elements: Expression[] = [];
-
-    if (this.check(TokenType.RBRACKET)) {
-      throw this.error('Ordered sequence cannot be empty');
-    }
-
-    do {
-      elements.push(this.parseExpression());
-    } while (this.match(TokenType.COMMA));
-
-    this.consume(TokenType.RBRACKET, "Expected ']'");
-
-    return { type: 'OrderedSequenceType', elements };
-  }
-
-  parseQualifiedName(): QualifiedName {
-    const parts: string[] = [];
-    parts.push(this.consume(TokenType.IDENTIFIER, 'Expected identifier').value);
-
-    while (this.match(TokenType.DOT)) {
-      parts.push(this.consume(TokenType.IDENTIFIER, 'Expected identifier').value);
-    }
-
-    return { type: 'QualifiedName', parts };
-  }
-}

package/src/parser/index.ts

@@ -1,3 +0,0 @@
-export { ReqonParser } from './parser.js';
-export { ReqonExpressionParser } from './expressions.js';
-export { ReqonParserBase } from './base.js';

package/src/parser/match.test.ts

@@ -1,296 +0,0 @@
-import { describe, it, expect } from 'vitest';
-import { ReqonLexer } from '../lexer/index.js';
-import { ReqonParser } from './parser.js';
-import type { ActionDefinition, MatchStep } from '../ast/nodes.js';
-
-describe('Match Step Parsing', () => {
-  function parseAction(source: string): ActionDefinition {
-    const lexer = new ReqonLexer(source);
-    const tokens = lexer.tokenize();
-    const parser = new ReqonParser(tokens, source);
-    const program = parser.parse();
-
-    const action = program.statements.find(
-      (s) => s.type === 'ActionDefinition'
-    ) as ActionDefinition;
-
-    if (!action) {
-      throw new Error('No action found in program');
-    }
-
-    return action;
-  }
-
-  describe('basic match step', () => {
-    it('parses match with single schema and flow directive', () => {
-      const action = parseAction(`
-        action HandleResponse {
-          match response {
-            SuccessResponse -> continue
-          }
-        }
-      `);
-
-      expect(action.steps).toHaveLength(1);
-      const matchStep = action.steps[0] as MatchStep;
-      expect(matchStep.type).toBe('MatchStep');
-      expect(matchStep.arms).toHaveLength(1);
-      expect(matchStep.arms[0].schema).toBe('SuccessResponse');
-      expect(matchStep.arms[0].flow).toEqual({ type: 'continue' });
-    });
-
-    it('parses match with multiple schemas', () => {
-      const action = parseAction(`
-        action HandleResponse {
-          match response {
-            SuccessResponse -> continue,
-            NotFoundError -> skip,
-            ServerError -> abort "Something went wrong"
-          }
-        }
-      `);
-
-      expect(action.steps).toHaveLength(1);
-      const matchStep = action.steps[0] as MatchStep;
-      expect(matchStep.arms).toHaveLength(3);
-
-      expect(matchStep.arms[0].schema).toBe('SuccessResponse');
-      expect(matchStep.arms[0].flow).toEqual({ type: 'continue' });
-
-      expect(matchStep.arms[1].schema).toBe('NotFoundError');
-      expect(matchStep.arms[1].flow).toEqual({ type: 'skip' });
-
-      expect(matchStep.arms[2].schema).toBe('ServerError');
-      expect(matchStep.arms[2].flow).toEqual({
-        type: 'abort',
-        message: 'Something went wrong',
-      });
-    });
-  });
-
-  describe('flow directives', () => {
-    it('parses continue directive', () => {
-      const action = parseAction(`
-        action Test {
-          match response {
-            Schema -> continue
-          }
-        }
-      `);
-
-      const matchStep = action.steps[0] as MatchStep;
-      expect(matchStep.arms[0].flow).toEqual({ type: 'continue' });
-    });
-
-    it('parses skip directive', () => {
-      const action = parseAction(`
-        action Test {
-          match response {
-            Schema -> skip
-          }
-        }
-      `);
-
-      const matchStep = action.steps[0] as MatchStep;
-      expect(matchStep.arms[0].flow).toEqual({ type: 'skip' });
-    });
-
-    it('parses abort directive without message', () => {
-      const action = parseAction(`
-        action Test {
-          match response {
-            Schema -> abort
-          }
-        }
-      `);
-
-      const matchStep = action.steps[0] as MatchStep;
-      expect(matchStep.arms[0].flow).toEqual({ type: 'abort' });
-    });
-
-    it('parses abort directive with message', () => {
-      const action = parseAction(`
-        action Test {
-          match response {
-            Schema -> abort "Error occurred"
-          }
-        }
-      `);
-
-      const matchStep = action.steps[0] as MatchStep;
-      expect(matchStep.arms[0].flow).toEqual({
-        type: 'abort',
-        message: 'Error occurred',
-      });
-    });
-
-    it('parses queue directive without target', () => {
-      const action = parseAction(`
-        action Test {
-          match response {
-            Schema -> queue
-          }
-        }
-      `);
-
-      const matchStep = action.steps[0] as MatchStep;
-      expect(matchStep.arms[0].flow).toEqual({ type: 'queue' });
-    });
-
-    it('parses queue directive with target', () => {
-      const action = parseAction(`
-        action Test {
-          match response {
-            Schema -> queue deadLetterQueue
-          }
-        }
-      `);
-
-      const matchStep = action.steps[0] as MatchStep;
-      expect(matchStep.arms[0].flow).toEqual({
-        type: 'queue',
-        target: 'deadLetterQueue',
-      });
-    });
-
-    it('parses jump directive without then', () => {
-      const action = parseAction(`
-        action Test {
-          match response {
-            Schema -> jump RefreshToken
-          }
-        }
-      `);
-
-      const matchStep = action.steps[0] as MatchStep;
-      expect(matchStep.arms[0].flow).toEqual({
-        type: 'jump',
-        action: 'RefreshToken',
-      });
-    });
-
-    it('parses jump directive with then retry', () => {
-      const action = parseAction(`
-        action Test {
-          match response {
-            Schema -> jump RefreshToken then retry
-          }
-        }
-      `);
-
-      const matchStep = action.steps[0] as MatchStep;
-      expect(matchStep.arms[0].flow).toEqual({
-        type: 'jump',
-        action: 'RefreshToken',
-        then: 'retry',
-      });
-    });
-
-    it('parses jump directive with then continue', () => {
-      const action = parseAction(`
-        action Test {
-          match response {
-            Schema -> jump RefreshToken then continue
-          }
-        }
-      `);
-
-      const matchStep = action.steps[0] as MatchStep;
-      expect(matchStep.arms[0].flow).toEqual({
-        type: 'jump',
-        action: 'RefreshToken',
-        then: 'continue',
-      });
-    });
-
-    it('parses retry directive without config', () => {
-      const action = parseAction(`
-        action Test {
-          match response {
-            Schema -> retry
-          }
-        }
-      `);
-
-      const matchStep = action.steps[0] as MatchStep;
-      expect(matchStep.arms[0].flow).toEqual({ type: 'retry' });
-    });
-
-    it('parses retry directive with config', () => {
-      const action = parseAction(`
-        action Test {
-          match response {
-            Schema -> retry { maxAttempts: 5, backoff: exponential, initialDelay: 1000 }
-          }
-        }
-      `);
-
-      const matchStep = action.steps[0] as MatchStep;
-      expect(matchStep.arms[0].flow?.type).toBe('retry');
-      if (matchStep.arms[0].flow?.type === 'retry') {
-        expect(matchStep.arms[0].flow.backoff).toEqual({
-          maxAttempts: 5,
-          backoff: 'exponential',
-          initialDelay: 1000,
-        });
-      }
-    });
-  });
-
-  describe('match with steps', () => {
-    it('parses match with single inline step', () => {
-      const action = parseAction(`
-        action Test {
-          match response {
-            SuccessResponse -> store response -> cache
-          }
-        }
-      `);
-
-      const matchStep = action.steps[0] as MatchStep;
-      expect(matchStep.arms[0].schema).toBe('SuccessResponse');
-      expect(matchStep.arms[0].steps).toHaveLength(1);
-      expect(matchStep.arms[0].steps![0].type).toBe('StoreStep');
-    });
-
-    it('parses match with step block', () => {
-      const action = parseAction(`
-        action Test {
-          match response {
-            SuccessResponse -> {
-              store response -> cache,
-              store response -> backup
-            }
-          }
-        }
-      `);
-
-      const matchStep = action.steps[0] as MatchStep;
-      expect(matchStep.arms[0].schema).toBe('SuccessResponse');
-      expect(matchStep.arms[0].steps).toHaveLength(2);
-      expect(matchStep.arms[0].steps![0].type).toBe('StoreStep');
-      expect(matchStep.arms[0].steps![1].type).toBe('StoreStep');
-    });
-  });
-
-  describe('wildcard pattern', () => {
-    it('parses wildcard pattern at end', () => {
-      const action = parseAction(`
-        action Test {
-          match response {
-            SuccessResponse -> continue,
-            _ -> abort "Unexpected response"
-          }
-        }
-      `);
-
-      const matchStep = action.steps[0] as MatchStep;
-      expect(matchStep.arms).toHaveLength(2);
-      expect(matchStep.arms[1].schema).toBe('_');
-      expect(matchStep.arms[1].flow).toEqual({
-        type: 'abort',
-        message: 'Unexpected response',
-      });
-    });
-  });
-});