Lambda tester strongly type (#37127)

* Apply typing based on `aws-lambda` handler type

* Add confitional check for verifier

types/lambda-tester/index.d.ts

@@ -1,34 +1,50 @@
-// Type definitions for lambda-tester 3.5
+// Type definitions for lambda-tester 3.6
 // Project: https://github.com/vandium-io/lambda-tester#readme
 // Definitions by: Ivan Kerin <https://github.com/ivank>
 //                 Hajo Aho-Mantila <https://github.com/HajoAhoMantila>
+//                 Suntharesan Mohan <https://github.com/msuntharesan>
 // Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
-// TypeScript Version: 2.3
+// TypeScript Version: 3.1
 
-import { Context, ClientContext, CognitoIdentity, Handler } from "aws-lambda";
+/* tslint:disable:no-unnecessary-generics */
+
+import { Context, ClientContext, CognitoIdentity, Handler, Callback } from 'aws-lambda';
 
 declare namespace lambdaTester {
-    type Verifier = (result: any) => void;
+    type HandlerEvent<T extends Handler> = T extends Handler<infer TEvent> ? TEvent : never;
+    type HandlerResult<T extends Handler> = T extends Handler<any, infer TResult> ? TResult : never;
+    type HandlerError<T extends Handler> = T extends Handler<any, infer TResult>
+        ? NonNullable<Parameters<Callback<TResult>>['0']>
+        : never;
 
-    class LambdaTester {
-        event(event: any): this;
+    interface VerifierFn<S> {
+        (result: S, additional?: any): void | Promise<void>;
+        (result: S, additional?: any, done?: () => {}): void;
+    }
+    type Verifier<S> = S extends HandlerError<Handler>
+        ? S extends string
+            ? VerifierFn<string>
+            : S extends Error
+            ? VerifierFn<Error>
+            : never
+        : VerifierFn<S>;
+
+    class LambdaTester<T extends Handler> {
+        event(event: HandlerEvent<T>): this;
         context(context: Context): this;
         clientContext(clientContext: ClientContext): this;
-        identity(
-            cognitoIdentityId: string,
-            cognitoIdentityPoolId: string
-        ): this;
+        identity(cognitoIdentityId: string, cognitoIdentityPoolId: string): this;
         timeout(seconds: number): this;
         xray(): this;
-        expectSucceed(verifier: Verifier): Promise<any>;
-        expectFail(verifier: Verifier): Promise<any>;
-        expectError(verifier: Verifier): Promise<any>;
-        expectResult(verifier: Verifier): Promise<any>;
-        expectReject(verifier: Verifier): Promise<any>;
-        expectResolve(verifier: Verifier): Promise<any>;
+        expectSucceed(verifier: Verifier<HandlerResult<T>>): Promise<any>;
+        expectFail(verifier: Verifier<HandlerError<T>>): Promise<any>;
+        expectResult(verifier: Verifier<HandlerResult<T>>): Promise<any>;
+        expectError(verifier: Verifier<HandlerError<T>>): Promise<any>;
+        expectResolve(verifier: Verifier<HandlerResult<T>>): Promise<any>;
+        expectReject(verifier: Verifier<HandlerError<T>>): Promise<any>;
     }
 }
 
-declare function lambdaTester(handler: Handler): lambdaTester.LambdaTester;
+declare function lambdaTester<T extends Handler>(handler: T): lambdaTester.LambdaTester<T>;
 
 export = lambdaTester;

types/lambda-tester/lambda-tester-tests.ts

@@ -1,5 +1,14 @@
-import * as lambdaTester from "lambda-tester";
-import { Handler, Context, ClientContext } from "aws-lambda";
+/* tslint:disable:no-object-literal-type-assertion */
+
+import * as lambdaTester from 'lambda-tester';
+import {
+    Handler,
+    Context,
+    ClientContext,
+    APIGatewayProxyHandler,
+    APIGatewayProxyEvent,
+    APIGatewayProxyResult,
+} from 'aws-lambda';
 
 const handler: Handler = () => Promise.resolve();
 const context: Context = {} as any;
@@ -13,14 +22,14 @@ interface TError {
 }
 
 function lambdaTesterInstance() {
-    return lambdaTester(handler).event({ test: "123" });
+    return lambdaTester(handler).event({ test: '123' });
 }
 
 lambdaTesterInstance()
     .context(context)
     .clientContext(clientContext)
     .xray()
-    .identity("123", "123")
+    .identity('123', '123')
     .expectSucceed((result: TResult) => {
         const t: string = result.data;
     });
@@ -44,3 +53,20 @@ lambdaTesterInstance().expectResult((result: TResult) => {
 lambdaTesterInstance().expectError((error: TError) => {
     const t: string = error.message;
 });
+
+const apiGateway: APIGatewayProxyHandler = (event, _context) => {};
+
+const s3Lambda = lambdaTester(apiGateway).event({} as APIGatewayProxyEvent);
+
+s3Lambda
+    .context(context)
+    .clientContext(clientContext)
+    .xray()
+    .identity('123', '123')
+    .expectSucceed((result: APIGatewayProxyResult) => {});
+
+s3Lambda.expectResolve((result: APIGatewayProxyResult) => {});
+
+s3Lambda.expectReject((error: TError) => {
+    const t: string = error.message;
+});