chore(cpsuLambda): to use middy logger as others do

Author: tstephen-nhs

packages/cpsuLambda/src/handler.ts

@@ -1,6 +1,6 @@
 import {APIGatewayProxyResult} from "aws-lambda"
 import middy from "@middy/core"
-import {MiddlewareGenerator} from "./middleware"
+import {MiddlewareApplicator} from "./middleware"
 import {Logger} from "@aws-lambda-powertools/logger"
 import {Result} from "pratica"
 import {Bundle, Task} from "fhir/r4"
@@ -18,7 +18,7 @@ type EventWithHeaders = {
   }
 }
 type HandlerConfig<Event, Message> = {
-  middleware: Array<MiddlewareGenerator>
+  middleware: Array<MiddlewareApplicator>
   params: HandlerParams<Event, Message>
   logger: Logger
   schema?: object
@@ -70,10 +70,10 @@ function append_headers(headers: Record<string, string>, logger: Logger) {
  *  Creates a new Lambda handler with the specified handler function and middleware.
  */
 export const newHandler = <Event extends EventWithHeaders, Message>(handlerConfig: HandlerConfig<Event, Message>) => {
-  const newHandler = middy((event: Event) => generic_handler(event, handlerConfig.params, handlerConfig.logger))
+  let newHandler = middy((event: Event) => generic_handler(event, handlerConfig.params, handlerConfig.logger))
 
-  for (const middleware_generator of handlerConfig.middleware) {
-    newHandler.use(middleware_generator(handlerConfig.logger, handlerConfig.schema))
+  for (const middleware_applicator of handlerConfig.middleware) {
+    newHandler = middleware_applicator(newHandler, handlerConfig.logger, handlerConfig.schema)
   }
 
   return newHandler

packages/cpsuLambda/src/middleware.ts

@@ -1,19 +1,26 @@
 import inputOutputLogger from "@middy/input-output-logger"
 import httpHeaderNormalizer from "@middy/http-header-normalizer"
 import {injectLambdaContext} from "@aws-lambda-powertools/logger/middleware"
-import middy from "@middy/core"
+import {MiddyfiedHandler} from "@middy/core"
+import {APIGatewayProxyResult} from "aws-lambda"
 import {Logger} from "@aws-lambda-powertools/logger"
 import validator from "@middy/validator"
 import {transpileSchema} from "@middy/validator/transpile"
 import {validationErrorHandler} from "./errorHandler"
 
-export type MiddlewareGenerator = (logger: Logger, schema?: object) => middy.MiddlewareObj
+export type MiddlewareApplicator = <Event>(
+  handler: MiddyfiedHandler<Event, APIGatewayProxyResult>,
+  logger: Logger,
+  schema?: object
+) => MiddyfiedHandler<Event, APIGatewayProxyResult>
 
-export const MIDDLEWARE: Record<string, MiddlewareGenerator> = {
-  injectLambdaContext: (logger) => injectLambdaContext(logger, {clearState: true}),
-  httpHeaderNormalizer: () => httpHeaderNormalizer() as middy.MiddlewareObj,
-  inputOutputLogger: (logger) =>
-    inputOutputLogger({
+export const MIDDLEWARE: Record<string, MiddlewareApplicator> = {
+  injectLambdaContext: (handler, logger) =>
+    handler.use(injectLambdaContext(logger, {clearState: true})),
+  httpHeaderNormalizer: (handler) =>
+    handler.use(httpHeaderNormalizer()),
+  inputOutputLogger: (handler, logger) =>
+    handler.use(inputOutputLogger({
       logger: (request) => {
         const response = (request as {response?: unknown} | null | undefined)?.response
         if (response === undefined) {
@@ -22,9 +29,11 @@ export const MIDDLEWARE: Record<string, MiddlewareGenerator> = {
           logger.debug("inputOutputLogger response", {response})
         }
       }
-    }),
-  validator: (logger, schema) => validator({eventSchema: transpileSchema(schema as object)}),
-  validationErrorHandler: (logger) => validationErrorHandler({logger: logger})
+    })),
+  validator: (handler, logger, schema) =>
+    handler.use(validator({eventSchema: transpileSchema(schema as object)})),
+  validationErrorHandler: (handler, logger) =>
+    handler.use(validationErrorHandler({logger: logger}))
 }
 
 export const DEFAULT_HANDLER_MIDDLEWARE = [