reqon-dsl 0.2.0

package/dist/parser/base.js

@@ -0,0 +1,97 @@
+import { TokenType } from 'vague-lang';
+import { ReqonTokenType } from '../lexer/tokens.js';
+import { ParseError } from '../errors/index.js';
+export class ReqonParserBase {
+    tokens;
+    pos = 0;
+    source;
+    filePath;
+    constructor(tokens, source, filePath) {
+        this.tokens = tokens.filter((t) => t.type !== TokenType.NEWLINE);
+        this.source = source;
+        this.filePath = filePath;
+    }
+    peek() {
+        return this.tokens[this.pos];
+    }
+    peekNext() {
+        return this.tokens[this.pos + 1];
+    }
+    check(type) {
+        return !this.isAtEnd() && this.peek().type === type;
+    }
+    checkAny(...types) {
+        return types.some((t) => this.check(t));
+    }
+    match(type) {
+        if (this.check(type)) {
+            this.advance();
+            return true;
+        }
+        return false;
+    }
+    matchAny(...types) {
+        for (const type of types) {
+            if (this.check(type)) {
+                this.advance();
+                return type;
+            }
+        }
+        return null;
+    }
+    advance() {
+        if (!this.isAtEnd())
+            this.pos++;
+        return this.tokens[this.pos - 1];
+    }
+    consume(type, message) {
+        if (this.check(type))
+            return this.advance();
+        throw this.error(message);
+    }
+    /**
+     * Consume an identifier, allowing HTTP method tokens to be used as identifiers.
+     * This is needed because 'get', 'post', etc. are valid variable/store names.
+     */
+    consumeIdentifier(message) {
+        const token = this.peek();
+        // Accept both regular identifiers and HTTP method tokens as identifiers
+        if (token.type === TokenType.IDENTIFIER ||
+            token.type === ReqonTokenType.GET ||
+            token.type === ReqonTokenType.POST ||
+            token.type === ReqonTokenType.PUT ||
+            token.type === ReqonTokenType.PATCH ||
+            token.type === ReqonTokenType.DELETE) {
+            return this.advance();
+        }
+        throw this.error(message);
+    }
+    /**
+     * Check if current token is an identifier (including HTTP methods as identifiers)
+     */
+    checkIdentifier() {
+        const type = this.peek().type;
+        return (type === TokenType.IDENTIFIER ||
+            type === ReqonTokenType.GET ||
+            type === ReqonTokenType.POST ||
+            type === ReqonTokenType.PUT ||
+            type === ReqonTokenType.PATCH ||
+            type === ReqonTokenType.DELETE);
+    }
+    isAtEnd() {
+        return this.peek().type === TokenType.EOF;
+    }
+    error(message) {
+        const token = this.peek();
+        const context = this.source
+            ? { source: this.source, filePath: this.filePath }
+            : undefined;
+        return new ParseError(message, { line: token.line, column: token.column }, context, token.value);
+    }
+    savePosition() {
+        return this.pos;
+    }
+    restorePosition(saved) {
+        this.pos = saved;
+    }
+}

package/dist/parser/expressions.d.ts

@@ -0,0 +1,27 @@
+import { type Expression, type QualifiedName } from 'vague-lang';
+import { ReqonParserBase } from './base.js';
+export interface IsExpression {
+    type: 'IsExpression';
+    operand: Expression;
+    typeCheck: string;
+}
+export declare class ReqonExpressionParser extends ReqonParserBase {
+    parseExpression(): Expression;
+    parseLogicalExpression(): Expression;
+    private parseTernary;
+    private parseOr;
+    private parseAnd;
+    private parseNot;
+    private parseSuperposition;
+    private parseSuperpositionOption;
+    parseComparison(): Expression;
+    parseRange(): Expression;
+    parseAdditive(): Expression;
+    private parseMultiplicative;
+    private parseUnary;
+    private parseCall;
+    parsePrimary(): Expression;
+    private parseMatchExpression;
+    private parseOrderedSequence;
+    parseQualifiedName(): QualifiedName;
+}

package/dist/parser/expressions.js

@@ -0,0 +1,248 @@
+import { TokenType } from 'vague-lang';
+import { ReqonTokenType } from '../lexer/tokens.js';
+import { ReqonParserBase } from './base.js';
+export class ReqonExpressionParser extends ReqonParserBase {
+    parseExpression() {
+        return this.parseTernary();
+    }
+    parseLogicalExpression() {
+        return this.parseOr();
+    }
+    parseTernary() {
+        const condition = this.parseOr();
+        if (this.match(TokenType.QUESTION)) {
+            const consequent = this.parseTernary();
+            this.consume(TokenType.COLON, "Expected ':' in ternary expression");
+            const alternate = this.parseTernary();
+            return {
+                type: 'TernaryExpression',
+                condition,
+                consequent,
+                alternate,
+            };
+        }
+        return condition;
+    }
+    parseOr() {
+        let left = this.parseAnd();
+        while (this.match(TokenType.OR)) {
+            const right = this.parseAnd();
+            left = { type: 'LogicalExpression', operator: 'or', left, right };
+        }
+        return left;
+    }
+    parseAnd() {
+        let left = this.parseNot();
+        while (this.match(TokenType.AND)) {
+            const right = this.parseNot();
+            left = { type: 'LogicalExpression', operator: 'and', left, right };
+        }
+        return left;
+    }
+    parseNot() {
+        if (this.match(TokenType.NOT)) {
+            const operand = this.parseNot();
+            return { type: 'NotExpression', operand };
+        }
+        return this.parseSuperposition();
+    }
+    parseSuperposition() {
+        const first = this.parseSuperpositionOption();
+        if (this.check(TokenType.PIPE)) {
+            const options = [first];
+            while (this.match(TokenType.PIPE)) {
+                options.push(this.parseSuperpositionOption());
+            }
+            return { type: 'SuperpositionExpression', options };
+        }
+        return first.value;
+    }
+    parseSuperpositionOption() {
+        const expr = this.parseComparison();
+        if (expr.type === 'Literal' && expr.dataType === 'number' && this.check(TokenType.COLON)) {
+            this.advance();
+            const value = this.parseComparison();
+            return { weight: expr.value, value };
+        }
+        return { value: expr };
+    }
+    parseComparison() {
+        let left = this.parseRange();
+        while (this.checkAny(TokenType.LT, TokenType.GT, TokenType.LTE, TokenType.GTE, TokenType.DOUBLE_EQUALS, ReqonTokenType.NOT_EQUALS)) {
+            const token = this.advance();
+            // Normalize the operator value for NOT_EQUALS
+            const operator = token.type === ReqonTokenType.NOT_EQUALS ? '!=' : token.value;
+            const right = this.parseRange();
+            left = { type: 'BinaryExpression', operator, left, right };
+        }
+        // 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;
+            return { type: 'IsExpression', operand: left, typeCheck };
+        }
+        return left;
+    }
+    parseRange() {
+        const left = this.parseAdditive();
+        if (this.match(TokenType.DOTDOT)) {
+            const right = this.check(TokenType.NUMBER) ? this.parseAdditive() : undefined;
+            return { type: 'RangeExpression', min: left, max: right };
+        }
+        return left;
+    }
+    parseAdditive() {
+        let left = this.parseMultiplicative();
+        while (this.checkAny(TokenType.PLUS, TokenType.MINUS)) {
+            const operator = this.advance().value;
+            const right = this.parseMultiplicative();
+            left = { type: 'BinaryExpression', operator, left, right };
+        }
+        return left;
+    }
+    parseMultiplicative() {
+        let left = this.parseUnary();
+        while (this.checkAny(TokenType.STAR, TokenType.SLASH)) {
+            const operator = this.advance().value;
+            const right = this.parseUnary();
+            left = { type: 'BinaryExpression', operator, left, right };
+        }
+        return left;
+    }
+    parseUnary() {
+        if (this.match(TokenType.CARET)) {
+            const path = this.parseQualifiedName();
+            return { type: 'ParentReference', path };
+        }
+        if (this.checkAny(TokenType.MINUS, TokenType.PLUS)) {
+            const operator = this.advance().value;
+            const operand = this.parseUnary();
+            return { type: 'UnaryExpression', operator, operand };
+        }
+        return this.parseCall();
+    }
+    parseCall() {
+        let expr = this.parsePrimary();
+        while (true) {
+            if (this.match(TokenType.LPAREN)) {
+                const args = [];
+                if (!this.check(TokenType.RPAREN)) {
+                    do {
+                        args.push(this.parseExpression());
+                    } while (this.match(TokenType.COMMA));
+                }
+                this.consume(TokenType.RPAREN, "Expected ')'");
+                if (expr.type === 'Identifier') {
+                    expr = { type: 'CallExpression', callee: expr.name, arguments: args };
+                }
+                else if (expr.type === 'QualifiedName') {
+                    expr = { type: 'CallExpression', callee: expr.parts.join('.'), arguments: args };
+                }
+            }
+            else if (this.match(TokenType.DOT)) {
+                const name = this.consume(TokenType.IDENTIFIER, 'Expected property name').value;
+                if (expr.type === 'Identifier') {
+                    expr = { type: 'QualifiedName', parts: [expr.name, name] };
+                }
+                else if (expr.type === 'QualifiedName') {
+                    expr.parts.push(name);
+                }
+            }
+            else {
+                break;
+            }
+        }
+        return expr;
+    }
+    parsePrimary() {
+        // Match expression
+        if (this.match(TokenType.MATCH)) {
+            return this.parseMatchExpression();
+        }
+        // Ordered sequence
+        if (this.match(TokenType.LBRACKET)) {
+            return this.parseOrderedSequence();
+        }
+        // Any of expression
+        if (this.match(TokenType.ANY)) {
+            this.consume(TokenType.OF, "Expected 'of'");
+            const collection = this.parseExpression();
+            let condition;
+            if (this.match(TokenType.WHERE)) {
+                condition = this.parseExpression();
+            }
+            return { type: 'AnyOfExpression', collection, condition };
+        }
+        // Parenthesized expression
+        if (this.match(TokenType.LPAREN)) {
+            const expr = this.parseExpression();
+            this.consume(TokenType.RPAREN, "Expected ')'");
+            return expr;
+        }
+        // Number literal
+        if (this.check(TokenType.NUMBER)) {
+            const value = parseFloat(this.advance().value);
+            return { type: 'Literal', value, dataType: 'number' };
+        }
+        // String literal
+        if (this.check(TokenType.STRING)) {
+            const value = this.advance().value;
+            return { type: 'Literal', value, dataType: 'string' };
+        }
+        // Null literal
+        if (this.match(TokenType.NULL)) {
+            return { type: 'Literal', value: null, dataType: 'null' };
+        }
+        // Boolean literals
+        if (this.match(TokenType.TRUE)) {
+            return { type: 'Literal', value: true, dataType: 'boolean' };
+        }
+        if (this.match(TokenType.FALSE)) {
+            return { type: 'Literal', value: false, dataType: 'boolean' };
+        }
+        // Identifier (including HTTP method tokens that can be used as identifiers)
+        if (this.checkIdentifier()) {
+            const name = this.advance().value;
+            return { type: 'Identifier', name };
+        }
+        // .field shorthand
+        if (this.match(TokenType.DOT)) {
+            const name = this.consumeIdentifier("Expected field name after '.'").value;
+            return { type: 'Identifier', name };
+        }
+        throw this.error(`Unexpected token: ${this.peek().value}`);
+    }
+    parseMatchExpression() {
+        const value = this.parsePrimary();
+        this.consume(TokenType.LBRACE, "Expected '{'");
+        const arms = [];
+        while (!this.check(TokenType.RBRACE) && !this.isAtEnd()) {
+            const pattern = this.parseExpression();
+            this.consume(TokenType.ARROW, "Expected '=>'");
+            const result = this.parseExpression();
+            arms.push({ pattern, result });
+            this.match(TokenType.COMMA);
+        }
+        this.consume(TokenType.RBRACE, "Expected '}'");
+        return { type: 'MatchExpression', value, arms };
+    }
+    parseOrderedSequence() {
+        const elements = [];
+        if (this.check(TokenType.RBRACKET)) {
+            throw this.error('Ordered sequence cannot be empty');
+        }
+        do {
+            elements.push(this.parseExpression());
+        } while (this.match(TokenType.COMMA));
+        this.consume(TokenType.RBRACKET, "Expected ']'");
+        return { type: 'OrderedSequenceType', elements };
+    }
+    parseQualifiedName() {
+        const parts = [];
+        parts.push(this.consume(TokenType.IDENTIFIER, 'Expected identifier').value);
+        while (this.match(TokenType.DOT)) {
+            parts.push(this.consume(TokenType.IDENTIFIER, 'Expected identifier').value);
+        }
+        return { type: 'QualifiedName', parts };
+    }
+}

package/dist/parser/expressions.test.d.ts

@@ -0,0 +1 @@
+export {};