Merge pull request #164 from fullfacing/develop

Release 2.1.0

Author: Executioner1939

.circleci/config.yml

@@ -3,7 +3,7 @@ jobs:
   test_213:
     working_directory: /code
     docker:
-        - image: openjdk:10
+        - image: openjdk:11
         - image: jboss/keycloak:latest
           environment:
             KEYCLOAK_USER: "admin"
@@ -40,7 +40,7 @@ jobs:
   test_212:
     working_directory: /code
     docker:
-      - image: openjdk:10
+      - image: openjdk:11
       - image: jboss/keycloak:latest
         environment:
           KEYCLOAK_USER: "admin"

CHANGELOG.md

@@ -3,6 +3,20 @@ All notable changes to this project will be documented in this file.
 
 The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/), and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
+## [2.1.0] - 2020-03-28
+### Changed
+- updated various dependencies
+### Fixed
+- deprecation warnings for Scala Test
+
+## [2.0.2] - 2020-02-13
+### Changed
+- `issueAccessToken` function in `TokenManager` made public.
+### Fixed
+- Renamed `RequiredAction` case class to `AuthRequiredAction` due to naming conflict with an enum.
+- `User` case class no longer uses incorrect type for `requiredActions` field.
+- `Users.sendActionsEmail` - changed `actions` parameter to `List[RequiredAction]`.
+
 ## [2.0.0] - 2019-12-06
 #### The following changes were made to support Keycloak 8.0.0:
 - Added `plainText` implicit def to `BodyMagnet` to support sending text/plain contentType.
@@ -16,10 +30,6 @@ The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/),
 - Fixed `User.Update` case class - made all fields optional and defaulted to `None`.
 
 ## [1.2.5] - 2019-11-27
-### Updated
-- SBT Plugins
-
-## [1.2.4] - 2019-11-20
 ### Changed
 - Dependency updates
 - Support for cross compiling added so that Scala 2.12 and 2.13 versions can be published.

README.md

@@ -32,10 +32,10 @@ The project is split into the following modules, each as a separate dependency:
 ## Installation
 
 Each module can be pulled into a project separately using the following SBT dependencies:
-* keycloak4s-core:              `"com.fullfacing" %% "keycloak4s-core" % "2.0.0"`
-* keycloak4s-admin:             `"com.fullfacing" %% "keycloak4s-admin" % "2.0.0"`
-* keycloak4s-admin-monix:       `"com.fullfacing" %% "keycloak4s-admin-monix" % "2.0.0"`
-* keycloak4s-auth-akka-http:    `"com.fullfacing" %% "keycloak4s-auth-akka-http" % "2.0.0"`
+* keycloak4s-core:              `"com.fullfacing" %% "keycloak4s-core" % "2.0.2"`
+* keycloak4s-admin:             `"com.fullfacing" %% "keycloak4s-admin" % "2.0.2"`
+* keycloak4s-admin-monix:       `"com.fullfacing" %% "keycloak4s-admin-monix" % "2.0.2"`
+* keycloak4s-auth-akka-http:    `"com.fullfacing" %% "keycloak4s-auth-akka-http" % "2.0.2"`
 
 The core module is a dependency for all other modules, and is automatically pulled in when using any other module.
 

build.sbt

@@ -4,7 +4,7 @@ import xerial.sbt.Sonatype.GitHubHosting
 
 lazy val global = {
   Seq(
-    version       := "2.0.2",
+    version       := "2.1.0",
     scalaVersion  := "2.13.1",
     organization  := "com.fullfacing",
     scalacOptions ++= (CrossVersion.partialVersion(scalaVersion.value) match {
@@ -89,16 +89,16 @@ val scalac212Opts = baseScalaOpts ++ Seq("-Ypartial-unification")
 //          Library Versions          //
 // ---------------------------------- //
 val akkaHttpVersion       = "10.1.11"
-val akkaStreamsVersion    = "2.6.3"
-val catsEffectVersion     = "2.1.1"
-val catsCoreVersion       = "2.1.0"
+val akkaStreamsVersion    = "2.6.4"
+val catsEffectVersion     = "2.1.2"
+val catsCoreVersion       = "2.1.1"
 val enumeratumVersion     = "1.5.15"
 val json4sVersion         = "3.6.7"
 val logbackVersion        = "1.2.3"
 val monixVersion          = "3.1.0"
-val nimbusVersion         = "8.6"
-val scalaTestVersion      = "3.1.0"
-val sttpVersion           = "1.7.2"
+val nimbusVersion         = "8.11"
+val scalaTestVersion      = "3.1.1"
+val sttpVersion           = "2.0.6"
 
 // -------------------------------------- //
 //          Library Dependencies          //
@@ -144,19 +144,19 @@ val scalaTest: Seq[ModuleID] = Seq(
 )
 
 val sttpAkka: Seq[ModuleID] = Seq(
-  "com.softwaremill.sttp" %% "akka-http-backend" % sttpVersion,
-  "com.softwaremill.sttp" %% "core"              % sttpVersion,
-  "com.softwaremill.sttp" %% "json4s"            % sttpVersion,
+  "com.softwaremill.sttp.client" %% "akka-http-backend" % sttpVersion,
+  "com.softwaremill.sttp.client" %% "core"              % sttpVersion,
+  "com.softwaremill.sttp.client" %% "json4s"            % sttpVersion,
   "com.typesafe.akka"     %% "akka-stream"       % akkaStreamsVersion
 )
 
 val sttpMonix: Seq[ModuleID] = Seq(
-  "com.softwaremill.sttp" %% "core"   % sttpVersion,
-  "com.softwaremill.sttp" %% "json4s" % sttpVersion
+  "com.softwaremill.sttp.client" %% "core"   % sttpVersion,
+  "com.softwaremill.sttp.client" %% "json4s" % sttpVersion
 )
 
 val sttpAkkaMonix: Seq[ModuleID] = Seq(
-  "com.fullfacing" %% "sttp-akka-monix" % "1.0.3"
+  "com.fullfacing" %% "sttp-akka-monix" % "1.1.0"
 )
 
 // --------------------------------------------- //
@@ -213,7 +213,7 @@ lazy val `keycloak4s-akka-http` = (project in file("./keycloak4s-auth/akka-http"
 // Project and configuration for keycloak4s-playground //
 // --------------------------------------------------- //
 lazy val `keycloak4s-playground` = (project in file("./keycloak4s-playground"))
-  .settings(scalaVersion  := "2.13.0")
+  .settings(scalaVersion  := "2.13.1")
   .settings(skip in publish := true)
   .settings(libraryDependencies ++= sttpAkkaMonix ++ scalaTest ++ akkaTestKit)
   .settings(coverageEnabled := false)

keycloak4s-admin-monix/src/main/scala/com/fullfacing/keycloak4s/admin/monix/client/KeycloakClient.scala

@@ -4,15 +4,15 @@ import cats.implicits._
 import com.fullfacing.keycloak4s.admin.client.{KeycloakClient => KeycloakClientA}
 import com.fullfacing.keycloak4s.admin.monix.utilities.ObservableExtensions.ObservableExtensions
 import com.fullfacing.keycloak4s.core.models._
-import com.softwaremill.sttp.SttpBackend
-import com.softwaremill.sttp.Uri.QueryFragment.KeyValue
 import monix.eval.Task
 import monix.reactive.Observable
+import sttp.client.{NothingT, SttpBackend}
+import sttp.model.Uri.QuerySegment.KeyValue
 
 import scala.collection.immutable.Seq
 import scala.reflect._
 
-class KeycloakClient[T](config: ConfigWithAuth)(implicit client: SttpBackend[Task, Observable[T]]) extends KeycloakClientA[Task, Observable[T]](config) {
+class KeycloakClient[T](config: ConfigWithAuth)(implicit client: SttpBackend[Task, Observable[T], NothingT]) extends KeycloakClientA[Task, Observable[T]](config) {
 
   /**
    * Used for calls that return a sequence of items, this sequentially makes calls to retrieve and process

keycloak4s-admin-monix/src/main/scala/com/fullfacing/keycloak4s/admin/monix/services/package.scala

@@ -1,7 +1,7 @@
 package com.fullfacing.keycloak4s.admin.monix
 
-import com.softwaremill.sttp.Uri.QueryFragment.KeyValue
 import monix.reactive.Consumer
+import sttp.model.Uri.QuerySegment.KeyValue
 
 import scala.collection.immutable.Seq
 

keycloak4s-admin/src/main/scala/com/fullfacing/keycloak4s.admin/client/KeycloakClient.scala

@@ -10,55 +10,58 @@ import com.fullfacing.keycloak4s.admin.handles.Logging
 import com.fullfacing.keycloak4s.admin.handles.Logging.logLeft
 import com.fullfacing.keycloak4s.core.models._
 import com.fullfacing.keycloak4s.core.serialization.JsonFormats.default
-import com.softwaremill.sttp.Uri.QueryFragment.KeyValue
-import com.softwaremill.sttp.{Id, RequestT, SttpBackend, Uri, asString, sttp}
 import org.json4s.jackson.Serialization.read
+import sttp.client.{Identity, NothingT, RequestT, SttpBackend, asString, _}
+import sttp.model.Uri
+import sttp.model.Uri.QuerySegment.KeyValue
 
 import scala.collection.immutable.Seq
 import scala.reflect._
 import scala.reflect.runtime.universe.{TypeTag, typeOf}
 import scala.util.control.NonFatal
 
-class KeycloakClient[F[+_] : Concurrent, -S](config: ConfigWithAuth)(implicit client: SttpBackend[F, S]) extends TokenManager[F, S](config) {
+class KeycloakClient[F[+_] : Concurrent, -S](config: ConfigWithAuth)(implicit client: SttpBackend[F, S, NothingT]) extends TokenManager[F, S](config) {
 
   val realm: String = config.realm
 
   /* Extracts the Manifest out of an implicit Anything. **/
   private implicit def ma[A : Anything]: Manifest[A] = implicitly[Anything[A]].manifest
 
   /* URI Builder **/
-  private[client] def createUri(path: Seq[String], query: Seq[KeyValue]) = Uri(
+  private[client] def createUri(path: Seq[String], query: Seq[KeyValue]) = Uri.notValidated(
     scheme         = config.scheme,
     userInfo       = None,
     host           = config.host,
     port           = Some(config.port),
     path           = Seq("auth", "admin", "realms") ++ path,
-    queryFragments = query,
+    querySegments  = query,
     fragment       = None
   )
 
   /* HTTP Call Builders **/
 
-  private def setResponse[A <: Any : Manifest](request: RequestT[Id, String, Nothing])(implicit tag: TypeTag[A], cId: UUID)
-  : F[Either[KeycloakSttpException, RequestT[Id, A, Nothing]]] = {
+  private def setResponse[A <: Any : Manifest](request: RequestT[Identity, Either[String, String], Nothing])(implicit tag: TypeTag[A], cId: UUID)
+  : F[Either[KeycloakSttpException, RequestT[Identity, Either[String, A], Nothing]]] = {
 
     val respAs = asString.mapWithMetadata { case (raw, meta) =>
-      Logging.requestSuccessful(raw, cId)
+      raw.map { body =>
+        Logging.requestSuccessful(body, cId)
 
-      if (tag.tpe =:= typeOf[Unit]) read[A]("null")
-      else if (tag.tpe =:= typeOf[Headers]) meta.headers.toMap.asInstanceOf[A]
-      else read[A](raw)
+        if (tag.tpe =:= typeOf[Unit]) read[A]("null")
+        else if (tag.tpe =:= typeOf[Headers]) meta.headers.map(h => h.name -> h.value).toMap.asInstanceOf[A]
+        else read[A](body)
+      }
     }
 
     withAuth(request.response(respAs))
   }
 
-  private def call[B <: Any : Manifest](request: RequestT[Id, String, Nothing], requestInfo: RequestInfo): F[Either[KeycloakError, B]] = {
+  private def call[B <: Any : Manifest](request: RequestT[Identity, Either[String, String], Nothing], requestInfo: RequestInfo): F[Either[KeycloakError, B]] = {
     implicit val cId: UUID = UUID.randomUUID()
 
     val resp = setResponse[B](request.header("Accept", "application/json"))
 
-    def sendWithLogging(req: RequestT[Id, B, Nothing]) = {
+    def sendWithLogging(req: RequestT[Identity, Either[String, B], Nothing]) = {
       Logging.requestSent(requestInfo, cId)
       req.send()
     }
@@ -75,24 +78,24 @@ class KeycloakClient[F[+_] : Concurrent, -S](config: ConfigWithAuth)(implicit cl
 
   /* REST Protocol Calls **/
   def get[A : Anything](path: Seq[String], query: Seq[KeyValue] = Seq.empty[KeyValue]): F[Either[KeycloakError, A]] = {
-    val request = sttp.get(createUri(path, query))
+    val request = basicRequest.get(createUri(path, query))
     call[A](request, buildRequestInfo(path, "GET", ()))
   }
 
   def put[A : Anything](path: Seq[String], payload: BodyMagnet = (), query: Seq[KeyValue] = Seq.empty[KeyValue]): F[Either[KeycloakError, A]] = {
-    val request   = sttp.put(createUri(path, query))
+    val request   = basicRequest.put(createUri(path, query))
     val injected  = payload.apply(request)
     call[A](injected, buildRequestInfo(path, "PUT", injected.body))
   }
 
   def post[A : Anything](path: Seq[String], payload: BodyMagnet = (), query: Seq[KeyValue] = Seq.empty[KeyValue]): F[Either[KeycloakError, A]] = {
-    val request   = sttp.post(createUri(path, query))
+    val request   = basicRequest.post(createUri(path, query))
     val injected  = payload.apply(request)
     call[A](injected, buildRequestInfo(path, "POST", injected.body))
   }
 
   def delete[A : Anything](path: Seq[String], payload: BodyMagnet = (), query: Seq[KeyValue] = Seq.empty[KeyValue]): F[Either[KeycloakError, A]] = {
-    val request   = sttp.delete(createUri(path, query))
+    val request   = basicRequest.delete(createUri(path, query))
     val injected  = payload.apply(request)
     call[A](injected, buildRequestInfo(path, "DELETE", injected.body))
   }

keycloak4s-admin/src/main/scala/com/fullfacing/keycloak4s.admin/client/TokenManager.scala

@@ -1,6 +1,5 @@
 package com.fullfacing.keycloak4s.admin.client
 
-import java.nio.charset.StandardCharsets
 import java.time.Instant
 import java.util.UUID
 import java.util.concurrent.atomic.AtomicReference
@@ -10,13 +9,14 @@ import cats.implicits._
 import com.fullfacing.keycloak4s.admin.client.TokenManager.{Token, TokenResponse}
 import com.fullfacing.keycloak4s.admin.handles.Logging
 import com.fullfacing.keycloak4s.admin.handles.Logging.handleLogging
+import com.fullfacing.keycloak4s.core.models.{ConfigWithAuth, KeycloakConfig, KeycloakSttpException, RequestInfo}
 import com.fullfacing.keycloak4s.core.serialization.JsonFormats.default
-import com.fullfacing.keycloak4s.core.models.{KeycloakConfig, ConfigWithAuth, KeycloakSttpException, RequestInfo}
-import com.softwaremill.sttp.json4s.asJson
-import com.softwaremill.sttp.{SttpBackend, _}
 import org.json4s.jackson.Serialization
+import sttp.client.json4s._
+import sttp.client.monad.MonadError
+import sttp.client.{Identity, NoBody, NothingT, RequestT, Response, SttpBackend, _}
 
-abstract class TokenManager[F[_] : Concurrent, -S](config: ConfigWithAuth)(implicit client: SttpBackend[F, S]) {
+abstract class TokenManager[F[_] : Concurrent, -S](config: ConfigWithAuth)(implicit client: SttpBackend[F, S, NothingT]) {
 
   protected implicit val serialization: Serialization.type = org.json4s.jackson.Serialization
 
@@ -34,18 +34,18 @@ abstract class TokenManager[F[_] : Concurrent, -S](config: ConfigWithAuth)(impli
     )
   }
 
-  protected def buildError(response: Response[_], requestInfo: RequestInfo): KeycloakSttpException = {
+  protected def buildError(response: Response[_], leftBody: String, requestInfo: RequestInfo): KeycloakSttpException = {
     KeycloakSttpException(
-      code        = response.code,
-      headers     = response.headers,
-      body        = response.rawErrorBody.fold(new String(_, StandardCharsets.UTF_8), _ => "N/A"),
+      code        = response.code.code,
+      headers     = response.headers.map(h => h.name -> h.value),
+      body        = leftBody,
       statusText  = response.statusText,
       requestInfo = requestInfo
     )
   }
 
-  protected def liftM[A](response: Response[A], requestInfo: RequestInfo): Either[KeycloakSttpException, A] = {
-    response.body.leftMap(_ => buildError(response, requestInfo))
+  protected def liftM[A](response: Response[Either[String, A]], requestInfo: RequestInfo): Either[KeycloakSttpException, A] = {
+    response.body.leftMap(l => buildError(response, l, requestInfo))
   }
 
   private val tokenEndpoint =
@@ -96,7 +96,7 @@ abstract class TokenManager[F[_] : Concurrent, -S](config: ConfigWithAuth)(impli
     val sendF = Concurrent[F].unit.flatMap { _ =>
       Logging.tokenRequest(config.realm, cId)
 
-      sttp.post(tokenEndpoint)
+      basicRequest.post(tokenEndpoint)
         .body(password)
         .response(asJson[TokenResponse])
         .mapResponse(mapToToken)
@@ -118,7 +118,7 @@ abstract class TokenManager[F[_] : Concurrent, -S](config: ConfigWithAuth)(impli
     val sendF = Concurrent[F].unit.flatMap { _ =>
       Logging.tokenRefresh(config.realm, cId)
 
-      sttp.post(tokenEndpoint)
+      basicRequest.post(tokenEndpoint)
         .body(body)
         .response(asJson[TokenResponse])
         .mapResponse(mapToToken)
@@ -139,15 +139,15 @@ abstract class TokenManager[F[_] : Concurrent, -S](config: ConfigWithAuth)(impli
     * @param response the oidc token response.
     * @return a new token instance.
     */
-  private def mapToToken(response: TokenResponse): Token = {
+  private def mapToToken(response: Either[ResponseError[Exception], TokenResponse]): Either[String, Token] = response.map { res =>
     val instant = Instant.now()
     Token(
-      access          = response.access_token,
-      refresh         = response.refresh_token,
-      refreshAt       = instant.plusSeconds(response.expires_in),
-      authenticateAt  = instant.plusSeconds(response.refresh_expires_in)
+      access          = res.access_token,
+      refresh         = res.refresh_token,
+      refreshAt       = instant.plusSeconds(res.expires_in),
+      authenticateAt  = instant.plusSeconds(res.refresh_expires_in)
     )
-  }
+  }.leftMap(_.body)
 
   /**
     * Inspect the status of the token, reissuing a new access token using the password
@@ -180,7 +180,7 @@ abstract class TokenManager[F[_] : Concurrent, -S](config: ConfigWithAuth)(impli
     }
   }
 
-  def withAuth[A](request: RequestT[Id, A, Nothing])(implicit cId: UUID): F[Either[KeycloakSttpException, RequestT[Id, A, Nothing]]] = {
+  def withAuth[A](request: RequestT[Identity, A, Nothing])(implicit cId: UUID): F[Either[KeycloakSttpException, RequestT[Identity, A, Nothing]]] = {
     Concurrent[F].map(validateToken())(_.map(tkn => request.auth.bearer(tkn.access)))
   }
 }