Migrate middlwares names to be consistent with verb-convention

RobinBuschmann · RobinBuschmann · commit 4800993aa9e4 · 2026-06-26T13:53:27.000+02:00
diff --git a/packages/cors/src/index.spec.ts b/packages/cors/src/index.spec.ts
@@ -1,7 +1,7 @@
 import { compose, typesOf } from '@thrty/core';
 import { args } from '@thrty/testing';
 import { NotFoundError } from '@thrty/http-errors';
-import { httpErrorHandler } from '@thrty/http-error-handler';
+import { catchHttpErrors } from '@thrty/http-error-handler';
 import { APIGatewayProxyEvent, APIGatewayProxyHandler, APIGatewayProxyResult } from 'aws-lambda';
 import { handleCors } from './index';
 
@@ -150,12 +150,12 @@ describe('preflight', () => {
   });
 });
 
-describe('with httpErrorHandler', () => {
+describe('with catchHttpErrors', () => {
   beforeAll(() => {
     handler = compose(
       typesOf<APIGatewayProxyHandler>(),
       handleCors(),
-      httpErrorHandler({ logger: false }),
+      catchHttpErrors({ logger: false }),
     )(async () => {
       throw new NotFoundError('Not found');
     });
diff --git a/packages/error-handler/src/index.spec.ts b/packages/error-handler/src/index.spec.ts
@@ -1,7 +1,7 @@
 import { compose, eventType } from '@thrty/core';
 import { inject } from '@thrty/inject';
 import { args } from '@thrty/testing';
-import { errorHandler } from './index';
+import { catchErrors } from './index';
 
 class MappedError extends Error {
   constructor(public readonly cause: unknown) {
@@ -10,11 +10,11 @@ class MappedError extends Error {
   }
 }
 
-describe('errorHandler', () => {
+describe('catchErrors', () => {
   it('passes through when the handler does not throw', async () => {
     const handler = compose(
       eventType<{ ok: true }>(),
-      errorHandler({ logger: false }),
+      catchErrors({ logger: false }),
     )(async () => 'ok');
 
     await expect(handler(...args<{ ok: true }>({ ok: true }))).resolves.toBe('ok');
@@ -24,7 +24,7 @@ describe('errorHandler', () => {
     const error = new Error('boom');
     const handler = compose(
       eventType<{}>(),
-      errorHandler({ logger: false }),
+      catchErrors({ logger: false }),
     )(async () => {
       throw error;
     });
@@ -37,7 +37,7 @@ describe('errorHandler', () => {
     const error = new Error('boom');
     const handler = compose(
       eventType<{}>(),
-      errorHandler({ logger: { error: logError } }),
+      catchErrors({ logger: { error: logError } }),
     )(async () => {
       throw error;
     });
@@ -49,7 +49,7 @@ describe('errorHandler', () => {
   it('substitutes the result when onError returns a value', async () => {
     const handler = compose(
       eventType<{ id: string }>(),
-      errorHandler({
+      catchErrors({
         logger: false,
         onError: (_error, { event }) => ({ fallback: event.id }),
       }),
@@ -65,7 +65,7 @@ describe('errorHandler', () => {
   it('propagates a mapped error when onError throws', async () => {
     const handler = compose(
       eventType<{}>(),
-      errorHandler({
+      catchErrors({
         logger: false,
         onError: (error) => {
           throw new MappedError(error);
@@ -81,7 +81,7 @@ describe('errorHandler', () => {
   it('propagates a mapped error when onError returns Promise.reject(...)', async () => {
     const handler = compose(
       eventType<{}>(),
-      errorHandler({
+      catchErrors({
         logger: false,
         onError: (error) => Promise.reject(new MappedError(error)),
       }),
@@ -96,7 +96,7 @@ describe('errorHandler', () => {
     const onError = jest.fn().mockResolvedValue('handled');
     const handler = compose(
       eventType<{ id: string }>(),
-      errorHandler({ logger: false, onError }),
+      catchErrors({ logger: false, onError }),
     )(async () => {
       throw new Error('boom');
     });
@@ -111,7 +111,7 @@ describe('errorHandler', () => {
     const logError = jest.fn();
     const handler = compose(
       eventType<{}>(),
-      errorHandler({
+      catchErrors({
         logger: { error: logError },
         onError: () => undefined as unknown as void,
       }),
@@ -128,7 +128,7 @@ describe('errorHandler', () => {
     const consoleSpy = jest.spyOn(console, 'error').mockImplementation(() => {});
     const handler = compose(
       eventType<{}>(),
-      errorHandler({
+      catchErrors({
         logger: false,
         onError: () => undefined as unknown as void,
       }),
@@ -148,7 +148,7 @@ describe('errorHandler', () => {
       inject({
         logger: () => ({ error: logError }),
       }),
-      errorHandler({
+      catchErrors({
         onError: () => undefined as unknown as void,
       }),
     )(async () => {
@@ -167,7 +167,7 @@ describe('errorHandler', () => {
       inject({
         logger: () => ({ error: depsLogger }),
       }),
-      errorHandler({
+      catchErrors({
         logger: { error: optionsLogger },
         onError: () => undefined as unknown as void,
       }),
@@ -183,7 +183,7 @@ describe('errorHandler', () => {
   it('awaits async onError', async () => {
     const handler = compose(
       eventType<{}>(),
-      errorHandler({
+      catchErrors({
         logger: false,
         onError: () =>
           new Promise<string>((resolve) => setTimeout(() => resolve('async-handled'), 1)),
diff --git a/packages/error-handler/src/index.ts b/packages/error-handler/src/index.ts
@@ -5,7 +5,7 @@ export interface ErrorLogger {
   [log: string]: any;
 }
 
-export interface ErrorHandlerOptions<TEvent, TContext, TResult> {
+export interface CatchErrorsOptions<TEvent, TContext, TResult> {
   /**
    * Called for every caught error, after logging. Return
    * `Promise.reject(...)` to propagate (the original or a mapped error);
@@ -33,9 +33,9 @@ export interface ErrorHandlerOptions<TEvent, TContext, TResult> {
  * semantics are preserved. Provide `onError` to map the error or substitute
  * a result (e.g. an HTTP response).
  */
-export const errorHandler =
+export const catchErrors =
   <TEvent, TContext, TResult>(
-    options: ErrorHandlerOptions<TEvent, TContext, TResult> = {},
+    options: CatchErrorsOptions<TEvent, TContext, TResult> = {},
   ): Middleware<TEvent, TEvent, Promise<TResult>, Promise<TResult>, TContext, TContext> =>
   (handler) =>
   async (event, context, ...rest: any[]) => {
diff --git a/packages/http-error-handler/src/index.spec.ts b/packages/http-error-handler/src/index.spec.ts
@@ -13,7 +13,7 @@ import {
   APIGatewayProxyEvent,
   APIGatewayProxyResult as AwsLambdaAPIGatewayProxyResult,
 } from 'aws-lambda';
-import { httpErrorHandler } from './index';
+import { catchHttpErrors } from './index';
 
 type APIGatewayProxyResult = Omit<AwsLambdaAPIGatewayProxyResult, 'body'> & {
   body?: string;
@@ -23,7 +23,7 @@ describe('simple setup', () => {
   let throwError: jest.Mock;
   let handler = compose(
     types<APIGatewayEvent, Promise<APIGatewayProxyResult>>(),
-    httpErrorHandler({ logger: false }),
+    catchHttpErrors({ logger: false }),
   )(async (event) => {
     throwError();
 
@@ -126,7 +126,7 @@ describe('simple setup', () => {
 describe('blacklist', () => {
   const handler = compose(
     types<APIGatewayEvent, Promise<APIGatewayProxyResult>>(),
-    httpErrorHandler({
+    catchHttpErrors({
       logger: false,
       blacklist: [{ alternativeMessage: 'Error', statusCode: 404 }],
     }),
@@ -184,7 +184,7 @@ describe('context.deps.logger', () => {
     inject({
       logger: () => ({ error: logError }),
     }),
-    httpErrorHandler(),
+    catchHttpErrors(),
   )(async (_event) => {
     throwError();
 
@@ -220,7 +220,7 @@ describe('options.logger', () => {
     logError = jest.fn();
     handler = compose(
       types<APIGatewayEvent, Promise<APIGatewayProxyResult>>(),
-      httpErrorHandler({
+      catchHttpErrors({
         logger: { error: logError },
       }),
     )(async (event) => {
diff --git a/packages/http-error-handler/src/index.ts b/packages/http-error-handler/src/index.ts
@@ -1,5 +1,5 @@
 import { Middleware } from '@thrty/core';
-import { errorHandler } from '@thrty/error-handler';
+import { catchErrors } from '@thrty/error-handler';
 import { BaseError } from '@thrty/http-errors';
 import { APIGatewayProxyResult } from 'aws-lambda';
 
@@ -14,7 +14,7 @@ interface ErrorLogger {
   [log: string]: any;
 }
 
-export interface HttpErrorHandlerOptions {
+export interface CatchHttpErrorsOptions {
   /**
    * Logger to use for logging errors.
    * If not provided, console will be used.
@@ -35,20 +35,20 @@ export interface HttpErrorHandlerOptions {
   safeBaseError?: any;
 }
 
-type ResolvedHttpErrorHandlerOptions = Required<
-  Pick<HttpErrorHandlerOptions, 'blacklist' | 'safeBaseError'>
+type ResolvedCatchHttpErrorsOptions = Required<
+  Pick<CatchHttpErrorsOptions, 'blacklist' | 'safeBaseError'>
 >;
 
-type HttpErrorHandlerRequiredEvents = {
+type CatchHttpErrorsRequiredEvents = {
   path: string;
   httpMethod: string;
 };
 
-export const httpErrorHandler = <T extends HttpErrorHandlerRequiredEvents, C, R>(
-  options: HttpErrorHandlerOptions = {},
+export const catchHttpErrors = <T extends CatchHttpErrorsRequiredEvents, C, R>(
+  options: CatchHttpErrorsOptions = {},
 ): Middleware<T, T, Promise<R>, Promise<R>, C, C> => {
   const resolvedOptions = { ...defaultOptions, ...options };
-  return errorHandler<T, C, R>({
+  return catchErrors<T, C, R>({
     logger: options.logger,
     onError: (error) => {
       const { statusCode, message, ...errorProps } = getSafeResponse(resolvedOptions, error);
@@ -66,7 +66,7 @@ export const httpErrorHandler = <T extends HttpErrorHandlerRequiredEvents, C, R>
   });
 };
 
-export const getSafeResponse = (options: ResolvedHttpErrorHandlerOptions, error?: any) => {
+export const getSafeResponse = (options: ResolvedCatchHttpErrorsOptions, error?: any) => {
   const isSafeErrorInstance = error instanceof options.safeBaseError;
   if (!isSafeErrorInstance) {
     return {
@@ -95,7 +95,7 @@ const internalServerError = { statusCode: 500, alternativeMessage: 'InternalServ
 const forbiddenError = { statusCode: 403, alternativeMessage: 'Forbidden' };
 const unauthorizedError = { statusCode: 401, alternativeMessage: 'Unauthorized' };
 
-const defaultOptions: ResolvedHttpErrorHandlerOptions = {
+const defaultOptions: ResolvedCatchHttpErrorsOptions = {
   blacklist: [internalServerError, forbiddenError, unauthorizedError, unknownError],
   safeBaseError: BaseError,
 };
diff --git a/packages/http-json-body-parser/src/index.spec.ts b/packages/http-json-body-parser/src/index.spec.ts
@@ -1,20 +1,20 @@
 import { APIGatewayProxyEvent } from 'aws-lambda';
 import { compose, types, of } from '@thrty/core';
-import { parseJson } from './index';
+import { parseRequestBody } from './index';
 
 let handler: any;
 const body = { name: 'bob', age: 12 };
 
 beforeEach(() => {
   handler = compose(
     types<APIGatewayProxyEvent, any>(),
-    parseJson(),
+    parseRequestBody(),
   )(async (event) => {
     return event.jsonBody;
   });
 });
 
-it('should return parseJson body', async () => {
+it('should parse the request body as JSON', async () => {
   const jsonBody = await handler({ body: JSON.stringify(body) });
   expect(jsonBody).toEqual(body);
 });
@@ -24,7 +24,7 @@ describe('given body type is specified', () => {
     it('should not throw ts errors', () => {
       handler = compose(
         types<APIGatewayProxyEvent, any>(),
-        parseJson(of<{ id: string; description: string }>),
+        parseRequestBody(of<{ id: string; description: string }>),
       )(async (event) => {
         event.jsonBody.id;
         event.jsonBody.description;
@@ -35,7 +35,7 @@ describe('given body type is specified', () => {
     it('should throw ts error', () => {
       handler = compose(
         types<APIGatewayProxyEvent, any>(),
-        parseJson(of<{ id: string; description: string }>),
+        parseRequestBody(of<{ id: string; description: string }>),
       )(async (event) => {
         // @ts-expect-error
         event.jsonBody.unknown;
diff --git a/packages/http-json-body-parser/src/index.ts b/packages/http-json-body-parser/src/index.ts
@@ -1,10 +1,10 @@
 import { Middleware, TypeRef } from '@thrty/core';
 
-export interface ParseJsonRequiredEvent {
+export interface ParseRequestBodyRequiredEvent {
   body: string | null;
 }
-export const parseJson =
-  <T extends ParseJsonRequiredEvent, C, R, TBody = object>(
+export const parseRequestBody =
+  <T extends ParseRequestBodyRequiredEvent, C, R, TBody = object>(
     bodyType?: TypeRef<TBody>,
   ): Middleware<T, T & { jsonBody: TBody }, R, R, C, C> =>
   (handler) =>
diff --git a/packages/http-json-body-serializer/src/index.spec.ts b/packages/http-json-body-serializer/src/index.spec.ts
@@ -1,13 +1,13 @@
 import { compose, types, of } from '@thrty/core';
 import { args } from '@thrty/testing';
 import { APIGatewayEvent, APIGatewayProxyResult } from 'aws-lambda';
-import { serializeJson } from './index';
+import { serializeResponseBody } from './index';
 
 describe('given no body type is specified', () => {
   const createHandler = () =>
     compose(
       types<APIGatewayEvent, Promise<APIGatewayProxyResult>>(),
-      serializeJson(),
+      serializeResponseBody(),
     )(async (event) => {
       return {
         statusCode: 200,
@@ -45,7 +45,7 @@ describe('given body type is specified', () => {
   const createHandler = () =>
     compose(
       types<APIGatewayEvent, Promise<APIGatewayProxyResult>>(),
-      serializeJson(of<Message>),
+      serializeResponseBody(of<Message>),
     )(async (event) => {
       return {
         statusCode: 200,
@@ -81,7 +81,7 @@ describe('given body type is specified but not returned properly', () => {
   it('should throw ts error', () => {
     compose(
       types<APIGatewayEvent, Promise<APIGatewayProxyResult>>(),
-      serializeJson(of<{ id: string; description: string }>),
+      serializeResponseBody(of<{ id: string; description: string }>),
       // @ts-expect-error
     )(async (event) => {
       return {
diff --git a/packages/http-json-body-serializer/src/index.ts b/packages/http-json-body-serializer/src/index.ts
@@ -1,11 +1,11 @@
 import { APIGatewayProxyResult } from 'aws-lambda';
 import { Middleware, TypeRef } from '@thrty/core';
 
-export type SerializeJsonOptions<TBody = object> = Omit<APIGatewayProxyResult, 'body'> & {
+export type SerializeResponseBodyOptions<TBody = object> = Omit<APIGatewayProxyResult, 'body'> & {
   body?: TBody;
 };
-export const serializeJson =
-  <E, C, R1 extends APIGatewayProxyResult, R2 extends SerializeJsonOptions<TBody>, TBody>(
+export const serializeResponseBody =
+  <E, C, R1 extends APIGatewayProxyResult, R2 extends SerializeResponseBodyOptions<TBody>, TBody>(
     bodyType?: TypeRef<TBody>,
   ): Middleware<E, E, Promise<R1>, Promise<R2>, C, C> =>
   (next) =>
