feat: upgrade types to reflect middy v2.x usage

Author: lkhari

packages/lambda-powertools-middleware-correlation-ids/index.d.ts

@@ -2,7 +2,6 @@ import middy from "@middy/core";
 import {
   Context,
   SQSRecord,
-  Handler,
   DynamoDBRecord,
   DynamoDBStreamEvent,
   Callback,
@@ -15,28 +14,38 @@ import CorrelationIds from "@dazn/lambda-powertools-correlation-ids";
 
 export default function <T, R, C extends Context = Context>(params: {
   sampleDebugLogRate: number;
-}): middy.MiddlewareObject<T, R, C>;
+}): middy.MiddlewareObj<T, R, C>;
 
 export type ExtractedCorrelationIdAndLogger<L = Log> = {
   logger: L;
   correlationIds: CorrelationIds;
 };
 
+export type Handler<
+  TEvent = any,
+  TResult = any,
+  TContext extends Context = Context
+> = (
+  event: TEvent,
+  context: TContext,
+  callback: Callback<TResult>
+) => void | Promise<TResult>;
+
 export type SQSEvent<L = Log> = {
   Records: (SQSRecord & ExtractedCorrelationIdAndLogger<L>)[];
 };
 
-export type SQSHandler<L = Log> = Handler<SQSEvent<L>, void>;
+export type SQSHandler = Handler<SQSEvent, void>;
 
 export type KinesisContext<T, L = Log> = Context & {
   parsedKinesisEvents: ((T & ExtractedCorrelationIdAndLogger<L>) | undefined)[];
 };
 
-export type KinesisStreamHandler<T, L = Log> = (
-  event: KinesisStreamEvent,
-  context: KinesisContext<T, L>,
-  callback: Callback<void>
-) => void | Promise<void>;
+export type KinesisStreamHandler<T> = Handler<
+  KinesisStreamEvent,
+  void,
+  KinesisContext<T>
+>;
 
 export type FirehoseContext<T, L = Log> = Context & {
   parsedFirehoseEvents: (
@@ -45,18 +54,18 @@ export type FirehoseContext<T, L = Log> = Context & {
   )[];
 };
 
-export type FirehoseTransformationHandler<T, L = Log> = (
-  event: FirehoseTransformationEvent,
-  context: FirehoseContext<T, L>,
-  callback: Callback<FirehoseTransformationResult>
-) => void | Promise<FirehoseTransformationResult>;
+export type FirehoseTransformationHandler<T> = Handler<
+  FirehoseTransformationEvent,
+  FirehoseTransformationResult,
+  FirehoseContext<T>
+>;
 
-export type DynamoStreamsContext<L = Log> = Context & {
-  parsedDynamoDbEvents: (DynamoDBRecord & ExtractedCorrelationIdAndLogger<L>)[];
+export type DynamoStreamsContext = Context & {
+  parsedDynamoDbEvents: (DynamoDBRecord & ExtractedCorrelationIdAndLogger)[];
 };
 
-export type DynamoDBStreamHandler<L = Log> = (
-  event: DynamoDBStreamEvent,
-  context: DynamoStreamsContext<L>,
-  callback: Callback<void>
-) => void | Promise<void>;
+export type DynamoDBStreamHandler = Handler<
+  DynamoDBStreamEvent,
+  void,
+  DynamoStreamsContext
+>;

packages/lambda-powertools-pattern-basic/index.d.ts

@@ -2,34 +2,15 @@ import middy from "@middy/core";
 import { Callback, Context } from "aws-lambda";
 export * from "@dazn/lambda-powertools-middleware-correlation-ids";
 
-declare type EventType<T, C> = T extends (
-  event: infer EventArgType,
-  context: C,
-  callback: Callback<any>
-) => void
-  ? EventArgType
-  : T extends (event: infer EventArgType, context: C) => Promise<any>
-  ? EventArgType
-  : never;
-
-declare type HandlerReturnType<T, C> = T extends (
-  event: any,
-  context: C
-) => Promise<infer RetType>
-  ? RetType
-  : T extends (
-      event: any,
-      context: C,
-      callback: Callback<infer RetType>
-    ) => void
-  ? RetType
-  : never;
-
-declare type AsyncHandler<C extends Context> =
-  | ((event: any, context: C, callback: Callback<any>) => void)
-  | ((event: any, context: C) => Promise<any>);
-
 export default function <
-  H extends AsyncHandler<C>,
-  C extends Context = Context
->(f: H): middy.Middy<EventType<H, C>, HandlerReturnType<H, C>, C>;
+  TEvent = any,
+  TResult = any,
+  TContext extends Context = Context,
+  TErr = Error
+>(
+  f: (
+    event: TEvent,
+    context: TContext,
+    callback: Callback<TResult>
+  ) => void | Promise<TResult>
+): middy.MiddyfiedHandler<TEvent, TResult, TErr>;

packages/lambda-powertools-pattern-obfuscate/index.d.ts

@@ -2,33 +2,6 @@ import middy from "@middy/core";
 import { Callback, Context } from "aws-lambda";
 export * from "@dazn/lambda-powertools-middleware-correlation-ids";
 
-declare type EventType<T, C> = T extends (
-  event: infer EventArgType,
-  context: C,
-  callback: Callback<any>
-) => void
-  ? EventArgType
-  : T extends (event: infer EventArgType, context: C) => Promise<any>
-  ? EventArgType
-  : never;
-
-declare type HandlerReturnType<T, C> = T extends (
-  event: any,
-  context: C
-) => Promise<infer RetType>
-  ? RetType
-  : T extends (
-      event: any,
-      context: C,
-      callback: Callback<infer RetType>
-    ) => void
-  ? RetType
-  : never;
-
-declare type AsyncHandler<C extends Context> =
-  | ((event: any, context: C, callback: Callback<any>) => void)
-  | ((event: any, context: C) => Promise<any>);
-
 declare enum FILTERING_MODE {
   BLACKLIST = "BLACKLIST",
   WHITELIST = "WHITELIST",
@@ -38,14 +11,20 @@ declare namespace dazn__lambda_powertools_pattern_obfuscate {
   const FILTERING_MODE: FILTERING_MODE;
 
   function obfuscaterPattern<
-    H extends AsyncHandler<C>,
-    C extends Context = Context
+    TEvent = any,
+    TResult = any,
+    TContext extends Context = Context,
+    TErr = Error
   >(
     obfuscationFilters: string[],
-    f: H,
+    f: (
+      event: TEvent,
+      context: TContext,
+      callback: Callback<TResult>
+    ) => void | Promise<TResult>,
     filterOnAfter?: boolean,
     filteringMode?: FILTERING_MODE
-  ): middy.Middy<EventType<H, C>, HandlerReturnType<H, C>, C>;
+  ): middy.MiddyfiedHandler<TEvent, TResult, TErr>;
 }
 
 export default dazn__lambda_powertools_pattern_obfuscate;