reqon-dsl 0.2.0

package/dist/parser/parser.js

@@ -0,0 +1,1229 @@
+import { TokenType } from 'vague-lang';
+import { ReqonTokenType } from '../lexer/tokens.js';
+import { ReqonExpressionParser } from './expressions.js';
+export class ReqonParser extends ReqonExpressionParser {
+    constructor(tokens, source, filePath) {
+        super(tokens, source, filePath);
+    }
+    parse() {
+        const statements = [];
+        while (!this.isAtEnd()) {
+            const stmt = this.parseStatement();
+            if (stmt)
+                statements.push(stmt);
+        }
+        return { type: 'ReqonProgram', statements };
+    }
+    parseStatement() {
+        // Reqon-specific statements
+        if (this.check(ReqonTokenType.MISSION))
+            return this.parseMission();
+        if (this.check(ReqonTokenType.SOURCE))
+            return this.parseSource();
+        if (this.check(ReqonTokenType.STORE))
+            return this.parseStoreDefinition();
+        if (this.check(ReqonTokenType.ACTION))
+            return this.parseAction();
+        // Vague statements (schema, import, let, etc.)
+        if (this.check(TokenType.SCHEMA))
+            return this.parseSchema();
+        if (this.check(TokenType.IMPORT))
+            return this.parseImport();
+        if (this.check(TokenType.LET))
+            return this.parseLet();
+        throw this.error(`Unexpected token: ${this.peek().value}`);
+    }
+    // ============================================
+    // Mission definition
+    // ============================================
+    parseMission() {
+        this.consume(ReqonTokenType.MISSION, "Expected 'mission'");
+        const name = this.consume(TokenType.IDENTIFIER, 'Expected mission name').value;
+        this.consume(TokenType.LBRACE, "Expected '{'");
+        const sources = [];
+        const stores = [];
+        const schemas = [];
+        const actions = [];
+        let pipeline;
+        let schedule;
+        while (!this.check(TokenType.RBRACE) && !this.isAtEnd()) {
+            if (this.check(ReqonTokenType.SOURCE)) {
+                sources.push(this.parseSource());
+            }
+            else if (this.check(ReqonTokenType.STORE)) {
+                stores.push(this.parseStoreDefinition());
+            }
+            else if (this.check(TokenType.SCHEMA)) {
+                schemas.push(this.parseSchema());
+            }
+            else if (this.check(ReqonTokenType.ACTION)) {
+                actions.push(this.parseAction());
+            }
+            else if (this.check(ReqonTokenType.RUN)) {
+                pipeline = this.parsePipeline();
+            }
+            else if (this.check(ReqonTokenType.SCHEDULE)) {
+                schedule = this.parseSchedule();
+            }
+            else {
+                throw this.error(`Unexpected token in mission: ${this.peek().value}`);
+            }
+            this.match(TokenType.COMMA);
+        }
+        this.consume(TokenType.RBRACE, "Expected '}'");
+        if (!pipeline) {
+            throw this.error('Mission must have a run pipeline');
+        }
+        // Build sets of defined names for validation
+        const definedStores = new Set(stores.map((s) => s.name));
+        const definedActions = new Set(actions.map((a) => a.name));
+        const definedSources = new Set(sources.map((s) => s.name));
+        // Validate all references
+        this.validateActionReferences(actions, definedStores, definedSources, definedActions);
+        this.validatePipelineReferences(pipeline, definedActions);
+        return {
+            type: 'MissionDefinition',
+            name,
+            schedule,
+            sources,
+            stores,
+            schemas,
+            actions,
+            pipeline,
+        };
+    }
+    /**
+     * Validate that all store, source, and action references in actions exist
+     */
+    validateActionReferences(actions, definedStores, definedSources, definedActions) {
+        for (const action of actions) {
+            this.validateStepsReferences(action.steps, definedStores, definedSources, definedActions, action.name);
+        }
+    }
+    /**
+     * Recursively validate store, source, and action references in action steps
+     */
+    validateStepsReferences(steps, definedStores, definedSources, definedActions, actionName) {
+        for (const step of steps) {
+            if (step.type === 'StoreStep') {
+                if (!definedStores.has(step.target)) {
+                    throw this.error(`Store '${step.target}' is not defined. ` +
+                        `Available stores: ${[...definedStores].join(', ') || 'none'}`);
+                }
+            }
+            else if (step.type === 'FetchStep') {
+                // Validate source reference if specified
+                if (step.source && !definedSources.has(step.source)) {
+                    throw this.error(`Source '${step.source}' is not defined. ` +
+                        `Available sources: ${[...definedSources].join(', ') || 'none'}`);
+                }
+                // Validate operationRef source if present
+                if (step.operationRef && !definedSources.has(step.operationRef.source)) {
+                    throw this.error(`Source '${step.operationRef.source}' is not defined. ` +
+                        `Available sources: ${[...definedSources].join(', ') || 'none'}`);
+                }
+            }
+            else if (step.type === 'ForStep') {
+                // Recursively validate nested steps
+                this.validateStepsReferences(step.steps, definedStores, definedSources, definedActions, actionName);
+            }
+            else if (step.type === 'MatchStep') {
+                // Validate steps in match arms
+                for (const arm of step.arms) {
+                    if (arm.steps) {
+                        this.validateStepsReferences(arm.steps, definedStores, definedSources, definedActions, actionName);
+                    }
+                    // Validate jump target in flow directive
+                    if (arm.flow?.type === 'jump' && !definedActions.has(arm.flow.action)) {
+                        throw this.error(`Action '${arm.flow.action}' referenced in jump is not defined. ` +
+                            `Available actions: ${[...definedActions].join(', ') || 'none'}`);
+                    }
+                }
+            }
+        }
+    }
+    /**
+     * Validate that all action references in the pipeline exist
+     */
+    validatePipelineReferences(pipeline, definedActions) {
+        for (const stage of pipeline.stages) {
+            if (stage.action) {
+                if (!definedActions.has(stage.action)) {
+                    throw this.error(`Action '${stage.action}' is not defined. ` +
+                        `Available actions: ${[...definedActions].join(', ') || 'none'}`);
+                }
+            }
+            if (stage.actions) {
+                for (const actionName of stage.actions) {
+                    if (!definedActions.has(actionName)) {
+                        throw this.error(`Action '${actionName}' is not defined. ` +
+                            `Available actions: ${[...definedActions].join(', ') || 'none'}`);
+                    }
+                }
+            }
+        }
+    }
+    // ============================================
+    // Schedule definition
+    // ============================================
+    parseSchedule() {
+        this.consume(ReqonTokenType.SCHEDULE, "Expected 'schedule'");
+        this.consume(TokenType.COLON, "Expected ':'");
+        let scheduleType;
+        let interval;
+        let cronExpression;
+        let runAt;
+        let timezone;
+        let maxConcurrency;
+        let skipIfRunning;
+        let retryOnFailure;
+        // Determine schedule type
+        if (this.check(ReqonTokenType.EVERY)) {
+            // Interval-based: schedule: every 6 hours
+            scheduleType = 'interval';
+            interval = this.parseIntervalSchedule();
+        }
+        else if (this.check(ReqonTokenType.CRON)) {
+            // Cron-based: schedule: cron "0 */6 * * *"
+            scheduleType = 'cron';
+            this.advance(); // consume 'cron'
+            cronExpression = this.consume(TokenType.STRING, 'Expected cron expression string').value;
+        }
+        else if (this.check(ReqonTokenType.AT)) {
+            // One-time: schedule: at "2025-01-20 09:00 UTC"
+            scheduleType = 'once';
+            this.advance(); // consume 'at'
+            runAt = this.consume(TokenType.STRING, 'Expected datetime string').value;
+        }
+        else {
+            throw this.error(`Expected 'every', 'cron', or 'at' for schedule type`);
+        }
+        // Optional configuration block
+        if (this.match(TokenType.LBRACE)) {
+            while (!this.check(TokenType.RBRACE) && !this.isAtEnd()) {
+                // Handle keyword tokens that can appear as option keys
+                let key;
+                if (this.check(ReqonTokenType.RETRY)) {
+                    this.advance();
+                    key = 'retry';
+                }
+                else {
+                    key = this.consume(TokenType.IDENTIFIER, 'Expected schedule option key').value;
+                }
+                this.consume(TokenType.COLON, "Expected ':'");
+                switch (key) {
+                    case 'timezone':
+                        timezone = this.consume(TokenType.STRING, 'Expected timezone string').value;
+                        break;
+                    case 'maxConcurrency':
+                        maxConcurrency = parseInt(this.consume(TokenType.NUMBER, 'Expected number').value, 10);
+                        break;
+                    case 'skipIfRunning':
+                        skipIfRunning = this.match(TokenType.TRUE);
+                        if (!skipIfRunning) {
+                            this.consume(TokenType.FALSE, "Expected 'true' or 'false'");
+                        }
+                        break;
+                    case 'retry':
+                        retryOnFailure = this.parseScheduleRetryConfig();
+                        break;
+                    default:
+                        throw this.error(`Unknown schedule option: ${key}`);
+                }
+                this.match(TokenType.COMMA);
+            }
+            this.consume(TokenType.RBRACE, "Expected '}'");
+        }
+        return {
+            type: 'ScheduleDefinition',
+            scheduleType,
+            interval,
+            cronExpression,
+            runAt,
+            timezone,
+            maxConcurrency,
+            skipIfRunning,
+            retryOnFailure,
+        };
+    }
+    parseIntervalSchedule() {
+        this.consume(ReqonTokenType.EVERY, "Expected 'every'");
+        const value = parseInt(this.consume(TokenType.NUMBER, 'Expected interval value').value, 10);
+        let unit;
+        const unitToken = this.advance();
+        switch (unitToken.type) {
+            case ReqonTokenType.SECONDS:
+                unit = 'seconds';
+                break;
+            case ReqonTokenType.MINUTES:
+                unit = 'minutes';
+                break;
+            case ReqonTokenType.HOURS:
+                unit = 'hours';
+                break;
+            case ReqonTokenType.DAYS:
+                unit = 'days';
+                break;
+            case ReqonTokenType.WEEKS:
+                unit = 'weeks';
+                break;
+            default:
+                throw this.error(`Expected time unit (seconds, minutes, hours, days, weeks), got: ${unitToken.value}`);
+        }
+        return { value, unit };
+    }
+    parseScheduleRetryConfig() {
+        this.consume(TokenType.LBRACE, "Expected '{'");
+        let maxRetries = 3;
+        let delaySeconds = 60;
+        while (!this.check(TokenType.RBRACE) && !this.isAtEnd()) {
+            const key = this.consume(TokenType.IDENTIFIER, 'Expected retry option').value;
+            this.consume(TokenType.COLON, "Expected ':'");
+            switch (key) {
+                case 'maxRetries':
+                    maxRetries = parseInt(this.consume(TokenType.NUMBER, 'Expected number').value, 10);
+                    break;
+                case 'delaySeconds':
+                    delaySeconds = parseInt(this.consume(TokenType.NUMBER, 'Expected number').value, 10);
+                    break;
+                default:
+                    throw this.error(`Unknown retry option: ${key}`);
+            }
+            this.match(TokenType.COMMA);
+        }
+        this.consume(TokenType.RBRACE, "Expected '}'");
+        return { maxRetries, delaySeconds };
+    }
+    // ============================================
+    // Source definition
+    // ============================================
+    parseSource() {
+        this.consume(ReqonTokenType.SOURCE, "Expected 'source'");
+        const name = this.consume(TokenType.IDENTIFIER, 'Expected source name').value;
+        // Check for 'from' clause (OAS spec path)
+        let specPath;
+        if (this.match(ReqonTokenType.FROM)) {
+            specPath = this.consume(TokenType.STRING, 'Expected OAS spec path').value;
+        }
+        this.consume(TokenType.LBRACE, "Expected '{'");
+        const config = this.parseSourceConfig(specPath !== undefined);
+        this.consume(TokenType.RBRACE, "Expected '}'");
+        return { type: 'SourceDefinition', name, specPath, config };
+    }
+    parseSourceConfig(hasOAS = false) {
+        let auth;
+        let base;
+        let validateResponses;
+        let rateLimit;
+        let circuitBreaker;
+        const headers = {};
+        while (!this.check(TokenType.RBRACE) && !this.isAtEnd()) {
+            const key = this.consume(TokenType.IDENTIFIER, 'Expected config key').value;
+            this.consume(TokenType.COLON, "Expected ':'");
+            if (key === 'auth') {
+                auth = this.parseAuthConfig();
+            }
+            else if (key === 'base') {
+                base = this.consume(TokenType.STRING, 'Expected base URL string').value;
+            }
+            else if (key === 'validateResponses') {
+                validateResponses = this.match(TokenType.TRUE);
+                if (!validateResponses) {
+                    this.consume(TokenType.FALSE, "Expected 'true' or 'false'");
+                }
+            }
+            else if (key === 'headers') {
+                this.consume(TokenType.LBRACE, "Expected '{'");
+                while (!this.check(TokenType.RBRACE) && !this.isAtEnd()) {
+                    const headerName = this.consume(TokenType.STRING, 'Expected header name').value;
+                    this.consume(TokenType.COLON, "Expected ':'");
+                    headers[headerName] = this.parseExpression();
+                    this.match(TokenType.COMMA);
+                }
+                this.consume(TokenType.RBRACE, "Expected '}'");
+            }
+            else if (key === 'rateLimit') {
+                rateLimit = this.parseRateLimitConfig();
+            }
+            else if (key === 'circuitBreaker') {
+                circuitBreaker = this.parseCircuitBreakerConfig();
+            }
+            this.match(TokenType.COMMA);
+        }
+        if (!auth)
+            throw this.error('Source must have auth config');
+        // Base URL is only required if not using OAS
+        if (!base && !hasOAS)
+            throw this.error('Source must have base URL (or use OAS spec)');
+        return {
+            auth,
+            base,
+            validateResponses,
+            headers: Object.keys(headers).length > 0 ? headers : undefined,
+            rateLimit,
+            circuitBreaker,
+        };
+    }
+    parseRateLimitConfig() {
+        this.consume(TokenType.LBRACE, "Expected '{'");
+        const config = {};
+        while (!this.check(TokenType.RBRACE) && !this.isAtEnd()) {
+            const key = this.consume(TokenType.IDENTIFIER, 'Expected rate limit option').value;
+            this.consume(TokenType.COLON, "Expected ':'");
+            switch (key) {
+                case 'strategy':
+                    config.strategy = this.consume(TokenType.IDENTIFIER, 'Expected strategy').value;
+                    break;
+                case 'maxWait':
+                    config.maxWait = parseInt(this.consume(TokenType.NUMBER, 'Expected number').value, 10);
+                    break;
+                case 'fallbackRpm':
+                    config.fallbackRpm = parseInt(this.consume(TokenType.NUMBER, 'Expected number').value, 10);
+                    break;
+                default:
+                    throw this.error(`Unknown rate limit option: ${key}`);
+            }
+            this.match(TokenType.COMMA);
+        }
+        this.consume(TokenType.RBRACE, "Expected '}'");
+        return config;
+    }
+    parseCircuitBreakerConfig() {
+        this.consume(TokenType.LBRACE, "Expected '{'");
+        const config = {};
+        while (!this.check(TokenType.RBRACE) && !this.isAtEnd()) {
+            const key = this.consume(TokenType.IDENTIFIER, 'Expected circuit breaker option').value;
+            this.consume(TokenType.COLON, "Expected ':'");
+            switch (key) {
+                case 'failureThreshold':
+                    config.failureThreshold = parseInt(this.consume(TokenType.NUMBER, 'Expected number').value, 10);
+                    break;
+                case 'resetTimeout':
+                    config.resetTimeout = parseInt(this.consume(TokenType.NUMBER, 'Expected number').value, 10);
+                    break;
+                case 'successThreshold':
+                    config.successThreshold = parseInt(this.consume(TokenType.NUMBER, 'Expected number').value, 10);
+                    break;
+                case 'failureWindow':
+                    config.failureWindow = parseInt(this.consume(TokenType.NUMBER, 'Expected number').value, 10);
+                    break;
+                default:
+                    throw this.error(`Unknown circuit breaker option: ${key}`);
+            }
+            this.match(TokenType.COMMA);
+        }
+        this.consume(TokenType.RBRACE, "Expected '}'");
+        return config;
+    }
+    parseAuthConfig() {
+        const typeToken = this.advance();
+        let type;
+        switch (typeToken.type) {
+            case ReqonTokenType.OAUTH2:
+                type = 'oauth2';
+                break;
+            case ReqonTokenType.BEARER:
+                type = 'bearer';
+                break;
+            case ReqonTokenType.BASIC:
+                type = 'basic';
+                break;
+            case ReqonTokenType.API_KEY:
+                type = 'api_key';
+                break;
+            case ReqonTokenType.NONE:
+                type = 'none';
+                break;
+            default:
+                throw this.error(`Unknown auth type: ${typeToken.value}`);
+        }
+        return { type };
+    }
+    // ============================================
+    // Store definition
+    // ============================================
+    parseStoreDefinition() {
+        this.consume(ReqonTokenType.STORE, "Expected 'store'");
+        const name = this.consumeIdentifier('Expected store name').value;
+        this.consume(TokenType.COLON, "Expected ':'");
+        let storeType;
+        const typeToken = this.advance();
+        switch (typeToken.type) {
+            case ReqonTokenType.NOSQL:
+                storeType = 'nosql';
+                break;
+            case ReqonTokenType.SQL:
+                storeType = 'sql';
+                break;
+            case ReqonTokenType.MEMORY:
+                storeType = 'memory';
+                break;
+            default:
+                throw this.error(`Unknown store type: ${typeToken.value}`);
+        }
+        this.consume(TokenType.LPAREN, "Expected '('");
+        const target = this.consume(TokenType.STRING, 'Expected target name').value;
+        this.consume(TokenType.RPAREN, "Expected ')'");
+        return { type: 'StoreDefinition', name, storeType, target };
+    }
+    // ============================================
+    // Action definition
+    // ============================================
+    parseAction() {
+        this.consume(ReqonTokenType.ACTION, "Expected 'action'");
+        const name = this.consume(TokenType.IDENTIFIER, 'Expected action name').value;
+        this.consume(TokenType.LBRACE, "Expected '{'");
+        const steps = [];
+        while (!this.check(TokenType.RBRACE) && !this.isAtEnd()) {
+            steps.push(this.parseActionStep());
+            this.match(TokenType.COMMA);
+        }
+        this.consume(TokenType.RBRACE, "Expected '}'");
+        return { type: 'ActionDefinition', name, steps };
+    }
+    parseActionStep() {
+        if (this.check(ReqonTokenType.CALL))
+            return this.parseCallStep();
+        // Shorthand: get "/path", post "/path", etc.
+        if (this.checkHttpMethod())
+            return this.parseHttpMethodStep();
+        if (this.check(ReqonTokenType.FOR))
+            return this.parseForStep();
+        if (this.check(ReqonTokenType.MAP))
+            return this.parseMapStep();
+        if (this.check(TokenType.VALIDATE))
+            return this.parseValidateStep();
+        if (this.check(ReqonTokenType.STORE))
+            return this.parseStoreStep();
+        if (this.check(TokenType.MATCH))
+            return this.parseMatchStep();
+        if (this.check(TokenType.LET))
+            return this.parseLetStep();
+        if (this.check(ReqonTokenType.WAIT))
+            return this.parseWaitStep();
+        throw this.error(`Expected action step, got: ${this.peek().value}`);
+    }
+    checkHttpMethod() {
+        const t = this.peek().type;
+        return (t === ReqonTokenType.GET ||
+            t === ReqonTokenType.POST ||
+            t === ReqonTokenType.PUT ||
+            t === ReqonTokenType.PATCH ||
+            t === ReqonTokenType.DELETE);
+    }
+    /**
+     * Parse HTTP method syntax: get "/path" { options }
+     */
+    parseHttpMethodStep() {
+        const methodToken = this.advance();
+        let method;
+        switch (methodToken.type) {
+            case ReqonTokenType.GET:
+                method = 'GET';
+                break;
+            case ReqonTokenType.POST:
+                method = 'POST';
+                break;
+            case ReqonTokenType.PUT:
+                method = 'PUT';
+                break;
+            case ReqonTokenType.PATCH:
+                method = 'PATCH';
+                break;
+            case ReqonTokenType.DELETE:
+                method = 'DELETE';
+                break;
+            default:
+                throw this.error(`Unexpected HTTP method token: ${methodToken.value}`);
+        }
+        const path = this.parseExpression();
+        // Parse optional config block (same as parseFetchStep)
+        let source;
+        let body;
+        let headers;
+        let paginate;
+        let until;
+        let retry;
+        let since;
+        if (this.match(TokenType.LBRACE)) {
+            while (!this.check(TokenType.RBRACE) && !this.isAtEnd()) {
+                let key;
+                if (this.check(ReqonTokenType.SOURCE)) {
+                    this.advance();
+                    key = 'source';
+                }
+                else if (this.check(ReqonTokenType.PAGINATE)) {
+                    this.advance();
+                    key = 'paginate';
+                }
+                else if (this.check(ReqonTokenType.UNTIL)) {
+                    this.advance();
+                    key = 'until';
+                }
+                else if (this.check(ReqonTokenType.RETRY)) {
+                    this.advance();
+                    key = 'retry';
+                }
+                else if (this.check(ReqonTokenType.SINCE)) {
+                    this.advance();
+                    key = 'since';
+                }
+                else {
+                    key = this.consume(TokenType.IDENTIFIER, 'Expected option key').value;
+                }
+                this.consume(TokenType.COLON, "Expected ':'");
+                switch (key) {
+                    case 'source':
+                        source = this.consume(TokenType.IDENTIFIER, 'Expected source name').value;
+                        break;
+                    case 'body':
+                        body = this.parseExpression();
+                        break;
+                    case 'paginate':
+                        paginate = this.parsePaginationConfig();
+                        break;
+                    case 'until':
+                        until = this.parseExpression();
+                        break;
+                    case 'retry':
+                        retry = this.parseRetryConfig();
+                        break;
+                    case 'since':
+                        since = this.parseSinceConfig();
+                        break;
+                    default:
+                        throw this.error(`Unknown fetch option: ${key}`);
+                }
+                this.match(TokenType.COMMA);
+            }
+            this.consume(TokenType.RBRACE, "Expected '}'");
+        }
+        return {
+            type: 'FetchStep',
+            method,
+            path,
+            source,
+            body,
+            headers,
+            paginate,
+            until,
+            retry,
+            since,
+        };
+    }
+    // ============================================
+    // Call step (OAS operationId)
+    // ============================================
+    /**
+     * Parse OAS-style call: call Source.operationId { options }
+     * For direct HTTP requests, use: get "/path", post "/path", etc.
+     */
+    parseCallStep() {
+        this.consume(ReqonTokenType.CALL, "Expected 'call'");
+        // OAS-style: call Source.operationId
+        const sourceName = this.consume(TokenType.IDENTIFIER, 'Expected source name').value;
+        this.consume(TokenType.DOT, "Expected '.'");
+        const opId = this.consume(TokenType.IDENTIFIER, 'Expected operationId').value;
+        const operationRef = { source: sourceName, operationId: opId };
+        let source;
+        let body;
+        let headers;
+        let paginate;
+        let until;
+        let retry;
+        let since;
+        if (this.match(TokenType.LBRACE)) {
+            while (!this.check(TokenType.RBRACE) && !this.isAtEnd()) {
+                // Accept keyword tokens as option keys
+                let key;
+                if (this.check(ReqonTokenType.SOURCE)) {
+                    this.advance();
+                    key = 'source';
+                }
+                else if (this.check(ReqonTokenType.PAGINATE)) {
+                    this.advance();
+                    key = 'paginate';
+                }
+                else if (this.check(ReqonTokenType.UNTIL)) {
+                    this.advance();
+                    key = 'until';
+                }
+                else if (this.check(ReqonTokenType.RETRY)) {
+                    this.advance();
+                    key = 'retry';
+                }
+                else if (this.check(ReqonTokenType.SINCE)) {
+                    this.advance();
+                    key = 'since';
+                }
+                else {
+                    key = this.consume(TokenType.IDENTIFIER, 'Expected option key').value;
+                }
+                this.consume(TokenType.COLON, "Expected ':'");
+                switch (key) {
+                    case 'source':
+                        source = this.consume(TokenType.IDENTIFIER, 'Expected source name').value;
+                        break;
+                    case 'body':
+                        body = this.parseExpression();
+                        break;
+                    case 'paginate':
+                        paginate = this.parsePaginationConfig();
+                        break;
+                    case 'until':
+                        until = this.parseExpression();
+                        break;
+                    case 'retry':
+                        retry = this.parseRetryConfig();
+                        break;
+                    case 'since':
+                        since = this.parseSinceConfig();
+                        break;
+                    default:
+                        throw this.error(`Unknown fetch option: ${key}`);
+                }
+                this.match(TokenType.COMMA);
+            }
+            this.consume(TokenType.RBRACE, "Expected '}'");
+        }
+        return {
+            type: 'FetchStep',
+            operationRef,
+            source,
+            body,
+            headers,
+            paginate,
+            until,
+            retry,
+            since,
+        };
+    }
+    parseSinceConfig() {
+        // since: lastSync
+        // since: lastSync("custom-key")
+        // since: lastSync { param: "modified_since", format: "unix" }
+        if (this.check(ReqonTokenType.LAST_SYNC)) {
+            this.advance();
+            let key;
+            let param;
+            let format;
+            let updateFrom;
+            // Check for optional key: lastSync("key")
+            if (this.match(TokenType.LPAREN)) {
+                key = this.consume(TokenType.STRING, 'Expected checkpoint key').value;
+                this.consume(TokenType.RPAREN, "Expected ')'");
+            }
+            // Check for optional config block
+            if (this.match(TokenType.LBRACE)) {
+                while (!this.check(TokenType.RBRACE) && !this.isAtEnd()) {
+                    const optionKey = this.consume(TokenType.IDENTIFIER, 'Expected option key').value;
+                    this.consume(TokenType.COLON, "Expected ':'");
+                    switch (optionKey) {
+                        case 'param':
+                            param = this.consume(TokenType.STRING, 'Expected param name').value;
+                            break;
+                        case 'format':
+                            format = this.consume(TokenType.IDENTIFIER, 'Expected format').value;
+                            break;
+                        case 'updateFrom':
+                            updateFrom = this.consume(TokenType.STRING, 'Expected field path').value;
+                            break;
+                        default:
+                            throw this.error(`Unknown since option: ${optionKey}`);
+                    }
+                    this.match(TokenType.COMMA);
+                }
+                this.consume(TokenType.RBRACE, "Expected '}'");
+            }
+            return {
+                type: 'lastSync',
+                key,
+                param,
+                format,
+                updateFrom,
+            };
+        }
+        // since: <expression> - custom expression for the timestamp
+        const expression = this.parseExpression();
+        return {
+            type: 'expression',
+            expression,
+        };
+    }
+    parsePaginationConfig() {
+        const typeToken = this.advance();
+        let type;
+        switch (typeToken.type) {
+            case ReqonTokenType.OFFSET:
+                type = 'offset';
+                break;
+            case ReqonTokenType.CURSOR:
+                type = 'cursor';
+                break;
+            case ReqonTokenType.PAGE:
+                type = 'page';
+                break;
+            default:
+                throw this.error(`Unknown pagination type: ${typeToken.value}`);
+        }
+        this.consume(TokenType.LPAREN, "Expected '('");
+        // Accept keyword tokens as param names (e.g., 'page', 'offset', 'cursor')
+        let param;
+        if (this.check(ReqonTokenType.PAGE)) {
+            param = this.advance().value;
+        }
+        else if (this.check(ReqonTokenType.OFFSET)) {
+            param = this.advance().value;
+        }
+        else if (this.check(ReqonTokenType.CURSOR)) {
+            param = this.advance().value;
+        }
+        else {
+            param = this.consume(TokenType.IDENTIFIER, 'Expected param name').value;
+        }
+        this.consume(TokenType.COMMA, "Expected ','");
+        const pageSize = parseInt(this.consume(TokenType.NUMBER, 'Expected page size').value, 10);
+        let cursorPath;
+        if (type === 'cursor' && this.match(TokenType.COMMA)) {
+            cursorPath = this.consume(TokenType.STRING, 'Expected cursor path').value;
+        }
+        this.consume(TokenType.RPAREN, "Expected ')'");
+        return { type, param, pageSize, cursorPath };
+    }
+    parseRetryConfig() {
+        this.consume(TokenType.LBRACE, "Expected '{'");
+        let maxAttempts = 3;
+        let backoff = 'exponential';
+        let initialDelay = 1000;
+        let maxDelay;
+        while (!this.check(TokenType.RBRACE) && !this.isAtEnd()) {
+            const key = this.consume(TokenType.IDENTIFIER, 'Expected retry option').value;
+            this.consume(TokenType.COLON, "Expected ':'");
+            switch (key) {
+                case 'maxAttempts':
+                    maxAttempts = parseInt(this.consume(TokenType.NUMBER, 'Expected number').value, 10);
+                    break;
+                case 'backoff':
+                    backoff = this.consume(TokenType.IDENTIFIER, 'Expected backoff type').value;
+                    break;
+                case 'initialDelay':
+                    initialDelay = parseInt(this.consume(TokenType.NUMBER, 'Expected number').value, 10);
+                    break;
+                case 'maxDelay':
+                    maxDelay = parseInt(this.consume(TokenType.NUMBER, 'Expected number').value, 10);
+                    break;
+            }
+            this.match(TokenType.COMMA);
+        }
+        this.consume(TokenType.RBRACE, "Expected '}'");
+        return { maxAttempts, backoff, initialDelay, maxDelay };
+    }
+    // ============================================
+    // For step
+    // ============================================
+    parseForStep() {
+        this.consume(ReqonTokenType.FOR, "Expected 'for'");
+        const variable = this.consumeIdentifier('Expected variable name').value;
+        this.consume(TokenType.IN, "Expected 'in'");
+        const collection = this.parseExpression();
+        let condition;
+        if (this.match(TokenType.WHERE)) {
+            condition = this.parseExpression();
+        }
+        this.consume(TokenType.LBRACE, "Expected '{'");
+        const steps = [];
+        while (!this.check(TokenType.RBRACE) && !this.isAtEnd()) {
+            steps.push(this.parseActionStep());
+            this.match(TokenType.COMMA);
+        }
+        this.consume(TokenType.RBRACE, "Expected '}'");
+        return { type: 'ForStep', variable, collection, condition, steps };
+    }
+    // ============================================
+    // Map step
+    // ============================================
+    parseMapStep() {
+        this.consume(ReqonTokenType.MAP, "Expected 'map'");
+        const source = this.parseExpression();
+        this.consume(TokenType.RIGHT_ARROW, "Expected '->'");
+        const targetSchema = this.consume(TokenType.IDENTIFIER, 'Expected target schema').value;
+        this.consume(TokenType.LBRACE, "Expected '{'");
+        const mappings = [];
+        while (!this.check(TokenType.RBRACE) && !this.isAtEnd()) {
+            const field = this.consumeIdentifier('Expected field name').value;
+            this.consume(TokenType.COLON, "Expected ':'");
+            const expression = this.parseExpression();
+            mappings.push({ field, expression });
+            this.match(TokenType.COMMA);
+        }
+        this.consume(TokenType.RBRACE, "Expected '}'");
+        return { type: 'MapStep', source, targetSchema, mappings };
+    }
+    // ============================================
+    // Validate step
+    // ============================================
+    parseValidateStep() {
+        this.consume(TokenType.VALIDATE, "Expected 'validate'");
+        const target = this.parseExpression();
+        this.consume(TokenType.LBRACE, "Expected '{'");
+        const constraints = [];
+        while (!this.check(TokenType.RBRACE) && !this.isAtEnd()) {
+            this.consume(TokenType.ASSUME, "Expected 'assume'");
+            const condition = this.parseExpression();
+            let message;
+            let severity = 'error';
+            // Optional message and severity could be added here
+            constraints.push({ type: 'ValidationConstraint', condition, message, severity });
+            this.match(TokenType.COMMA);
+        }
+        this.consume(TokenType.RBRACE, "Expected '}'");
+        return { type: 'ValidateStep', target, constraints };
+    }
+    // ============================================
+    // Store step
+    // ============================================
+    parseStoreStep() {
+        this.consume(ReqonTokenType.STORE, "Expected 'store'");
+        // Check for 'each' keyword
+        let isEach = false;
+        if (this.match(ReqonTokenType.EACH)) {
+            isEach = true;
+        }
+        const source = this.parseExpression();
+        this.consume(TokenType.RIGHT_ARROW, "Expected '->'");
+        const target = this.consumeIdentifier('Expected store name').value;
+        const options = {};
+        if (this.match(TokenType.LBRACE)) {
+            while (!this.check(TokenType.RBRACE) && !this.isAtEnd()) {
+                // Accept keyword tokens as option keys
+                let key;
+                if (this.check(ReqonTokenType.KEY)) {
+                    this.advance();
+                    key = 'key';
+                }
+                else if (this.check(ReqonTokenType.PARTIAL)) {
+                    this.advance();
+                    key = 'partial';
+                }
+                else if (this.check(ReqonTokenType.UPSERT)) {
+                    this.advance();
+                    key = 'upsert';
+                }
+                else {
+                    key = this.consume(TokenType.IDENTIFIER, 'Expected option key').value;
+                }
+                this.consume(TokenType.COLON, "Expected ':'");
+                switch (key) {
+                    case 'key':
+                        options.key = this.parseExpression();
+                        break;
+                    case 'partial':
+                        options.partial = this.match(TokenType.TRUE);
+                        if (!options.partial) {
+                            this.consume(TokenType.FALSE, "Expected 'true' or 'false'");
+                        }
+                        break;
+                    case 'upsert':
+                        options.upsert = this.match(TokenType.TRUE);
+                        if (!options.upsert) {
+                            this.consume(TokenType.FALSE, "Expected 'true' or 'false'");
+                        }
+                        break;
+                }
+                this.match(TokenType.COMMA);
+            }
+            this.consume(TokenType.RBRACE, "Expected '}'");
+        }
+        return { type: 'StoreStep', source, target, options };
+    }
+    // ============================================
+    // Match step (schema overloading)
+    // ============================================
+    parseMatchStep() {
+        this.consume(TokenType.MATCH, "Expected 'match'");
+        const target = this.parseExpression();
+        this.consume(TokenType.LBRACE, "Expected '{'");
+        const arms = [];
+        while (!this.check(TokenType.RBRACE) && !this.isAtEnd()) {
+            arms.push(this.parseMatchArm());
+            this.match(TokenType.COMMA);
+        }
+        this.consume(TokenType.RBRACE, "Expected '}'");
+        return { type: 'MatchStep', target, arms };
+    }
+    parseMatchArm() {
+        // Schema name or '_' for wildcard
+        const schema = this.consume(TokenType.IDENTIFIER, 'Expected schema name or _').value;
+        this.consume(TokenType.RIGHT_ARROW, "Expected '->'");
+        // After -> we have either:
+        // 1. A flow directive (continue, skip, abort, retry, queue, jump)
+        // 2. Steps in braces { ... }
+        // 3. A single step (store, fetch, etc.)
+        // Check for flow directives
+        const flow = this.tryParseFlowDirective();
+        if (flow) {
+            return { schema, flow };
+        }
+        // Check for step block
+        if (this.check(TokenType.LBRACE)) {
+            this.advance();
+            const steps = [];
+            while (!this.check(TokenType.RBRACE) && !this.isAtEnd()) {
+                steps.push(this.parseActionStep());
+                this.match(TokenType.COMMA);
+            }
+            this.consume(TokenType.RBRACE, "Expected '}'");
+            return { schema, steps };
+        }
+        // Single step
+        const step = this.parseActionStep();
+        return { schema, steps: [step] };
+    }
+    tryParseFlowDirective() {
+        if (this.match(ReqonTokenType.CONTINUE)) {
+            return { type: 'continue' };
+        }
+        if (this.match(ReqonTokenType.SKIP)) {
+            return { type: 'skip' };
+        }
+        if (this.match(ReqonTokenType.ABORT)) {
+            let message;
+            if (this.check(TokenType.STRING)) {
+                message = this.advance().value;
+            }
+            return { type: 'abort', message };
+        }
+        if (this.match(ReqonTokenType.RETRY)) {
+            let backoff;
+            if (this.check(TokenType.LBRACE)) {
+                backoff = this.parseRetryConfig();
+            }
+            return { type: 'retry', backoff };
+        }
+        if (this.match(ReqonTokenType.QUEUE)) {
+            let target;
+            if (this.check(TokenType.IDENTIFIER)) {
+                target = this.advance().value;
+            }
+            return { type: 'queue', target };
+        }
+        if (this.match(ReqonTokenType.JUMP)) {
+            const action = this.consume(TokenType.IDENTIFIER, 'Expected action name').value;
+            let then;
+            if (this.match(TokenType.THEN)) {
+                if (this.match(ReqonTokenType.RETRY)) {
+                    then = 'retry';
+                }
+                else if (this.match(ReqonTokenType.CONTINUE)) {
+                    then = 'continue';
+                }
+                else {
+                    throw this.error("Expected 'retry' or 'continue' after 'then'");
+                }
+            }
+            return { type: 'jump', action, then };
+        }
+        return undefined;
+    }
+    // ============================================
+    // Let step (variable binding)
+    // ============================================
+    parseLetStep() {
+        this.consume(TokenType.LET, "Expected 'let'");
+        const name = this.consumeIdentifier('Expected variable name').value;
+        this.consume(TokenType.EQUALS, "Expected '='");
+        const value = this.parseExpression();
+        return { type: 'LetStep', name, value };
+    }
+    // ============================================
+    // Wait step (webhook support)
+    // ============================================
+    /**
+     * Parse wait step: wait { timeout: 60000, path: "/webhooks/callback", ... }
+     * Waits for an external webhook callback before continuing execution
+     */
+    parseWaitStep() {
+        this.consume(ReqonTokenType.WAIT, "Expected 'wait'");
+        this.consume(TokenType.LBRACE, "Expected '{'");
+        const step = { type: 'WebhookStep' };
+        while (!this.check(TokenType.RBRACE) && !this.isAtEnd()) {
+            // Accept keyword tokens as option keys
+            let key;
+            if (this.check(ReqonTokenType.TIMEOUT)) {
+                this.advance();
+                key = 'timeout';
+            }
+            else if (this.check(ReqonTokenType.PATH)) {
+                this.advance();
+                key = 'path';
+            }
+            else if (this.check(ReqonTokenType.EXPECTED_EVENTS)) {
+                this.advance();
+                key = 'expectedEvents';
+            }
+            else if (this.check(ReqonTokenType.EVENT_FILTER)) {
+                this.advance();
+                key = 'eventFilter';
+            }
+            else if (this.check(ReqonTokenType.RETRY)) {
+                this.advance();
+                key = 'retry';
+            }
+            else if (this.check(ReqonTokenType.STORAGE)) {
+                this.advance();
+                key = 'storage';
+            }
+            else {
+                key = this.consume(TokenType.IDENTIFIER, 'Expected option key').value;
+            }
+            this.consume(TokenType.COLON, "Expected ':'");
+            switch (key) {
+                case 'timeout':
+                    step.timeout = parseInt(this.consume(TokenType.NUMBER, 'Expected timeout value').value, 10);
+                    break;
+                case 'path':
+                    step.path = this.consume(TokenType.STRING, 'Expected path string').value;
+                    break;
+                case 'expectedEvents':
+                    step.expectedEvents = parseInt(this.consume(TokenType.NUMBER, 'Expected number').value, 10);
+                    break;
+                case 'eventFilter':
+                    step.eventFilter = this.parseExpression();
+                    break;
+                case 'retry':
+                    step.retryOnTimeout = this.parseRetryConfig();
+                    break;
+                case 'storage':
+                    step.storage = this.parseWebhookStorageConfig();
+                    break;
+                default:
+                    throw this.error(`Unknown wait option: ${key}`);
+            }
+            this.match(TokenType.COMMA);
+        }
+        this.consume(TokenType.RBRACE, "Expected '}'");
+        return step;
+    }
+    /**
+     * Parse webhook storage config: { target: store_name, key: .id }
+     */
+    parseWebhookStorageConfig() {
+        this.consume(TokenType.LBRACE, "Expected '{'");
+        let target;
+        let key;
+        while (!this.check(TokenType.RBRACE) && !this.isAtEnd()) {
+            let optionKey;
+            if (this.check(ReqonTokenType.KEY)) {
+                this.advance();
+                optionKey = 'key';
+            }
+            else {
+                optionKey = this.consume(TokenType.IDENTIFIER, 'Expected option key').value;
+            }
+            this.consume(TokenType.COLON, "Expected ':'");
+            switch (optionKey) {
+                case 'target':
+                    target = this.consume(TokenType.IDENTIFIER, 'Expected store name').value;
+                    break;
+                case 'key':
+                    key = this.parseExpression();
+                    break;
+                default:
+                    throw this.error(`Unknown storage option: ${optionKey}`);
+            }
+            this.match(TokenType.COMMA);
+        }
+        this.consume(TokenType.RBRACE, "Expected '}'");
+        if (!target) {
+            throw this.error('Webhook storage must have a target store');
+        }
+        return { target, key };
+    }
+    // ============================================
+    // Pipeline definition
+    // ============================================
+    parsePipeline() {
+        this.consume(ReqonTokenType.RUN, "Expected 'run'");
+        const stages = [];
+        // First stage
+        stages.push(this.parsePipelineStage());
+        // Subsequent stages with 'then'
+        while (this.match(TokenType.THEN)) {
+            stages.push(this.parsePipelineStage());
+        }
+        return { type: 'PipelineDefinition', stages };
+    }
+    parsePipelineStage() {
+        let condition;
+        // Check for parallel stage: [Action1, Action2, ...]
+        if (this.match(TokenType.LBRACKET)) {
+            const actions = [];
+            // First action
+            actions.push(this.consume(TokenType.IDENTIFIER, 'Expected action name').value);
+            // Additional actions separated by commas
+            while (this.match(TokenType.COMMA)) {
+                actions.push(this.consume(TokenType.IDENTIFIER, 'Expected action name').value);
+            }
+            this.consume(TokenType.RBRACKET, "Expected ']'");
+            // Optional 'if' condition
+            if (this.match(TokenType.IF)) {
+                condition = this.parseExpression();
+            }
+            return { actions, condition };
+        }
+        // Single action (sequential)
+        const action = this.consume(TokenType.IDENTIFIER, 'Expected action name').value;
+        // Optional 'if' condition
+        if (this.match(TokenType.IF)) {
+            condition = this.parseExpression();
+        }
+        return { action, condition };
+    }
+    // ============================================
+    // Vague statement parsing (simplified)
+    // ============================================
+    parseSchema() {
+        this.consume(TokenType.SCHEMA, "Expected 'schema'");
+        const name = this.consume(TokenType.IDENTIFIER, 'Expected schema name').value;
+        this.consume(TokenType.LBRACE, "Expected '{'");
+        const fields = [];
+        while (!this.check(TokenType.RBRACE) && !this.isAtEnd()) {
+            fields.push(this.parseFieldDefinition());
+            this.match(TokenType.COMMA);
+        }
+        this.consume(TokenType.RBRACE, "Expected '}'");
+        return {
+            type: 'SchemaDefinition',
+            name,
+            fields,
+        };
+    }
+    parseFieldDefinition() {
+        const name = this.consumeIdentifier('Expected field name').value;
+        this.consume(TokenType.COLON, "Expected ':'");
+        // Simplified field type parsing - just grab the type name for now
+        // Type names are standard types (string, int, etc.) not HTTP methods
+        const typeName = this.consume(TokenType.IDENTIFIER, 'Expected type').value;
+        // Handle optional/nullable type marker (?)
+        this.match(TokenType.QUESTION);
+        return {
+            type: 'FieldDefinition',
+            name,
+            fieldType: { type: 'PrimitiveType', name: typeName },
+        };
+    }
+    parseImport() {
+        this.consume(TokenType.IMPORT, "Expected 'import'");
+        const name = this.consume(TokenType.IDENTIFIER, 'Expected import name').value;
+        this.consume(TokenType.FROM, "Expected 'from'");
+        const path = this.consume(TokenType.STRING, 'Expected import path').value;
+        return { type: 'ImportStatement', name, path };
+    }
+    parseLet() {
+        this.consume(TokenType.LET, "Expected 'let'");
+        const name = this.consumeIdentifier('Expected variable name').value;
+        this.consume(TokenType.EQUALS, "Expected '='");
+        const value = this.parseExpression();
+        return { type: 'LetStatement', name, value };
+    }
+}