reqon-dsl 0.2.0 → 0.3.0

package/src/interpreter/evaluator.ts

@@ -1,245 +0,0 @@
-import type { Expression } from 'vague-lang';
-import type { ExecutionContext } from './context.js';
-import { getVariable } from './context.js';
-import type { IsExpression } from '../parser/expressions.js';
-
-export function evaluate(expr: Expression, ctx: ExecutionContext, current?: unknown): unknown {
-  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 as Record<string, unknown>;
-        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 as Record<string, unknown>;
-        if (expr.name in resp) return resp[expr.name];
-      }
-      return undefined;
-    }
-
-    case 'QualifiedName': {
-      // Try from current/response first (common case)
-      let value: unknown = 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 as Record<string, unknown>)[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 as Record<string, unknown>)[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 as number) + (right as number);
-        case '-':
-          return (left as number) - (right as number);
-        case '*':
-          return (left as number) * (right as number);
-        case '/':
-          return (left as number) / (right as number);
-        case '==':
-          return left === right;
-        case '!=':
-          return left !== right;
-        case '<':
-          return (left as number) < (right as number);
-        case '>':
-          return (left as number) > (right as number);
-        case '<=':
-          return (left as number) <= (right as number);
-        case '>=':
-          return (left as number) >= (right as number);
-        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 as number);
-      if (expr.operator === '+') return +(operand as number);
-      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] as number[]).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] as number);
-        case 'floor':
-          return Math.floor(args[0] as number);
-        case 'ceil':
-          return Math.ceil(args[0] as number);
-        default:
-          throw new Error(`Unknown function: ${expr.callee}`);
-      }
-    }
-
-    case 'AnyOfExpression': {
-      const collection = evaluate(expr.collection, ctx, current) as unknown[];
-      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 as unknown as IsExpression;
-      const value = evaluate(isExpr.operand, ctx, current);
-      return checkType(value, isExpr.typeCheck);
-    }
-
-    default:
-      throw new Error(`Cannot evaluate expression type: ${(expr as Expression).type}`);
-  }
-}
-
-export function evaluateToString(expr: Expression, ctx: ExecutionContext, current?: unknown): string {
-  const value = evaluate(expr, ctx, current);
-  return String(value ?? '');
-}
-
-export function interpolatePath(path: string, ctx: ExecutionContext, current?: unknown): string {
-  return path.replace(/\{([^}]+)\}/g, (_, expr) => {
-    // Simple variable interpolation
-    const parts = expr.split('.');
-    let value: unknown = current;
-
-    for (const part of parts) {
-      if (value && typeof value === 'object') {
-        value = (value as Record<string, unknown>)[part];
-      } else {
-        value = getVariable(ctx, part);
-      }
-    }
-
-    return String(value ?? '');
-  });
-}
-
-/** Type check functions map - more efficient than switch statement */
-const TYPE_CHECKERS: Map<string, (value: unknown) => boolean> = 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: unknown, typeName: string): boolean {
-  const checker = TYPE_CHECKERS.get(typeName.toLowerCase());
-  if (!checker) {
-    throw new Error(`Unknown type for 'is' check: ${typeName}`);
-  }
-  return checker(value);
-}