reqon-dsl 0.2.0 → 0.3.0

package/dist/errors/errors.test.js

@@ -1,165 +0,0 @@
-import { describe, it, expect } from 'vitest';
-import { ReqonError, ParseError, LexerError, RuntimeError, ValidationError, formatErrors, getSourceLine, getSourceContext, } from './index.js';
-import { ReqonLexer } from '../lexer/index.js';
-import { ReqonParser } from '../parser/index.js';
-describe('Error classes', () => {
-    describe('ReqonError', () => {
-        it('should format error with location', () => {
-            const error = new ReqonError('Something went wrong', { line: 5, column: 10 });
-            const formatted = error.format();
-            expect(formatted).toContain('ReqonError: Something went wrong');
-            expect(formatted).toContain('5:10');
-        });
-        it('should format error with source context', () => {
-            const source = `mission Test {
-  source API {
-    auth: bearer,
-    base: "https://api.example.com"
-  }
-}`;
-            const error = new ReqonError('Unexpected token', { line: 3, column: 5 }, { source });
-            const formatted = error.format();
-            expect(formatted).toContain('auth: bearer,');
-            expect(formatted).toContain('3 |');
-            expect(formatted).toContain('^');
-        });
-        it('should include file path when provided', () => {
-            const error = new ReqonError('Test error', { line: 1, column: 1 }, { source: 'test', filePath: '/path/to/file.reqon' });
-            const formatted = error.format();
-            expect(formatted).toContain('/path/to/file.reqon:');
-        });
-    });
-    describe('ParseError', () => {
-        it('should include token value in format', () => {
-            const error = new ParseError("Expected '{'", { line: 2, column: 15 }, undefined, 'identifier');
-            const formatted = error.format();
-            expect(formatted).toContain("found: 'identifier'");
-        });
-        it('should format with source context and pointer', () => {
-            const source = `mission Test {
-  source API auth: bearer
-}`;
-            const error = new ParseError("Expected '{'", { line: 2, column: 14 }, { source }, 'auth');
-            const formatted = error.format();
-            expect(formatted).toContain('ParseError');
-            expect(formatted).toContain('2:14');
-            expect(formatted).toContain('source API auth: bearer');
-            expect(formatted).toContain('^');
-        });
-    });
-    describe('LexerError', () => {
-        it('should format with source context', () => {
-            const source = 'mission Test { @ }';
-            const error = new LexerError("Unexpected character '@'", { line: 1, column: 16 }, { source });
-            const formatted = error.format();
-            expect(formatted).toContain('LexerError');
-            expect(formatted).toContain("Unexpected character '@'");
-        });
-    });
-    describe('RuntimeError', () => {
-        it('should include action and step info', () => {
-            const error = new RuntimeError('Request failed with status 404', { line: 5, column: 3 }, undefined, { action: 'FetchData', stepType: 'fetch' });
-            const formatted = error.format();
-            expect(formatted).toContain('in action: FetchData');
-            expect(formatted).toContain('at step: fetch');
-        });
-    });
-    describe('ValidationError', () => {
-        it('should include severity', () => {
-            const error = new ValidationError('Value must be positive', { line: 10, column: 5 }, undefined, { severity: 'warning' });
-            expect(error.severity).toBe('warning');
-        });
-    });
-});
-describe('formatErrors', () => {
-    it('should format multiple errors', () => {
-        const errors = [
-            new ParseError('Error 1', { line: 1, column: 1 }),
-            new ParseError('Error 2', { line: 5, column: 10 }),
-        ];
-        const formatted = formatErrors(errors);
-        expect(formatted).toContain('Error 1');
-        expect(formatted).toContain('Error 2');
-        expect(formatted).toContain('1:1');
-        expect(formatted).toContain('5:10');
-    });
-});
-describe('getSourceLine', () => {
-    it('should return the correct line', () => {
-        const source = 'line1\nline2\nline3';
-        expect(getSourceLine(source, 1)).toBe('line1');
-        expect(getSourceLine(source, 2)).toBe('line2');
-        expect(getSourceLine(source, 3)).toBe('line3');
-    });
-    it('should return undefined for out of range', () => {
-        const source = 'line1\nline2';
-        expect(getSourceLine(source, 5)).toBeUndefined();
-    });
-});
-describe('getSourceContext', () => {
-    it('should return surrounding lines', () => {
-        const source = 'line1\nline2\nline3\nline4\nline5';
-        const context = getSourceContext(source, 3, 1);
-        expect(context.lines).toHaveLength(3);
-        expect(context.lines[0]).toEqual({ num: 2, text: 'line2' });
-        expect(context.lines[1]).toEqual({ num: 3, text: 'line3' });
-        expect(context.lines[2]).toEqual({ num: 4, text: 'line4' });
-        expect(context.errorLineIndex).toBe(1);
-    });
-});
-describe('Integration with parser', () => {
-    it('should produce ParseError with source context', () => {
-        const source = `mission Test {
-  source API {
-    auth: bearer
-  }
-
-  action Fetch {
-    fetch GET "/items
-  }
-
-  run Fetch
-}`;
-        const lexer = new ReqonLexer(source);
-        expect(() => lexer.tokenize()).toThrow();
-        try {
-            lexer.tokenize();
-        }
-        catch (e) {
-            expect(e).toBeInstanceOf(Error);
-            const error = e;
-            expect(error.message).toContain('Unterminated string');
-        }
-    });
-    it('should produce ParseError for syntax errors', () => {
-        const source = `mission Test {
-  source API {
-    auth: bearer,
-    base: "https://api.example.com"
-  }
-
-  action Fetch
-    fetch GET "/items"
-  }
-
-  run Fetch
-}`;
-        const lexer = new ReqonLexer(source);
-        const tokens = lexer.tokenize();
-        const parser = new ReqonParser(tokens, source, 'test.reqon');
-        expect(() => parser.parse()).toThrow();
-        try {
-            parser.parse();
-        }
-        catch (e) {
-            expect(e).toBeInstanceOf(ParseError);
-            const error = e;
-            expect(error.location.line).toBeGreaterThan(0);
-            expect(error.context?.source).toBe(source);
-            expect(error.context?.filePath).toBe('test.reqon');
-            const formatted = error.format();
-            expect(formatted).toContain('test.reqon:');
-            expect(formatted).toContain('ParseError');
-        }
-    });
-});

package/dist/execution/execution.test.d.ts

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

package/dist/execution/execution.test.js

@@ -1,246 +0,0 @@
-import { describe, it, expect, beforeEach, afterEach } from 'vitest';
-import { rmSync, existsSync } from 'node:fs';
-import { createExecutionState, findResumePoint, canResume, getProgress, getExecutionSummary, } from './state.js';
-import { FileExecutionStore, MemoryExecutionStore } from './store.js';
-const TEST_DIR = '.reqon-test-executions';
-describe('ExecutionState', () => {
-    describe('createExecutionState', () => {
-        it('creates initial state with pending stages', () => {
-            const state = createExecutionState({
-                mission: 'TestMission',
-                stages: ['FetchData', 'ProcessData', 'StoreResults'],
-            });
-            expect(state.mission).toBe('TestMission');
-            expect(state.status).toBe('pending');
-            expect(state.stages).toHaveLength(3);
-            expect(state.stages[0].action).toBe('FetchData');
-            expect(state.stages[0].status).toBe('pending');
-            expect(state.id).toMatch(/^exec_/);
-        });
-        it('includes metadata', () => {
-            const state = createExecutionState({
-                mission: 'Test',
-                stages: ['A'],
-                metadata: { tenant: 'acme', userId: '123' },
-            });
-            expect(state.metadata).toEqual({ tenant: 'acme', userId: '123' });
-        });
-    });
-    describe('findResumePoint', () => {
-        it('returns 0 for fresh execution', () => {
-            const state = createExecutionState({
-                mission: 'Test',
-                stages: ['A', 'B', 'C'],
-            });
-            expect(findResumePoint(state)).toBe(0);
-        });
-        it('returns index of first non-completed stage', () => {
-            const state = createExecutionState({
-                mission: 'Test',
-                stages: ['A', 'B', 'C'],
-            });
-            state.stages[0].status = 'completed';
-            state.stages[1].status = 'failed';
-            expect(findResumePoint(state)).toBe(1);
-        });
-        it('returns -1 when all stages complete', () => {
-            const state = createExecutionState({
-                mission: 'Test',
-                stages: ['A', 'B'],
-            });
-            state.stages[0].status = 'completed';
-            state.stages[1].status = 'completed';
-            expect(findResumePoint(state)).toBe(-1);
-        });
-        it('skips over skipped stages', () => {
-            const state = createExecutionState({
-                mission: 'Test',
-                stages: ['A', 'B', 'C'],
-            });
-            state.stages[0].status = 'completed';
-            state.stages[1].status = 'skipped';
-            expect(findResumePoint(state)).toBe(2);
-        });
-    });
-    describe('canResume', () => {
-        it('returns true for failed executions', () => {
-            const state = createExecutionState({ mission: 'Test', stages: ['A'] });
-            state.status = 'failed';
-            expect(canResume(state)).toBe(true);
-        });
-        it('returns true for paused executions', () => {
-            const state = createExecutionState({ mission: 'Test', stages: ['A'] });
-            state.status = 'paused';
-            expect(canResume(state)).toBe(true);
-        });
-        it('returns false for completed executions', () => {
-            const state = createExecutionState({ mission: 'Test', stages: ['A'] });
-            state.status = 'completed';
-            expect(canResume(state)).toBe(false);
-        });
-        it('returns false for running executions', () => {
-            const state = createExecutionState({ mission: 'Test', stages: ['A'] });
-            state.status = 'running';
-            expect(canResume(state)).toBe(false);
-        });
-    });
-    describe('getProgress', () => {
-        it('returns 0 for no completed stages', () => {
-            const state = createExecutionState({
-                mission: 'Test',
-                stages: ['A', 'B', 'C', 'D'],
-            });
-            expect(getProgress(state)).toBe(0);
-        });
-        it('returns 50 for half completed', () => {
-            const state = createExecutionState({
-                mission: 'Test',
-                stages: ['A', 'B', 'C', 'D'],
-            });
-            state.stages[0].status = 'completed';
-            state.stages[1].status = 'completed';
-            expect(getProgress(state)).toBe(50);
-        });
-        it('returns 100 for all completed', () => {
-            const state = createExecutionState({
-                mission: 'Test',
-                stages: ['A', 'B'],
-            });
-            state.stages[0].status = 'completed';
-            state.stages[1].status = 'completed';
-            expect(getProgress(state)).toBe(100);
-        });
-        it('counts skipped as progress', () => {
-            const state = createExecutionState({
-                mission: 'Test',
-                stages: ['A', 'B'],
-            });
-            state.stages[0].status = 'completed';
-            state.stages[1].status = 'skipped';
-            expect(getProgress(state)).toBe(100);
-        });
-    });
-    describe('getExecutionSummary', () => {
-        it('generates readable summary', () => {
-            const state = createExecutionState({
-                mission: 'SyncInvoices',
-                stages: ['Fetch', 'Process', 'Store'],
-            });
-            state.stages[0].status = 'completed';
-            state.stages[1].status = 'failed';
-            state.status = 'failed';
-            const summary = getExecutionSummary(state);
-            expect(summary).toContain('SyncInvoices');
-            expect(summary).toContain('failed');
-            expect(summary).toContain('1 completed');
-            expect(summary).toContain('1 failed');
-            expect(summary).toContain('1 pending');
-        });
-    });
-});
-describe('MemoryExecutionStore', () => {
-    let store;
-    beforeEach(() => {
-        store = new MemoryExecutionStore();
-    });
-    it('saves and loads execution state', async () => {
-        const state = createExecutionState({
-            mission: 'Test',
-            stages: ['A', 'B'],
-        });
-        await store.save(state);
-        const loaded = await store.load(state.id);
-        expect(loaded).not.toBeNull();
-        expect(loaded.id).toBe(state.id);
-        expect(loaded.mission).toBe('Test');
-    });
-    it('returns null for unknown ID', async () => {
-        const loaded = await store.load('nonexistent');
-        expect(loaded).toBeNull();
-    });
-    it('lists by mission', async () => {
-        const state1 = createExecutionState({ mission: 'A', stages: ['X'] });
-        const state2 = createExecutionState({ mission: 'B', stages: ['X'] });
-        const state3 = createExecutionState({ mission: 'A', stages: ['X'] });
-        await store.save(state1);
-        await store.save(state2);
-        await store.save(state3);
-        const aExecutions = await store.listByMission('A');
-        expect(aExecutions).toHaveLength(2);
-    });
-    it('finds resumable executions', async () => {
-        const completed = createExecutionState({ mission: 'Test', stages: ['A'] });
-        completed.status = 'completed';
-        const failed = createExecutionState({ mission: 'Test', stages: ['A'] });
-        failed.status = 'failed';
-        const paused = createExecutionState({ mission: 'Test', stages: ['A'] });
-        paused.status = 'paused';
-        await store.save(completed);
-        await store.save(failed);
-        await store.save(paused);
-        const resumable = await store.findResumable('Test');
-        expect(resumable).toHaveLength(2);
-    });
-    it('deletes execution state', async () => {
-        const state = createExecutionState({ mission: 'Test', stages: ['A'] });
-        await store.save(state);
-        await store.delete(state.id);
-        const loaded = await store.load(state.id);
-        expect(loaded).toBeNull();
-    });
-});
-describe('FileExecutionStore', () => {
-    let store;
-    beforeEach(() => {
-        if (existsSync(TEST_DIR)) {
-            rmSync(TEST_DIR, { recursive: true, force: true });
-        }
-        store = new FileExecutionStore(TEST_DIR);
-    });
-    afterEach(() => {
-        if (existsSync(TEST_DIR)) {
-            rmSync(TEST_DIR, { recursive: true, force: true });
-        }
-    });
-    it('creates directory if not exists', async () => {
-        // Trigger initialization by calling any async method
-        await store.listRecent();
-        expect(existsSync(TEST_DIR)).toBe(true);
-    });
-    it('persists state to disk', async () => {
-        const state = createExecutionState({
-            mission: 'Persistent',
-            stages: ['A', 'B'],
-        });
-        state.stages[0].status = 'completed';
-        await store.save(state);
-        // Create new store instance
-        const newStore = new FileExecutionStore(TEST_DIR);
-        const loaded = await newStore.load(state.id);
-        expect(loaded).not.toBeNull();
-        expect(loaded.stages[0].status).toBe('completed');
-    });
-    it('preserves Date objects', async () => {
-        const state = createExecutionState({
-            mission: 'Test',
-            stages: ['A'],
-        });
-        state.stages[0].startedAt = new Date();
-        state.stages[0].completedAt = new Date();
-        await store.save(state);
-        const loaded = await store.load(state.id);
-        expect(loaded.startedAt).toBeInstanceOf(Date);
-        expect(loaded.stages[0].startedAt).toBeInstanceOf(Date);
-        expect(loaded.stages[0].completedAt).toBeInstanceOf(Date);
-    });
-    it('finds latest execution for mission', async () => {
-        const older = createExecutionState({ mission: 'Test', stages: ['A'] });
-        older.startedAt = new Date(Date.now() - 10000);
-        const newer = createExecutionState({ mission: 'Test', stages: ['A'] });
-        newer.startedAt = new Date();
-        await store.save(older);
-        await store.save(newer);
-        const latest = await store.findLatest('Test');
-        expect(latest.id).toBe(newer.id);
-    });
-});

package/dist/integration.test.d.ts

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

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 {};