after upgrading api endpoints dependencies

Author: fupelaqu

api/src/main/resources/reference.conf

@@ -1,7 +1,7 @@
 include "softnetwork-jdbc-persistence.conf"
 
 softnetwork.api.name = "softnetwork-resource"
-softnetwork.api.version = "0.2.2.2"
+softnetwork.api.version = "0.2.3"
 softnetwork.api.server.port = 9000
 softnetwork.api.server.request-timeout = 120 s
 softnetwork.api.server.swagger-path-prefix = ["swagger", "resource"]

build.sbt

@@ -31,7 +31,7 @@ ThisBuild / organization := "app.softnetwork"
 
 name := "resource"
 
-ThisBuild / version := "0.2.2.2"
+ThisBuild / version := "0.2.3"
 
 ThisBuild / scalaVersion := "2.12.15"
 

core/src/main/scala/app/softnetwork/resource/launch/ResourceEndpoints.scala

@@ -1,16 +1,12 @@
 package app.softnetwork.resource.launch
 
 import akka.actor.typed.ActorSystem
-import app.softnetwork.api.server.ApiEndpoints
+import app.softnetwork.api.server.{ApiEndpoint, ApiEndpoints}
 import app.softnetwork.persistence.schema.SchemaProvider
 import app.softnetwork.resource.model.GenericResource
 import app.softnetwork.resource.service.ResourceServiceEndpoints
 import app.softnetwork.session.service.SessionEndpoints
 import com.softwaremill.session.CsrfCheck
-import sttp.capabilities.akka.AkkaStreams
-import sttp.tapir.server.ServerEndpoint
-
-import scala.concurrent.Future
 
 trait ResourceEndpoints[Resource <: GenericResource]
     extends ApiEndpoints
@@ -20,6 +16,9 @@ trait ResourceEndpoints[Resource <: GenericResource]
 
   def resourceEndpoints: ActorSystem[_] => ResourceServiceEndpoints
 
-  override def endpoints: ActorSystem[_] => List[ServerEndpoint[Any with AkkaStreams, Future]] =
-    system => resourceEndpoints(system).endpoints
+  override def endpoints: ActorSystem[_] => List[ApiEndpoint] =
+    system =>
+      List(
+        resourceEndpoints(system)
+      )
 }

core/src/main/scala/app/softnetwork/resource/persistence/typed/ResourceBehavior.scala

@@ -8,7 +8,7 @@ import app.softnetwork.resource.message.ResourceMessages._
 import app.softnetwork.resource.model.Resource
 
 import scala.language.implicitConversions
-import app.softnetwork.persistence.{now, ManifestWrapper}
+import app.softnetwork.persistence.ManifestWrapper
 import app.softnetwork.persistence.typed._
 import app.softnetwork.resource.config.ResourceSettings
 import app.softnetwork.utils.{Base64Tools, HashTools}

core/src/main/scala/app/softnetwork/resource/service/ResourceServiceEndpoints.scala

@@ -3,129 +3,95 @@ package app.softnetwork.resource.service
 import akka.http.scaladsl.server.Route
 import akka.stream.scaladsl.{FileIO, Source}
 import akka.util.ByteString
-import app.softnetwork.api.server.{ApiEndpoint, ApiErrors}
+import app.softnetwork.api.server.ApiErrors
 import app.softnetwork.resource.config.ResourceSettings
 import app.softnetwork.resource.handlers.GenericResourceHandler
 import app.softnetwork.resource.message.ResourceMessages._
 import app.softnetwork.resource.spi.{ResourceProvider, SimpleResource}
-import app.softnetwork.session.service.SessionEndpoints
-import com.softwaremill.session.{
-  GetSessionTransport,
-  SetSessionTransport,
-  TapirCsrfCheckMode,
-  TapirSessionContinuity
-}
+import app.softnetwork.session.service.ServiceWithSessionEndpoints
 import org.softnetwork.session.model.Session
 import sttp.capabilities.akka.AkkaStreams
 import sttp.model.headers.CookieValueWithMeta
 import sttp.model.{Method, Part, StatusCode}
-import sttp.monad.FutureMonad
 import sttp.tapir._
-import sttp.tapir.generic.auto._
 import sttp.tapir.json.json4s.jsonBody
-import sttp.tapir.server.{PartialServerEndpoint, ServerEndpoint}
+import sttp.tapir.server.{PartialServerEndpointWithSecurityOutput, ServerEndpoint}
 
 import scala.concurrent.Future
 
-trait ResourceServiceEndpoints extends LoadResourceService with ApiEndpoint {
+trait ResourceServiceEndpoints
+    extends LoadResourceService
+    with ServiceWithSessionEndpoints[ResourceCommand, ResourceResult] {
   _: GenericResourceHandler with ResourceProvider =>
 
   import app.softnetwork.serialization._
 
-  def sessionEndpoints: SessionEndpoints
-
-  def sc: TapirSessionContinuity[Session] = sessionEndpoints.sc
-
-  def st: SetSessionTransport = sessionEndpoints.st
-
-  def gt: GetSessionTransport = sessionEndpoints.gt
-
-  def checkMode: TapirCsrfCheckMode[Session] = sessionEndpoints.checkMode
-
   def error(e: ResourceError): ApiErrors.ErrorInfo =
     e match {
       case ResourceNotFound => ApiErrors.NotFound(ResourceNotFound)
       case _                => ApiErrors.BadRequest(e.message)
     }
 
-  def rootEndpoint: PartialServerEndpoint[
+  def secureEndpoint: PartialServerEndpointWithSecurityOutput[
     (Seq[Option[String]], Option[String], Method, Option[String]),
-    ((Seq[Option[String]], Option[CookieValueWithMeta]), Session),
+    Session,
     Unit,
-    ApiErrors.ErrorInfo,
+    Any,
     (Seq[Option[String]], Option[CookieValueWithMeta]),
+    Unit,
     Any,
     Future
-  ] = {
-    val partial =
-      sessionEndpoints.antiCsrfWithRequiredSession(sc, gt, checkMode)
-    partial.endpoint
+  ] =
+    ApiErrors
+      .withApiErrorVariants(
+        antiCsrfWithRequiredSession(sc, gt, checkMode)
+      )
       .in(ResourceSettings.ResourcePath)
-      .out(partial.securityOutput)
-      .errorOut(errors)
-      .serverSecurityLogic { inputs =>
-        partial.securityLogic(new FutureMonad())(inputs).map {
-          case Left(_)  => Left(ApiErrors.Unauthorized("Unauthorized"))
-          case Right(r) => Right((r._1, r._2))
-        }
-      }
-  }
 
   val library: ServerEndpoint[Any with AkkaStreams, Future] =
-    rootEndpoint.get
+    secureEndpoint.get
       .in("library")
       .in(paths)
       .out(jsonBody[List[SimpleResource]])
-      .serverLogicSuccess(principal =>
-        segments =>
-          Future.successful(
-            (principal._1._1, principal._1._2, listResources(segments.mkString("/")))
-          )
-      )
+      .serverLogicSuccess(_ => segments => Future.successful(listResources(segments.mkString("/"))))
 
-  def loadResourceBusinessLogic(
-    principal: ((Seq[Option[String]], Option[CookieValueWithMeta]), Session)
-  ): List[String] => Either[
+  def loadResourceBusinessLogic(segments: List[String]): Either[
     ApiErrors.ErrorInfo,
-    (Seq[Option[String]], Option[CookieValueWithMeta], Source[ByteString, Any])
+    Source[ByteString, Any]
   ] =
-    segments =>
-      loadResource(segments) match {
-        case Some((path, _)) => Right((principal._1._1, principal._1._2, FileIO.fromPath(path)))
-        case _               => Left(error(ResourceNotFound))
-      }
+    loadResource(segments) match {
+      case Some((path, _)) => Right(FileIO.fromPath(path))
+      case _               => Left(error(ResourceNotFound))
+    }
 
   val getResource: ServerEndpoint[Any with AkkaStreams, Future] =
-    rootEndpoint.get
+    secureEndpoint.get
       .in(paths)
       .out(streamBinaryBody(AkkaStreams)(CodecFormat.OctetStream()))
-      .serverLogic(principal =>
-        segments => Future.successful(loadResourceBusinessLogic(principal)(segments))
-      )
+      .serverLogic(_ => segments => Future.successful(loadResourceBusinessLogic(segments)))
 
   val getImage: ServerEndpoint[Any with AkkaStreams, Future] =
-    rootEndpoint.get
+    secureEndpoint.get
       .in("images")
       .in(paths)
       .out(
         streamBinaryBody(AkkaStreams)(CodecFormat.OctetStream())
       )
-      .serverLogic(principal =>
-        segments => Future.successful(loadResourceBusinessLogic(principal)(segments))
-      )
+      .serverLogic(_ => segments => Future.successful(loadResourceBusinessLogic(segments)))
 
   def uploadResource[T <: Upload](implicit
     multipartCodec: MultipartCodec[T]
-  ): PartialServerEndpoint[
+  ): PartialServerEndpointWithSecurityOutput[
     (Seq[Option[String]], Option[String], Method, Option[String]),
-    ((Seq[Option[String]], Option[CookieValueWithMeta]), Session),
+    Session,
     (List[String], T),
-    ApiErrors.ErrorInfo,
-    (Seq[Option[String]], Option[CookieValueWithMeta], ResourceResult),
+    Any,
+    (Seq[Option[String]], Option[CookieValueWithMeta]),
+    ResourceResult,
     Any,
     Future
   ] =
-    rootEndpoint
+    secureEndpoint
       .in(paths.description("URI of the resource"))
       .in(multipartBody[T].description("Multipart file to upload"))
       .out(
@@ -146,10 +112,10 @@ trait ResourceServiceEndpoints extends LoadResourceService with ApiEndpoint {
   ): ServerEndpoint[Any with AkkaStreams, Future] =
     uploadResource[T].post
       .description("Add a resource")
-      .serverLogic(principal => { case (segments, upload) =>
-        uploadResource(principal._2, segments, upload.bytes, update = false) map {
+      .serverLogic(session => { case (segments, upload) =>
+        uploadResource(session, segments, upload.bytes, update = false) map {
+          case Right(r) => Right(r)
           case Left(l)  => Left(error(l))
-          case Right(r) => Right((principal._1._1, principal._1._2, r))
         }
       })
 
@@ -158,25 +124,26 @@ trait ResourceServiceEndpoints extends LoadResourceService with ApiEndpoint {
   ): ServerEndpoint[Any with AkkaStreams, Future] =
     uploadResource[T].put
       .description("Update the resource")
-      .serverLogic(principal => { case (segments, upload) =>
-        uploadResource(principal._2, segments, upload.bytes, update = true) map {
+      .serverLogic(session => { case (segments, upload) =>
+        uploadResource(session, segments, upload.bytes, update = true) map {
+          case Right(r) => Right(r)
           case Left(l)  => Left(error(l))
-          case Right(r) => Right((principal._1._1, principal._1._2, r))
         }
       })
 
   def uploadImage[T <: Upload](implicit
     multipartCodec: MultipartCodec[T]
-  ): PartialServerEndpoint[
+  ): PartialServerEndpointWithSecurityOutput[
     (Seq[Option[String]], Option[String], Method, Option[String]),
-    ((Seq[Option[String]], Option[CookieValueWithMeta]), Session),
+    Session,
     (List[String], T),
-    ApiErrors.ErrorInfo,
-    (Seq[Option[String]], Option[CookieValueWithMeta], ResourceResult),
+    Any,
+    (Seq[Option[String]], Option[CookieValueWithMeta]),
+    ResourceResult,
     Any,
     Future
   ] =
-    rootEndpoint
+    secureEndpoint
       .in("images")
       .in(paths.description("URI of the image"))
       .in(multipartBody[T].description("Multipart image to upload"))
@@ -198,10 +165,10 @@ trait ResourceServiceEndpoints extends LoadResourceService with ApiEndpoint {
   ): ServerEndpoint[Any with AkkaStreams, Future] =
     uploadImage[T].post
       .description("Add an image")
-      .serverLogic(principal => { case (segments, upload) =>
-        uploadResource(principal._2, segments, upload.bytes, update = false) map {
+      .serverLogic(session => { case (segments, upload) =>
+        uploadResource(session, segments, upload.bytes, update = false) map {
+          case Right(r) => Right(r)
           case Left(l)  => Left(error(l))
-          case Right(r) => Right((principal._1._1, principal._1._2, r))
         }
       })
 
@@ -210,10 +177,10 @@ trait ResourceServiceEndpoints extends LoadResourceService with ApiEndpoint {
   ): ServerEndpoint[Any with AkkaStreams, Future] =
     uploadImage[T].put
       .description("Update the image")
-      .serverLogic(principal => { case (segments, upload) =>
-        uploadResource(principal._2, segments, upload.bytes, update = true) map {
+      .serverLogic(session => { case (segments, upload) =>
+        uploadResource(session, segments, upload.bytes, update = true) map {
+          case Right(r) => Right(r)
           case Left(l)  => Left(error(l))
-          case Right(r) => Right((principal._1._1, principal._1._2, r))
         }
       })
 
@@ -229,27 +196,27 @@ trait ResourceServiceEndpoints extends LoadResourceService with ApiEndpoint {
   }
 
   val deleteResource: ServerEndpoint[Any with AkkaStreams, Future] =
-    rootEndpoint
+    secureEndpoint
       .in(paths)
       .delete
-      .serverLogic(principal =>
+      .serverLogic(session =>
         segments =>
-          deleteResourceBusinessLogic(principal._2, segments) map {
+          deleteResourceBusinessLogic(session, segments) map {
+            case Right(_) => Right(())
             case Left(l)  => Left(error(l))
-            case Right(_) => Right((principal._1._1, principal._1._2))
           }
       )
 
   val deleteImage: ServerEndpoint[Any with AkkaStreams, Future] =
-    rootEndpoint
+    secureEndpoint
       .in("images")
       .in(paths)
       .delete
-      .serverLogic(principal =>
+      .serverLogic(session =>
         segments =>
-          deleteResourceBusinessLogic(principal._2, segments) map {
+          deleteResourceBusinessLogic(session, segments) map {
+            case Right(_) => Right(())
             case Left(l)  => Left(error(l))
-            case Right(_) => Right((principal._1._1, principal._1._2))
           }
       )
 

project/src/main/scala/app/softnetwork/sbt/build/Versions.scala

@@ -2,7 +2,7 @@ package app.softnetwork.sbt.build
 
 object Versions {
 
-  val genericPersistence = "0.3.2.4"
+  val genericPersistence = "0.3.4"
 
   val scalatest = "3.1.1"
 }

testkit/src/main/scala/app/softnetwork/resource/scalatest/ResourceEndpointsTestKit.scala

@@ -1,21 +1,19 @@
 package app.softnetwork.resource.scalatest
 
 import akka.actor.typed.ActorSystem
+import app.softnetwork.api.server.ApiEndpoint
 import app.softnetwork.resource.service.ResourceServiceEndpoints
 import app.softnetwork.session.scalatest.SessionEndpointsRoutes
 import com.softwaremill.session.CsrfCheck
-import sttp.capabilities
-import sttp.capabilities.akka.AkkaStreams
-import sttp.tapir.server.ServerEndpoint
-
-import scala.concurrent.Future
 
 trait ResourceEndpointsTestKit extends SessionEndpointsRoutes { _: CsrfCheck =>
 
   def resourceServiceEndpoints: ActorSystem[_] => ResourceServiceEndpoints
 
-  override def endpoints
-    : ActorSystem[_] => List[ServerEndpoint[AkkaStreams with capabilities.WebSockets, Future]] =
+  override def endpoints: ActorSystem[_] => List[ApiEndpoint] =
     system =>
-      sessionServiceEndpoints(system).endpoints ++ resourceServiceEndpoints(system).endpoints
+      List(
+        sessionServiceEndpoints(system),
+        resourceServiceEndpoints(system)
+      )
 }