reqon-dsl 0.2.0

package/src/benchmark/index.ts

@@ -0,0 +1,108 @@
+/**
+ * Benchmark suite for Reqon
+ *
+ * Run all benchmarks: npx tsx src/benchmark/index.ts
+ * Run specific suite: npx tsx src/benchmark/index.ts --suite lexer
+ */
+
+import { runLexerBenchmarks } from './lexer.bench.js';
+import { runParserBenchmarks } from './parser.bench.js';
+import { runEvaluatorBenchmarks } from './evaluator.bench.js';
+import { runStoreBenchmarks } from './store.bench.js';
+import { runResilienceBenchmarks } from './resilience.bench.js';
+import { runE2EBenchmarks } from './e2e.bench.js';
+
+const SUITES: Record<string, () => Promise<void>> = {
+  lexer: runLexerBenchmarks,
+  parser: runParserBenchmarks,
+  evaluator: runEvaluatorBenchmarks,
+  store: runStoreBenchmarks,
+  resilience: runResilienceBenchmarks,
+  e2e: runE2EBenchmarks,
+};
+
+function printUsage(): void {
+  console.log(`
+Reqon Benchmark Suite
+=====================
+
+Usage:
+  npx tsx src/benchmark/index.ts [options]
+
+Options:
+  --suite <name>    Run a specific benchmark suite
+  --list            List available benchmark suites
+  --help            Show this help message
+
+Available Suites:
+  lexer       - Tokenization benchmarks
+  parser      - Parsing benchmarks
+  evaluator   - Expression evaluation benchmarks
+  store       - Store adapter benchmarks
+  resilience  - Circuit breaker and rate limiter benchmarks
+  e2e         - End-to-end execution benchmarks
+  all         - Run all benchmarks (default)
+
+Examples:
+  npx tsx src/benchmark/index.ts              # Run all benchmarks
+  npx tsx src/benchmark/index.ts --suite lexer   # Run only lexer benchmarks
+  npx tsx src/benchmark/index.ts --suite parser  # Run only parser benchmarks
+`);
+}
+
+async function main(): Promise<void> {
+  const args = process.argv.slice(2);
+
+  // Parse arguments
+  let suiteName = 'all';
+  for (let i = 0; i < args.length; i++) {
+    if (args[i] === '--help' || args[i] === '-h') {
+      printUsage();
+      process.exit(0);
+    }
+    if (args[i] === '--list') {
+      console.log('\nAvailable benchmark suites:');
+      for (const name of Object.keys(SUITES)) {
+        console.log(`  - ${name}`);
+      }
+      console.log('  - all (runs all suites)');
+      process.exit(0);
+    }
+    if (args[i] === '--suite' || args[i] === '-s') {
+      suiteName = args[++i];
+    }
+  }
+
+  console.log(`
+╔═══════════════════════════════════════════════════════════════╗
+║                   REQON BENCHMARK SUITE                       ║
+╚═══════════════════════════════════════════════════════════════╝
+`);
+
+  const startTime = Date.now();
+
+  if (suiteName === 'all') {
+    console.log('Running all benchmark suites...\n');
+    for (const [name, runFn] of Object.entries(SUITES)) {
+      console.log(`\n>>> Running ${name} benchmarks...`);
+      await runFn();
+    }
+  } else if (SUITES[suiteName]) {
+    console.log(`Running ${suiteName} benchmarks...\n`);
+    await SUITES[suiteName]();
+  } else {
+    console.error(`Unknown suite: ${suiteName}`);
+    console.error(`Available suites: ${Object.keys(SUITES).join(', ')}, all`);
+    process.exit(1);
+  }
+
+  const totalTime = ((Date.now() - startTime) / 1000).toFixed(2);
+  console.log(`\n${'═'.repeat(60)}`);
+  console.log(`Benchmarks completed in ${totalTime}s`);
+  console.log(`${'═'.repeat(60)}`);
+}
+
+main().catch((err) => {
+  console.error('Benchmark failed:', err);
+  process.exit(1);
+});

package/src/benchmark/lexer.bench.ts

@@ -0,0 +1,69 @@
+/**
+ * Lexer benchmarks
+ */
+
+import { ReqonLexer } from '../lexer/lexer.js';
+import { BenchmarkSuite } from './utils.js';
+import {
+  SIMPLE_DSL,
+  MEDIUM_DSL,
+  COMPLEX_DSL,
+  EXPRESSION_HEAVY_DSL,
+  generateLargeDSL,
+} from './fixtures.js';
+
+export async function runLexerBenchmarks(): Promise<void> {
+  const suite = new BenchmarkSuite('Lexer');
+
+  // Simple DSL tokenization
+  suite.addSync('simple-dsl', () => {
+    const lexer = new ReqonLexer(SIMPLE_DSL);
+    return lexer.tokenize();
+  });
+
+  // Medium complexity DSL
+  suite.addSync('medium-dsl', () => {
+    const lexer = new ReqonLexer(MEDIUM_DSL);
+    return lexer.tokenize();
+  });
+
+  // Complex DSL
+  suite.addSync('complex-dsl', () => {
+    const lexer = new ReqonLexer(COMPLEX_DSL);
+    return lexer.tokenize();
+  });
+
+  // Expression-heavy DSL
+  suite.addSync('expression-heavy', () => {
+    const lexer = new ReqonLexer(EXPRESSION_HEAVY_DSL);
+    return lexer.tokenize();
+  });
+
+  // Large generated DSL (10 actions)
+  const largeDsl10 = generateLargeDSL(10);
+  suite.addSync('large-10-actions', () => {
+    const lexer = new ReqonLexer(largeDsl10);
+    return lexer.tokenize();
+  });
+
+  // Large generated DSL (50 actions)
+  const largeDsl50 = generateLargeDSL(50);
+  suite.addSync('large-50-actions', () => {
+    const lexer = new ReqonLexer(largeDsl50);
+    return lexer.tokenize();
+  }, { iterations: 500 });
+
+  // Large generated DSL (100 actions) - stress test
+  const largeDsl100 = generateLargeDSL(100);
+  suite.addSync('large-100-actions', () => {
+    const lexer = new ReqonLexer(largeDsl100);
+    return lexer.tokenize();
+  }, { iterations: 100, warmupIterations: 10 });
+
+  suite.print();
+}
+
+// Run if executed directly
+if (import.meta.url === `file://${process.argv[1]}`) {
+  runLexerBenchmarks().catch(console.error);
+}

package/src/benchmark/parser.bench.ts

@@ -0,0 +1,103 @@
+/**
+ * Parser benchmarks
+ */
+
+import { ReqonLexer } from '../lexer/lexer.js';
+import { ReqonParser } from '../parser/parser.js';
+import { BenchmarkSuite } from './utils.js';
+import {
+  SIMPLE_DSL,
+  MEDIUM_DSL,
+  COMPLEX_DSL,
+  EXPRESSION_HEAVY_DSL,
+  MATCH_HEAVY_DSL,
+  generateLargeDSL,
+} from './fixtures.js';
+
+// Pre-tokenize for parser-only benchmarks
+function preTokenize(source: string) {
+  const lexer = new ReqonLexer(source);
+  return lexer.tokenize();
+}
+
+export async function runParserBenchmarks(): Promise<void> {
+  const suite = new BenchmarkSuite('Parser');
+
+  // Pre-tokenize all fixtures
+  const simpleTokens = preTokenize(SIMPLE_DSL);
+  const mediumTokens = preTokenize(MEDIUM_DSL);
+  const complexTokens = preTokenize(COMPLEX_DSL);
+  const expressionTokens = preTokenize(EXPRESSION_HEAVY_DSL);
+  const matchTokens = preTokenize(MATCH_HEAVY_DSL);
+  const large10Tokens = preTokenize(generateLargeDSL(10));
+  const large50Tokens = preTokenize(generateLargeDSL(50));
+
+  // Parser-only benchmarks (with pre-tokenized input)
+  suite.addSync('simple-dsl', () => {
+    const parser = new ReqonParser([...simpleTokens]);
+    return parser.parse();
+  });
+
+  suite.addSync('medium-dsl', () => {
+    const parser = new ReqonParser([...mediumTokens]);
+    return parser.parse();
+  });
+
+  suite.addSync('complex-dsl', () => {
+    const parser = new ReqonParser([...complexTokens]);
+    return parser.parse();
+  });
+
+  suite.addSync('expression-heavy', () => {
+    const parser = new ReqonParser([...expressionTokens]);
+    return parser.parse();
+  });
+
+  suite.addSync('match-heavy', () => {
+    const parser = new ReqonParser([...matchTokens]);
+    return parser.parse();
+  });
+
+  suite.addSync('large-10-actions', () => {
+    const parser = new ReqonParser([...large10Tokens]);
+    return parser.parse();
+  });
+
+  suite.addSync('large-50-actions', () => {
+    const parser = new ReqonParser([...large50Tokens]);
+    return parser.parse();
+  }, { iterations: 500 });
+
+  suite.print();
+
+  // Full pipeline benchmarks (lexer + parser)
+  const pipelineSuite = new BenchmarkSuite('Lexer + Parser Pipeline');
+
+  pipelineSuite.addSync('simple-full', () => {
+    const lexer = new ReqonLexer(SIMPLE_DSL);
+    const tokens = lexer.tokenize();
+    const parser = new ReqonParser(tokens);
+    return parser.parse();
+  });
+
+  pipelineSuite.addSync('medium-full', () => {
+    const lexer = new ReqonLexer(MEDIUM_DSL);
+    const tokens = lexer.tokenize();
+    const parser = new ReqonParser(tokens);
+    return parser.parse();
+  });
+
+  pipelineSuite.addSync('complex-full', () => {
+    const lexer = new ReqonLexer(COMPLEX_DSL);
+    const tokens = lexer.tokenize();
+    const parser = new ReqonParser(tokens);
+    return parser.parse();
+  });
+
+  pipelineSuite.print();
+}
+
+// Run if executed directly
+if (import.meta.url === `file://${process.argv[1]}`) {
+  runParserBenchmarks().catch(console.error);
+}

package/src/benchmark/resilience.bench.ts

@@ -0,0 +1,193 @@
+/**
+ * Resilience component benchmarks (Circuit Breaker and Rate Limiter)
+ */
+
+import { CircuitBreaker } from '../auth/circuit-breaker.js';
+import { AdaptiveRateLimiter } from '../auth/rate-limiter.js';
+import { BenchmarkSuite } from './utils.js';
+
+export async function runResilienceBenchmarks(): Promise<void> {
+  // Circuit Breaker benchmarks
+  const cbSuite = new BenchmarkSuite('CircuitBreaker');
+
+  // Basic operations in closed state
+  const closedBreaker = new CircuitBreaker();
+
+  cbSuite.addSync('canProceed-closed', () => {
+    return closedBreaker.canProceed('test-source', '/endpoint');
+  });
+
+  cbSuite.addSync('ensureCanProceed-closed', () => {
+    closedBreaker.ensureCanProceed('test-source', '/endpoint');
+  });
+
+  cbSuite.addSync('recordSuccess-closed', () => {
+    closedBreaker.recordSuccess('test-source', '/endpoint');
+  });
+
+  cbSuite.addSync('recordFailure-closed', () => {
+    const breaker = new CircuitBreaker({ failureThreshold: 1000 }); // High threshold to stay closed
+    breaker.recordFailure('test-source', '/endpoint');
+  });
+
+  // Configure operation
+  cbSuite.addSync('configure', () => {
+    const breaker = new CircuitBreaker();
+    breaker.configure('new-source', {
+      failureThreshold: 10,
+      resetTimeout: 60000,
+    });
+  });
+
+  // State transition to open
+  cbSuite.addSync('transition-to-open', () => {
+    const breaker = new CircuitBreaker({ failureThreshold: 3 });
+    breaker.recordFailure('source', '/ep');
+    breaker.recordFailure('source', '/ep');
+    breaker.recordFailure('source', '/ep');
+    return breaker.getStatus('source', '/ep');
+  });
+
+  // Multiple sources/endpoints
+  cbSuite.addSync('multi-source-check', () => {
+    const breaker = new CircuitBreaker();
+    for (let i = 0; i < 10; i++) {
+      breaker.canProceed(`source-${i}`, `/endpoint-${i}`);
+    }
+  });
+
+  // Simulate realistic request pattern
+  cbSuite.addSync('realistic-request-pattern', () => {
+    const breaker = new CircuitBreaker({ failureThreshold: 5 });
+    // 80% success, 20% failure
+    for (let i = 0; i < 100; i++) {
+      breaker.ensureCanProceed('api', '/data');
+      if (Math.random() > 0.2) {
+        breaker.recordSuccess('api', '/data');
+      } else {
+        breaker.recordFailure('api', '/data');
+      }
+    }
+  }, { iterations: 100 });
+
+  cbSuite.print();
+
+  // Rate Limiter benchmarks
+  const rlSuite = new BenchmarkSuite('AdaptiveRateLimiter');
+
+  const limiter = new AdaptiveRateLimiter();
+
+  await rlSuite.addAsync('canProceed-fresh', async () => {
+    const rl = new AdaptiveRateLimiter();
+    return await rl.canProceed('api', '/endpoint');
+  });
+
+  await rlSuite.addAsync('canProceed-existing', async () => {
+    return await limiter.canProceed('test-api', '/test-endpoint');
+  });
+
+  // Configure operation
+  rlSuite.addSync('configure', () => {
+    const rl = new AdaptiveRateLimiter();
+    rl.configure('api', {
+      strategy: 'pause',
+      maxWait: 60,
+      notifyAt: 5,
+      fallbackRpm: 100,
+    });
+  });
+
+  // Record response with rate limit info
+  await rlSuite.addAsync('recordResponse-with-headers', async () => {
+    const rl = new AdaptiveRateLimiter();
+    rl.recordResponse('api', {
+      remaining: 50,
+      limit: 100,
+      resetAt: new Date(Date.now() + 3600000),
+    }, '/endpoint');
+  });
+
+  // Record response without rate limit info
+  await rlSuite.addAsync('recordResponse-no-headers', async () => {
+    const rl = new AdaptiveRateLimiter();
+    rl.recordResponse('api', {}, '/endpoint');
+  });
+
+  // Record 429 response with retry-after
+  await rlSuite.addAsync('recordResponse-429', async () => {
+    const rl = new AdaptiveRateLimiter();
+    rl.recordResponse('api', {
+      retryAfter: 60,
+    }, '/endpoint');
+  });
+
+  // getStatus operation
+  await rlSuite.addAsync('getStatus', async () => {
+    return limiter.getStatus('test-api', '/test-endpoint');
+  });
+
+  // Multiple endpoints check
+  await rlSuite.addAsync('multi-endpoint-check', async () => {
+    const rl = new AdaptiveRateLimiter();
+    for (let i = 0; i < 10; i++) {
+      await rl.canProceed(`source-${i}`, `/endpoint-${i}`);
+    }
+  });
+
+  // Simulate realistic request pattern
+  await rlSuite.addAsync('realistic-request-pattern', async () => {
+    const rl = new AdaptiveRateLimiter();
+
+    for (let i = 0; i < 20; i++) {
+      await rl.canProceed('api', '/data');
+      rl.recordResponse('api', {
+        remaining: 95 - i,
+        limit: 100,
+        resetAt: new Date(Date.now() + 60000),
+      }, '/data');
+    }
+  }, { iterations: 100 });
+
+  rlSuite.print();
+
+  // Combined resilience pattern
+  const combinedSuite = new BenchmarkSuite('Combined Resilience Pattern');
+
+  await combinedSuite.addAsync('circuit-breaker-plus-rate-limiter', async () => {
+    const cb = new CircuitBreaker({ failureThreshold: 5 });
+    const rl = new AdaptiveRateLimiter();
+
+    // Simulate 50 requests
+    for (let i = 0; i < 50; i++) {
+      // Check circuit breaker
+      try {
+        cb.ensureCanProceed('api', '/data');
+      } catch {
+        continue;
+      }
+
+      // Check rate limiter
+      if (!(await rl.canProceed('api', '/data'))) {
+        continue;
+      }
+
+      // Simulate response
+      const success = Math.random() > 0.1;
+      if (success) {
+        cb.recordSuccess('api', '/data');
+        rl.recordResponse('api', {
+          remaining: 50,
+        }, '/data');
+      } else {
+        cb.recordFailure('api', '/data');
+      }
+    }
+  }, { iterations: 100 });
+
+  combinedSuite.print();
+}
+
+// Run if executed directly
+if (import.meta.url === `file://${process.argv[1]}`) {
+  runResilienceBenchmarks().catch(console.error);
+}

package/src/benchmark/store.bench.ts

@@ -0,0 +1,147 @@
+/**
+ * Store adapter benchmarks
+ */
+
+import { MemoryStore } from '../stores/memory.js';
+import { applyStoreFilter } from '../stores/types.js';
+import { BenchmarkSuite, generateRecords } from './utils.js';
+
+export async function runStoreBenchmarks(): Promise<void> {
+  const suite = new BenchmarkSuite('MemoryStore Operations');
+
+  // Prepare test data
+  const smallRecords = generateRecords(100);
+  const mediumRecords = generateRecords(1000);
+  const largeRecords = generateRecords(10000);
+
+  // Individual set operations
+  await suite.addAsync('set-single', async () => {
+    const store = new MemoryStore('test');
+    await store.set('key-1', { id: '1', value: 42 });
+  });
+
+  // Batch set operations
+  await suite.addAsync('set-100-records', async () => {
+    const store = new MemoryStore('test');
+    for (const record of smallRecords) {
+      await store.set(record.id as string, record);
+    }
+  }, { iterations: 100 });
+
+  await suite.addAsync('set-1000-records', async () => {
+    const store = new MemoryStore('test');
+    for (const record of mediumRecords) {
+      await store.set(record.id as string, record);
+    }
+  }, { iterations: 50, warmupIterations: 5 });
+
+  // Get operations (pre-populate store)
+  const prePopulatedStore = new MemoryStore('prepopulated');
+  for (const record of mediumRecords) {
+    await prePopulatedStore.set(record.id as string, record);
+  }
+
+  await suite.addAsync('get-existing', async () => {
+    await prePopulatedStore.get('record-500');
+  });
+
+  await suite.addAsync('get-nonexistent', async () => {
+    await prePopulatedStore.get('nonexistent-key');
+  });
+
+  await suite.addAsync('get-100-sequential', async () => {
+    for (let i = 0; i < 100; i++) {
+      await prePopulatedStore.get(`record-${i}`);
+    }
+  }, { iterations: 100 });
+
+  // Update operations
+  await suite.addAsync('update-existing', async () => {
+    await prePopulatedStore.update('record-500', { updated: true });
+  });
+
+  await suite.addAsync('update-100-records', async () => {
+    for (let i = 0; i < 100; i++) {
+      await prePopulatedStore.update(`record-${i}`, { updated: true });
+    }
+  }, { iterations: 100 });
+
+  // List operations
+  await suite.addAsync('list-all-1000', async () => {
+    await prePopulatedStore.list();
+  }, { iterations: 100 });
+
+  // Large store for list benchmarks
+  const largeStore = new MemoryStore('large');
+  for (const record of largeRecords) {
+    await largeStore.set(record.id as string, record);
+  }
+
+  await suite.addAsync('list-all-10000', async () => {
+    await largeStore.list();
+  }, { iterations: 20, warmupIterations: 5 });
+
+  // List with filters
+  await suite.addAsync('list-with-limit-100', async () => {
+    await largeStore.list({ limit: 100 });
+  }, { iterations: 100 });
+
+  await suite.addAsync('list-with-offset-and-limit', async () => {
+    await largeStore.list({ offset: 5000, limit: 100 });
+  }, { iterations: 100 });
+
+  await suite.addAsync('list-with-where-clause', async () => {
+    await largeStore.list({ where: { active: true } });
+  }, { iterations: 50, warmupIterations: 5 });
+
+  // Delete operations
+  await suite.addAsync('delete-single', async () => {
+    const store = new MemoryStore('test');
+    await store.set('key-1', { id: '1' });
+    await store.delete('key-1');
+  });
+
+  suite.print();
+
+  // Filter function benchmarks
+  const filterSuite = new BenchmarkSuite('applyStoreFilter');
+
+  filterSuite.addSync('no-filter-1000', () => {
+    return applyStoreFilter(mediumRecords);
+  });
+
+  filterSuite.addSync('no-filter-10000', () => {
+    return applyStoreFilter(largeRecords);
+  }, { iterations: 100 });
+
+  filterSuite.addSync('limit-only-1000', () => {
+    return applyStoreFilter(mediumRecords, { limit: 100 });
+  });
+
+  filterSuite.addSync('offset-limit-1000', () => {
+    return applyStoreFilter(mediumRecords, { offset: 500, limit: 100 });
+  });
+
+  filterSuite.addSync('where-simple-1000', () => {
+    return applyStoreFilter(mediumRecords, { where: { active: true } });
+  });
+
+  filterSuite.addSync('where-simple-10000', () => {
+    return applyStoreFilter(largeRecords, { where: { active: true } });
+  }, { iterations: 100 });
+
+  filterSuite.addSync('where-multiple-conditions', () => {
+    return applyStoreFilter(largeRecords, {
+      where: { active: true },
+      offset: 100,
+      limit: 50,
+    });
+  }, { iterations: 100 });
+
+  filterSuite.print();
+}
+
+// Run if executed directly
+if (import.meta.url === `file://${process.argv[1]}`) {
+  runStoreBenchmarks().catch(console.error);
+}