refactor ro use new scala-aws-lambda-runtime 0.9.5

Author: arturopala

ApiGatewayRequestHandler.scala

@@ -3,13 +3,13 @@ package org.encalmo.lambda
 import scala.util.matching.Regex
 
 /** Abstract base class of an http request handler. */
-trait ApiGatewayRequestHandler[OtherContext] {
+trait ApiGatewayRequestHandler[ApplicationContext] {
 
   type Resource = (String, Regex)
 
   def handleRequest(
       request: ApiGatewayRequest
-  )(using LambdaContext, OtherContext): Option[ApiGatewayResponse]
+  )(using LambdaContext, ApplicationContext): Option[ApiGatewayResponse]
 
   extension (r: Resource)
     inline def httpMethod: String = r._1

GenericEvent.scala

@@ -0,0 +1,9 @@
+package org.encalmo.lambda
+
+import upickle.default.ReadWriter
+import org.encalmo.lambda.OptionPickler.*
+
+final case class GenericEvent(
+    funtionName: String,
+    funtionInput: ujson.Value
+) derives ReadWriter

GenericEventHandler.scala

@@ -3,7 +3,7 @@ package org.encalmo.lambda
 import ujson.Value
 
 /** Abstract base class of an generic event handler. */
-trait GenericEventHandler[OtherContext] {
+trait GenericEventHandler[ApplicationContext] {
 
   /** Optional function name for handling events having `function` property. If not defined it will default to the
     * simple class name.
@@ -12,5 +12,5 @@ trait GenericEventHandler[OtherContext] {
 
   def handleEvent(
       event: Value
-  )(using LambdaContext, OtherContext): Option[String]
+  )(using LambdaContext, ApplicationContext): Option[String]
 }

MultipleHandlersSupport.scala

@@ -11,9 +11,7 @@ final case class UnsupportedRequestError(message: String) extends Exception(mess
 
 final case class UnsupportedEventError(message: String) extends Exception(message)
 
-trait MultipleHandlersSupport[OtherContext] extends EventHandler, EventHandlerTag {
-
-  given otherContext: OtherContext
+trait MultipleHandlersSupport extends EventHandler, EventHandlerTag {
 
   private val functionNameRegex = "\"(?:function|functionName|handler)\"(?:\\s*):(?:\\s*)\"(.+?)\"".r
   private val requestPathRegex = "\"path\"(?:\\s*):(?:\\s*)\"(.+?)\"".r
@@ -26,13 +24,13 @@ trait MultipleHandlersSupport[OtherContext] extends EventHandler, EventHandlerTa
         .flatMap(m => Option(m.group(1)))
     } catch { case NonFatal(_) => None }
 
-  def apiGatewayRequestHandlers: Iterable[ApiGatewayRequestHandler[OtherContext]]
+  def apiGatewayRequestHandlers: Iterable[ApiGatewayRequestHandler[ApplicationContext]]
 
-  def sqsEventHandlers: Iterable[SqsEventHandler[OtherContext]]
+  def sqsEventHandlers: Iterable[SqsEventHandler[ApplicationContext]]
 
-  def genericEventHandlers: Iterable[GenericEventHandler[OtherContext]]
+  def genericEventHandlers: Iterable[GenericEventHandler[ApplicationContext]]
 
-  lazy val sqsEventHandlersMap: Map[String, SqsEventHandler[OtherContext]] =
+  lazy val sqsEventHandlersMap: Map[String, SqsEventHandler[ApplicationContext]] =
     sqsEventHandlers
       .map(handler =>
         (
@@ -47,7 +45,7 @@ trait MultipleHandlersSupport[OtherContext] extends EventHandler, EventHandlerTa
       )
       .toMap
 
-  lazy val genericEventHandlersMap: Map[String, GenericEventHandler[OtherContext]] = genericEventHandlers
+  lazy val genericEventHandlersMap: Map[String, GenericEventHandler[ApplicationContext]] = genericEventHandlers
     .map(handler =>
       (
         handler.functionName
@@ -61,9 +59,7 @@ trait MultipleHandlersSupport[OtherContext] extends EventHandler, EventHandlerTa
     )
     .toMap
 
-  final override inline def handleRequest(
-      input: String
-  )(using lambdaContext: LambdaContext): String =
+  final override def handleRequest(input: String)(using LambdaContext, ApplicationContext): String =
     parseInput(input).match {
       case request: ApiGatewayRequest =>
         try {
@@ -87,18 +83,23 @@ trait MultipleHandlersSupport[OtherContext] extends EventHandler, EventHandlerTa
                 sqsEventHandlersMap
                   .get(functionName)
                   .flatMap { handler =>
-                    lambdaContext.debug(
-                      s"[EVENT][${index + 1}] Invoking $functionName with payload ${record.writeAsString}"
-                    )
-                    val r = handler.handleRecord(getFunctionInput(record))
-                    lambdaContext.debug(s"[EVENT][${index + 1}] Handler returned result ${r.getOrElse("none")}")
-                    r
+                    handler.handleRecord(getFunctionInput(record))
                   }
                   .getOrElse(
                     throw UnsupportedEventError(write(event))
                   )
               case None =>
-                throw UnsupportedEventError(write(event))
+                if (sqsEventHandlersMap.size == 1)
+                then
+                  sqsEventHandlersMap.head._2
+                    .handleRecord(record)
+                    .getOrElse(
+                      throw UnsupportedEventError(write(event))
+                    )
+                else
+                  throw UnsupportedEventError(
+                    "Ambiguous SQS event cannot be processed because 'handler' parameter is missing. Add \"handler\":\"{sqsHandlerName}\" field to your record body."
+                  )
             }
           } catch handleSqsEventHandlerException(input)
         }
@@ -115,7 +116,17 @@ trait MultipleHandlersSupport[OtherContext] extends EventHandler, EventHandlerTa
                   throw UnsupportedEventError(write(event))
                 )
             case None =>
-              throw UnsupportedEventError(write(event))
+              if (genericEventHandlersMap.size == 1)
+              then
+                genericEventHandlersMap.head._2
+                  .handleEvent(event)
+                  .getOrElse(
+                    throw UnsupportedEventError(write(event))
+                  )
+              else
+                throw UnsupportedEventError(
+                  "Ambiguous generic event cannot be processed because 'handler' parameter is missing. Add \"handler\":\"{genericHandlerName}\" field to your event body."
+                )
           }
 
         } catch handleGenericEventHandlerException(input)
@@ -203,34 +214,33 @@ trait MultipleHandlersSupport[OtherContext] extends EventHandler, EventHandlerTa
 
   private inline def maybeFunctionName(json: ujson.Value): Option[String] =
     json
-      .get("functionName")
-      .flatMap(_.strOpt)
-      .orElse(
-        json
-          .get("function")
-          .flatMap(_.strOpt)
-      )
-      .orElse(
-        json
-          .get("handler")
-          .flatMap(_.strOpt)
-      )
+      .maybeString("functionName")
+      .orElse(json.maybeString("handlerName"))
+      .orElse(json.maybeString("handler"))
+      .orElse(json.maybeString("function"))
 
   private inline def getFunctionInput(event: ujson.Value): ujson.Value =
-    event.get("functionInputParts") match {
-      case Some(ujson.Arr(values)) =>
-        values.foldLeft(ujson.Obj()) { (a, v) =>
-          v match {
-            case Obj(newFields) => Obj.from(a.value ++ newFields)
-            case other =>
-              throw new Exception(
-                s"Expected functionInputParts array to contain only objects, but got ${other.getClass().getSimpleName()} $other"
-              )
+    event
+      .get("functionInputParts")
+      .orElse(event.get("handlerInputParts"))
+      .match {
+        case Some(ujson.Arr(values)) =>
+          values.foldLeft(ujson.Obj()) { (a, v) =>
+            v match {
+              case Obj(newFields) => Obj.from(a.value ++ newFields)
+              case other =>
+                throw new Exception(
+                  s"Expected functionInputParts array to contain only objects, but got ${other.getClass().getSimpleName()} $other"
+                )
+            }
           }
-        }
-      case Some(value) => value
-      case None        => event.get("functionInput").getOrElse(event)
-    }
+        case Some(value) => value
+        case None =>
+          event
+            .get("functionInput")
+            .orElse(event.get("handlerInput"))
+            .getOrElse(event)
+      }
 
   private inline def getFunctionInput(record: SqsEvent.Record): SqsEvent.Record =
     record.copy(body =

MultipleHandlersSupport.test.scala

@@ -6,14 +6,14 @@ import ujson.Value
 import upickle.default.*
 import java.time.Instant
 
+class Foo
+
 class MultipleHandlersSupportSpec extends munit.FunSuite {
 
   override def munitFixtures = List(lambdaService)
 
   val lambdaService = new LambdaServiceFixture()
 
-  class Foo
-
   test("Execute generic event handler") {
 
     assertEquals(
@@ -31,6 +31,16 @@ class MultipleHandlersSupportSpec extends munit.FunSuite {
       "bar"
     )
 
+    assertEquals(
+      lambdaRuntime.test("""{"handlerName":"TestMe","foo":"bar"}"""),
+      "bar"
+    )
+
+    assertEquals(
+      lambdaRuntime.test("""{"foo":"bar"}"""),
+      "bar"
+    )
+
     assertEquals(
       lambdaRuntime.test("""{"bar":"foo"}"""),
       """{"success":false,"timestamp":"""
@@ -45,15 +55,15 @@ class MultipleHandlersSupportSpec extends munit.FunSuite {
       "bar"
     )
     assertEquals(
-      lambdaRuntime.test("""{"function":"TestMe", "functionInput": {"foo":"bar"}}"""),
+      lambdaRuntime.test("""{"functionName":"TestMe", "functionInput": {"foo":"bar"}}"""),
       "bar"
     )
     assertEquals(
-      lambdaRuntime.test("""{"function":"TestMe", "functionInputParts": {"foo":"bar"}}"""),
+      lambdaRuntime.test("""{"handler":"TestMe", "functionInputParts": {"foo":"bar"}}"""),
       "bar"
     )
     assertEquals(
-      lambdaRuntime.test("""{"function":"TestMe", "functionInputParts": [{"foo":"bar"}]}"""),
+      lambdaRuntime.test("""{"handlerName":"TestMe", "handlerInputParts": [{"foo":"bar"}]}"""),
       "bar"
     )
     assertEquals(
@@ -148,41 +158,61 @@ class MultipleHandlersSupportSpec extends munit.FunSuite {
   override def afterAll(): Unit =
     lambdaService.close()
 
-  def lambdaRuntime = new LambdaRuntime with MultipleHandlersSupport[Foo] {
+  def lambdaRuntime =
+    new LambdaRuntime with MultipleHandlersSupport {
 
-    override given otherContext: Foo = new Foo
+      override type ApplicationContext = Foo
 
-    override def apiGatewayRequestHandlers: Iterable[ApiGatewayRequestHandler[Foo]] = Seq.empty
+      override def initialize(using environment: LambdaEnvironment) = {
+        environment.info(
+          s"Initializing lambda ${environment.getFunctionName()} ..."
+        )
+        new Foo
+      }
 
-    override def sqsEventHandlers: Iterable[SqsEventHandler[Foo]] = Seq(
-      new SqsEventHandler[Foo] {
+      override def apiGatewayRequestHandlers = Seq(new TestApiGatewayRequestHandler)
 
-        override def functionName: Option[String] = Some("TestMe")
+      override def sqsEventHandlers = Seq(new TestSqsEventHandler)
 
-        override def handleRecord(record: SqsEvent.Record)(using
-            LambdaContext,
-            Foo
-        ): Option[String] =
-          record.maybeParseBodyAsJson.flatMap(_.maybeString("foo"))
+      override def genericEventHandlers = Seq(new TestGenericEventHandler)
+    }
 
-      }
-    )
+}
 
-    override def genericEventHandlers: Iterable[GenericEventHandler[Foo]] =
-      Seq(new GenericEventHandler[Foo] {
+class TestGenericEventHandler extends GenericEventHandler[Foo] {
 
-        override def functionName: Option[String] = Some("TestMe")
+  override def functionName: Option[String] = Some("TestMe")
 
-        override def handleEvent(event: Value)(using
-            LambdaContext,
-            Foo
-        ): Option[String] = event.maybeString("foo")
+  override def handleEvent(event: Value)(using
+      LambdaContext,
+      Foo
+  ): Option[String] = event.maybeString("foo")
 
-      })
+}
 
-    lazy val config = configure { (environment: LambdaEnvironment) =>
-      println(s"Initializing lambda ${environment.getFunctionName()} ...")
-    }
-  }
+class TestSqsEventHandler extends SqsEventHandler[Foo] {
+
+  override def functionName: Option[String] = Some("TestMe")
+
+  override def handleRecord(record: SqsEvent.Record)(using
+      LambdaContext,
+      Foo
+  ): Option[String] =
+    record.maybeParseBodyAsJson.flatMap(_.maybeString("foo"))
+}
+
+class TestApiGatewayRequestHandler extends ApiGatewayRequestHandler[Foo] {
+
+  override def handleRequest(request: ApiGatewayRequest)(using LambdaContext, Foo): Option[ApiGatewayResponse] =
+    request.body.maybeReadAsJson
+      .flatMap(_.maybeString("foo"))
+      .map(foo =>
+        ApiGatewayResponse(
+          body = foo,
+          statusCode = 200,
+          headers = Map.empty,
+          isBase64Encoded = false
+        )
+      )
 
 }

SqsEventHandler.scala

@@ -1,7 +1,7 @@
 package org.encalmo.lambda
 
 /** Abstract base class of an SQS event handler. */
-trait SqsEventHandler[OtherContext] {
+trait SqsEventHandler[ApplicationContext] {
 
   /** Optional function name for handling events having `function` property. If not defined it will default to the
     * simple class name.
@@ -10,5 +10,5 @@ trait SqsEventHandler[OtherContext] {
 
   def handleRecord(
       record: SqsEvent.Record
-  )(using LambdaContext, OtherContext): Option[String]
+  )(using LambdaContext, ApplicationContext): Option[String]
 }

project.scala

@@ -1,6 +1,6 @@
 //> using scala 3.3.5
 //> using exclude scripts
-//> using dep org.encalmo::scala-aws-lambda-runtime:0.9.0
+//> using dep org.encalmo::scala-aws-lambda-runtime:0.9.5
 //> using dep org.encalmo::scala-aws-lambda-utils:0.9.2
 //> using test.dep org.encalmo::scala-aws-lambda-testkit:0.9.0
 //> using test.dep org.scalameta::munit:1.1.0