reqon-dsl 0.2.0

package/dist/interpreter/evaluator.test.js

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

@@ -0,0 +1,131 @@
+import type { ReqonProgram } from '../ast/nodes.js';
+import type { StoreAdapter } from '../stores/types.js';
+import { type CircuitBreakerCallbacks } from '../auth/circuit-breaker.js';
+import type { RateLimitCallbacks } from '../auth/types.js';
+import { type ExecutionState, type ExecutionStore } from '../execution/index.js';
+import { type SyncStore } from '../sync/index.js';
+import type { WebhookServer } from '../webhook/index.js';
+export interface ExecutionResult {
+    success: boolean;
+    duration: number;
+    actionsRun: string[];
+    errors: ExecutionError[];
+    stores: Map<string, StoreAdapter>;
+    /** Execution ID for resuming */
+    executionId?: string;
+    /** Execution state (if persistence enabled) */
+    state?: ExecutionState;
+}
+export interface ExecutionError {
+    action: string;
+    step: string;
+    message: string;
+    details?: unknown;
+}
+/** Event emitted when execution starts */
+export interface ExecutionStartEvent {
+    executionId: string;
+    mission: string;
+    stageCount: number;
+    isResume: boolean;
+    metadata?: Record<string, unknown>;
+}
+/** Event emitted when execution completes */
+export interface ExecutionCompleteEvent {
+    executionId: string;
+    mission: string;
+    success: boolean;
+    duration: number;
+    stagesCompleted: number;
+    stagesFailed: number;
+    errors: ExecutionError[];
+}
+/** Event emitted when a stage starts */
+export interface StageStartEvent {
+    executionId: string;
+    mission: string;
+    stageIndex: number;
+    stageName: string;
+    totalStages: number;
+}
+/** Event emitted when a stage completes */
+export interface StageCompleteEvent {
+    executionId: string;
+    mission: string;
+    stageIndex: number;
+    stageName: string;
+    totalStages: number;
+    success: boolean;
+    duration: number;
+    error?: string;
+}
+/** Callbacks for execution progress */
+export interface ProgressCallbacks {
+    onExecutionStart?: (event: ExecutionStartEvent) => void;
+    onExecutionComplete?: (event: ExecutionCompleteEvent) => void;
+    onStageStart?: (event: StageStartEvent) => void;
+    onStageComplete?: (event: StageCompleteEvent) => void;
+}
+export interface ExecutorConfig {
+    auth?: Record<string, AuthConfig>;
+    stores?: Record<string, StoreAdapter>;
+    dryRun?: boolean;
+    verbose?: boolean;
+    rateLimitCallbacks?: RateLimitCallbacks;
+    circuitBreakerCallbacks?: CircuitBreakerCallbacks;
+    developmentMode?: boolean;
+    dataDir?: string;
+    persistState?: boolean;
+    executionStore?: ExecutionStore;
+    resumeFrom?: string;
+    metadata?: Record<string, unknown>;
+    syncStore?: SyncStore;
+    progress?: ProgressCallbacks;
+    webhookServer?: WebhookServer;
+}
+interface AuthConfig {
+    type: 'bearer' | 'oauth2' | 'none';
+    token?: string;
+    accessToken?: string;
+    refreshToken?: string;
+    tokenEndpoint?: string;
+    clientId?: string;
+    clientSecret?: string;
+}
+export declare class MissionExecutor {
+    private config;
+    private ctx;
+    private errors;
+    private actionsRun;
+    private oasSources;
+    private sourceConfigs;
+    private rateLimiter;
+    private circuitBreaker;
+    private executionStore?;
+    private executionState?;
+    private syncStore?;
+    private missionName?;
+    constructor(config?: ExecutorConfig);
+    execute(program: ReqonProgram): Promise<ExecutionResult>;
+    private initializeExecutionState;
+    private saveExecutionState;
+    private updateStageState;
+    private executeMission;
+    private getStageName;
+    private executeSequentialStage;
+    private executeParallelStage;
+    private initializeSource;
+    private initializeStore;
+    private executeAction;
+    private executeStep;
+    private executeFetch;
+    private executeFor;
+    private executeMap;
+    private executeValidate;
+    private executeStore;
+    private executeMatch;
+    private executeLet;
+    private executeWebhook;
+    private log;
+}
+export {};