reqon-dsl 0.2.0 → 0.4.0

package/dist/parser/action-parser.js

@@ -0,0 +1,645 @@
+/**
+ * Action and step parsing
+ * Handles parsing of action definitions and all step types.
+ */
+import { TokenType, } from 'vague-lang';
+import { ReqonTokenType } from '../lexer/tokens.js';
+import { FetchParser } from './fetch-parser.js';
+export class ActionParser extends FetchParser {
+    /**
+     * Parse a 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;
+            case ReqonTokenType.FILE:
+                storeType = 'file';
+                break;
+            case ReqonTokenType.POSTGREST:
+                storeType = 'postgrest';
+                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 };
+    }
+    /**
+     * Parse an 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 };
+    }
+    /**
+     * Parse a single action step
+     */
+    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(ReqonTokenType.APPLY))
+            return this.parseApplyStep();
+        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();
+        if (this.check(ReqonTokenType.PAUSE))
+            return this.parsePauseStep();
+        throw this.error(`Expected action step, got: ${this.peek().value}`);
+    }
+    /**
+     * Parse a for loop 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 };
+    }
+    /**
+     * Parse a 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.consumeName('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 };
+    }
+    /**
+     * Parse a transform definition
+     */
+    parseTransform() {
+        this.consume(ReqonTokenType.TRANSFORM, "Expected 'transform'");
+        const name = this.consume(TokenType.IDENTIFIER, 'Expected transform name').value;
+        const variants = [];
+        // Check for simple syntax: transform Name: Source -> Target { ... }
+        // or: transform Name -> Target { ... }
+        if (this.match(TokenType.COLON)) {
+            // Simple syntax with explicit source schema
+            const sourceSchema = this.consume(TokenType.IDENTIFIER, 'Expected source schema').value;
+            this.consume(TokenType.RIGHT_ARROW, "Expected '->'");
+            const targetSchema = this.consume(TokenType.IDENTIFIER, 'Expected target schema').value;
+            const mappings = this.parseFieldMappings();
+            variants.push({ sourceSchema, targetSchema, mappings });
+        }
+        else if (this.match(TokenType.RIGHT_ARROW)) {
+            // Simple syntax without explicit source (inferred at runtime)
+            const targetSchema = this.consume(TokenType.IDENTIFIER, 'Expected target schema').value;
+            const mappings = this.parseFieldMappings();
+            variants.push({ sourceSchema: '_', targetSchema, mappings });
+        }
+        else {
+            // Overloaded syntax: multiple variants
+            this.consume(TokenType.LBRACE, "Expected '{' for transform variants");
+            while (!this.check(TokenType.RBRACE) && !this.isAtEnd()) {
+                const variant = this.parseTransformVariant();
+                variants.push(variant);
+                this.match(TokenType.COMMA);
+            }
+            this.consume(TokenType.RBRACE, "Expected '}'");
+        }
+        if (variants.length === 0) {
+            throw this.error('Transform must have at least one variant');
+        }
+        // Validate: all variants must have the same target schema
+        const targetSchemas = new Set(variants.map((v) => v.targetSchema));
+        if (targetSchemas.size > 1) {
+            throw this.error(`All transform variants must have the same target schema. Found: ${[...targetSchemas].join(', ')}`);
+        }
+        return { type: 'TransformDefinition', name, variants };
+    }
+    /**
+     * Parse a single transform variant
+     */
+    parseTransformVariant() {
+        this.consume(TokenType.LPAREN, "Expected '(' for variant source schema");
+        // Source schema: identifier or '_' for wildcard
+        let sourceSchema;
+        if (this.check(TokenType.IDENTIFIER)) {
+            sourceSchema = this.advance().value;
+        }
+        else if (this.peek().value === '_') {
+            this.advance();
+            sourceSchema = '_';
+        }
+        else {
+            throw this.error('Expected schema name or _ for wildcard');
+        }
+        this.consume(TokenType.RPAREN, "Expected ')'");
+        // Optional guard condition: where condition
+        let guard;
+        if (this.match(TokenType.WHERE)) {
+            guard = this.parseExpression();
+        }
+        this.consume(TokenType.RIGHT_ARROW, "Expected '->'");
+        const targetSchema = this.consume(TokenType.IDENTIFIER, 'Expected target schema').value;
+        const mappings = this.parseFieldMappings();
+        return { sourceSchema, targetSchema, guard, mappings };
+    }
+    /**
+     * Parse field mappings: { field: expression, ... }
+     */
+    parseFieldMappings() {
+        this.consume(TokenType.LBRACE, "Expected '{'");
+        const mappings = [];
+        while (!this.check(TokenType.RBRACE) && !this.isAtEnd()) {
+            const field = this.consumeName('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 mappings;
+    }
+    /**
+     * Parse apply step: apply TransformName to expression [as variableName]
+     */
+    parseApplyStep() {
+        this.consume(ReqonTokenType.APPLY, "Expected 'apply'");
+        const transform = this.consume(TokenType.IDENTIFIER, 'Expected transform name').value;
+        this.consume(ReqonTokenType.TO, "Expected 'to'");
+        const source = this.parseExpression();
+        // Optional: as variableName
+        let as;
+        if (this.match(ReqonTokenType.AS)) {
+            as = this.consume(TokenType.IDENTIFIER, 'Expected variable name').value;
+        }
+        return { type: 'ApplyStep', transform, source, as };
+    }
+    /**
+     * Parse 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;
+            const severity = 'error';
+            constraints.push({ type: 'ValidationConstraint', condition, message, severity });
+            this.match(TokenType.COMMA);
+        }
+        this.consume(TokenType.RBRACE, "Expected '}'");
+        return { type: 'ValidateStep', target, constraints };
+    }
+    /**
+     * Parse store step
+     */
+    parseStoreStep() {
+        this.consume(ReqonTokenType.STORE, "Expected 'store'");
+        // Check for 'each' keyword (consume but not used yet - reserved for future)
+        this.match(ReqonTokenType.EACH);
+        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()) {
+                const key = this.parseStoreOptionKey();
+                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 };
+    }
+    /**
+     * Parse a store option key, handling keyword tokens
+     */
+    parseStoreOptionKey() {
+        if (this.check(ReqonTokenType.KEY)) {
+            this.advance();
+            return 'key';
+        }
+        else if (this.check(ReqonTokenType.PARTIAL)) {
+            this.advance();
+            return 'partial';
+        }
+        else if (this.check(ReqonTokenType.UPSERT)) {
+            this.advance();
+            return 'upsert';
+        }
+        return this.consume(TokenType.IDENTIFIER, 'Expected option key').value;
+    }
+    /**
+     * Parse 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 };
+    }
+    /**
+     * Parse a match arm
+     */
+    parseMatchArm() {
+        // Schema name or '_' for wildcard
+        const schema = this.consume(TokenType.IDENTIFIER, 'Expected schema name or _').value;
+        // Optional guard condition: _ where <condition>
+        let guard;
+        if (this.match(TokenType.WHERE)) {
+            guard = this.parseExpression();
+        }
+        this.consume(TokenType.RIGHT_ARROW, "Expected '->'");
+        // Check for flow directives
+        const flow = this.tryParseFlowDirective();
+        if (flow) {
+            return { schema, guard, 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, guard, steps };
+        }
+        // Single step
+        const step = this.parseActionStep();
+        return { schema, guard, steps: [step] };
+    }
+    /**
+     * Try to parse a flow directive
+     */
+    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;
+    }
+    /**
+     * Parse 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 };
+    }
+    /**
+     * Parse wait step (webhook support)
+     */
+    parseWaitStep() {
+        this.consume(ReqonTokenType.WAIT, "Expected 'wait'");
+        this.consume(TokenType.LBRACE, "Expected '{'");
+        const step = { type: 'WebhookStep' };
+        while (!this.check(TokenType.RBRACE) && !this.isAtEnd()) {
+            const key = this.parseWaitOptionKey();
+            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 a wait option key, handling keyword tokens
+     */
+    parseWaitOptionKey() {
+        if (this.check(ReqonTokenType.TIMEOUT)) {
+            this.advance();
+            return 'timeout';
+        }
+        else if (this.check(ReqonTokenType.PATH)) {
+            this.advance();
+            return 'path';
+        }
+        else if (this.check(ReqonTokenType.EXPECTED_EVENTS)) {
+            this.advance();
+            return 'expectedEvents';
+        }
+        else if (this.check(ReqonTokenType.EVENT_FILTER)) {
+            this.advance();
+            return 'eventFilter';
+        }
+        else if (this.check(ReqonTokenType.RETRY)) {
+            this.advance();
+            return 'retry';
+        }
+        else if (this.check(ReqonTokenType.STORAGE)) {
+            this.advance();
+            return 'storage';
+        }
+        return this.consume(TokenType.IDENTIFIER, 'Expected option key').value;
+    }
+    /**
+     * Parse webhook storage config
+     */
+    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 };
+    }
+    /**
+     * Parse pause step: pause { duration: "7d", persist: FileStore, resume-on: timeout | webhook "/path" }
+     */
+    parsePauseStep() {
+        this.consume(ReqonTokenType.PAUSE, "Expected 'pause'");
+        this.consume(TokenType.LBRACE, "Expected '{'");
+        let duration;
+        let persist;
+        let resumeOn;
+        while (!this.check(TokenType.RBRACE) && !this.isAtEnd()) {
+            const key = this.parsePauseOptionKey();
+            this.consume(TokenType.COLON, "Expected ':'");
+            switch (key) {
+                case 'duration':
+                    if (this.check(TokenType.STRING)) {
+                        duration = this.advance().value;
+                    }
+                    else if (this.check(TokenType.NUMBER)) {
+                        duration = parseInt(this.advance().value, 10);
+                    }
+                    else {
+                        throw this.error('Expected duration string or number');
+                    }
+                    break;
+                case 'persist':
+                    persist = this.consume(TokenType.IDENTIFIER, 'Expected store name').value;
+                    break;
+                case 'resumeOn':
+                    resumeOn = this.parsePauseResumeTriggers();
+                    break;
+                default:
+                    throw this.error(`Unknown pause option: ${key}`);
+            }
+            this.match(TokenType.COMMA);
+        }
+        this.consume(TokenType.RBRACE, "Expected '}'");
+        if (duration === undefined) {
+            throw this.error('Pause step requires a duration');
+        }
+        return { type: 'PauseStep', duration, persist, resumeOn };
+    }
+    /**
+     * Parse pause option key, handling keyword tokens
+     */
+    parsePauseOptionKey() {
+        if (this.check(ReqonTokenType.DURATION)) {
+            this.advance();
+            return 'duration';
+        }
+        else if (this.check(ReqonTokenType.PERSIST)) {
+            this.advance();
+            return 'persist';
+        }
+        else if (this.check(ReqonTokenType.RESUME_ON)) {
+            this.advance();
+            return 'resumeOn';
+        }
+        return this.consume(TokenType.IDENTIFIER, 'Expected option key').value;
+    }
+    /**
+     * Parse pause resume triggers: timeout | webhook "/path"
+     */
+    parsePauseResumeTriggers() {
+        const triggers = [];
+        do {
+            if (this.check(ReqonTokenType.TIMEOUT)) {
+                this.advance();
+                triggers.push({ type: 'timeout' });
+            }
+            else if (this.check(ReqonTokenType.WAIT)) {
+                // 'wait' keyword for webhook trigger (reusing wait keyword)
+                this.advance();
+                const path = this.consume(TokenType.STRING, 'Expected webhook path').value;
+                let eventFilter;
+                if (this.match(TokenType.WHERE)) {
+                    eventFilter = this.parseExpression();
+                }
+                triggers.push({ type: 'webhook', path, eventFilter });
+            }
+            else if (this.peek().value === 'webhook') {
+                // Allow 'webhook' as an identifier too
+                this.advance();
+                const path = this.consume(TokenType.STRING, 'Expected webhook path').value;
+                let eventFilter;
+                if (this.match(TokenType.WHERE)) {
+                    eventFilter = this.parseExpression();
+                }
+                triggers.push({ type: 'webhook', path, eventFilter });
+            }
+            else {
+                throw this.error('Expected timeout or webhook trigger');
+            }
+        } while (this.match(TokenType.PIPE)); // Allow: timeout | webhook "/path"
+        return triggers;
+    }
+    /**
+     * Parse a schema definition
+     */
+    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,
+        };
+    }
+    /**
+     * Parse a field definition
+     */
+    parseFieldDefinition() {
+        const name = this.consumeIdentifier('Expected field name').value;
+        this.consume(TokenType.COLON, "Expected ':'");
+        // Simplified field type parsing
+        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,
+            },
+        };
+    }
+}

package/dist/parser/base.d.ts

@@ -21,6 +21,13 @@ export declare class ReqonParserBase {
      * This is needed because 'get', 'post', etc. are valid variable/store names.
      */
     protected consumeIdentifier(message: string): Token;
+    /**
+     * Consume a token in name/property position (after a dot, a map/transform field
+     * name, or the type name after `is`). Any reserved keyword's text is a valid name
+     * here because the position is unambiguous, so accept any non-EOF token and return
+     * it by value.
+     */
+    protected consumeName(message: string): Token;
     /**
      * Check if current token is an identifier (including HTTP methods as identifiers)
      */

package/dist/parser/base.js

@@ -66,6 +66,17 @@ export class ReqonParserBase {
         }
         throw this.error(message);
     }
+    /**
+     * Consume a token in name/property position (after a dot, a map/transform field
+     * name, or the type name after `is`). Any reserved keyword's text is a valid name
+     * here because the position is unambiguous, so accept any non-EOF token and return
+     * it by value.
+     */
+    consumeName(message) {
+        if (this.isAtEnd())
+            throw this.error(message);
+        return this.advance();
+    }
     /**
      * Check if current token is an identifier (including HTTP methods as identifiers)
      */