@energica-city/shared-amplify-utils
Version:
Shared utilities for AWS Amplify projects
283 lines • 32.8 kB
JavaScript
import { logger } from '../log';
/**
* Generic middleware chain implementation
*
* Provides Express-style middleware functionality for AWS Lambda handlers and GraphQL resolvers.
* Middleware executes in an "onion model" where each middleware wraps the next one in the chain.
*
* **Execution Flow:**
* ```
* Middleware 1 (before) →
* Middleware 2 (before) →
* Final Handler →
* Middleware 2 (after) ←
* Middleware 1 (after) ←
* ```
*
* **Input Mutation:**
* - Middleware can mutate the input object directly
* - Changes are visible to all subsequent middleware and the final handler
* - Consider input immutability for complex applications
*
* **Error Handling:**
* - Errors thrown by middleware are enhanced with chain context
* - Execution stops at the first error (no subsequent middleware execute)
* - Configure `onError` handler for centralized error processing
*
* **Performance:**
* - Each execution creates a closure chain - consider reusing chains for high-frequency operations
* - Debug logging adds overhead - disable in production
*
* @template TInput - Type of input data passed through the chain
* @template TOutput - Type of output returned by the chain
*
* @example
* ```typescript
* const chain = new MiddlewareChain<MyInput, MyOutput>({
* enableDebugLogging: true,
* onError: (error, middlewareName) => {
* console.error(`Middleware ${middlewareName} failed:`, error);
* }
* });
*
* chain
* .use('auth', authMiddleware)
* .use('logging', loggingMiddleware)
* .use('validation', validationMiddleware);
*
* const result = await chain.execute(input, finalHandler);
* ```
*/
export class MiddlewareChain {
middlewares = [];
config;
constructor(config = {}) {
this.config = config;
}
/**
* Create a middleware chain specifically for AWS Lambda handlers
*
* This is a convenience method that creates a chain with the standard
* Lambda input structure: `{ event: TEvent; context: TContext }`
*
* @template TEvent - Type of the Lambda event
* @template TContext - Type of the Lambda context
* @template TReturn - Type of the Lambda return value
* @param config - Configuration options for the chain
* @returns A new middleware chain configured for Lambda handlers
*
* @example
* ```typescript
* const chain = MiddlewareChain.createLambdaChain<APIGatewayProxyEvent, Context, APIGatewayProxyResult>();
* ```
*/
static createLambdaChain(config = {}) {
return new MiddlewareChain(config);
}
/**
* Create a middleware chain specifically for GraphQL resolvers
*
* This is a convenience method that creates a chain with the standard
* GraphQL resolver input structure: `{ source, args, context, info }`
*
* @template TArgs - Type of the GraphQL arguments
* @template TSource - Type of the GraphQL source
* @template TReturn - Type of the GraphQL return value
* @param config - Configuration options for the chain
* @returns A new middleware chain configured for GraphQL resolvers
*
* @example
* ```typescript
* const chain = MiddlewareChain.createGraphQLChain<MyArgs, MySource, MyReturn>();
* ```
*/
static createGraphQLChain(config = {}) {
return new MiddlewareChain(config);
}
/**
* Add middleware to the chain
*
* Middleware functions are executed in the order they are added.
* Each middleware receives the input and a `next` function to continue
* to the next middleware or final handler.
*
* @param name - Descriptive name for the middleware (used in error messages and logging)
* @param middleware - The middleware function to add
* @returns This chain instance for method chaining
*
* @example
* ```typescript
* chain
* .use('authentication', authMiddleware)
* .use('logging', loggingMiddleware)
* .use('validation', validationMiddleware);
* ```
*/
use(name, middleware) {
this.middlewares.push({ name, middleware });
return this;
}
/**
* Execute the middleware chain with the given input and final handler
*
* This method runs all middleware in the chain, followed by the final handler.
* If any middleware throws an error, execution stops and the error is enhanced
* with chain context before being re-thrown.
*
* @param input - The input data to pass through the middleware chain
* @param finalHandler - The final handler function that processes the input
* @returns Promise resolving to the output from the final handler
*
* @example
* ```typescript
* const result = await chain.execute(
* { userId: '123', data: { name: 'John' } },
* async (input) => {
* return await fetchUserData(input.userId);
* }
* );
* ```
*/
async execute(input, finalHandler) {
if (this.middlewares.length === 0) {
return finalHandler(input);
}
let index = 0;
const executeNext = async (modifiedInput) => {
if (index >= this.middlewares.length) {
return finalHandler(modifiedInput ?? input);
}
const { name, middleware } = this.middlewares[index];
index++;
if (this.config.enableDebugLogging) {
logger.debug(`Executing middleware: ${name}`);
}
try {
return await middleware(modifiedInput ?? input, executeNext);
}
catch (error) {
// Create enhanced error with chain context
const enhancedError = error instanceof Error ? error : new Error(String(error));
// Add middleware context without mutating original error
if (!enhancedError.middlewareName) {
enhancedError.middlewareName = name;
enhancedError.middlewareIndex = index - 1;
enhancedError.totalMiddlewares = this.middlewares.length;
enhancedError.middlewareChain = this.middlewares.map(m => m.name);
// Store original error if we created a new Error object
if (!(error instanceof Error)) {
enhancedError.originalError = error;
}
}
if (this.config.onError) {
this.config.onError(enhancedError, name);
}
throw enhancedError;
}
};
return executeNext();
}
/**
* Get the number of middlewares in the chain
*
* @returns The count of middleware functions currently in the chain
*
* @example
* ```typescript
* const chain = new MiddlewareChain();
* console.log(chain.length); // 0
*
* chain.use('auth', authMiddleware);
* chain.use('logging', loggingMiddleware);
* console.log(chain.length); // 2
* ```
*/
get length() {
return this.middlewares.length;
}
/**
* Clear all middlewares from the chain
*
* Removes all middleware functions, resetting the chain to empty state.
* Useful for reusing chain instances or cleaning up during testing.
*
* @returns This chain instance for method chaining
*
* @example
* ```typescript
* const chain = new MiddlewareChain();
* chain.use('auth', authMiddleware);
* chain.use('logging', loggingMiddleware);
*
* chain.clear(); // Chain is now empty
* console.log(chain.length); // 0
* ```
*/
clear() {
this.middlewares = [];
return this;
}
}
/**
* Wrap a Lambda handler with middleware chain functionality
*
* This function creates a new Lambda handler that executes the middleware chain
* before calling the original handler. The middleware chain receives the Lambda
* event and context as input.
*
* @template TEvent - Type of the Lambda event
* @template TContext - Type of the Lambda context
* @template TReturn - Type of the Lambda return value
* @param chain - The middleware chain to execute
* @param handler - The original Lambda handler function
* @returns A new Lambda handler function that includes middleware execution
*
* @example
* ```typescript
* const wrappedHandler = wrapLambdaHandler(
* chain,
* async (event, context) => {
* return { statusCode: 200, body: 'Hello World' };
* }
* );
* ```
*/
export function wrapLambdaHandler(chain, handler) {
return async (event, context) => {
return await chain.execute({ event, context }, async (input) => {
return await handler(input.event, input.context);
});
};
}
/**
* Wrap a GraphQL resolver with middleware chain functionality
*
* This function creates a new GraphQL resolver that executes the middleware chain
* before calling the original resolver. The middleware chain receives the GraphQL
* source, args, context, and info as input.
*
* @template TArgs - Type of the GraphQL arguments
* @template TSource - Type of the GraphQL source
* @template TReturn - Type of the GraphQL return value
* @param chain - The middleware chain to execute
* @param resolver - The original GraphQL resolver function
* @returns A new GraphQL resolver function that includes middleware execution
*
* @example
* ```typescript
* const wrappedResolver = wrapGraphQLResolver(
* chain,
* async (source, args, context, info) => {
* return await fetchUserData(args.id);
* }
* );
* ```
*/
export function wrapGraphQLResolver(chain, resolver) {
return async (source, args, context, info) => {
return await chain.execute({ source, args, context, info }, async (input) => {
return await resolver(input.source, input.args, input.context, input.info);
});
};
}
//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"middlewareChain.js","sourceRoot":"","sources":["../../middleware/middlewareChain.ts"],"names":[],"mappings":"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","sourcesContent":["import { logger } from '../log';\n\n// Future Enhancement: Response Transformation Support\n// Planned features for response processing:\n// - useResponseTransformer() method for response-only transformations\n// - useFull() method for combined request/response middleware\n// - ResponseTransformer<TInput, TOutput> type for type-safe response modifications\n// These features will provide cleaner patterns for response processing (timestamps, compression, headers, etc.)\n\n/**\n * Base middleware function type\n *\n * Middleware follows the \"onion model\" pattern:\n * 1. Middleware executes in the order they were added\n * 2. Each middleware can modify input before calling next()\n * 3. Each middleware can process the result after next() returns\n * 4. If next() is not called, the chain stops and remaining middleware/handler are skipped\n *\n * @template TInput - Type of input passed to middleware\n * @template TOutput - Type of output returned by middleware chain\n * @param input - The input data passed through the chain\n * @param next - Function to continue to the next middleware or final handler\n * @returns Promise resolving to the output of the chain\n *\n * @example\n * ```typescript\n * const loggingMiddleware: Middleware<MyInput, MyOutput> = async (input, next) => {\n *   console.log('Before handler');\n *   const result = await next();\n *   console.log('After handler');\n *   return result;\n * };\n * ```\n */\nexport type Middleware<TInput = unknown, TOutput = unknown> = (\n  input: TInput,\n  next: (input?: TInput) => Promise<TOutput>,\n) => Promise<TOutput>;\n\n/**\n * Enhanced error with middleware chain context\n */\nexport interface MiddlewareError extends Error {\n  middlewareName?: string;\n  middlewareIndex?: number;\n  totalMiddlewares?: number;\n  middlewareChain?: string[];\n  originalError?: unknown;\n}\n\n/**\n * Configuration for middleware chain\n */\ninterface MiddlewareChainConfig {\n  enableDebugLogging?: boolean;\n  onError?: (error: unknown, middlewareName: string) => void;\n}\n\n/**\n * Generic middleware chain implementation\n *\n * Provides Express-style middleware functionality for AWS Lambda handlers and GraphQL resolvers.\n * Middleware executes in an \"onion model\" where each middleware wraps the next one in the chain.\n *\n * **Execution Flow:**\n * ```\n * Middleware 1 (before) →\n *   Middleware 2 (before) →\n *     Final Handler →\n *   Middleware 2 (after) ←\n * Middleware 1 (after) ←\n * ```\n *\n * **Input Mutation:**\n * - Middleware can mutate the input object directly\n * - Changes are visible to all subsequent middleware and the final handler\n * - Consider input immutability for complex applications\n *\n * **Error Handling:**\n * - Errors thrown by middleware are enhanced with chain context\n * - Execution stops at the first error (no subsequent middleware execute)\n * - Configure `onError` handler for centralized error processing\n *\n * **Performance:**\n * - Each execution creates a closure chain - consider reusing chains for high-frequency operations\n * - Debug logging adds overhead - disable in production\n *\n * @template TInput - Type of input data passed through the chain\n * @template TOutput - Type of output returned by the chain\n *\n * @example\n * ```typescript\n * const chain = new MiddlewareChain<MyInput, MyOutput>({\n *   enableDebugLogging: true,\n *   onError: (error, middlewareName) => {\n *     console.error(`Middleware ${middlewareName} failed:`, error);\n *   }\n * });\n *\n * chain\n *   .use('auth', authMiddleware)\n *   .use('logging', loggingMiddleware)\n *   .use('validation', validationMiddleware);\n *\n * const result = await chain.execute(input, finalHandler);\n * ```\n */\nexport class MiddlewareChain<TInput = unknown, TOutput = unknown> {\n  private middlewares: Array<{\n    name: string;\n    middleware: Middleware<TInput, TOutput>;\n  }> = [];\n  private config: MiddlewareChainConfig;\n\n  constructor(config: MiddlewareChainConfig = {}) {\n    this.config = config;\n  }\n\n  /**\n   * Create a middleware chain specifically for AWS Lambda handlers\n   *\n   * This is a convenience method that creates a chain with the standard\n   * Lambda input structure: `{ event: TEvent; context: TContext }`\n   *\n   * @template TEvent - Type of the Lambda event\n   * @template TContext - Type of the Lambda context\n   * @template TReturn - Type of the Lambda return value\n   * @param config - Configuration options for the chain\n   * @returns A new middleware chain configured for Lambda handlers\n   *\n   * @example\n   * ```typescript\n   * const chain = MiddlewareChain.createLambdaChain<APIGatewayProxyEvent, Context, APIGatewayProxyResult>();\n   * ```\n   */\n  static createLambdaChain<\n    TEvent = Record<string, unknown>,\n    TContext = Record<string, unknown>,\n    TReturn = Record<string, unknown>,\n  >(\n    config: MiddlewareChainConfig = {},\n  ): MiddlewareChain<{ event: TEvent; context: TContext }, TReturn> {\n    return new MiddlewareChain<{ event: TEvent; context: TContext }, TReturn>(\n      config,\n    );\n  }\n\n  /**\n   * Create a middleware chain specifically for GraphQL resolvers\n   *\n   * This is a convenience method that creates a chain with the standard\n   * GraphQL resolver input structure: `{ source, args, context, info }`\n   *\n   * @template TArgs - Type of the GraphQL arguments\n   * @template TSource - Type of the GraphQL source\n   * @template TReturn - Type of the GraphQL return value\n   * @param config - Configuration options for the chain\n   * @returns A new middleware chain configured for GraphQL resolvers\n   *\n   * @example\n   * ```typescript\n   * const chain = MiddlewareChain.createGraphQLChain<MyArgs, MySource, MyReturn>();\n   * ```\n   */\n  static createGraphQLChain<\n    TArgs = Record<string, unknown>,\n    TSource = unknown,\n    TReturn = unknown,\n  >(\n    config: MiddlewareChainConfig = {},\n  ): MiddlewareChain<\n    {\n      source: TSource;\n      args: TArgs;\n      context: Record<string, unknown>;\n      info: Record<string, unknown>;\n    },\n    TReturn\n  > {\n    return new MiddlewareChain<\n      {\n        source: TSource;\n        args: TArgs;\n        context: Record<string, unknown>;\n        info: Record<string, unknown>;\n      },\n      TReturn\n    >(config);\n  }\n\n  /**\n   * Add middleware to the chain\n   *\n   * Middleware functions are executed in the order they are added.\n   * Each middleware receives the input and a `next` function to continue\n   * to the next middleware or final handler.\n   *\n   * @param name - Descriptive name for the middleware (used in error messages and logging)\n   * @param middleware - The middleware function to add\n   * @returns This chain instance for method chaining\n   *\n   * @example\n   * ```typescript\n   * chain\n   *   .use('authentication', authMiddleware)\n   *   .use('logging', loggingMiddleware)\n   *   .use('validation', validationMiddleware);\n   * ```\n   */\n  use(name: string, middleware: Middleware<TInput, TOutput>): this {\n    this.middlewares.push({ name, middleware });\n    return this;\n  }\n\n  /**\n   * Execute the middleware chain with the given input and final handler\n   *\n   * This method runs all middleware in the chain, followed by the final handler.\n   * If any middleware throws an error, execution stops and the error is enhanced\n   * with chain context before being re-thrown.\n   *\n   * @param input - The input data to pass through the middleware chain\n   * @param finalHandler - The final handler function that processes the input\n   * @returns Promise resolving to the output from the final handler\n   *\n   * @example\n   * ```typescript\n   * const result = await chain.execute(\n   *   { userId: '123', data: { name: 'John' } },\n   *   async (input) => {\n   *     return await fetchUserData(input.userId);\n   *   }\n   * );\n   * ```\n   */\n  async execute(\n    input: TInput,\n    finalHandler: (input: TInput) => Promise<TOutput>,\n  ): Promise<TOutput> {\n    if (this.middlewares.length === 0) {\n      return finalHandler(input);\n    }\n\n    let index = 0;\n\n    const executeNext = async (modifiedInput?: TInput): Promise<TOutput> => {\n      if (index >= this.middlewares.length) {\n        return finalHandler(modifiedInput ?? input);\n      }\n\n      const { name, middleware } = this.middlewares[index];\n      index++;\n\n      if (this.config.enableDebugLogging) {\n        logger.debug(`Executing middleware: ${name}`);\n      }\n\n      try {\n        return await middleware(modifiedInput ?? input, executeNext);\n      } catch (error) {\n        // Create enhanced error with chain context\n        const enhancedError: MiddlewareError =\n          error instanceof Error ? error : new Error(String(error));\n\n        // Add middleware context without mutating original error\n        if (!enhancedError.middlewareName) {\n          enhancedError.middlewareName = name;\n          enhancedError.middlewareIndex = index - 1;\n          enhancedError.totalMiddlewares = this.middlewares.length;\n          enhancedError.middlewareChain = this.middlewares.map(m => m.name);\n\n          // Store original error if we created a new Error object\n          if (!(error instanceof Error)) {\n            enhancedError.originalError = error;\n          }\n        }\n\n        if (this.config.onError) {\n          this.config.onError(enhancedError, name);\n        }\n        throw enhancedError;\n      }\n    };\n\n    return executeNext();\n  }\n\n  /**\n   * Get the number of middlewares in the chain\n   *\n   * @returns The count of middleware functions currently in the chain\n   *\n   * @example\n   * ```typescript\n   * const chain = new MiddlewareChain();\n   * console.log(chain.length); // 0\n   *\n   * chain.use('auth', authMiddleware);\n   * chain.use('logging', loggingMiddleware);\n   * console.log(chain.length); // 2\n   * ```\n   */\n  get length(): number {\n    return this.middlewares.length;\n  }\n\n  /**\n   * Clear all middlewares from the chain\n   *\n   * Removes all middleware functions, resetting the chain to empty state.\n   * Useful for reusing chain instances or cleaning up during testing.\n   *\n   * @returns This chain instance for method chaining\n   *\n   * @example\n   * ```typescript\n   * const chain = new MiddlewareChain();\n   * chain.use('auth', authMiddleware);\n   * chain.use('logging', loggingMiddleware);\n   *\n   * chain.clear(); // Chain is now empty\n   * console.log(chain.length); // 0\n   * ```\n   */\n  clear(): this {\n    this.middlewares = [];\n    return this;\n  }\n}\n\n/**\n * Wrap a Lambda handler with middleware chain functionality\n *\n * This function creates a new Lambda handler that executes the middleware chain\n * before calling the original handler. The middleware chain receives the Lambda\n * event and context as input.\n *\n * @template TEvent - Type of the Lambda event\n * @template TContext - Type of the Lambda context\n * @template TReturn - Type of the Lambda return value\n * @param chain - The middleware chain to execute\n * @param handler - The original Lambda handler function\n * @returns A new Lambda handler function that includes middleware execution\n *\n * @example\n * ```typescript\n * const wrappedHandler = wrapLambdaHandler(\n *   chain,\n *   async (event, context) => {\n *     return { statusCode: 200, body: 'Hello World' };\n *   }\n * );\n * ```\n */\nexport function wrapLambdaHandler<\n  TEvent = Record<string, unknown>,\n  TContext = Record<string, unknown>,\n  TReturn = unknown,\n>(\n  chain: MiddlewareChain<{ event: TEvent; context: TContext }, TReturn>,\n  handler: (event: TEvent, context: TContext) => Promise<TReturn>,\n): (event: TEvent, context: TContext) => Promise<TReturn> {\n  return async (event: TEvent, context: TContext) => {\n    return await chain.execute({ event, context }, async input => {\n      return await handler(input.event, input.context);\n    });\n  };\n}\n\n/**\n * Wrap a GraphQL resolver with middleware chain functionality\n *\n * This function creates a new GraphQL resolver that executes the middleware chain\n * before calling the original resolver. The middleware chain receives the GraphQL\n * source, args, context, and info as input.\n *\n * @template TArgs - Type of the GraphQL arguments\n * @template TSource - Type of the GraphQL source\n * @template TReturn - Type of the GraphQL return value\n * @param chain - The middleware chain to execute\n * @param resolver - The original GraphQL resolver function\n * @returns A new GraphQL resolver function that includes middleware execution\n *\n * @example\n * ```typescript\n * const wrappedResolver = wrapGraphQLResolver(\n *   chain,\n *   async (source, args, context, info) => {\n *     return await fetchUserData(args.id);\n *   }\n * );\n * ```\n */\nexport function wrapGraphQLResolver<\n  TArgs = Record<string, unknown>,\n  TSource = unknown,\n  TReturn = unknown,\n>(\n  chain: MiddlewareChain<\n    {\n      source: TSource;\n      args: TArgs;\n      context: Record<string, unknown>;\n      info: Record<string, unknown>;\n    },\n    TReturn\n  >,\n  resolver: (\n    source: TSource,\n    args: TArgs,\n    context: Record<string, unknown>,\n    info: Record<string, unknown>,\n  ) => Promise<TReturn> | TReturn,\n): (\n  source: TSource,\n  args: TArgs,\n  context: Record<string, unknown>,\n  info: Record<string, unknown>,\n) => Promise<TReturn> {\n  return async (\n    source: TSource,\n    args: TArgs,\n    context: Record<string, unknown>,\n    info: Record<string, unknown>,\n  ) => {\n    return await chain.execute({ source, args, context, info }, async input => {\n      return await resolver(\n        input.source,\n        input.args,\n        input.context,\n        input.info,\n      );\n    });\n  };\n}\n"]}