Add direct-style AwsSyncServerInterpreter for AWS Lambda

build.sbt

@@ -1702,7 +1702,12 @@ lazy val awsLambdaCore: ProjectMatrix = (projectMatrix in file("serverless/aws/l
   .settings(
     name := "tapir-aws-lambda-core"
   )
-  .jvmPlatform(scalaVersions = scala2And3Versions, settings = commonJvmSettings)
+  .jvmPlatform(
+    scalaVersions = scala2And3Versions,
+    settings = commonJvmSettings ++ Seq(
+      libraryDependencies += "com.amazonaws" % "aws-lambda-java-runtime-interface-client" % Versions.awsLambdaInterface
+    )
+  )
   .jsPlatform(scalaVersions = scala2Versions, settings = commonJsSettings)
   .dependsOn(serverCore, circeJson, tests % "test")
 

doc/server/aws.md

@@ -12,12 +12,13 @@ For an overview of how this works in more detail, see [this blog post](https://b
 ## Runtime & Server interpreters
 
 Tapir supports three of the AWS Lambda runtimes: custom runtime, Java, and NodeJS. Below you have a list of classes that can be used as an entry point
-to your Lambda application depending on runtime of your choice. Each one of them uses server interpreter, which responsibility is to transform Tapir
-endpoints with associated server logic to function like `AwsRequest => F[AwsResponse]` in case of custom and Java runtime,
-or `AwsJsRequest => Future[AwsJsResponse]` in case of NodeJS runtime. Currently, two server interpreters are available, the first one is using
-cats-effect (`AwsCatsEffectServerInterpreter`), and the other one is using Scala Future (`AwsFutureServerInterpreter`). Custom runtime, and Java
-runtime are using only cats-effect interpreter, where NodeJS runtime can be used with both interpreters.
-These are corresponding classes for each of the supported runtime:
+to your Lambda application depending on runtime of your choice. Each one of them uses the server interpreter, whose responsibility is to transform Tapir
+endpoints with associated server logic to a function like `AwsRequest => F[AwsResponse]` (or `AwsRequest => AwsResponse` for direct-style) in case of custom and Java runtime,
+or `AwsJsRequest => Future[AwsJsResponse]` in case of NodeJS runtime. Currently, three server interpreters are available: `AwsCatsEffectServerInterpreter`
+using cats-effect, `AwsFutureServerInterpreter` using Scala Future, and `AwsSyncServerInterpreter` using direct-style (no effect wrapper).
+Custom runtime uses the cats-effect interpreter. Java runtime can use the cats-effect interpreter (`LambdaHandler`) or the direct-style interpreter
+(`SyncLambdaHandler`). NodeJS runtime can be used with both Future and cats-effect interpreters.
+These are the corresponding classes for each of the supported runtimes:
 
 * The `AwsLambdaIORuntime` for custom runtime. Implement the Lambda loop of reading the next request, computing and sending the response
   through [Lambda runtime API](https://docs.aws.amazon.com/lambda/latest/dg/runtimes-api.html).
@@ -26,11 +27,16 @@ These are corresponding classes for each of the supported runtime:
   interface for handling requests, response flow inside Java runtime.
 * The `AwsJsRouteHandler` for NodeJS runtime. The main benefit is the reduced deployment time. Initialization of JVM-based application (
   with `sam local`) took ~11 seconds on average, while Node.js based one only ~2 seconds.
+* The `SyncLambdaHandler` for Java runtime, a direct-style alternative to `LambdaHandler` that uses `Identity` instead of cats-effect.
+  Uses `AwsSyncServerInterpreter` and doesn't require any effect library.
 
-To start using any of the above add the following dependency:
+To start using any of the above add one of the following dependencies:
 
 ```scala
+// for cats-effect (LambdaHandler, AwsLambdaIORuntime, AwsCatsEffectServerInterpreter)
 "com.softwaremill.sttp.tapir" %% "tapir-aws-lambda" % "@VERSION@"
+// for direct-style / Future (SyncLambdaHandler, AwsSyncServerInterpreter, AwsFutureServerInterpreter)
+"com.softwaremill.sttp.tapir" %% "tapir-aws-lambda-core" % "@VERSION@"
 ```
 
 ## Deployment

serverless/aws/lambda-core/src/main/scala/sttp/tapir/serverless/aws/lambda/AwsSyncServerInterpreter.scala

@@ -0,0 +1,25 @@
+package sttp.tapir.serverless.aws.lambda
+
+import sttp.monad.MonadError
+import sttp.monad.IdentityMonad
+import sttp.shared.Identity
+import AwsSyncServerInterpreter._
+
+abstract class AwsSyncServerInterpreter extends AwsServerInterpreter[Identity]
+
+object AwsSyncServerInterpreter {
+
+  implicit val idMonadError: MonadError[Identity] = IdentityMonad
+
+  def apply(serverOptions: AwsServerOptions[Identity]): AwsSyncServerInterpreter = {
+    new AwsSyncServerInterpreter {
+      override def awsServerOptions: AwsServerOptions[Identity] = serverOptions
+    }
+  }
+
+  def apply(): AwsSyncServerInterpreter = {
+    new AwsSyncServerInterpreter {
+      override def awsServerOptions: AwsServerOptions[Identity] = AwsSyncServerOptions.default
+    }
+  }
+}

serverless/aws/lambda-core/src/main/scala/sttp/tapir/serverless/aws/lambda/AwsSyncServerOptions.scala

@@ -0,0 +1,19 @@
+package sttp.tapir.serverless.aws.lambda
+
+import sttp.shared.Identity
+import sttp.tapir.server.interceptor.CustomiseInterceptors
+
+object AwsSyncServerOptions {
+
+  /** Allows customising the interceptors used by the server interpreter. */
+  def customiseInterceptors: CustomiseInterceptors[Identity, AwsServerOptions[Identity]] =
+    CustomiseInterceptors(
+      createOptions =
+        (ci: CustomiseInterceptors[Identity, AwsServerOptions[Identity]]) => AwsServerOptions(encodeResponseBody = true, ci.interceptors)
+    )
+
+  def default: AwsServerOptions[Identity] = customiseInterceptors.options
+
+  def noEncoding: AwsServerOptions[Identity] =
+    default.copy(encodeResponseBody = false)
+}

serverless/aws/lambda-core/src/main/scalajvm/sttp/tapir/serverless/aws/lambda/SyncLambdaHandler.scala

@@ -0,0 +1,63 @@
+package sttp.tapir.serverless.aws.lambda
+
+import com.amazonaws.services.lambda.runtime.{Context, RequestStreamHandler}
+import io.circe._
+import io.circe.generic.auto._
+import io.circe.parser.decode
+import io.circe.syntax._
+import sttp.shared.Identity
+import sttp.tapir.server.ServerEndpoint
+
+import java.io.{BufferedWriter, InputStream, OutputStream, OutputStreamWriter}
+import java.nio.charset.StandardCharsets
+
+/** [[SyncLambdaHandler]] is a direct-style entry point for handling requests sent to AWS Lambda application which exposes Tapir endpoints.
+  *
+  * @tparam R
+  *   AWS API Gateway request type [[AwsRequestV1]] or [[AwsRequest]].
+  * @param options
+  *   Server options of type AwsServerOptions.
+  */
+abstract class SyncLambdaHandler[R: Decoder](options: AwsServerOptions[Identity]) extends RequestStreamHandler {
+
+  protected def getAllEndpoints: List[ServerEndpoint[Any, Identity]]
+
+  override def handleRequest(input: InputStream, output: OutputStream, context: Context): Unit = {
+    val server: AwsSyncServerInterpreter = AwsSyncServerInterpreter(options)
+
+    val allBytes = input.readAllBytes()
+    val decoded = decode[R](new String(allBytes, StandardCharsets.UTF_8))
+    val response = decoded match {
+      case Left(e) => AwsResponse.badRequest(s"Invalid AWS request: ${e.getMessage}")
+      case Right(awsRequest) =>
+        awsRequest match {
+          case r: AwsRequestV1 => server.toRoute(getAllEndpoints)(r.toV2)
+          case r: AwsRequest   => server.toRoute(getAllEndpoints)(r)
+          case r =>
+            throw new IllegalArgumentException(s"Request of type ${r.getClass.getCanonicalName} is not supported")
+        }
+    }
+
+    val writer = new BufferedWriter(new OutputStreamWriter(output, StandardCharsets.UTF_8))
+    try {
+      writer.write(Printer.noSpaces.print(response.asJson))
+    } finally {
+      writer.flush()
+      writer.close()
+    }
+  }
+}
+
+object SyncLambdaHandler {
+
+  def apply[R: Decoder](
+      endpoints: List[ServerEndpoint[Any, Identity]],
+      serverOptions: AwsServerOptions[Identity]
+  ): SyncLambdaHandler[R] =
+    new SyncLambdaHandler[R](serverOptions) {
+      override protected def getAllEndpoints: List[ServerEndpoint[Any, Identity]] = endpoints
+    }
+
+  def default[R: Decoder](endpoints: List[ServerEndpoint[Any, Identity]]): SyncLambdaHandler[R] =
+    apply(endpoints, AwsSyncServerOptions.noEncoding)
+}