@fortify-ts/middleware

@fortify-ts/middleware

Middleware chain for composing resilience patterns in Fortify-TS.

Installation

npm install @fortify-ts/middleware
# or
pnpm add @fortify-ts/middleware

Features

• Pattern Composition: Combine multiple patterns in a chain
• Fluent API: Method chaining for easy configuration
• Custom Middleware: Add your own middleware functions
• Execution Order: Outer to inner (first added = outermost)

Usage

Basic Usage

import { Chain } from '@fortify-ts/middleware';
import { CircuitBreaker } from '@fortify-ts/circuit-breaker';
import { Retry } from '@fortify-ts/retry';
import { Timeout } from '@fortify-ts/timeout';

const circuitBreaker = new CircuitBreaker({ maxFailures: 5 });
const retry = new Retry({ maxAttempts: 3 });
const timeout = new Timeout({ defaultTimeout: 5000 });

const chain = new Chain<Response>()
  .withCircuitBreaker(circuitBreaker)
  .withRetry(retry)
  .withTimeout(timeout);

const result = await chain.execute(async (signal) => {
  return fetch('/api/data', { signal });
});

Full Pattern Stack

import { Chain } from '@fortify-ts/middleware';
import { Bulkhead } from '@fortify-ts/bulkhead';
import { RateLimiter } from '@fortify-ts/rate-limit';
import { Timeout } from '@fortify-ts/timeout';
import { CircuitBreaker } from '@fortify-ts/circuit-breaker';
import { Retry } from '@fortify-ts/retry';
import { Fallback } from '@fortify-ts/fallback';

const chain = new Chain<Response>()
  .withBulkhead(bulkhead)           // 1st: Limit concurrency
  .withRateLimit(rateLimiter, key)  // 2nd: Rate limiting
  .withTimeout(timeout, 5000)       // 3rd: Timeout
  .withCircuitBreaker(circuitBreaker) // 4th: Circuit breaker
  .withRetry(retry)                 // 5th: Retry
  .withFallback(fallback);          // 6th: Fallback (innermost)

const result = await chain.execute(operation);

Custom Middleware

import { Chain, type Middleware } from '@fortify-ts/middleware';

// Custom logging middleware
const loggingMiddleware: Middleware<Response> = (next) => async (signal) => {
  console.log('Starting operation');
  const start = Date.now();
  try {
    const result = await next(signal);
    console.log(`Completed in ${Date.now() - start}ms`);
    return result;
  } catch (error) {
    console.log(`Failed in ${Date.now() - start}ms`);
    throw error;
  }
};

const chain = new Chain<Response>()
  .use(loggingMiddleware)
  .withRetry(retry);

Execution Order

Middleware executes from first added (outermost) to last added (innermost):

Request Flow:
  Bulkhead → RateLimit → Timeout → CircuitBreaker → Retry → Fallback → Operation

Response Flow:
  Operation → Fallback → Retry → CircuitBreaker → Timeout → RateLimit → Bulkhead

API Reference

Method	Description
withCircuitBreaker(cb)	Add circuit breaker
withRetry(retry)	Add retry
withTimeout(timeout, duration?)	Add timeout
withRateLimit(rl, key?)	Add rate limiting
withBulkhead(bh)	Add bulkhead
withFallback(fb)	Add fallback
use(middleware)	Add custom middleware
execute(operation, signal?)	Execute chain

License

MIT