Remove dependency on in-request-handler, added hooks

Author: janaz

package-lock.json

@@ -40,21 +40,20 @@
   "main": "./dist/compile/lambda",
   "types": "./dist/compile/lambda.d.ts",
   "dependencies": {
-    "in-process-request": "^0.3.1",
     "isutf8": "^4.0.0",
     "light-my-request": "^5.6.1"
   },
   "devDependencies": {
     "@types/compression": "^1.7.2",
     "@types/cookie-parser": "^1.4.3",
     "@types/express": "^4.17.14",
-    "@types/jest": "^29.2.1",
-    "@types/node": "^18.11.8",
+    "@types/jest": "^29.2.2",
+    "@types/node": "^18.11.9",
     "compression": "^1.7.4",
     "cookie-parser": "^1.4.6",
     "ejs": "^3.1.8",
     "express": "^4.18.2",
-    "jest": "^29.2.2",
+    "jest": "^29.3.1",
     "prettier": "^2.7.1",
     "ts-jest": "^29.0.3",
     "ts-node": "^10.9.1",

package.json

@@ -0,0 +1,30 @@
+import { Server, RequestListener } from "http"
+
+interface MockServer extends Server {
+  __handler: RequestListener
+}
+
+const serverFactory = (handler: RequestListener): MockServer => {
+  return {
+    __handler: handler,
+    on: () => {},
+    once: () => {},
+    removeListener: () => {},
+    address: () => "0.0.0.0",
+    listen: (_: unknown, cb: () => void) => {
+      cb()
+    },
+  } as any
+}
+
+type Output = (options: object) => Promise<RequestListener>
+type FastifyBuilder = (options: object) => any
+
+const fastifyHandler =
+  (fastifyBuilder: FastifyBuilder): Output =>
+  (options = {}) => {
+    const app = fastifyBuilder({ ...options, serverFactory })
+    return app.listen(0).then(() => app.server.__handler)
+  }
+
+export default fastifyHandler

src/handlers/fastifyHandler.ts

@@ -0,0 +1,12 @@
+const fastifyV4Handler = (app: any) =>
+  new Promise((resolve, reject) => {
+    app.ready((err: Error) => {
+      if (err) {
+        reject(err)
+      } else {
+        resolve(app.routing)
+      }
+    })
+  })
+
+export default fastifyV4Handler

src/handlers/fastifyV4Handler.ts

@@ -0,0 +1,23 @@
+import { EventEmitter } from "events"
+import { IncomingMessage, ServerResponse } from "http"
+
+type Callback = () => void
+
+export class HapiListener extends EventEmitter {
+  listen(_port: any, maybeCallback?: any, maybeCallback2?: any) {
+    let callback: Callback | undefined =
+      typeof maybeCallback === "function" ? maybeCallback : undefined
+    if (!callback) {
+      callback =
+        typeof maybeCallback2 === "function" ? maybeCallback2 : undefined
+    }
+    if (callback) {
+      callback()
+    }
+  }
+
+  get handler() {
+    return (req: IncomingMessage, res: ServerResponse) =>
+      this.emit("request", req, res)
+  }
+}

src/handlers/hapiListener.ts

@@ -0,0 +1,7 @@
+const getNestHandler = async (nestApp: any) => {
+  !nestApp.isInitialized && (await nestApp.init())
+  // nestApp.isListening = true;
+  return nestApp.httpAdapter.getInstance()
+}
+
+export default getNestHandler

src/handlers/nestHandler.ts

@@ -1,9 +1,12 @@
 import { RequestListener } from "http"
-import inProcessRequestHandler from "in-process-request"
+import { HapiListener } from "./handlers/hapiListener"
 import * as apigw from "./types"
 import eventToRequestOptions from "./eventToRequestOptions"
 import { inProcessResponseToLambdaResponse, errorResponse } from "./response"
 import { inject } from "light-my-request"
+import getNestHandler from "./handlers/nestHandler"
+import fastifyHandler from "./handlers/fastifyHandler"
+import fastifyV4Handler from "./handlers/fastifyV4Handler"
 
 declare namespace handler {
   type APIGatewayEvent = apigw.APIGatewayEvent
@@ -16,7 +19,6 @@ declare namespace handler {
   ) => Promise<handler.LambdaResponse>
 }
 
-type F<A, B> = (a: A) => B
 type Nullable<T> = T | null
 type PromiseFactory<A> = () => Promise<A>
 
@@ -31,34 +33,58 @@ const eventSupportsCookies = (event: handler.APIGatewayEvent): boolean => {
   return event.version === "2.0" && !eventHasMultiValueHeaders(event)
 }
 
+interface Options {
+  beforeDispatch?: (r: apigw.APIGatewayEvent) => Promise<apigw.APIGatewayEvent>
+  beforeReturn?: (r: apigw.LambdaResponse) => Promise<apigw.LambdaResponse>
+  onError?: (e: Error) => Promise<void>
+}
+
 const handlerBuilder = (
-  appFn: PromiseFactory<RequestListener>
+  appFn: PromiseFactory<RequestListener>,
+  options?: Options
 ): handler.APIGatewayEventHandler => {
   let dispatch: Nullable<RequestListener>
   return async (event, ctx) => {
     if (!dispatch) {
       dispatch = await appFn()
     }
     try {
-      const reqOptions = eventToRequestOptions(event, ctx)
+      let theEvent = event
+      if (options?.beforeDispatch) {
+        theEvent = await options.beforeDispatch(theEvent)
+      }
+      const reqOptions = eventToRequestOptions(theEvent, ctx)
       const mockResponse = await inject(dispatch, reqOptions)
-      return inProcessResponseToLambdaResponse(
+      let response = inProcessResponseToLambdaResponse(
         mockResponse,
         eventHasMultiValueHeaders(event),
         eventSupportsCookies(event)
       )
+      if (options?.beforeReturn) {
+        response = await options.beforeReturn(response)
+      }
+      return response
     } catch (e) {
-      console.error(e)
+      if (options?.onError) {
+        try {
+          await options.onError(e as Error)
+        } catch (e2) {
+          console.error(e)
+        }
+      } else {
+        console.error(e)
+      }
       return errorResponse()
     }
   }
 }
 
-const handler = (app: RequestListener) =>
-  handlerBuilder(() => Promise.resolve(app))
+const handler = (app: RequestListener, options?: Options) =>
+  handlerBuilder(() => Promise.resolve(app), options)
 handler.deferred = handlerBuilder
-handler.HapiListener = inProcessRequestHandler.HapiListener
-handler.nestHandler = inProcessRequestHandler.nestHandler
-handler.fastifyHandler = inProcessRequestHandler.fastifyHandler
+handler.HapiListener = HapiListener
+handler.nestHandler = getNestHandler
+handler.fastifyHandler = fastifyHandler
+handler.fastifyV4Handler = fastifyV4Handler
 
 export = handler

src/lambda.ts

@@ -54,8 +54,9 @@ describe("integration for deferred app", () => {
   })
 
   it("handler returns rejected promise if app cannot be initialized", async () => {
-    const failingHandler = lambda.deferred(() =>
-      Promise.reject(new Error("failed to initialize app"))
+    const failingHandler = lambda.deferred(
+      () => Promise.reject(new Error("failed to initialize app")),
+      { onError: async () => undefined }
     )
     const myEvent = {
       path: "/static/file.png",
@@ -75,10 +76,12 @@ describe("integration for deferred app", () => {
   })
 
   it("returns 500 if there is a problem with the request", async () => {
-    const failingApp = lambda.deferred(() =>
-      Promise.resolve(() => {
-        throw new Error("failed")
-      })
+    const failingApp = lambda.deferred(
+      () =>
+        Promise.resolve(() => {
+          throw new Error("failed")
+        }),
+      { onError: async () => undefined }
     )
     const myEvent = {
       path: "/static/file.png",