reqon-dsl 0.2.0

package/dist/interpreter/context.js

@@ -0,0 +1,29 @@
+export function createContext() {
+    return {
+        stores: new Map(),
+        sources: new Map(),
+        schemas: new Map(),
+        variables: new Map(),
+    };
+}
+export function childContext(parent) {
+    return {
+        stores: parent.stores,
+        sources: parent.sources,
+        schemas: parent.schemas,
+        variables: new Map(),
+        parent,
+    };
+}
+export function getVariable(ctx, name) {
+    if (ctx.variables.has(name)) {
+        return ctx.variables.get(name);
+    }
+    if (ctx.parent) {
+        return getVariable(ctx.parent, name);
+    }
+    return undefined;
+}
+export function setVariable(ctx, name, value) {
+    ctx.variables.set(name, value);
+}

package/dist/interpreter/evaluator.d.ts

@@ -0,0 +1,5 @@
+import type { Expression } from 'vague-lang';
+import type { ExecutionContext } from './context.js';
+export declare function evaluate(expr: Expression, ctx: ExecutionContext, current?: unknown): unknown;
+export declare function evaluateToString(expr: Expression, ctx: ExecutionContext, current?: unknown): string;
+export declare function interpolatePath(path: string, ctx: ExecutionContext, current?: unknown): string;

package/dist/interpreter/evaluator.js

@@ -0,0 +1,223 @@
+import { getVariable } from './context.js';
+export function evaluate(expr, ctx, current) {
+    switch (expr.type) {
+        case 'Literal':
+            return expr.value;
+        case 'Identifier': {
+            // Check if it's a field on current object
+            if (current && typeof current === 'object' && current !== null) {
+                const obj = current;
+                if (expr.name in obj) {
+                    return obj[expr.name];
+                }
+            }
+            // Check variables
+            const value = getVariable(ctx, expr.name);
+            if (value !== undefined)
+                return value;
+            // Special case: 'response' refers to ctx.response
+            if (expr.name === 'response') {
+                return ctx.response;
+            }
+            // Check if the identifier is a field on response
+            if (ctx.response && typeof ctx.response === 'object') {
+                const resp = ctx.response;
+                if (expr.name in resp)
+                    return resp[expr.name];
+            }
+            return undefined;
+        }
+        case 'QualifiedName': {
+            // Try from current/response first (common case)
+            let value = current ?? ctx.response;
+            if (value && typeof value === 'object' && value !== null) {
+                let found = true;
+                for (const part of expr.parts) {
+                    if (value && typeof value === 'object' && value !== null) {
+                        value = value[part];
+                    }
+                    else {
+                        found = false;
+                        break;
+                    }
+                }
+                if (found && value !== undefined) {
+                    return value;
+                }
+            }
+            // Fall back: try from variables (first part is variable name)
+            if (expr.parts.length > 0) {
+                value = getVariable(ctx, expr.parts[0]);
+                if (value !== undefined) {
+                    for (let i = 1; i < expr.parts.length; i++) {
+                        if (value && typeof value === 'object') {
+                            value = value[expr.parts[i]];
+                        }
+                        else {
+                            return undefined;
+                        }
+                    }
+                    return value;
+                }
+            }
+            return undefined;
+        }
+        case 'BinaryExpression': {
+            const left = evaluate(expr.left, ctx, current);
+            const right = evaluate(expr.right, ctx, current);
+            switch (expr.operator) {
+                case '+':
+                    return left + right;
+                case '-':
+                    return left - right;
+                case '*':
+                    return left * right;
+                case '/':
+                    return left / right;
+                case '==':
+                    return left === right;
+                case '!=':
+                    return left !== right;
+                case '<':
+                    return left < right;
+                case '>':
+                    return left > right;
+                case '<=':
+                    return left <= right;
+                case '>=':
+                    return left >= right;
+                default:
+                    throw new Error(`Unknown operator: ${expr.operator}`);
+            }
+        }
+        case 'LogicalExpression': {
+            const left = evaluate(expr.left, ctx, current);
+            if (expr.operator === 'and') {
+                return left ? evaluate(expr.right, ctx, current) : false;
+            }
+            else {
+                return left ? true : evaluate(expr.right, ctx, current);
+            }
+        }
+        case 'NotExpression':
+            return !evaluate(expr.operand, ctx, current);
+        case 'UnaryExpression': {
+            const operand = evaluate(expr.operand, ctx, current);
+            if (expr.operator === '-')
+                return -operand;
+            if (expr.operator === '+')
+                return +operand;
+            return operand;
+        }
+        case 'TernaryExpression': {
+            const condition = evaluate(expr.condition, ctx, current);
+            return condition
+                ? evaluate(expr.consequent, ctx, current)
+                : evaluate(expr.alternate, ctx, current);
+        }
+        case 'MatchExpression': {
+            const value = evaluate(expr.value, ctx, current);
+            for (const arm of expr.arms) {
+                const pattern = evaluate(arm.pattern, ctx, current);
+                // Wildcard pattern
+                if (arm.pattern.type === 'Identifier' && arm.pattern.name === '_') {
+                    return evaluate(arm.result, ctx, current);
+                }
+                if (value === pattern) {
+                    return evaluate(arm.result, ctx, current);
+                }
+            }
+            return undefined;
+        }
+        case 'CallExpression': {
+            const args = expr.arguments.map((arg) => evaluate(arg, ctx, current));
+            // Built-in functions
+            switch (expr.callee) {
+                case 'length':
+                    if (Array.isArray(args[0]))
+                        return args[0].length;
+                    if (typeof args[0] === 'string')
+                        return args[0].length;
+                    return 0;
+                case 'sum':
+                    return args[0].reduce((a, b) => a + b, 0);
+                case 'count':
+                    return Array.isArray(args[0]) ? args[0].length : 0;
+                case 'first':
+                    return Array.isArray(args[0]) ? args[0][0] : undefined;
+                case 'last':
+                    return Array.isArray(args[0]) ? args[0][args[0].length - 1] : undefined;
+                case 'round':
+                    return Math.round(args[0]);
+                case 'floor':
+                    return Math.floor(args[0]);
+                case 'ceil':
+                    return Math.ceil(args[0]);
+                default:
+                    throw new Error(`Unknown function: ${expr.callee}`);
+            }
+        }
+        case 'AnyOfExpression': {
+            const collection = evaluate(expr.collection, ctx, current);
+            if (!Array.isArray(collection))
+                return undefined;
+            if (expr.condition) {
+                return collection.find((item) => evaluate(expr.condition, ctx, item));
+            }
+            return collection[Math.floor(Math.random() * collection.length)];
+        }
+        case 'IsExpression': {
+            // Type checking expression: value is array, value is string, etc.
+            const isExpr = expr;
+            const value = evaluate(isExpr.operand, ctx, current);
+            return checkType(value, isExpr.typeCheck);
+        }
+        default:
+            throw new Error(`Cannot evaluate expression type: ${expr.type}`);
+    }
+}
+export function evaluateToString(expr, ctx, current) {
+    const value = evaluate(expr, ctx, current);
+    return String(value ?? '');
+}
+export function interpolatePath(path, ctx, current) {
+    return path.replace(/\{([^}]+)\}/g, (_, expr) => {
+        // Simple variable interpolation
+        const parts = expr.split('.');
+        let value = current;
+        for (const part of parts) {
+            if (value && typeof value === 'object') {
+                value = value[part];
+            }
+            else {
+                value = getVariable(ctx, part);
+            }
+        }
+        return String(value ?? '');
+    });
+}
+/** Type check functions map - more efficient than switch statement */
+const TYPE_CHECKERS = new Map([
+    ['array', (v) => Array.isArray(v)],
+    ['object', (v) => v !== null && typeof v === 'object' && !Array.isArray(v)],
+    ['string', (v) => typeof v === 'string'],
+    ['number', (v) => typeof v === 'number'],
+    ['decimal', (v) => typeof v === 'number'],
+    ['int', (v) => typeof v === 'number' && Number.isInteger(v)],
+    ['integer', (v) => typeof v === 'number' && Number.isInteger(v)],
+    ['boolean', (v) => typeof v === 'boolean'],
+    ['null', (v) => v === null],
+    ['undefined', (v) => v === undefined],
+    ['date', (v) => v instanceof Date || (typeof v === 'string' && !isNaN(Date.parse(v)))],
+]);
+/**
+ * Check if a value matches a type.
+ * Supports: array, object, string, number, boolean, null, undefined, int, decimal, date
+ */
+function checkType(value, typeName) {
+    const checker = TYPE_CHECKERS.get(typeName.toLowerCase());
+    if (!checker) {
+        throw new Error(`Unknown type for 'is' check: ${typeName}`);
+    }
+    return checker(value);
+}

package/dist/interpreter/evaluator.test.d.ts

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