reqon-dsl 0.2.0 → 0.4.0

package/dist/integration.test.js

@@ -1,168 +0,0 @@
-import { describe, it, expect } from 'vitest';
-import { parse, execute } from './index.js';
-import { MemoryStore } from './stores/index.js';
-describe('Reqon Integration', () => {
-    it('parses and executes a simple mission with dry run', async () => {
-        const source = `
-      mission TestMission {
-        source API {
-          auth: bearer,
-          base: "https://api.example.com"
-        }
-
-        store items: memory("items")
-
-        action FetchItems {
-          fetch GET "/items"
-
-          store response -> items {
-            key: .id
-          }
-        }
-
-        run FetchItems
-      }
-    `;
-        const program = parse(source);
-        expect(program.type).toBe('ReqonProgram');
-        const result = await execute(source, { dryRun: true, verbose: false });
-        expect(result.success).toBe(true);
-        expect(result.actionsRun).toContain('FetchItems');
-    });
-    it('executes a mission with mock data flow', async () => {
-        const source = `
-      mission MockDataFlow {
-        source API {
-          auth: bearer,
-          base: "https://api.example.com"
-        }
-
-        store raw: memory("raw")
-        store processed: memory("processed")
-
-        action Process {
-          for item in raw {
-            map item -> Processed {
-              id: .id,
-              name: .title,
-              value: .amount
-            }
-
-            store response -> processed {
-              key: .id
-            }
-          }
-        }
-
-        run Process
-      }
-    `;
-        // Pre-populate the raw store
-        const rawStore = new MemoryStore('raw');
-        await rawStore.set('1', { id: '1', title: 'Item 1', amount: 100 });
-        await rawStore.set('2', { id: '2', title: 'Item 2', amount: 200 });
-        const result = await execute(source, {
-            dryRun: false,
-            verbose: false,
-            stores: { raw: rawStore },
-        });
-        expect(result.success).toBe(true);
-        expect(result.actionsRun).toContain('Process');
-        // Check processed store
-        const processedStore = result.stores.get('processed');
-        expect(processedStore).toBeDefined();
-        const items = await processedStore.list();
-        expect(items).toHaveLength(2);
-        expect(items[0]).toMatchObject({ id: '1', name: 'Item 1', value: 100 });
-    });
-    it('parses the Xero example file', async () => {
-        const fs = await import('node:fs/promises');
-        const source = await fs.readFile('./examples/xero/invoices.reqon', 'utf-8');
-        const program = parse(source);
-        expect(program.type).toBe('ReqonProgram');
-        expect(program.statements).toHaveLength(1);
-        const mission = program.statements[0];
-        if (mission.type === 'MissionDefinition') {
-            expect(mission.name).toBe('SyncXeroInvoices');
-            expect(mission.sources).toHaveLength(1);
-            expect(mission.stores).toHaveLength(2);
-            expect(mission.actions).toHaveLength(3);
-            expect(mission.pipeline.stages).toHaveLength(3);
-        }
-    });
-    it('handles validation failures gracefully', async () => {
-        const source = `
-      mission ValidationTest {
-        source API {
-          auth: bearer,
-          base: "https://api.example.com"
-        }
-
-        store items: memory("items")
-
-        action Validate {
-          for item in items {
-            validate item {
-              assume .value > 0
-            }
-          }
-        }
-
-        run Validate
-      }
-    `;
-        const itemsStore = new MemoryStore('items');
-        await itemsStore.set('1', { id: '1', value: -5 }); // Invalid: negative value
-        const result = await execute(source, {
-            stores: { items: itemsStore },
-        });
-        // Validation should fail
-        expect(result.success).toBe(false);
-        expect(result.errors.length).toBeGreaterThan(0);
-    });
-    it('processes match expressions in map steps', async () => {
-        const source = `
-      mission MatchTest {
-        source API {
-          auth: bearer,
-          base: "https://api.example.com"
-        }
-
-        store input: memory("input")
-        store output: memory("output")
-
-        action Transform {
-          for item in input {
-            map item -> Output {
-              id: .id,
-              status: match .state {
-                "A" => "active",
-                "I" => "inactive",
-                _ => "unknown"
-              }
-            }
-
-            store response -> output {
-              key: .id
-            }
-          }
-        }
-
-        run Transform
-      }
-    `;
-        const inputStore = new MemoryStore('input');
-        await inputStore.set('1', { id: '1', state: 'A' });
-        await inputStore.set('2', { id: '2', state: 'I' });
-        await inputStore.set('3', { id: '3', state: 'X' });
-        const result = await execute(source, {
-            stores: { input: inputStore },
-        });
-        expect(result.success).toBe(true);
-        const outputStore = result.stores.get('output');
-        const items = await outputStore.list();
-        expect(items).toContainEqual(expect.objectContaining({ id: '1', status: 'active' }));
-        expect(items).toContainEqual(expect.objectContaining({ id: '2', status: 'inactive' }));
-        expect(items).toContainEqual(expect.objectContaining({ id: '3', status: 'unknown' }));
-    });
-});

package/dist/interpreter/evaluator.test.d.ts

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

package/dist/interpreter/evaluator.test.js

@@ -1,512 +0,0 @@
-import { describe, it, expect } from 'vitest';
-import { evaluate, evaluateToString, interpolatePath } from './evaluator.js';
-import { createContext, childContext, setVariable } from './context.js';
-describe('evaluate', () => {
-    describe('literals', () => {
-        it('evaluates number literal', () => {
-            const ctx = createContext();
-            const expr = { type: 'Literal', value: 42, dataType: 'number' };
-            expect(evaluate(expr, ctx)).toBe(42);
-        });
-        it('evaluates string literal', () => {
-            const ctx = createContext();
-            const expr = { type: 'Literal', value: 'hello', dataType: 'string' };
-            expect(evaluate(expr, ctx)).toBe('hello');
-        });
-        it('evaluates boolean literal', () => {
-            const ctx = createContext();
-            const trueExpr = { type: 'Literal', value: true, dataType: 'boolean' };
-            const falseExpr = { type: 'Literal', value: false, dataType: 'boolean' };
-            expect(evaluate(trueExpr, ctx)).toBe(true);
-            expect(evaluate(falseExpr, ctx)).toBe(false);
-        });
-        it('evaluates null literal', () => {
-            const ctx = createContext();
-            const expr = { type: 'Literal', value: null, dataType: 'null' };
-            expect(evaluate(expr, ctx)).toBe(null);
-        });
-    });
-    describe('identifiers', () => {
-        it('resolves variable from context', () => {
-            const ctx = createContext();
-            setVariable(ctx, 'myVar', 'hello');
-            const expr = { type: 'Identifier', name: 'myVar' };
-            expect(evaluate(expr, ctx)).toBe('hello');
-        });
-        it('resolves response special identifier', () => {
-            const ctx = createContext();
-            ctx.response = { data: 'test' };
-            const expr = { type: 'Identifier', name: 'response' };
-            expect(evaluate(expr, ctx)).toEqual({ data: 'test' });
-        });
-        it('resolves field from current object', () => {
-            const ctx = createContext();
-            const current = { name: 'Alice', age: 30 };
-            const expr = { type: 'Identifier', name: 'name' };
-            expect(evaluate(expr, ctx, current)).toBe('Alice');
-        });
-        it('resolves field from response when no current object', () => {
-            const ctx = createContext();
-            ctx.response = { name: 'Response Name' };
-            const expr = { type: 'Identifier', name: 'name' };
-            expect(evaluate(expr, ctx)).toBe('Response Name');
-        });
-        it('returns undefined for non-existent variable', () => {
-            const ctx = createContext();
-            const expr = { type: 'Identifier', name: 'nonExistent' };
-            expect(evaluate(expr, ctx)).toBeUndefined();
-        });
-    });
-    describe('qualified names (property access)', () => {
-        it('resolves nested properties from current', () => {
-            const ctx = createContext();
-            const current = { user: { profile: { name: 'Alice' } } };
-            const expr = {
-                type: 'QualifiedName',
-                parts: ['user', 'profile', 'name'],
-            };
-            expect(evaluate(expr, ctx, current)).toBe('Alice');
-        });
-        it('resolves from response when no current', () => {
-            const ctx = createContext();
-            ctx.response = { data: { items: [1, 2, 3] } };
-            const expr = {
-                type: 'QualifiedName',
-                parts: ['data', 'items'],
-            };
-            expect(evaluate(expr, ctx)).toEqual([1, 2, 3]);
-        });
-        it('resolves from variables', () => {
-            const ctx = createContext();
-            setVariable(ctx, 'config', { settings: { theme: 'dark' } });
-            const expr = {
-                type: 'QualifiedName',
-                parts: ['config', 'settings', 'theme'],
-            };
-            expect(evaluate(expr, ctx)).toBe('dark');
-        });
-    });
-    describe('binary expressions', () => {
-        it('evaluates addition', () => {
-            const ctx = createContext();
-            const expr = {
-                type: 'BinaryExpression',
-                operator: '+',
-                left: { type: 'Literal', value: 5, dataType: 'number' },
-                right: { type: 'Literal', value: 3, dataType: 'number' },
-            };
-            expect(evaluate(expr, ctx)).toBe(8);
-        });
-        it('evaluates subtraction', () => {
-            const ctx = createContext();
-            const expr = {
-                type: 'BinaryExpression',
-                operator: '-',
-                left: { type: 'Literal', value: 10, dataType: 'number' },
-                right: { type: 'Literal', value: 4, dataType: 'number' },
-            };
-            expect(evaluate(expr, ctx)).toBe(6);
-        });
-        it('evaluates multiplication', () => {
-            const ctx = createContext();
-            const expr = {
-                type: 'BinaryExpression',
-                operator: '*',
-                left: { type: 'Literal', value: 6, dataType: 'number' },
-                right: { type: 'Literal', value: 7, dataType: 'number' },
-            };
-            expect(evaluate(expr, ctx)).toBe(42);
-        });
-        it('evaluates division', () => {
-            const ctx = createContext();
-            const expr = {
-                type: 'BinaryExpression',
-                operator: '/',
-                left: { type: 'Literal', value: 20, dataType: 'number' },
-                right: { type: 'Literal', value: 4, dataType: 'number' },
-            };
-            expect(evaluate(expr, ctx)).toBe(5);
-        });
-        it('evaluates equality', () => {
-            const ctx = createContext();
-            const expr = {
-                type: 'BinaryExpression',
-                operator: '==',
-                left: { type: 'Literal', value: 5, dataType: 'number' },
-                right: { type: 'Literal', value: 5, dataType: 'number' },
-            };
-            expect(evaluate(expr, ctx)).toBe(true);
-        });
-        it('evaluates inequality', () => {
-            const ctx = createContext();
-            const expr = {
-                type: 'BinaryExpression',
-                operator: '!=',
-                left: { type: 'Literal', value: 5, dataType: 'number' },
-                right: { type: 'Literal', value: 3, dataType: 'number' },
-            };
-            expect(evaluate(expr, ctx)).toBe(true);
-        });
-        it('evaluates less than', () => {
-            const ctx = createContext();
-            const expr = {
-                type: 'BinaryExpression',
-                operator: '<',
-                left: { type: 'Literal', value: 3, dataType: 'number' },
-                right: { type: 'Literal', value: 5, dataType: 'number' },
-            };
-            expect(evaluate(expr, ctx)).toBe(true);
-        });
-        it('evaluates greater than or equal', () => {
-            const ctx = createContext();
-            const expr = {
-                type: 'BinaryExpression',
-                operator: '>=',
-                left: { type: 'Literal', value: 5, dataType: 'number' },
-                right: { type: 'Literal', value: 5, dataType: 'number' },
-            };
-            expect(evaluate(expr, ctx)).toBe(true);
-        });
-    });
-    describe('logical expressions', () => {
-        it('evaluates and (true && true)', () => {
-            const ctx = createContext();
-            const expr = {
-                type: 'LogicalExpression',
-                operator: 'and',
-                left: { type: 'Literal', value: true, dataType: 'boolean' },
-                right: { type: 'Literal', value: true, dataType: 'boolean' },
-            };
-            expect(evaluate(expr, ctx)).toBe(true);
-        });
-        it('evaluates and (true && false)', () => {
-            const ctx = createContext();
-            const expr = {
-                type: 'LogicalExpression',
-                operator: 'and',
-                left: { type: 'Literal', value: true, dataType: 'boolean' },
-                right: { type: 'Literal', value: false, dataType: 'boolean' },
-            };
-            expect(evaluate(expr, ctx)).toBe(false);
-        });
-        it('short-circuits and on falsy left', () => {
-            const ctx = createContext();
-            // If short-circuiting works, the right side should not be evaluated
-            const expr = {
-                type: 'LogicalExpression',
-                operator: 'and',
-                left: { type: 'Literal', value: false, dataType: 'boolean' },
-                right: { type: 'Literal', value: true, dataType: 'boolean' },
-            };
-            expect(evaluate(expr, ctx)).toBe(false);
-        });
-        it('evaluates or (false || true)', () => {
-            const ctx = createContext();
-            const expr = {
-                type: 'LogicalExpression',
-                operator: 'or',
-                left: { type: 'Literal', value: false, dataType: 'boolean' },
-                right: { type: 'Literal', value: true, dataType: 'boolean' },
-            };
-            expect(evaluate(expr, ctx)).toBe(true);
-        });
-        it('short-circuits or on truthy left', () => {
-            const ctx = createContext();
-            const expr = {
-                type: 'LogicalExpression',
-                operator: 'or',
-                left: { type: 'Literal', value: true, dataType: 'boolean' },
-                right: { type: 'Literal', value: false, dataType: 'boolean' },
-            };
-            expect(evaluate(expr, ctx)).toBe(true);
-        });
-    });
-    describe('not expression', () => {
-        it('negates true to false', () => {
-            const ctx = createContext();
-            const expr = {
-                type: 'NotExpression',
-                operand: { type: 'Literal', value: true, dataType: 'boolean' },
-            };
-            expect(evaluate(expr, ctx)).toBe(false);
-        });
-        it('negates false to true', () => {
-            const ctx = createContext();
-            const expr = {
-                type: 'NotExpression',
-                operand: { type: 'Literal', value: false, dataType: 'boolean' },
-            };
-            expect(evaluate(expr, ctx)).toBe(true);
-        });
-    });
-    describe('unary expressions', () => {
-        it('negates a number', () => {
-            const ctx = createContext();
-            const expr = {
-                type: 'UnaryExpression',
-                operator: '-',
-                operand: { type: 'Literal', value: 5, dataType: 'number' },
-            };
-            expect(evaluate(expr, ctx)).toBe(-5);
-        });
-        it('positive unary has no effect', () => {
-            const ctx = createContext();
-            const expr = {
-                type: 'UnaryExpression',
-                operator: '+',
-                operand: { type: 'Literal', value: 5, dataType: 'number' },
-            };
-            expect(evaluate(expr, ctx)).toBe(5);
-        });
-    });
-    describe('ternary expressions', () => {
-        it('returns consequent when condition is true', () => {
-            const ctx = createContext();
-            const expr = {
-                type: 'TernaryExpression',
-                condition: { type: 'Literal', value: true, dataType: 'boolean' },
-                consequent: { type: 'Literal', value: 'yes', dataType: 'string' },
-                alternate: { type: 'Literal', value: 'no', dataType: 'string' },
-            };
-            expect(evaluate(expr, ctx)).toBe('yes');
-        });
-        it('returns alternate when condition is false', () => {
-            const ctx = createContext();
-            const expr = {
-                type: 'TernaryExpression',
-                condition: { type: 'Literal', value: false, dataType: 'boolean' },
-                consequent: { type: 'Literal', value: 'yes', dataType: 'string' },
-                alternate: { type: 'Literal', value: 'no', dataType: 'string' },
-            };
-            expect(evaluate(expr, ctx)).toBe('no');
-        });
-    });
-    describe('match expressions', () => {
-        it('matches value and returns result', () => {
-            const ctx = createContext();
-            const expr = {
-                type: 'MatchExpression',
-                value: { type: 'Literal', value: 'A', dataType: 'string' },
-                arms: [
-                    {
-                        pattern: { type: 'Literal', value: 'A', dataType: 'string' },
-                        result: { type: 'Literal', value: 'active', dataType: 'string' },
-                    },
-                    {
-                        pattern: { type: 'Literal', value: 'I', dataType: 'string' },
-                        result: { type: 'Literal', value: 'inactive', dataType: 'string' },
-                    },
-                ],
-            };
-            expect(evaluate(expr, ctx)).toBe('active');
-        });
-        it('matches wildcard pattern', () => {
-            const ctx = createContext();
-            const expr = {
-                type: 'MatchExpression',
-                value: { type: 'Literal', value: 'X', dataType: 'string' },
-                arms: [
-                    {
-                        pattern: { type: 'Literal', value: 'A', dataType: 'string' },
-                        result: { type: 'Literal', value: 'active', dataType: 'string' },
-                    },
-                    {
-                        pattern: { type: 'Identifier', name: '_' },
-                        result: { type: 'Literal', value: 'unknown', dataType: 'string' },
-                    },
-                ],
-            };
-            expect(evaluate(expr, ctx)).toBe('unknown');
-        });
-        it('returns undefined when no match', () => {
-            const ctx = createContext();
-            const expr = {
-                type: 'MatchExpression',
-                value: { type: 'Literal', value: 'X', dataType: 'string' },
-                arms: [
-                    {
-                        pattern: { type: 'Literal', value: 'A', dataType: 'string' },
-                        result: { type: 'Literal', value: 'active', dataType: 'string' },
-                    },
-                ],
-            };
-            expect(evaluate(expr, ctx)).toBeUndefined();
-        });
-    });
-    describe('call expressions (built-in functions)', () => {
-        it('evaluates length function', () => {
-            const ctx = createContext();
-            const expr = {
-                type: 'CallExpression',
-                callee: 'length',
-                arguments: [{
-                        type: 'OrderedSequenceType',
-                        elements: [
-                            { type: 'Literal', value: 1, dataType: 'number' },
-                            { type: 'Literal', value: 2, dataType: 'number' },
-                            { type: 'Literal', value: 3, dataType: 'number' },
-                            { type: 'Literal', value: 4, dataType: 'number' },
-                            { type: 'Literal', value: 5, dataType: 'number' },
-                        ],
-                    }],
-            };
-            expect(evaluate(expr, ctx)).toBe(5);
-        });
-        it('evaluates sum function', () => {
-            const ctx = createContext();
-            const expr = {
-                type: 'CallExpression',
-                callee: 'sum',
-                arguments: [{
-                        type: 'OrderedSequenceType',
-                        elements: [
-                            { type: 'Literal', value: 10, dataType: 'number' },
-                            { type: 'Literal', value: 20, dataType: 'number' },
-                            { type: 'Literal', value: 30, dataType: 'number' },
-                        ],
-                    }],
-            };
-            expect(evaluate(expr, ctx)).toBe(60);
-        });
-        it('evaluates first function', () => {
-            const ctx = createContext();
-            const expr = {
-                type: 'CallExpression',
-                callee: 'first',
-                arguments: [{
-                        type: 'OrderedSequenceType',
-                        elements: [
-                            { type: 'Literal', value: 'a', dataType: 'string' },
-                            { type: 'Literal', value: 'b', dataType: 'string' },
-                            { type: 'Literal', value: 'c', dataType: 'string' },
-                        ],
-                    }],
-            };
-            expect(evaluate(expr, ctx)).toBe('a');
-        });
-        it('evaluates last function', () => {
-            const ctx = createContext();
-            const expr = {
-                type: 'CallExpression',
-                callee: 'last',
-                arguments: [{
-                        type: 'OrderedSequenceType',
-                        elements: [
-                            { type: 'Literal', value: 'a', dataType: 'string' },
-                            { type: 'Literal', value: 'b', dataType: 'string' },
-                            { type: 'Literal', value: 'c', dataType: 'string' },
-                        ],
-                    }],
-            };
-            expect(evaluate(expr, ctx)).toBe('c');
-        });
-        it('evaluates round function', () => {
-            const ctx = createContext();
-            const expr = {
-                type: 'CallExpression',
-                callee: 'round',
-                arguments: [{ type: 'Literal', value: 3.7, dataType: 'number' }],
-            };
-            expect(evaluate(expr, ctx)).toBe(4);
-        });
-        it('evaluates floor function', () => {
-            const ctx = createContext();
-            const expr = {
-                type: 'CallExpression',
-                callee: 'floor',
-                arguments: [{ type: 'Literal', value: 3.9, dataType: 'number' }],
-            };
-            expect(evaluate(expr, ctx)).toBe(3);
-        });
-        it('evaluates ceil function', () => {
-            const ctx = createContext();
-            const expr = {
-                type: 'CallExpression',
-                callee: 'ceil',
-                arguments: [{ type: 'Literal', value: 3.1, dataType: 'number' }],
-            };
-            expect(evaluate(expr, ctx)).toBe(4);
-        });
-        it('throws on unknown function', () => {
-            const ctx = createContext();
-            const expr = {
-                type: 'CallExpression',
-                callee: 'unknownFn',
-                arguments: [],
-            };
-            expect(() => evaluate(expr, ctx)).toThrow('Unknown function: unknownFn');
-        });
-    });
-});
-describe('evaluateToString', () => {
-    it('converts number to string', () => {
-        const ctx = createContext();
-        const expr = { type: 'Literal', value: 42, dataType: 'number' };
-        expect(evaluateToString(expr, ctx)).toBe('42');
-    });
-    it('converts null to empty string', () => {
-        const ctx = createContext();
-        const expr = { type: 'Literal', value: null, dataType: 'null' };
-        expect(evaluateToString(expr, ctx)).toBe('');
-    });
-    it('converts undefined to empty string', () => {
-        const ctx = createContext();
-        const expr = { type: 'Identifier', name: 'nonExistent' };
-        expect(evaluateToString(expr, ctx)).toBe('');
-    });
-});
-describe('interpolatePath', () => {
-    it('interpolates simple variables', () => {
-        const ctx = createContext();
-        const current = { id: '123' };
-        const result = interpolatePath('/users/{id}', ctx, current);
-        expect(result).toBe('/users/123');
-    });
-    it('interpolates nested properties', () => {
-        const ctx = createContext();
-        const current = { user: { profile: { id: 'abc' } } };
-        const result = interpolatePath('/profiles/{user.profile.id}', ctx, current);
-        expect(result).toBe('/profiles/abc');
-    });
-    it('interpolates from context variables', () => {
-        const ctx = createContext();
-        setVariable(ctx, 'userId', '456');
-        const result = interpolatePath('/users/{userId}', ctx);
-        expect(result).toBe('/users/456');
-    });
-    it('handles multiple interpolations', () => {
-        const ctx = createContext();
-        const current = { org: 'acme', project: 'widget' };
-        const result = interpolatePath('/orgs/{org}/projects/{project}', ctx, current);
-        expect(result).toBe('/orgs/acme/projects/widget');
-    });
-    it('handles missing values as empty string', () => {
-        const ctx = createContext();
-        const result = interpolatePath('/users/{nonExistent}', ctx, {});
-        expect(result).toBe('/users/');
-    });
-});
-describe('context variable resolution', () => {
-    it('resolves variables from parent context', () => {
-        const parent = createContext();
-        setVariable(parent, 'parentVar', 'from parent');
-        const child = childContext(parent);
-        const expr = { type: 'Identifier', name: 'parentVar' };
-        expect(evaluate(expr, child)).toBe('from parent');
-    });
-    it('child variables shadow parent variables', () => {
-        const parent = createContext();
-        setVariable(parent, 'sharedVar', 'parent value');
-        const child = childContext(parent);
-        setVariable(child, 'sharedVar', 'child value');
-        const expr = { type: 'Identifier', name: 'sharedVar' };
-        expect(evaluate(expr, child)).toBe('child value');
-        expect(evaluate(expr, parent)).toBe('parent value');
-    });
-    it('shares stores between parent and child', () => {
-        const parent = createContext();
-        const child = childContext(parent);
-        expect(child.stores).toBe(parent.stores);
-        expect(child.sources).toBe(parent.sources);
-    });
-});

package/dist/interpreter/http.test.d.ts

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