add GrpService, update GrpcClient and GrpcServices

build.sbt

@@ -8,7 +8,7 @@ ThisBuild / organization := "app.softnetwork"
 
 name := "generic-persistence-api"
 
-ThisBuild / version := "0.6.1"
+ThisBuild / version := "0.6.2"
 
 ThisBuild / scalaVersion := "2.12.18"
 

server/src/main/scala/app/softnetwork/api/server/GrpcServer.scala

@@ -44,7 +44,7 @@ trait GrpcServer extends PersistenceGuardian with Server {
             }
         }
       case Failure(ex) =>
-        classicSystem.log.error("Failed to bind HTTP endpoint, terminating system", ex)
+        classicSystem.log.error(ex, "Failed to bind HTTP endpoint, terminating system")
         classicSystem.terminate()
     }
   }

server/src/main/scala/app/softnetwork/api/server/GrpcService.scala

@@ -0,0 +1,15 @@
+package app.softnetwork.api.server
+
+import akka.actor.typed.ActorSystem
+import akka.http.scaladsl.model.{HttpRequest, HttpResponse}
+import akka.http.scaladsl.server.Directives
+import akka.http.scaladsl.server.Route
+
+import scala.concurrent.Future
+
+trait GrpcService extends Directives {
+
+  def grpcService: ActorSystem[_] => PartialFunction[HttpRequest, Future[HttpResponse]]
+
+  def route: ActorSystem[_] => Route = system => handle(grpcService(system))
+}

server/src/main/scala/app/softnetwork/api/server/GrpcServices.scala

@@ -1,23 +1,13 @@
 package app.softnetwork.api.server
 
 import akka.actor.typed.ActorSystem
-import akka.grpc.scaladsl.ServiceHandler
-import akka.http.scaladsl.model.{HttpRequest, HttpResponse}
-import akka.http.scaladsl.server.Directives.handle
-import akka.http.scaladsl.server.Route
+import akka.http.scaladsl.server.{Route, RouteConcatenation}
 
-import scala.concurrent.Future
+trait GrpcServices extends RouteConcatenation {
 
-trait GrpcServices {
-
-  def grpcServices: ActorSystem[_] => Seq[PartialFunction[HttpRequest, Future[HttpResponse]]] = _ =>
-    Seq.empty
+  def grpcServices: ActorSystem[_] => Seq[GrpcService] = _ => Seq.empty
 
   final def grpcRoutes: ActorSystem[_] => Route = system =>
-    handle(
-      ServiceHandler.concatOrNotFound(
-        grpcServices(system): _*
-      )
-    )
+    concat(grpcServices(system).map(_.route(system)): _*)
 
 }

server/src/main/scala/app/softnetwork/api/server/client/GrpcClient.scala

@@ -1,8 +1,9 @@
 package app.softnetwork.api.server.client
 
 import akka.actor.typed.ActorSystem
-import akka.grpc.scaladsl.AkkaGrpcClient
+import akka.grpc.scaladsl.{AkkaGrpcClient, SingleResponseRequestBuilder}
 
+import java.net.PasswordAuthentication
 import scala.concurrent.ExecutionContext
 
 trait GrpcClient {
@@ -13,4 +14,85 @@ trait GrpcClient {
   def name: String
 
   def grpcClient: AkkaGrpcClient
+
+  /** add headers to grpc request
+    * @param request
+    *   - grpc request
+    * @param headers
+    *   - headers
+    * @tparam Req
+    *   - Request
+    * @tparam Res
+    *   - Response
+    * @return
+    *   request with headers
+    */
+  def withHeaders[Req, Res](
+    request: SingleResponseRequestBuilder[Req, Res],
+    headers: Seq[(String, String)]
+  ): SingleResponseRequestBuilder[Req, Res] = {
+    headers.foldLeft(request) { case (acc, (k, v)) =>
+      acc.addHeader(k, v)
+    }
+  }
+
+  /** add authorization header to grpc request
+    * @param request
+    *   - grpc request
+    * @param value
+    *   - authorization value
+    * @tparam Req
+    *   - Request
+    * @tparam Res
+    *   - Response
+    * @return
+    *   request with authorization header
+    */
+  def withAuthorization[Req, Res](
+    request: SingleResponseRequestBuilder[Req, Res],
+    value: String
+  ): SingleResponseRequestBuilder[Req, Res] = {
+    withHeaders(request, Seq("Authorization" -> value))
+  }
+
+  /** add oauth2 authorization header to grpc request
+    * @param request
+    *   - grpc request
+    * @param token
+    *   - oauth2 token
+    * @tparam Req
+    *   - Request
+    * @tparam Res
+    *   - Response
+    * @return
+    *   request with oauth2 authorization
+    */
+  def oauth2[Req, Res](
+    request: SingleResponseRequestBuilder[Req, Res],
+    token: String
+  ): SingleResponseRequestBuilder[Req, Res] = {
+    withAuthorization(request, s"Bearer $token")
+  }
+
+  /** add basic authorization header to grpc request
+    * @param request
+    *   - grpc request
+    * @param credentials
+    *   - basic credentials
+    * @tparam Req
+    *   - Request
+    * @tparam Res
+    *   - Response
+    * @return
+    *   request with basic authorization
+    */
+  def basic[Req, Res](
+    request: SingleResponseRequestBuilder[Req, Res],
+    credentials: PasswordAuthentication
+  ): SingleResponseRequestBuilder[Req, Res] = {
+    val token = java.util.Base64.getEncoder.encodeToString(
+      s"${credentials.getUserName}:${new String(credentials.getPassword)}".getBytes
+    )
+    withAuthorization(request, s"Basic $token")
+  }
 }