reqon-dsl 0.2.0

package/src/parser/parser.ts

@@ -0,0 +1,1469 @@
+import { TokenType, type Expression, type SchemaDefinition, type FieldDefinition, type Token } from 'vague-lang';
+import { ReqonTokenType } from '../lexer/tokens.js';
+import { ReqonExpressionParser } from './expressions.js';
+import type {
+  ReqonProgram,
+  Statement,
+  MissionDefinition,
+  SourceDefinition,
+  SourceConfig,
+  AuthConfig,
+  StoreDefinition,
+  ActionDefinition,
+  ActionStep,
+  FetchStep,
+  ForStep,
+  MapStep,
+  ValidateStep,
+  StoreStep,
+  MatchStep,
+  MatchArm,
+  FlowDirective,
+  LetStep,
+  WebhookStep,
+  WebhookStorageConfig,
+  PaginationConfig,
+  RetryConfig,
+  FieldMapping,
+  ValidationConstraint,
+  StoreOptions,
+  PipelineDefinition,
+  PipelineStage,
+  OperationRef,
+  ScheduleDefinition,
+  IntervalSchedule,
+  ScheduleRetryConfig,
+  SinceConfig,
+  RateLimitSourceConfig,
+  CircuitBreakerSourceConfig,
+} from '../ast/nodes.js';
+
+export class ReqonParser extends ReqonExpressionParser {
+  constructor(tokens: Token[], source?: string, filePath?: string) {
+    super(tokens, source, filePath);
+  }
+
+  parse(): ReqonProgram {
+    const statements: Statement[] = [];
+
+    while (!this.isAtEnd()) {
+      const stmt = this.parseStatement();
+      if (stmt) statements.push(stmt);
+    }
+
+    return { type: 'ReqonProgram', statements };
+  }
+
+  private parseStatement(): Statement | null {
+    // 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
+  // ============================================
+
+  private parseMission(): MissionDefinition {
+    this.consume(ReqonTokenType.MISSION, "Expected 'mission'");
+    const name = this.consume(TokenType.IDENTIFIER, 'Expected mission name').value;
+
+    this.consume(TokenType.LBRACE, "Expected '{'");
+
+    const sources: SourceDefinition[] = [];
+    const stores: StoreDefinition[] = [];
+    const schemas: SchemaDefinition[] = [];
+    const actions: ActionDefinition[] = [];
+    let pipeline: PipelineDefinition | undefined;
+    let schedule: ScheduleDefinition | undefined;
+
+    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
+   */
+  private validateActionReferences(
+    actions: ActionDefinition[],
+    definedStores: Set<string>,
+    definedSources: Set<string>,
+    definedActions: Set<string>
+  ): void {
+    for (const action of actions) {
+      this.validateStepsReferences(
+        action.steps,
+        definedStores,
+        definedSources,
+        definedActions,
+        action.name
+      );
+    }
+  }
+
+  /**
+   * Recursively validate store, source, and action references in action steps
+   */
+  private validateStepsReferences(
+    steps: ActionStep[],
+    definedStores: Set<string>,
+    definedSources: Set<string>,
+    definedActions: Set<string>,
+    actionName: string
+  ): void {
+    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
+   */
+  private validatePipelineReferences(
+    pipeline: PipelineDefinition,
+    definedActions: Set<string>
+  ): void {
+    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
+  // ============================================
+
+  private parseSchedule(): ScheduleDefinition {
+    this.consume(ReqonTokenType.SCHEDULE, "Expected 'schedule'");
+    this.consume(TokenType.COLON, "Expected ':'");
+
+    let scheduleType: ScheduleDefinition['scheduleType'];
+    let interval: IntervalSchedule | undefined;
+    let cronExpression: string | undefined;
+    let runAt: string | undefined;
+    let timezone: string | undefined;
+    let maxConcurrency: number | undefined;
+    let skipIfRunning: boolean | undefined;
+    let retryOnFailure: ScheduleRetryConfig | undefined;
+
+    // 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: string;
+        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,
+    };
+  }
+
+  private parseIntervalSchedule(): IntervalSchedule {
+    this.consume(ReqonTokenType.EVERY, "Expected 'every'");
+    const value = parseInt(this.consume(TokenType.NUMBER, 'Expected interval value').value, 10);
+
+    let unit: IntervalSchedule['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 };
+  }
+
+  private parseScheduleRetryConfig(): ScheduleRetryConfig {
+    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
+  // ============================================
+
+  private parseSource(): SourceDefinition {
+    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: string | undefined;
+    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 };
+  }
+
+  private parseSourceConfig(hasOAS = false): SourceConfig {
+    let auth: AuthConfig | undefined;
+    let base: string | undefined;
+    let validateResponses: boolean | undefined;
+    let rateLimit: RateLimitSourceConfig | undefined;
+    let circuitBreaker: CircuitBreakerSourceConfig | undefined;
+    const headers: Record<string, Expression> = {};
+
+    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,
+    };
+  }
+
+  private parseRateLimitConfig(): RateLimitSourceConfig {
+    this.consume(TokenType.LBRACE, "Expected '{'");
+
+    const config: RateLimitSourceConfig = {};
+
+    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 as 'pause' | 'throttle' | 'fail';
+          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;
+  }
+
+  private parseCircuitBreakerConfig(): CircuitBreakerSourceConfig {
+    this.consume(TokenType.LBRACE, "Expected '{'");
+
+    const config: CircuitBreakerSourceConfig = {};
+
+    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;
+  }
+
+  private parseAuthConfig(): AuthConfig {
+    const typeToken = this.advance();
+    let type: AuthConfig['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
+  // ============================================
+
+  private parseStoreDefinition(): StoreDefinition {
+    this.consume(ReqonTokenType.STORE, "Expected 'store'");
+    const name = this.consumeIdentifier('Expected store name').value;
+    this.consume(TokenType.COLON, "Expected ':'");
+
+    let storeType: StoreDefinition['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
+  // ============================================
+
+  private parseAction(): ActionDefinition {
+    this.consume(ReqonTokenType.ACTION, "Expected 'action'");
+    const name = this.consume(TokenType.IDENTIFIER, 'Expected action name').value;
+
+    this.consume(TokenType.LBRACE, "Expected '{'");
+    const steps: ActionStep[] = [];
+
+    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 };
+  }
+
+  private parseActionStep(): ActionStep {
+    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}`);
+  }
+
+  private checkHttpMethod(): boolean {
+    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 }
+   */
+  private parseHttpMethodStep(): FetchStep {
+    const methodToken = this.advance();
+    let method: FetchStep['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: string | undefined;
+    let body: Expression | undefined;
+    let headers: Record<string, Expression> | undefined;
+    let paginate: PaginationConfig | undefined;
+    let until: Expression | undefined;
+    let retry: RetryConfig | undefined;
+    let since: SinceConfig | undefined;
+
+    if (this.match(TokenType.LBRACE)) {
+      while (!this.check(TokenType.RBRACE) && !this.isAtEnd()) {
+        let key: string;
+        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.
+   */
+  private parseCallStep(): FetchStep {
+    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: OperationRef = { source: sourceName, operationId: opId };
+
+    let source: string | undefined;
+    let body: Expression | undefined;
+    let headers: Record<string, Expression> | undefined;
+    let paginate: PaginationConfig | undefined;
+    let until: Expression | undefined;
+    let retry: RetryConfig | undefined;
+    let since: SinceConfig | undefined;
+
+    if (this.match(TokenType.LBRACE)) {
+      while (!this.check(TokenType.RBRACE) && !this.isAtEnd()) {
+        // Accept keyword tokens as option keys
+        let key: string;
+        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,
+    };
+  }
+
+  private parseSinceConfig(): SinceConfig {
+    // since: lastSync
+    // since: lastSync("custom-key")
+    // since: lastSync { param: "modified_since", format: "unix" }
+
+    if (this.check(ReqonTokenType.LAST_SYNC)) {
+      this.advance();
+
+      let key: string | undefined;
+      let param: string | undefined;
+      let format: SinceConfig['format'];
+      let updateFrom: string | undefined;
+
+      // 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 as SinceConfig['format'];
+              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,
+    };
+  }
+
+  private parsePaginationConfig(): PaginationConfig {
+    const typeToken = this.advance();
+    let type: PaginationConfig['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: string;
+    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: string | undefined;
+    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 };
+  }
+
+  private parseRetryConfig(): RetryConfig {
+    this.consume(TokenType.LBRACE, "Expected '{'");
+
+    let maxAttempts = 3;
+    let backoff: RetryConfig['backoff'] = 'exponential';
+    let initialDelay = 1000;
+    let maxDelay: number | undefined;
+
+    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 as RetryConfig['backoff'];
+          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
+  // ============================================
+
+  private parseForStep(): ForStep {
+    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: Expression | undefined;
+    if (this.match(TokenType.WHERE)) {
+      condition = this.parseExpression();
+    }
+
+    this.consume(TokenType.LBRACE, "Expected '{'");
+    const steps: ActionStep[] = [];
+
+    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
+  // ============================================
+
+  private parseMapStep(): MapStep {
+    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: FieldMapping[] = [];
+
+    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
+  // ============================================
+
+  private parseValidateStep(): ValidateStep {
+    this.consume(TokenType.VALIDATE, "Expected 'validate'");
+    const target = this.parseExpression();
+
+    this.consume(TokenType.LBRACE, "Expected '{'");
+    const constraints: ValidationConstraint[] = [];
+
+    while (!this.check(TokenType.RBRACE) && !this.isAtEnd()) {
+      this.consume(TokenType.ASSUME, "Expected 'assume'");
+      const condition = this.parseExpression();
+
+      let message: string | undefined;
+      let severity: ValidationConstraint['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
+  // ============================================
+
+  private parseStoreStep(): StoreStep {
+    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: StoreOptions = {};
+
+    if (this.match(TokenType.LBRACE)) {
+      while (!this.check(TokenType.RBRACE) && !this.isAtEnd()) {
+        // Accept keyword tokens as option keys
+        let key: string;
+        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)
+  // ============================================
+
+  private parseMatchStep(): MatchStep {
+    this.consume(TokenType.MATCH, "Expected 'match'");
+    const target = this.parseExpression();
+
+    this.consume(TokenType.LBRACE, "Expected '{'");
+    const arms: MatchArm[] = [];
+
+    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 };
+  }
+
+  private parseMatchArm(): MatchArm {
+    // 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: ActionStep[] = [];
+
+      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] };
+  }
+
+  private tryParseFlowDirective(): FlowDirective | undefined {
+    if (this.match(ReqonTokenType.CONTINUE)) {
+      return { type: 'continue' };
+    }
+
+    if (this.match(ReqonTokenType.SKIP)) {
+      return { type: 'skip' };
+    }
+
+    if (this.match(ReqonTokenType.ABORT)) {
+      let message: string | undefined;
+      if (this.check(TokenType.STRING)) {
+        message = this.advance().value;
+      }
+      return { type: 'abort', message };
+    }
+
+    if (this.match(ReqonTokenType.RETRY)) {
+      let backoff: RetryConfig | undefined;
+      if (this.check(TokenType.LBRACE)) {
+        backoff = this.parseRetryConfig();
+      }
+      return { type: 'retry', backoff };
+    }
+
+    if (this.match(ReqonTokenType.QUEUE)) {
+      let target: string | undefined;
+      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: 'retry' | 'continue' | undefined;
+      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)
+  // ============================================
+
+  private parseLetStep(): LetStep {
+    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
+   */
+  private parseWaitStep(): WebhookStep {
+    this.consume(ReqonTokenType.WAIT, "Expected 'wait'");
+    this.consume(TokenType.LBRACE, "Expected '{'");
+
+    const step: WebhookStep = { type: 'WebhookStep' };
+
+    while (!this.check(TokenType.RBRACE) && !this.isAtEnd()) {
+      // Accept keyword tokens as option keys
+      let key: string;
+      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 }
+   */
+  private parseWebhookStorageConfig(): WebhookStorageConfig {
+    this.consume(TokenType.LBRACE, "Expected '{'");
+
+    let target: string | undefined;
+    let key: Expression | undefined;
+
+    while (!this.check(TokenType.RBRACE) && !this.isAtEnd()) {
+      let optionKey: string;
+      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
+  // ============================================
+
+  private parsePipeline(): PipelineDefinition {
+    this.consume(ReqonTokenType.RUN, "Expected 'run'");
+
+    const stages: PipelineStage[] = [];
+
+    // First stage
+    stages.push(this.parsePipelineStage());
+
+    // Subsequent stages with 'then'
+    while (this.match(TokenType.THEN)) {
+      stages.push(this.parsePipelineStage());
+    }
+
+    return { type: 'PipelineDefinition', stages };
+  }
+
+  private parsePipelineStage(): PipelineStage {
+    let condition: Expression | undefined;
+
+    // Check for parallel stage: [Action1, Action2, ...]
+    if (this.match(TokenType.LBRACKET)) {
+      const actions: string[] = [];
+
+      // 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)
+  // ============================================
+
+  private parseSchema(): SchemaDefinition {
+    this.consume(TokenType.SCHEMA, "Expected 'schema'");
+    const name = this.consume(TokenType.IDENTIFIER, 'Expected schema name').value;
+
+    this.consume(TokenType.LBRACE, "Expected '{'");
+    const fields: FieldDefinition[] = [];
+
+    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,
+    };
+  }
+
+  private parseFieldDefinition(): FieldDefinition {
+    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 as 'string' | 'int' | 'decimal' | 'date' | 'boolean' },
+    };
+  }
+
+  private parseImport(): Statement {
+    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 };
+  }
+
+  private parseLet(): Statement {
+    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 };
+  }
+}