reqon-dsl 0.2.0

package/dist/errors/errors.test.js

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

@@ -0,0 +1,83 @@
+export interface SourceLocation {
+    line: number;
+    column: number;
+    /** End column (optional, for ranges) */
+    endColumn?: number;
+}
+export interface ErrorContext {
+    /** The source code being parsed/executed */
+    source?: string;
+    /** File path if available */
+    filePath?: string;
+}
+/**
+ * Base class for Reqon errors with source location info
+ */
+export declare class ReqonError extends Error {
+    readonly location: SourceLocation;
+    readonly context?: ErrorContext;
+    constructor(message: string, location: SourceLocation, context?: ErrorContext);
+    /**
+     * Format the error with source context for display
+     */
+    format(): string;
+    toString(): string;
+}
+/**
+ * Error during lexical analysis
+ */
+export declare class LexerError extends ReqonError {
+    constructor(message: string, location: SourceLocation, context?: ErrorContext);
+}
+/**
+ * Error during parsing
+ */
+export declare class ParseError extends ReqonError {
+    /** The token value that caused the error */
+    readonly tokenValue?: string;
+    constructor(message: string, location: SourceLocation, context?: ErrorContext, tokenValue?: string);
+    format(): string;
+}
+/**
+ * Error during runtime evaluation
+ */
+export declare class RuntimeError extends ReqonError {
+    /** The action/step where the error occurred */
+    readonly action?: string;
+    /** The step type (fetch, map, validate, etc.) */
+    readonly stepType?: string;
+    constructor(message: string, location: SourceLocation, context?: ErrorContext, options?: {
+        action?: string;
+        stepType?: string;
+    });
+    format(): string;
+}
+/**
+ * Error during validation
+ */
+export declare class ValidationError extends ReqonError {
+    readonly constraint?: string;
+    readonly severity: 'error' | 'warning';
+    constructor(message: string, location: SourceLocation, context?: ErrorContext, options?: {
+        constraint?: string;
+        severity?: 'error' | 'warning';
+    });
+}
+/**
+ * Format multiple errors for display
+ */
+export declare function formatErrors(errors: ReqonError[]): string;
+/**
+ * Get the source line at a given line number
+ */
+export declare function getSourceLine(source: string, lineNumber: number): string | undefined;
+/**
+ * Get surrounding context lines
+ */
+export declare function getSourceContext(source: string, lineNumber: number, contextLines?: number): {
+    lines: Array<{
+        num: number;
+        text: string;
+    }>;
+    errorLineIndex: number;
+};

package/dist/errors/index.js

@@ -0,0 +1,159 @@
+/**
+ * Base class for Reqon errors with source location info
+ */
+export class ReqonError extends Error {
+    location;
+    context;
+    constructor(message, location, context) {
+        super(message);
+        this.name = 'ReqonError';
+        this.location = location;
+        this.context = context;
+    }
+    /**
+     * Format the error with source context for display
+     */
+    format() {
+        const lines = [];
+        // Header with location
+        const fileInfo = this.context?.filePath ? `${this.context.filePath}:` : '';
+        lines.push(`${this.name}: ${this.message}`);
+        lines.push(`  --> ${fileInfo}${this.location.line}:${this.location.column}`);
+        // Show source context if available
+        if (this.context?.source) {
+            const sourceLines = this.context.source.split('\n');
+            const errorLine = sourceLines[this.location.line - 1];
+            if (errorLine !== undefined) {
+                const lineNum = this.location.line.toString();
+                const padding = ' '.repeat(lineNum.length);
+                lines.push(`${padding} |`);
+                lines.push(`${lineNum} | ${errorLine}`);
+                // Underline the error position
+                const underlineStart = this.location.column - 1;
+                const underlineLength = this.location.endColumn
+                    ? this.location.endColumn - this.location.column
+                    : 1;
+                const underline = ' '.repeat(underlineStart) + '^'.repeat(Math.max(1, underlineLength));
+                lines.push(`${padding} | ${underline}`);
+            }
+        }
+        return lines.join('\n');
+    }
+    toString() {
+        return this.format();
+    }
+}
+/**
+ * Error during lexical analysis
+ */
+export class LexerError extends ReqonError {
+    constructor(message, location, context) {
+        super(message, location, context);
+        this.name = 'LexerError';
+    }
+}
+/**
+ * Error during parsing
+ */
+export class ParseError extends ReqonError {
+    /** The token value that caused the error */
+    tokenValue;
+    constructor(message, location, context, tokenValue) {
+        super(message, location, context);
+        this.name = 'ParseError';
+        this.tokenValue = tokenValue;
+    }
+    format() {
+        const base = super.format();
+        if (this.tokenValue) {
+            return `${base}\n  found: '${this.tokenValue}'`;
+        }
+        return base;
+    }
+}
+/**
+ * Error during runtime evaluation
+ */
+export class RuntimeError extends ReqonError {
+    /** The action/step where the error occurred */
+    action;
+    /** The step type (fetch, map, validate, etc.) */
+    stepType;
+    constructor(message, location, context, options) {
+        super(message, location, context);
+        this.name = 'RuntimeError';
+        this.action = options?.action;
+        this.stepType = options?.stepType;
+    }
+    format() {
+        const lines = [];
+        // Header
+        lines.push(`${this.name}: ${this.message}`);
+        if (this.action) {
+            lines.push(`  in action: ${this.action}`);
+        }
+        if (this.stepType) {
+            lines.push(`  at step: ${this.stepType}`);
+        }
+        // Location
+        const fileInfo = this.context?.filePath ? `${this.context.filePath}:` : '';
+        lines.push(`  --> ${fileInfo}${this.location.line}:${this.location.column}`);
+        // Source context
+        if (this.context?.source) {
+            const sourceLines = this.context.source.split('\n');
+            const errorLine = sourceLines[this.location.line - 1];
+            if (errorLine !== undefined) {
+                const lineNum = this.location.line.toString();
+                const padding = ' '.repeat(lineNum.length);
+                lines.push(`${padding} |`);
+                lines.push(`${lineNum} | ${errorLine}`);
+                const underlineStart = this.location.column - 1;
+                const underline = ' '.repeat(underlineStart) + '^';
+                lines.push(`${padding} | ${underline}`);
+            }
+        }
+        return lines.join('\n');
+    }
+}
+/**
+ * Error during validation
+ */
+export class ValidationError extends ReqonError {
+    constraint;
+    severity;
+    constructor(message, location, context, options) {
+        super(message, location, context);
+        this.name = 'ValidationError';
+        this.constraint = options?.constraint;
+        this.severity = options?.severity ?? 'error';
+    }
+}
+/**
+ * Format multiple errors for display
+ */
+export function formatErrors(errors) {
+    return errors.map(e => e.format()).join('\n\n');
+}
+/**
+ * Get the source line at a given line number
+ */
+export function getSourceLine(source, lineNumber) {
+    const lines = source.split('\n');
+    return lines[lineNumber - 1];
+}
+/**
+ * Get surrounding context lines
+ */
+export function getSourceContext(source, lineNumber, contextLines = 2) {
+    const allLines = source.split('\n');
+    const start = Math.max(0, lineNumber - 1 - contextLines);
+    const end = Math.min(allLines.length, lineNumber + contextLines);
+    const lines = [];
+    for (let i = start; i < end; i++) {
+        lines.push({ num: i + 1, text: allLines[i] });
+    }
+    return {
+        lines,
+        errorLineIndex: lineNumber - 1 - start,
+    };
+}

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

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

package/dist/execution/execution.test.js

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

@@ -0,0 +1,4 @@
+export type { ExecutionState, ExecutionStatus, StageState, StageStatus, Checkpoint, ExecutionStateError, CreateExecutionOptions, } from './state.js';
+export { generateExecutionId, createExecutionState, findResumePoint, canResume, getProgress, getExecutionSummary, } from './state.js';
+export type { ExecutionStore } from './store.js';
+export { FileExecutionStore, MemoryExecutionStore } from './store.js';

package/dist/execution/index.js

@@ -0,0 +1,2 @@
+export { generateExecutionId, createExecutionState, findResumePoint, canResume, getProgress, getExecutionSummary, } from './state.js';
+export { FileExecutionStore, MemoryExecutionStore } from './store.js';