fix: remove handler callback argument

Middy does not support callback handlers since 1.x, the third argument
is actually the timeout signal.

Author: everett1992

packages/core/index.d.ts

@@ -1,5 +1,4 @@
 import {
-  Callback as LambdaCallback,
   Context as LambdaContext,
   Handler as LambdaHandler
 } from 'aws-lambda'
@@ -59,6 +58,14 @@ export interface MiddlewareObj<
   name?: string
 }
 
+export interface MiddyHandlerObject {
+  /**
+   * An abort signal that will be canceled just before the lambda times out.
+   * @see timeoutEarlyInMillis
+   */
+  signal: AbortSignal
+}
+
 // The AWS provided Handler type uses void | Promise<TResult> so we have no choice but to follow and suppress the linter warning
 // eslint-disable-next-line @typescript-eslint/no-invalid-void-type
 type MiddyInputHandler<
@@ -68,7 +75,7 @@ type MiddyInputHandler<
 > = (
   event: TEvent,
   context: TContext,
-  callback: LambdaCallback<TResult>
+  opts: MiddyHandlerObject,
 ) => // eslint-disable-next-line @typescript-eslint/no-invalid-void-type
 void | Promise<TResult> | TResult
 type MiddyInputPromiseHandler<

packages/core/index.test-d.ts

@@ -1,4 +1,4 @@
-import { expectType } from 'tsd'
+import { expectType, expectAssignable } from 'tsd'
 import middy from '.'
 import {
   APIGatewayProxyEvent,
@@ -11,12 +11,17 @@ import {
 type EnhanceHandlerType<T, NewReturn> = T extends (
   event: infer TEvent,
   context: infer TContextType,
-  callback: infer TCallbackType
+  opts: infer TOptsType
 ) => infer R
-  ? (event: TEvent, context: TContextType, callback: TCallbackType) => R | NewReturn
+  ? (event: TEvent, context: TContextType, opts: TOptsType) => R | NewReturn
   : never
 
-type LambdaHandler<TEvent = any, TResult = any> = EnhanceHandlerType<AWSLambdaHandler<TEvent, TResult>, TResult>
+type AWSLambdaHandlerWithoutCallback<TEvent = any, TResult = any> = (
+  event: TEvent,
+  context: Context,
+) => void | Promise<TResult>;
+
+type LambdaHandler<TEvent = any, TResult = any> = EnhanceHandlerType<AWSLambdaHandlerWithoutCallback<TEvent, TResult>, TResult>
 
 const lambdaHandler: LambdaHandler<APIGatewayProxyEvent, APIGatewayProxyResult> = async (event) => {
   return {
@@ -54,6 +59,12 @@ handler = middy(lambdaHandler, {
 })
 expectType<Handler>(handler)
 
+// middy wrapped handler should be assignable to aws-lambda handler type.
+expectAssignable<AWSLambdaHandler<APIGatewayProxyEvent, APIGatewayProxyResult>>(handler)
+
+// Middy handlers third argument is an object containing a abort signal
+middy((event, context, { signal }) => expectType<AbortSignal>(signal));
+
 // invokes the handler to test that it is callable
 // eslint-disable-next-line @typescript-eslint/no-invalid-void-type
 async function invokeHandler (): Promise<void | APIGatewayProxyResult> {
@@ -127,7 +138,7 @@ async function invokeHandler (): Promise<void | APIGatewayProxyResult> {
     fail: (_) => { },
     succeed: () => { }
   }
-  return await handler(sampleEvent, sampleContext, () => {})
+  return await handler(sampleEvent, sampleContext)
 }
 invokeHandler().catch(console.error)
 
@@ -315,7 +326,7 @@ async function invokSyncedHandler (): Promise<void | APIGatewayProxyResult> {
     fail: (_) => { },
     succeed: () => { }
   }
-  return await syncedHandler(sampleEvent, sampleContext, () => {})
+  return await syncedHandler(sampleEvent, sampleContext)
 }
 invokSyncedHandler().catch(console.error)