use official ZIO-lambda library in product-move-api

build.sbt

@@ -568,6 +568,7 @@ lazy val `product-move-api` = lambdaProject(
     "com.softwaremill.sttp.tapir" %% "tapir-core" % tapirVersion,
     "com.softwaremill.sttp.tapir" %% "tapir-json-zio" % tapirVersion,
     "com.softwaremill.sttp.tapir" %% "tapir-aws-lambda" % tapirVersion,
+    "com.softwaremill.sttp.tapir" %% "tapir-aws-lambda-zio" % tapirVersion,
     "com.softwaremill.sttp.tapir" %% "tapir-swagger-ui-bundle" % tapirVersion,
     awsSecretsManager,
     upickle,

handlers/product-move-api/src/main/scala/com/gu/productmove/AwsCredentialsLive.scala

@@ -13,8 +13,8 @@ object AwsCredentialsLive {
 
   private val ProfileName = "membership"
 
-  val layer: Layer[String, AwsCredentialsProvider] =
-    ZLayer.scoped(ZIO.fromAutoCloseable(ZIO.attempt(impl))).mapError(_.toString)
+  val layer: Layer[Throwable, AwsCredentialsProvider] =
+    ZLayer.scoped(ZIO.fromAutoCloseable(ZIO.attempt(impl)))
 
   private def impl: AwsCredentialsProviderChain =
     AwsCredentialsProviderChain

handlers/product-move-api/src/main/scala/com/gu/productmove/Dynamo.scala

@@ -29,7 +29,7 @@ object DynamoLive {
       case Stage.PROD => PROD
   }
 
-  val layer: ZLayer[Stage, ErrorResponse, Dynamo] =
+  val layer: RLayer[Stage, Dynamo] =
     ZLayer.scoped {
       ZIO.service[Stage].map { stage =>
         val dynamoService = SupporterDataDynamoService(getStage(stage))

handlers/product-move-api/src/main/scala/com/gu/productmove/GuStageLive.scala

@@ -6,12 +6,12 @@ object GuStageLive {
   enum Stage:
     case PROD, CODE
 
-  val layer: Layer[String, Stage] =
+  val layer: Layer[Throwable, Stage] =
     ZLayer {
       for {
         stageString <- System.envOrElse("Stage", "CODE")
         stage <- ZIO.attempt(Stage.valueOf(stageString))
       } yield stage
-    }.mapError(_.toString)
+    }
 
 }

handlers/product-move-api/src/main/scala/com/gu/productmove/Handler.scala

@@ -8,7 +8,7 @@ import com.gu.productmove.endpoint.cancel.SubscriptionCancelEndpoint
 import com.gu.productmove.endpoint.move.{ProductMoveEndpoint, ProductMoveEndpointTypes}
 import com.gu.productmove.endpoint.updateamount.UpdateSupporterPlusAmountEndpoint
 import com.gu.productmove.framework.ZIOApiGatewayRequestHandler
-import com.gu.productmove.framework.ZIOApiGatewayRequestHandler.TIO
+import zio.Task
 import com.gu.productmove.zuora.rest.{ZuoraClient, ZuoraClientLive, ZuoraGet, ZuoraGetLive}
 import com.gu.productmove.zuora.{GetSubscription, GetSubscriptionLive}
 import software.amazon.awssdk.auth.credentials.*
@@ -65,8 +65,18 @@ object Handler extends ZIOApiGatewayRequestHandler {
     )
   }
 
+  @main
+  // this will output the HTML to the console
+  def testDocsHtml(): Unit = {
+    Handler.runTest(
+      "GET",
+      "/docs/",
+      None,
+    )
+  }
+
   // this represents all the routes for the server
-  override val server: List[ServerEndpoint[Any, TIO]] = List(
+  override val server: List[ServerEndpoint[Any, Task]] = List(
     AvailableProductMovesEndpoint.server,
     ProductMoveEndpoint.server,
     UpdateSupporterPlusAmountEndpoint.server,

handlers/product-move-api/src/main/scala/com/gu/productmove/SQS.scala

@@ -44,11 +44,11 @@ object SQS {
 }
 
 object SQSLive {
-  val layer: ZLayer[AwsCredentialsProvider with Stage, ErrorResponse, SQS] =
+  val layer: RLayer[AwsCredentialsProvider & Stage, SQS] =
     ZLayer.scoped(for {
       stage <- ZIO.service[Stage]
       sqsClient <- initializeSQSClient().mapError(ex =>
-        InternalServerError(s"Failed to initialize SQS Client with error: $ex"),
+        new Throwable(s"Failed to initialize SQS Client with error", ex),
       )
       emailQueueName = EmailQueueName.value
       emailQueueUrlResponse <- getQueue(emailQueueName, sqsClient)
@@ -154,14 +154,14 @@ object SQSLive {
   private def getQueue(
       queueName: String,
       sqsAsyncClient: SqsAsyncClient,
-  ): ZIO[Any, ErrorResponse, GetQueueUrlResponse] =
+  ): Task[GetQueueUrlResponse] =
     val queueUrl = GetQueueUrlRequest.builder.queueName(queueName).build()
 
     ZIO
       .fromCompletableFuture(
         sqsAsyncClient.getQueueUrl(queueUrl),
       )
-      .mapError { ex => InternalServerError(s"Failed to get sqs queue name: $queueName, error: ${ex.getMessage}") }
+      .mapError { ex => new Throwable(s"Failed to get sqs queue name: $queueName", ex) }
 
   private def impl(creds: AwsCredentialsProvider): SqsAsyncClient =
     SqsAsyncClient.builder

handlers/product-move-api/src/main/scala/com/gu/productmove/Secrets.scala

@@ -1,17 +1,16 @@
 package com.gu.productmove
 
-import software.amazon.awssdk.services.secretsmanager.*
-import software.amazon.awssdk.services.secretsmanager.model.GetSecretValueRequest
-import upickle.default.*
-
-import scala.util.{Try, Success, Failure}
-import zio.{ZIO, ULayer, ZLayer}
-import com.gu.productmove.endpoint.move.ProductMoveEndpointTypes.{SecretsError, ErrorResponse}
 import software.amazon.awssdk.auth.credentials.{
   AwsCredentialsProviderChain,
-  ProfileCredentialsProvider,
   EnvironmentVariableCredentialsProvider,
+  ProfileCredentialsProvider,
 }
+import software.amazon.awssdk.services.secretsmanager.*
+import software.amazon.awssdk.services.secretsmanager.model.GetSecretValueRequest
+import upickle.default.*
+import zio.{RIO, Task, ULayer, ZIO, ZLayer}
+
+import scala.util.{Failure, Success, Try}
 
 /*
   In Secrets Store we have the following JSON objects:
@@ -52,75 +51,60 @@ case class SalesforceSSLSecrets(
 )
 
 trait Secrets {
-  def getInvoicingAPISecrets: ZIO[Any, ErrorResponse, InvoicingAPISecrets]
-  def getZuoraApiUserSecrets: ZIO[Any, ErrorResponse, ZuoraApiUserSecrets]
-  def getSalesforceSSLSecrets: ZIO[Any, ErrorResponse, SalesforceSSLSecrets]
+  def getInvoicingAPISecrets: Task[InvoicingAPISecrets]
+  def getZuoraApiUserSecrets: Task[ZuoraApiUserSecrets]
+  def getSalesforceSSLSecrets: Task[SalesforceSSLSecrets]
 }
 
 object Secrets {
-  def getInvoicingAPISecrets: ZIO[Secrets, ErrorResponse, InvoicingAPISecrets] =
+  def getInvoicingAPISecrets: RIO[Secrets, InvoicingAPISecrets] =
     ZIO.environmentWithZIO[Secrets](_.get.getInvoicingAPISecrets)
-  def getZuoraApiUserSecrets: ZIO[Secrets, ErrorResponse, ZuoraApiUserSecrets] =
+  def getZuoraApiUserSecrets: RIO[Secrets, ZuoraApiUserSecrets] =
     ZIO.environmentWithZIO[Secrets](_.get.getZuoraApiUserSecrets)
 
-  def getSalesforceSSLSecrets: ZIO[Secrets, ErrorResponse, SalesforceSSLSecrets] =
+  def getSalesforceSSLSecrets: RIO[Secrets, SalesforceSSLSecrets] =
     ZIO.environmentWithZIO[Secrets](_.get.getSalesforceSSLSecrets)
 }
 object SecretsLive extends Secrets {
 
   implicit val reader1: Reader[InvoicingAPISecrets] = macroRW
   implicit val reader2: Reader[ZuoraApiUserSecrets] = macroRW
   implicit val reader3: Reader[SalesforceSSLSecrets] = macroRW
-
-  private val ProfileName = "membership"
-
+  private lazy val secretsClient = SecretsManagerClient.builder().credentialsProvider(credentialsProvider).build()
   val credentialsProvider = AwsCredentialsProviderChain
     .builder()
     .credentialsProviders(
       ProfileCredentialsProvider.create(ProfileName),
       EnvironmentVariableCredentialsProvider.create(),
     )
     .build()
-  private lazy val secretsClient = SecretsManagerClient.builder().credentialsProvider(credentialsProvider).build()
+  val layer: ULayer[Secrets] = ZLayer.succeed(SecretsLive)
+  private val ProfileName = "membership"
+
+  def getInvoicingAPISecrets: Task[InvoicingAPISecrets] = {
+    for {
+      stg <- getStage
+      secretId: String = s"${stg}/InvoicingApi"
+      secretJsonString = getJSONString(secretId)
+      secrets <- parseInvoicingAPISecretsJSONString(secretJsonString)
+    } yield secrets
+  }
 
   def getJSONString(secretId: String): String = {
     secretsClient.getSecretValue(GetSecretValueRequest.builder().secretId(secretId).build()).secretString()
   }
 
-  def getStage: ZIO[Any, ErrorResponse, String] =
+  def getStage: Task[String] =
     ZIO.succeed(sys.env.getOrElse("Stage", "CODE"))
 
-  def parseInvoicingAPISecretsJSONString(str: String): ZIO[Any, ErrorResponse, InvoicingAPISecrets] = {
+  def parseInvoicingAPISecretsJSONString(str: String): Task[InvoicingAPISecrets] = {
     Try(read[InvoicingAPISecrets](str)) match {
       case Success(x) => ZIO.succeed(x)
-      case Failure(s) => ZIO.fail(SecretsError(s"Failure while parsing json string: ${s}"))
+      case Failure(s) => ZIO.fail(new Throwable(s"Failure while parsing json string: ${s}"))
     }
   }
 
-  def parseZuoraApiUserSecretsJSONString(str: String): ZIO[Any, ErrorResponse, ZuoraApiUserSecrets] = {
-    Try(read[ZuoraApiUserSecrets](str)) match {
-      case Success(x) => ZIO.succeed(x)
-      case Failure(s) => ZIO.fail(SecretsError(s"Failure while parsing json string: ${s}"))
-    }
-  }
-
-  def parseSalesforceSSLSecretsJSONString(str: String): ZIO[Any, ErrorResponse, SalesforceSSLSecrets] = {
-    Try(read[SalesforceSSLSecrets](str)) match {
-      case Success(x) => ZIO.succeed(x)
-      case Failure(s) => ZIO.fail(SecretsError(s"Failure while parsing json string: ${s}"))
-    }
-  }
-
-  def getInvoicingAPISecrets: ZIO[Any, ErrorResponse, InvoicingAPISecrets] = {
-    for {
-      stg <- getStage
-      secretId: String = s"${stg}/InvoicingApi"
-      secretJsonString = getJSONString(secretId)
-      secrets <- parseInvoicingAPISecretsJSONString(secretJsonString)
-    } yield secrets
-  }
-
-  def getZuoraApiUserSecrets: ZIO[Any, ErrorResponse, ZuoraApiUserSecrets] = {
+  def getZuoraApiUserSecrets: Task[ZuoraApiUserSecrets] = {
     for {
       stg <- getStage
       secretId: String = s"${stg}/Zuora/User/ZuoraApiUser"
@@ -129,7 +113,14 @@ object SecretsLive extends Secrets {
     } yield secrets
   }
 
-  def getSalesforceSSLSecrets: ZIO[Any, ErrorResponse, SalesforceSSLSecrets] = {
+  def parseZuoraApiUserSecretsJSONString(str: String): Task[ZuoraApiUserSecrets] = {
+    Try(read[ZuoraApiUserSecrets](str)) match {
+      case Success(x) => ZIO.succeed(x)
+      case Failure(s) => ZIO.fail(new Throwable(s"Failure while parsing json string: ${s}"))
+    }
+  }
+
+  def getSalesforceSSLSecrets: Task[SalesforceSSLSecrets] = {
     for {
       stg <- getStage
       secretId: String = s"${stg}/Salesforce/User/SupportServiceLambdas"
@@ -138,5 +129,10 @@ object SecretsLive extends Secrets {
     } yield secrets
   }
 
-  val layer: ZLayer[Any, ErrorResponse, Secrets] = ZLayer.succeed(SecretsLive)
+  def parseSalesforceSSLSecretsJSONString(str: String): Task[SalesforceSSLSecrets] = {
+    Try(read[SalesforceSSLSecrets](str)) match {
+      case Success(x) => ZIO.succeed(x)
+      case Failure(s) => ZIO.fail(new Throwable(s"Failure while parsing json string: ${s}"))
+    }
+  }
 }

handlers/product-move-api/src/main/scala/com/gu/productmove/endpoint/available/AvailableProductMovesEndpoint.scala

@@ -5,7 +5,7 @@ import com.gu.productmove.SecretsLive
 import com.gu.productmove.GuStageLive.Stage
 import com.gu.productmove.endpoint.available.AvailableProductMovesEndpointTypes.*
 import com.gu.productmove.endpoint.available.Currency.GBP
-import com.gu.productmove.framework.ZIOApiGatewayRequestHandler.TIO
+import zio.Task
 import com.gu.productmove.framework.{LambdaEndpoint, ZIOApiGatewayRequestHandler}
 import com.gu.productmove.zuora.GetAccount.{GetAccountResponse, PaymentMethodResponse}
 import com.gu.productmove.zuora.*
@@ -40,7 +40,7 @@ object AvailableProductMovesEndpoint {
     Unit,
     OutputBody,
     Any,
-    ZIOApiGatewayRequestHandler.TIO,
+    Task,
   ] = {
     val subscriptionNameCapture: EndpointInput.PathCapture[String] =
       EndpointInput.PathCapture[String](
@@ -74,13 +74,13 @@ object AvailableProductMovesEndpoint {
       .description("""Returns an array of eligible products that the given subscription could be moved to,
           |which will be empty if there aren't any for the given subscription.
           |""".stripMargin)
-      .serverLogic[TIO] { subscriptionName =>
+      .serverLogic[Task] { subscriptionName =>
         run(subscriptionName).tapEither(result => ZIO.log("result tapped: " + result)).map(Right.apply)
       }
   }
 
   // sub to test on: "A-S00334930"
-  private def run(subscriptionName: String): TIO[OutputBody] =
+  private def run(subscriptionName: String): Task[OutputBody] =
     runWithEnvironment(SubscriptionName("A-S00334930")).provide(
       AwsS3Live.layer,
       AwsCredentialsLive.layer,