reqon-dsl 0.2.0

package/dist/parser/expressions.test.js

@@ -0,0 +1,378 @@
+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/index.d.ts

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

package/dist/parser/index.js

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

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

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

package/dist/parser/match.test.js

@@ -0,0 +1,254 @@
+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',
+            });
+        });
+    });
+});