reqon-dsl 0.2.0 → 0.3.0

package/dist/parser/expressions.test.js

@@ -1,378 +0,0 @@
-import { describe, it, expect } from 'vitest';
-import { ReqonLexer } from '../lexer/index.js';
-import { ReqonExpressionParser } from './expressions.js';
-describe('ReqonExpressionParser', () => {
-    function parseExpr(source) {
-        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) {
-            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('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 });
-            }
-        });
-    });
-});

package/dist/parser/match.test.d.ts

@@ -1 +0,0 @@
-export {};

package/dist/parser/match.test.js

@@ -1,254 +0,0 @@
-import { describe, it, expect } from 'vitest';
-import { ReqonLexer } from '../lexer/index.js';
-import { ReqonParser } from './parser.js';
-describe('Match Step Parsing', () => {
-    function parseAction(source) {
-        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');
-        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];
-            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];
-            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];
-            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];
-            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];
-            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];
-            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];
-            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];
-            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];
-            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];
-            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];
-            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];
-            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];
-            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];
-            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];
-            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];
-            expect(matchStep.arms).toHaveLength(2);
-            expect(matchStep.arms[1].schema).toBe('_');
-            expect(matchStep.arms[1].flow).toEqual({
-                type: 'abort',
-                message: 'Unexpected response',
-            });
-        });
-    });
-});

package/dist/parser/parser.test.d.ts

@@ -1 +0,0 @@
-export {};