reqon-dsl 0.2.0 → 0.4.0

package/dist/parser/expressions.d.ts

@@ -5,10 +5,23 @@ export interface IsExpression {
     operand: Expression;
     typeCheck: string;
 }
+export interface ObjectLiteralExpression {
+    type: 'ObjectLiteral';
+    properties: ObjectProperty[];
+}
+export interface ObjectProperty {
+    key: string;
+    value: Expression;
+}
 export declare class ReqonExpressionParser extends ReqonParserBase {
+    private expressionDepth;
     parseExpression(): Expression;
     parseLogicalExpression(): Expression;
     private parseTernary;
+    private parseTernaryBranch;
+    private parseTernaryBranchOr;
+    private parseTernaryBranchAnd;
+    private parseTernaryBranchNot;
     private parseOr;
     private parseAnd;
     private parseNot;
@@ -23,5 +36,6 @@ export declare class ReqonExpressionParser extends ReqonParserBase {
     parsePrimary(): Expression;
     private parseMatchExpression;
     private parseOrderedSequence;
+    private parseObjectLiteral;
     parseQualifiedName(): QualifiedName;
 }

package/dist/parser/expressions.js

@@ -1,9 +1,22 @@
 import { TokenType } from 'vague-lang';
 import { ReqonTokenType } from '../lexer/tokens.js';
 import { ReqonParserBase } from './base.js';
+// Guards unbounded recursive descent from blowing the JS stack on deeply nested
+// input, surfacing a structured ParseError instead of a raw V8 RangeError.
+const MAX_EXPRESSION_DEPTH = 200;
 export class ReqonExpressionParser extends ReqonParserBase {
+    expressionDepth = 0;
     parseExpression() {
-        return this.parseTernary();
+        if (++this.expressionDepth > MAX_EXPRESSION_DEPTH) {
+            this.expressionDepth--;
+            throw this.error('Expression nesting too deep (maximum depth 200 exceeded)');
+        }
+        try {
+            return this.parseTernary();
+        }
+        finally {
+            this.expressionDepth--;
+        }
     }
     parseLogicalExpression() {
         return this.parseOr();
@@ -11,9 +24,9 @@ export class ReqonExpressionParser extends ReqonParserBase {
     parseTernary() {
         const condition = this.parseOr();
         if (this.match(TokenType.QUESTION)) {
-            const consequent = this.parseTernary();
+            const consequent = this.parseTernaryBranch();
             this.consume(TokenType.COLON, "Expected ':' in ternary expression");
-            const alternate = this.parseTernary();
+            const alternate = this.parseTernaryBranch();
             return {
                 type: 'TernaryExpression',
                 condition,
@@ -23,6 +36,46 @@ export class ReqonExpressionParser extends ReqonParserBase {
         }
         return condition;
     }
+    // Parse a ternary branch - allows nested ternaries but skips superposition
+    parseTernaryBranch() {
+        const expr = this.parseTernaryBranchOr();
+        if (this.match(TokenType.QUESTION)) {
+            const consequent = this.parseTernaryBranch();
+            this.consume(TokenType.COLON, "Expected ':' in ternary expression");
+            const alternate = this.parseTernaryBranch();
+            return {
+                type: 'TernaryExpression',
+                condition: expr,
+                consequent,
+                alternate,
+            };
+        }
+        return expr;
+    }
+    parseTernaryBranchOr() {
+        let left = this.parseTernaryBranchAnd();
+        while (this.match(TokenType.OR)) {
+            const right = this.parseTernaryBranchAnd();
+            left = { type: 'LogicalExpression', operator: 'or', left, right };
+        }
+        return left;
+    }
+    parseTernaryBranchAnd() {
+        let left = this.parseTernaryBranchNot();
+        while (this.match(TokenType.AND)) {
+            const right = this.parseTernaryBranchNot();
+            left = { type: 'LogicalExpression', operator: 'and', left, right };
+        }
+        return left;
+    }
+    parseTernaryBranchNot() {
+        if (this.match(TokenType.NOT)) {
+            const operand = this.parseTernaryBranchNot();
+            return { type: 'NotExpression', operand };
+        }
+        // Skip superposition, go directly to comparison
+        return this.parseComparison();
+    }
     parseOr() {
         let left = this.parseAnd();
         while (this.match(TokenType.OR)) {
@@ -78,7 +131,7 @@ export class ReqonExpressionParser extends ReqonParserBase {
         // Check for 'is' type checking: expr is array, expr is string, etc.
         if (this.check(ReqonTokenType.IS)) {
             this.advance(); // consume 'is'
-            const typeCheck = this.consume(TokenType.IDENTIFIER, "Expected type name after 'is'").value;
+            const typeCheck = this.consumeName("Expected type name after 'is'").value;
             return { type: 'IsExpression', operand: left, typeCheck };
         }
         return left;
@@ -140,7 +193,7 @@ export class ReqonExpressionParser extends ReqonParserBase {
                 }
             }
             else if (this.match(TokenType.DOT)) {
-                const name = this.consume(TokenType.IDENTIFIER, 'Expected property name').value;
+                const name = this.consumeName('Expected property name').value;
                 if (expr.type === 'Identifier') {
                     expr = { type: 'QualifiedName', parts: [expr.name, name] };
                 }
@@ -200,6 +253,10 @@ export class ReqonExpressionParser extends ReqonParserBase {
         if (this.match(TokenType.FALSE)) {
             return { type: 'Literal', value: false, dataType: 'boolean' };
         }
+        // Object literal: { key: value, ... }
+        if (this.match(TokenType.LBRACE)) {
+            return this.parseObjectLiteral();
+        }
         // Identifier (including HTTP method tokens that can be used as identifiers)
         if (this.checkIdentifier()) {
             const name = this.advance().value;
@@ -207,7 +264,7 @@ export class ReqonExpressionParser extends ReqonParserBase {
         }
         // .field shorthand
         if (this.match(TokenType.DOT)) {
-            const name = this.consumeIdentifier("Expected field name after '.'").value;
+            const name = this.consumeName("Expected field name after '.'").value;
             return { type: 'Identifier', name };
         }
         throw this.error(`Unexpected token: ${this.peek().value}`);
@@ -237,6 +294,32 @@ export class ReqonExpressionParser extends ReqonParserBase {
         this.consume(TokenType.RBRACKET, "Expected ']'");
         return { type: 'OrderedSequenceType', elements };
     }
+    parseObjectLiteral() {
+        const properties = [];
+        // Handle empty object {}
+        if (this.check(TokenType.RBRACE)) {
+            this.advance();
+            return { type: 'ObjectLiteral', properties };
+        }
+        do {
+            // Key can be an identifier or a string
+            let key;
+            if (this.check(TokenType.STRING)) {
+                key = this.advance().value;
+            }
+            else if (this.checkIdentifier()) {
+                key = this.advance().value;
+            }
+            else {
+                throw this.error('Expected property key (identifier or string)');
+            }
+            this.consume(TokenType.COLON, "Expected ':' after property key");
+            const value = this.parseExpression();
+            properties.push({ key, value });
+        } while (this.match(TokenType.COMMA) && !this.check(TokenType.RBRACE));
+        this.consume(TokenType.RBRACE, "Expected '}'");
+        return { type: 'ObjectLiteral', properties };
+    }
     parseQualifiedName() {
         const parts = [];
         parts.push(this.consume(TokenType.IDENTIFIER, 'Expected identifier').value);

package/dist/parser/fetch-parser.d.ts

@@ -0,0 +1,27 @@
+import type { FetchStep, PaginationConfig, RetryConfig, SinceConfig } from '../ast/nodes.js';
+import { ScheduleParser } from './schedule-parser.js';
+export declare class FetchParser extends ScheduleParser {
+    /**
+     * Check if current token is an HTTP method keyword
+     */
+    protected checkHttpMethod(): boolean;
+    /**
+     * Parse HTTP method syntax: get "/path" { options }
+     */
+    protected parseHttpMethodStep(): FetchStep;
+    /**
+     * Parse OAS-style call: call Source.operationId { options }
+     */
+    protected parseCallStep(): FetchStep;
+    /**
+     * Parse fetch options block (shared between HTTP methods and call)
+     */
+    protected parseFetchOptions(): Partial<FetchStep>;
+    /**
+     * Parse a fetch option key, handling keyword tokens that can appear as keys
+     */
+    private parseFetchOptionKey;
+    protected parseSinceConfig(): SinceConfig;
+    protected parsePaginationConfig(): PaginationConfig;
+    protected parseRetryConfig(): RetryConfig;
+}

package/dist/parser/fetch-parser.js

@@ -0,0 +1,280 @@
+/**
+ * Fetch step parsing
+ * Handles parsing of HTTP fetch steps (get, post, put, patch, delete, call).
+ */
+import { TokenType } from 'vague-lang';
+import { ReqonTokenType } from '../lexer/tokens.js';
+import { ScheduleParser } from './schedule-parser.js';
+export class FetchParser extends ScheduleParser {
+    /**
+     * Check if current token is an HTTP method keyword
+     */
+    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
+        const options = this.parseFetchOptions();
+        return {
+            type: 'FetchStep',
+            method,
+            path,
+            ...options,
+        };
+    }
+    /**
+     * Parse OAS-style call: call Source.operationId { options }
+     */
+    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 };
+        const options = this.parseFetchOptions();
+        return {
+            type: 'FetchStep',
+            operationRef,
+            ...options,
+        };
+    }
+    /**
+     * Parse fetch options block (shared between HTTP methods and call)
+     */
+    parseFetchOptions() {
+        let source;
+        let body;
+        let headers;
+        let paginate;
+        let until;
+        let retry;
+        let since;
+        let backfill;
+        if (this.match(TokenType.LBRACE)) {
+            while (!this.check(TokenType.RBRACE) && !this.isAtEnd()) {
+                const key = this.parseFetchOptionKey();
+                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;
+                    case 'backfill':
+                        backfill = this.match(TokenType.TRUE);
+                        if (!backfill) {
+                            this.consume(TokenType.FALSE, "Expected 'true' or 'false'");
+                        }
+                        break;
+                    default:
+                        throw this.error(`Unknown fetch option: ${key}`);
+                }
+                this.match(TokenType.COMMA);
+            }
+            this.consume(TokenType.RBRACE, "Expected '}'");
+        }
+        return { source, body, headers, paginate, until, retry, since, backfill };
+    }
+    /**
+     * Parse a fetch option key, handling keyword tokens that can appear as keys
+     */
+    parseFetchOptionKey() {
+        if (this.check(ReqonTokenType.SOURCE)) {
+            this.advance();
+            return 'source';
+        }
+        else if (this.check(ReqonTokenType.PAGINATE)) {
+            this.advance();
+            return 'paginate';
+        }
+        else if (this.check(ReqonTokenType.UNTIL)) {
+            this.advance();
+            return 'until';
+        }
+        else if (this.check(ReqonTokenType.RETRY)) {
+            this.advance();
+            return 'retry';
+        }
+        else if (this.check(ReqonTokenType.SINCE)) {
+            this.advance();
+            return 'since';
+        }
+        return this.consume(TokenType.IDENTIFIER, 'Expected option key').value;
+    }
+    parseSinceConfig() {
+        // since: lastSync
+        // since: lastSync("custom-key")
+        // since: lastSync { param: "modified_since", format: "unix" }
+        // since: lastSync { header: "If-Modified-Since" }
+        if (this.check(ReqonTokenType.LAST_SYNC)) {
+            this.advance();
+            let key;
+            let param;
+            let header;
+            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 'header':
+                            header = this.consume(TokenType.STRING, 'Expected header 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,
+                header,
+                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;
+        let timeout;
+        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;
+                case 'timeout':
+                    timeout = parseInt(this.consume(TokenType.NUMBER, 'Expected number').value, 10);
+                    break;
+            }
+            this.match(TokenType.COMMA);
+        }
+        this.consume(TokenType.RBRACE, "Expected '}'");
+        return { maxAttempts, backoff, initialDelay, maxDelay, timeout };
+    }
+}

package/dist/parser/index.d.ts

@@ -1,3 +1,20 @@
+/**
+ * ---
+ * purpose: Parser module exports - inheritance chain of specialized parsers
+ * note: Parser classes form inheritance chain (Base -> Expression -> Source -> Schedule -> Fetch -> Action -> Pipeline -> ReqonParser)
+ * exports:
+ *   - ReqonParser - top-level parser for .vague files
+ * related:
+ *   - ./parser.ts - ReqonParser implementation
+ *   - ./base.ts - token manipulation utilities
+ *   - ../lexer/index.ts - tokenization
+ * ---
+ */
 export { ReqonParser } from './parser.js';
 export { ReqonExpressionParser } from './expressions.js';
 export { ReqonParserBase } from './base.js';
+export { SourceParser } from './source-parser.js';
+export { ScheduleParser } from './schedule-parser.js';
+export { FetchParser } from './fetch-parser.js';
+export { ActionParser } from './action-parser.js';
+export { PipelineParser } from './pipeline-parser.js';

package/dist/parser/index.js

@@ -1,3 +1,20 @@
+/**
+ * ---
+ * purpose: Parser module exports - inheritance chain of specialized parsers
+ * note: Parser classes form inheritance chain (Base -> Expression -> Source -> Schedule -> Fetch -> Action -> Pipeline -> ReqonParser)
+ * exports:
+ *   - ReqonParser - top-level parser for .vague files
+ * related:
+ *   - ./parser.ts - ReqonParser implementation
+ *   - ./base.ts - token manipulation utilities
+ *   - ../lexer/index.ts - tokenization
+ * ---
+ */
 export { ReqonParser } from './parser.js';
 export { ReqonExpressionParser } from './expressions.js';
 export { ReqonParserBase } from './base.js';
+export { SourceParser } from './source-parser.js';
+export { ScheduleParser } from './schedule-parser.js';
+export { FetchParser } from './fetch-parser.js';
+export { ActionParser } from './action-parser.js';
+export { PipelineParser } from './pipeline-parser.js';

package/dist/parser/parser.d.ts

@@ -1,68 +1,66 @@
+/**
+ * ---
+ * purpose: Top-level parser - combines all domain-specific parser modules
+ * inputs:
+ *   - Token[] from lexer
+ *   - source string for error messages
+ * outputs:
+ *   - ReqonProgram AST
+ * related:
+ *   - ./pipeline-parser.ts - parent class (pipeline stage parsing)
+ *   - ./action-parser.ts - action/step parsing
+ *   - ./fetch-parser.ts - HTTP fetch parsing
+ *   - ../ast/nodes.ts - AST node types
+ * ---
+ */
 import { type Token } from 'vague-lang';
-import { ReqonExpressionParser } from './expressions.js';
-import type { ReqonProgram } from '../ast/nodes.js';
-export declare class ReqonParser extends ReqonExpressionParser {
+import type { ReqonProgram, PipelineDefinition } from '../ast/nodes.js';
+import { PipelineParser } from './pipeline-parser.js';
+export declare class ReqonParser extends PipelineParser {
     constructor(tokens: Token[], source?: string, filePath?: string);
+    /**
+     * Parse a complete Reqon program
+     */
     parse(): ReqonProgram;
+    /**
+     * Parse a top-level statement
+     */
     private parseStatement;
+    /**
+     * Parse a mission definition
+     */
     private parseMission;
     /**
-     * Validate that all store, source, and action references in actions exist
+     * Parse checkpoint configuration: checkpoint: afterStep | onFailure
      */
-    private validateActionReferences;
+    private parseCheckpointConfig;
     /**
-     * Recursively validate store, source, and action references in action steps
+     * Parse trace configuration: trace: full | minimal
      */
-    private validateStepsReferences;
+    private parseTraceConfig;
     /**
-     * Validate that all action references in the pipeline exist
+     * Validate that all store, source, action, and transform references in actions exist
      */
-    private validatePipelineReferences;
-    private parseSchedule;
-    private parseIntervalSchedule;
-    private parseScheduleRetryConfig;
-    private parseSource;
-    private parseSourceConfig;
-    private parseRateLimitConfig;
-    private parseCircuitBreakerConfig;
-    private parseAuthConfig;
-    private parseStoreDefinition;
-    private parseAction;
-    private parseActionStep;
-    private checkHttpMethod;
+    private validateActionReferences;
     /**
-     * Parse HTTP method syntax: get "/path" { options }
+     * Recursively validate store, source, action, and transform references in action steps
      */
-    private parseHttpMethodStep;
+    private validateStepsReferences;
     /**
-     * Parse OAS-style call: call Source.operationId { options }
-     * For direct HTTP requests, use: get "/path", post "/path", etc.
+     * Validate references in a single step
      */
-    private parseCallStep;
-    private parseSinceConfig;
-    private parsePaginationConfig;
-    private parseRetryConfig;
-    private parseForStep;
-    private parseMapStep;
-    private parseValidateStep;
-    private parseStoreStep;
-    private parseMatchStep;
-    private parseMatchArm;
-    private tryParseFlowDirective;
-    private parseLetStep;
+    private validateStepReferences;
     /**
-     * Parse wait step: wait { timeout: 60000, path: "/webhooks/callback", ... }
-     * Waits for an external webhook callback before continuing execution
+     * Validate that all action references in the pipeline exist
+     * Note: This is called by the loader after action merging
      */
-    private parseWaitStep;
+    validatePipelineReferences(pipeline: PipelineDefinition, definedActions: Set<string>): void;
     /**
-     * Parse webhook storage config: { target: store_name, key: .id }
+     * Parse an import statement
      */
-    private parseWebhookStorageConfig;
-    private parsePipeline;
-    private parsePipelineStage;
-    private parseSchema;
-    private parseFieldDefinition;
     private parseImport;
+    /**
+     * Parse a let statement
+     */
     private parseLet;
 }