reqon-dsl 0.2.0

package/src/benchmark/evaluator.bench.ts

@@ -0,0 +1,331 @@
+/**
+ * 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

@@ -0,0 +1,295 @@
+/**
+ * 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,
+};