reqon-dsl 0.2.0 → 0.4.0

package/src/benchmark/evaluator.bench.ts

@@ -1,331 +0,0 @@
-/**
- * Evaluator benchmarks
- */
-
-import type { Expression } from 'vague-lang';
-import { evaluate, interpolatePath } from '../interpreter/evaluator.js';
-import { createContext, setVariable } from '../interpreter/context.js';
-import type { ExecutionContext } from '../interpreter/context.js';
-import { BenchmarkSuite } from './utils.js';
-
-// Create a rich test context
-function createTestContext(): ExecutionContext {
-  const ctx = createContext();
-
-  // Set up variables
-  setVariable(ctx, 'user', {
-    id: '12345',
-    firstName: 'John',
-    lastName: 'Doe',
-    email: 'john@example.com',
-    age: 30,
-    active: true,
-    score: 85,
-    tags: ['admin', 'premium', 'verified'],
-    nested: {
-      level1: {
-        level2: {
-          level3: {
-            value: 42,
-          },
-        },
-      },
-    },
-  });
-
-  setVariable(ctx, 'items', [
-    { id: 1, name: 'Item 1', price: 10 },
-    { id: 2, name: 'Item 2', price: 20 },
-    { id: 3, name: 'Item 3', price: 30 },
-  ]);
-
-  setVariable(ctx, 'a', 10);
-  setVariable(ctx, 'b', 20);
-  setVariable(ctx, 'c', 30);
-  setVariable(ctx, 'x', 5);
-  setVariable(ctx, 'y', 15);
-
-  // Set up response
-  ctx.response = {
-    data: {
-      users: [
-        { id: 1, name: 'User 1' },
-        { id: 2, name: 'User 2' },
-      ],
-      total: 100,
-    },
-    status: 'success',
-  };
-
-  return ctx;
-}
-
-// Expression factories
-function literal(value: string | number | boolean): Expression {
-  return { type: 'Literal', value };
-}
-
-function identifier(name: string): Expression {
-  return { type: 'Identifier', name };
-}
-
-function qualifiedName(...parts: string[]): Expression {
-  return { type: 'QualifiedName', parts };
-}
-
-function binary(left: Expression, operator: string, right: Expression): Expression {
-  return { type: 'BinaryExpression', left, operator, right } as Expression;
-}
-
-function logical(left: Expression, operator: 'and' | 'or', right: Expression): Expression {
-  return { type: 'LogicalExpression', left, operator, right } as Expression;
-}
-
-function call(callee: string, ...args: Expression[]): Expression {
-  return { type: 'CallExpression', callee, arguments: args } as Expression;
-}
-
-function ternary(condition: Expression, consequent: Expression, alternate: Expression): Expression {
-  return { type: 'TernaryExpression', condition, consequent, alternate } as Expression;
-}
-
-function matchExpr(value: Expression, arms: Array<{ pattern: Expression; result: Expression }>): Expression {
-  return { type: 'MatchExpression', value, arms } as Expression;
-}
-
-export async function runEvaluatorBenchmarks(): Promise<void> {
-  const suite = new BenchmarkSuite('Evaluator');
-  const ctx = createTestContext();
-
-  // Literal evaluation
-  suite.addSync('literal-string', () => {
-    return evaluate(literal('hello world'), ctx);
-  });
-
-  suite.addSync('literal-number', () => {
-    return evaluate(literal(42), ctx);
-  });
-
-  // Identifier evaluation
-  suite.addSync('identifier-simple', () => {
-    return evaluate(identifier('a'), ctx);
-  });
-
-  suite.addSync('identifier-object', () => {
-    return evaluate(identifier('user'), ctx);
-  });
-
-  // Qualified name (nested access)
-  suite.addSync('qualified-2-levels', () => {
-    return evaluate(qualifiedName('user', 'firstName'), ctx);
-  });
-
-  suite.addSync('qualified-4-levels', () => {
-    return evaluate(qualifiedName('user', 'nested', 'level1', 'level2'), ctx);
-  });
-
-  suite.addSync('qualified-deep', () => {
-    return evaluate(qualifiedName('user', 'nested', 'level1', 'level2', 'level3', 'value'), ctx);
-  });
-
-  // Arithmetic operations
-  suite.addSync('arithmetic-add', () => {
-    return evaluate(binary(identifier('a'), '+', identifier('b')), ctx);
-  });
-
-  suite.addSync('arithmetic-complex', () => {
-    // (a + b) * (c - x) / (y + 1)
-    const expr = binary(
-      binary(
-        binary(identifier('a'), '+', identifier('b')),
-        '*',
-        binary(identifier('c'), '-', identifier('x'))
-      ),
-      '/',
-      binary(identifier('y'), '+', literal(1))
-    );
-    return evaluate(expr, ctx);
-  });
-
-  suite.addSync('arithmetic-deeply-nested', () => {
-    // ((a + b) * (c + x)) + ((y - a) * (b - c))
-    const expr = binary(
-      binary(
-        binary(identifier('a'), '+', identifier('b')),
-        '*',
-        binary(identifier('c'), '+', identifier('x'))
-      ),
-      '+',
-      binary(
-        binary(identifier('y'), '-', identifier('a')),
-        '*',
-        binary(identifier('b'), '-', identifier('c'))
-      )
-    );
-    return evaluate(expr, ctx);
-  });
-
-  // Comparison operations
-  suite.addSync('comparison-simple', () => {
-    return evaluate(binary(identifier('a'), '<', identifier('b')), ctx);
-  });
-
-  suite.addSync('comparison-equality', () => {
-    return evaluate(binary(qualifiedName('user', 'active'), '==', literal(true)), ctx);
-  });
-
-  // Logical operations
-  suite.addSync('logical-and', () => {
-    return evaluate(
-      logical(
-        binary(identifier('a'), '>', literal(5)),
-        'and',
-        binary(identifier('b'), '<', literal(30))
-      ),
-      ctx
-    );
-  });
-
-  suite.addSync('logical-complex', () => {
-    // (a > 5 and b < 30) or (c == 30 and x != 10)
-    return evaluate(
-      logical(
-        logical(
-          binary(identifier('a'), '>', literal(5)),
-          'and',
-          binary(identifier('b'), '<', literal(30))
-        ),
-        'or',
-        logical(
-          binary(identifier('c'), '==', literal(30)),
-          'and',
-          binary(identifier('x'), '!=', literal(10))
-        )
-      ),
-      ctx
-    );
-  });
-
-  // Function calls
-  suite.addSync('call-length-array', () => {
-    return evaluate(call('length', qualifiedName('user', 'tags')), ctx);
-  });
-
-  suite.addSync('call-sum', () => {
-    return evaluate(call('sum', identifier('items')), ctx);
-  });
-
-  suite.addSync('call-first', () => {
-    return evaluate(call('first', identifier('items')), ctx);
-  });
-
-  // Ternary expressions
-  suite.addSync('ternary-simple', () => {
-    return evaluate(
-      ternary(
-        binary(identifier('a'), '>', literal(5)),
-        literal('yes'),
-        literal('no')
-      ),
-      ctx
-    );
-  });
-
-  suite.addSync('ternary-nested', () => {
-    return evaluate(
-      ternary(
-        binary(identifier('a'), '>', literal(50)),
-        literal('high'),
-        ternary(
-          binary(identifier('a'), '>', literal(20)),
-          literal('medium'),
-          literal('low')
-        )
-      ),
-      ctx
-    );
-  });
-
-  // Match expressions
-  suite.addSync('match-3-arms', () => {
-    return evaluate(
-      matchExpr(qualifiedName('user', 'score'), [
-        { pattern: literal(100), result: literal('perfect') },
-        { pattern: literal(85), result: literal('good') },
-        { pattern: identifier('_'), result: literal('other') },
-      ]),
-      ctx
-    );
-  });
-
-  suite.addSync('match-6-arms', () => {
-    return evaluate(
-      matchExpr(identifier('a'), [
-        { pattern: literal(1), result: literal('one') },
-        { pattern: literal(2), result: literal('two') },
-        { pattern: literal(5), result: literal('five') },
-        { pattern: literal(10), result: literal('ten') },
-        { pattern: literal(20), result: literal('twenty') },
-        { pattern: identifier('_'), result: literal('other') },
-      ]),
-      ctx
-    );
-  });
-
-  // Path interpolation
-  suite.addSync('interpolate-simple', () => {
-    return interpolatePath('/users/{user.id}', ctx);
-  });
-
-  suite.addSync('interpolate-multiple', () => {
-    return interpolatePath('/users/{user.id}/orders/{a}/items/{b}', ctx);
-  });
-
-  suite.print();
-
-  // Stress test suite
-  const stressSuite = new BenchmarkSuite('Evaluator Stress Tests');
-
-  // Many sequential evaluations
-  stressSuite.addSync('100-sequential-evals', () => {
-    let result: unknown;
-    for (let i = 0; i < 100; i++) {
-      result = evaluate(binary(identifier('a'), '+', literal(i)), ctx);
-    }
-    return result;
-  }, { iterations: 100 });
-
-  // Complex nested expression
-  const deeplyNestedExpr = binary(
-    binary(
-      binary(
-        binary(identifier('a'), '+', identifier('b')),
-        '*',
-        binary(identifier('c'), '-', identifier('x'))
-      ),
-      '/',
-      binary(
-        binary(identifier('y'), '+', literal(1)),
-        '*',
-        binary(identifier('a'), '-', literal(2))
-      )
-    ),
-    '+',
-    binary(
-      binary(identifier('b'), '*', identifier('c')),
-      '-',
-      binary(identifier('x'), '/', binary(identifier('y'), '+', literal(1)))
-    )
-  );
-
-  stressSuite.addSync('deeply-nested-expression', () => {
-    return evaluate(deeplyNestedExpr, ctx);
-  });
-
-  stressSuite.print();
-}
-
-// Run if executed directly
-if (import.meta.url === `file://${process.argv[1]}`) {
-  runEvaluatorBenchmarks().catch(console.error);
-}

package/src/benchmark/fixtures.ts

@@ -1,295 +0,0 @@
-/**
- * DSL fixtures of varying complexity for benchmarking
- */
-
-// Simple: minimal valid DSL
-export const SIMPLE_DSL = `
-mission "simple"
-  source api from "https://api.example.com"
-  store results in memory
-
-  action fetchData
-    fetch "/data" from api
-    store response in results
-`;
-
-// Medium: typical real-world usage with mapping and validation
-export const MEDIUM_DSL = `
-mission "medium-complexity"
-  source api from "https://api.example.com" with
-    auth: bearer "token123"
-    rateLimit: 100
-
-  store users in memory
-  store orders in memory
-
-  action fetchUsers
-    fetch "/users" from api
-    for user in response.data where user.active == true
-      map user -> {
-        id: user.id,
-        name: user.firstName + " " + user.lastName,
-        email: user.email
-      }
-      validate
-        assume id is string
-        assume name is string
-        assume email is string
-      store mapped in users with key: mapped.id
-    end
-
-  action fetchOrders
-    fetch "/orders" from api with
-      pagination: offset
-      pageSize: 50
-    for order in response
-      map order -> {
-        orderId: order.id,
-        total: order.amount * 100,
-        status: order.status
-      }
-      store mapped in orders with key: mapped.orderId
-    end
-
-  run fetchUsers then fetchOrders
-`;
-
-// Complex: multiple sources, conditional logic, nested transformations
-export const COMPLEX_DSL = `
-mission "complex-pipeline"
-  source primaryApi from "https://api.primary.com" with
-    auth: oauth2 {
-      tokenUrl: "https://auth.primary.com/token",
-      clientId: "client123",
-      clientSecret: "secret456",
-      scope: "read write"
-    }
-    timeout: 30000
-    retries: 3
-    backoff: exponential
-    circuitBreaker: {
-      failureThreshold: 5,
-      resetTimeout: 60000
-    }
-
-  source secondaryApi from "https://api.secondary.com" with
-    auth: apiKey {
-      header: "X-API-Key",
-      value: "key789"
-    }
-    rateLimit: 50
-
-  store products in memory
-  store inventory in memory
-  store combined in memory
-  store errors in memory
-
-  action fetchProducts
-    fetch "/products" from primaryApi with
-      pagination: cursor
-      pageSize: 100
-      since: lastSync
-    for product in response.items where product.status != "deleted"
-      map product -> {
-        sku: product.sku,
-        name: product.name,
-        price: product.price.amount,
-        currency: product.price.currency,
-        category: product.category.name,
-        tags: product.tags
-      }
-      validate
-        assume sku is string
-        assume name is string
-        assume price is number
-        assume price > 0
-      store mapped in products with key: mapped.sku
-    end
-
-  action fetchInventory
-    fetch "/inventory" from secondaryApi with
-      pagination: page
-      pageSize: 200
-    for item in response.data
-      map item -> {
-        sku: item.productSku,
-        quantity: item.onHand,
-        warehouse: item.location.warehouse,
-        lastUpdated: item.updatedAt
-      }
-      validate
-        assume sku is string
-        assume quantity is number
-        assume quantity >= 0
-      store mapped in inventory with key: mapped.sku + "-" + mapped.warehouse
-    end
-
-  action combineData
-    for product in products
-      for inv in inventory where inv.sku == product.sku
-        map { product: product, inventory: inv } -> {
-          sku: product.sku,
-          name: product.name,
-          price: product.price,
-          quantity: inv.quantity,
-          warehouse: inv.warehouse,
-          available: inv.quantity > 0,
-          value: product.price * inv.quantity
-        }
-        store mapped in combined with key: mapped.sku + "-" + mapped.warehouse
-      end
-    end
-
-  run [fetchProducts, fetchInventory] then combineData
-`;
-
-// Expression-heavy: for evaluator benchmarking
-export const EXPRESSION_HEAVY_DSL = `
-mission "expressions"
-  source api from "https://api.example.com"
-  store results in memory
-
-  action calculate
-    fetch "/data" from api
-    for item in response.items
-      map item -> {
-        // Arithmetic
-        sum: item.a + item.b + item.c,
-        product: item.x * item.y * item.z,
-        complex: (item.a + item.b) * (item.c - item.d) / (item.e + 1),
-
-        // String operations
-        fullName: item.firstName + " " + item.middleName + " " + item.lastName,
-        code: item.prefix + "-" + item.id + "-" + item.suffix,
-
-        // Boolean logic
-        isValid: item.active == true and item.verified == true,
-        needsReview: item.score < 50 or item.flagged == true,
-        complexCheck: (item.type == "A" or item.type == "B") and item.status != "deleted",
-
-        // Comparisons
-        tier: match item.score
-          when score >= 90 then "platinum"
-          when score >= 70 then "gold"
-          when score >= 50 then "silver"
-          else "bronze"
-        end,
-
-        // Nested access
-        nested1: item.level1.level2.level3.value,
-        nested2: item.data.items[0].nested.field,
-
-        // Mixed
-        final: (item.base * item.multiplier) + item.bonus - item.penalty
-      }
-      store mapped in results with key: mapped.code
-    end
-`;
-
-// Large: stress test with many actions and stores
-export function generateLargeDSL(actionCount: number = 20): string {
-  const stores = Array.from(
-    { length: actionCount },
-    (_, i) => `  store store${i} in memory`
-  ).join('\n');
-
-  const actions = Array.from({ length: actionCount }, (_, i) => `
-  action action${i}
-    fetch "/endpoint${i}" from api with
-      pagination: offset
-      pageSize: 100
-    for item in response.data where item.active == true
-      map item -> {
-        id: item.id,
-        value${i}: item.value * ${i + 1},
-        computed: item.a + item.b + ${i}
-      }
-      validate
-        assume id is string
-        assume value${i} is number
-      store mapped in store${i} with key: mapped.id
-    end
-`).join('\n');
-
-  const runSequence = Array.from(
-    { length: actionCount },
-    (_, i) => `action${i}`
-  ).join(', ');
-
-  return `
-mission "large-stress-test"
-  source api from "https://api.example.com" with
-    auth: bearer "token"
-    rateLimit: 1000
-
-${stores}
-
-${actions}
-
-  run [${runSequence}]
-`;
-}
-
-// Deeply nested expressions for evaluator stress testing
-export const DEEPLY_NESTED_EXPRESSIONS = `
-mission "nested-expressions"
-  source api from "https://api.example.com"
-  store results in memory
-
-  action process
-    fetch "/data" from api
-    for item in response
-      map item -> {
-        result: ((((item.a + item.b) * (item.c + item.d)) + ((item.e - item.f) * (item.g - item.h))) * (((item.i + item.j) / (item.k + 1)) - ((item.l * item.m) + (item.n / (item.o + 1)))))
-      }
-      store mapped in results
-    end
-`;
-
-// Match-heavy for pattern matching benchmarks
-export const MATCH_HEAVY_DSL = `
-mission "pattern-matching"
-  source api from "https://api.example.com"
-  store results in memory
-
-  action categorize
-    fetch "/items" from api
-    for item in response
-      map item -> {
-        id: item.id,
-        category: match item.type
-          when "A" then "category-a"
-          when "B" then "category-b"
-          when "C" then "category-c"
-          when "D" then "category-d"
-          when "E" then "category-e"
-          else "other"
-        end,
-        priority: match item.urgency
-          when urgency > 90 then "critical"
-          when urgency > 70 then "high"
-          when urgency > 50 then "medium"
-          when urgency > 30 then "low"
-          else "none"
-        end,
-        status: match item.state
-          when "pending" then "awaiting"
-          when "processing" then "in-progress"
-          when "completed" then "done"
-          when "failed" then "error"
-          when "cancelled" then "stopped"
-          else "unknown"
-        end
-      }
-      store mapped in results with key: mapped.id
-    end
-`;
-
-export const ALL_FIXTURES = {
-  simple: SIMPLE_DSL,
-  medium: MEDIUM_DSL,
-  complex: COMPLEX_DSL,
-  expressionHeavy: EXPRESSION_HEAVY_DSL,
-  deeplyNested: DEEPLY_NESTED_EXPRESSIONS,
-  matchHeavy: MATCH_HEAVY_DSL,
-};