reqon-dsl 0.2.0 → 0.4.0

package/src/benchmark/index.ts

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

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

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

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

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