hydra-keycloak-client 0.1.17 → 0.1.19

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 61046cc3cd3ab5bc987ab0769799054193795ad82fca2ca46450b3cd6a1d1c44
-  data.tar.gz: 408a84fdaa9a9d769e54a6bfb57fba5bcfdc9c74fe158e3062128b53a29e9a37
+  metadata.gz: 53ac1a0505551350a5f1374aa7bd3fb390c68047b8be65e87ec00f6f36e6394a
+  data.tar.gz: 050da3e0481a21c09aa00410dcaf19b514bf23d6dfc868261d8205120898cd2e
 SHA512:
-  metadata.gz: bd7d6888768745cc897b554ec7f8342e12ec879258eafe967a947a2c902af32ba0e7ba4b46b3dc1c7b826b2f99962f8112698fbb50484951100ab6ff4ed64f0c
-  data.tar.gz: e82f992be649e2d1923df2fdff0292a5b906e82c61082671f5fecb038c4dd3cd40d567e6f05b413d35b5ab8df99bf0d031c3e56b32ae2c0b8f435822a8734d86
+  metadata.gz: c4ae1d7d6ce9deb7c39c7a4b82d3e3a2caf8fd9a05d9d4a089929e62a98081020699808c21745045461c30a70fa690a6706232126fa100137fe9e37a2bd183d5
+  data.tar.gz: e7761077fd40bb285b57136fa6b800c5f393746a9e02aab44969f81bd19a9eb5ca3fd4aaefe31718680e987999688e217ec7f36fc14d2dd7c9f839f374522b83

data/Gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: .
   specs:
-    hydra-keycloak-client (0.1.17)
+    hydra-keycloak-client (0.1.19)
       dry-auto_inject
       dry-container
       dry-monads

data/lib/hydra/keycloak/client.rb

@@ -176,17 +176,13 @@ module Hydra
       end
 
       def access_token(session_state)
-        return Failure(status: 400, code: :not_authenticated) unless authenticated?(session_state)
-
         fetch_token(session_state, 'access_token')
       end
 
       def authorize!(session_state)
-        return Failure(status: 400, code: :not_authenticated) unless authenticated?(session_state)
-
         access_token = yield fetch_token(session_state, 'access_token')
         if token_expired?(access_token)
-          refresh_tokens(session_state)
+          yield refresh_tokens(session_state)
 
           access_token = yield fetch_token(session_state, 'access_token')
         end
@@ -195,9 +191,7 @@ module Hydra
       end
 
       def access_token_jti(session_state)
-        return Failure(status: 400, code: :not_authenticated) unless authenticated?(session_state)
-
-        fetch_token(session_state, 'access_token').fmap(&:jti)
+        fetch_token(session_state, 'access_token').fmap { |token| token[:jti] }
       end
 
       def logout!(session_state)
@@ -223,7 +217,10 @@ module Hydra
           if value
             Success(::Hydra::Keycloak::Token.new(value))
           else
-            Failure(status: 400, code: :token_not_found)
+            Failure(code: :token_not_found,
+                    context: { args: { session_state: session_state,
+                                       token_name: token_name },
+                               caller: caller })
           end
         end
       end
@@ -250,6 +247,8 @@ module Hydra
         yield save_token(session_state, 'access_token',  new_tokens[:access_token])
         yield save_token(session_state, 'id_token',      new_tokens[:id_token])
         yield save_token(session_state, 'refresh_token', new_tokens[:refresh_token])
+
+        Success()
       end
     end
   end

data/lib/hydra/keycloak/store/memcached_client.rb

@@ -15,22 +15,25 @@ module Hydra
           dalli.set(key, value)
 
           Success(:ok)
-        rescue Dalli::DalliError
-          Failure(status: 400, code: :memcached_unavailable)
+        rescue Dalli::DalliError => e
+          Failure(code: :memcached_unavailable,
+                  context: { args: { key: key }, action: :set, error: e.message, caller: caller })
         end
 
         def get(key)
           Success(dalli.get(key))
-        rescue Dalli::DalliError
-          Failure(status: 400, code: :memcached_unavailable)
+        rescue Dalli::DalliError => e
+          Failure(code: :memcached_unavailable,
+                  context: { args: { key: key }, action: :get, error: e.message, caller: caller })
         end
 
         def delete(key)
           dalli.delete(key)
 
           Success(:ok)
-        rescue Dalli::DalliError
-          Failure(status: 400, code: :memcached_unavailable)
+        rescue Dalli::DalliError => e
+          Failure(code: :memcached_unavailable,
+                  context: { args: { key: key }, action: :delete, error: e.message, caller: caller })
         end
       end
     end

data/lib/hydra/keycloak/store/redis_client.rb

@@ -15,22 +15,25 @@ module Hydra
           redis.set(key, value)
 
           Success(:ok)
-        rescue Redis::BaseError
-          Failure(status: 400, code: :redis_unavailable)
+        rescue Redis::BaseError => e
+          Failure(code: :redis_unavailable,
+                  context: { args: { key: key }, action: :set, error: e.message, caller: caller })
         end
 
         def get(key)
           Success(redis.get(key))
-        rescue Redis::BaseError
-          Failure(status: 400, code: :redis_unavailable)
+        rescue Redis::BaseError => e
+          Failure(code: :redis_unavailable,
+                  context: { args: { key: key }, action: :get, error: e.message, caller: caller })
         end
 
         def delete(key)
           redis.del(key)
 
           Success(:ok)
-        rescue Redis::BaseError
-          Failure(status: 400, code: :redis_unavailable)
+        rescue Redis::BaseError => e
+          Failure(code: :redis_unavailable,
+                  context: { args: { key: key }, action: :delete, error: e.message, caller: caller })
         end
       end
     end

data/lib/hydra/keycloak/tokens/gateway.rb

@@ -25,19 +25,46 @@ module Hydra
                           Net::ProtocolError].freeze
 
         def post(path, body)
-          response = http.post_form(URI(path), body)
+          _post(URI(path), body)
+            .bind { |resp| parse_response(resp.body) }
+        end
 
-          if response.code == '200'
-            json = JSON.parse(response.body)
+        private
 
-            Success(json)
+        def _post(path, body)
+          response = http.post_form(URI(path), body)
+
+          if %w[200 201].include?(response.code)
+            Success(response)
           else
-            Failure(status: response.code, code: :bad_keycloak_response)
+            Failure(code: :bad_keycloak_response,
+                    context: { args: { path: path,
+                                       body: hide_secrets(body) },
+                               caller: caller,
+                               method: :post,
+                               response: { code: response.code,
+                                           body: response.body } })
           end
-        rescue *NETWORK_ERRORS
-          Failure(status: 400, code: :keycloak_unavailable)
-        rescue JSON::ParserError
-          Failure(status: 400, code: :json_parser_error)
+        rescue *NETWORK_ERRORS => e
+          Failure(code: :keycloak_unavailable, context: { error: e.message, caller: caller })
+        end
+
+        def parse_response(body)
+          Success(JSON.parse(body))
+        rescue JSON::ParserError => e
+          Failure(code: :json_parser_error, context: { args: { body: body }, error: e.message, caller: caller })
+        end
+
+        def hide_secrets(body)
+          secret_fields = %i[client_secret]
+
+          body.map do |k, v|
+            if secret_fields.include?(k)
+              [k, '**hidden**']
+            else
+              [k, v]
+            end
+          end.to_h
         end
       end
     end

data/lib/hydra/keycloak/tokens/repo.rb

@@ -14,7 +14,7 @@ module Hydra
         inject['tokens_gateway', 'urls']
 
         def get_tokens(auth_code, code_verifier)
-          return Failure(status: 400, code: :auth_code_was_not_received) unless auth_code
+          return Failure(code: :auth_code_was_not_received, context: { caller: caller }) unless auth_code
 
           result = tokens_gateway.post(
             urls.token_endpoint,
@@ -31,7 +31,10 @@ module Hydra
         end
 
         def get_tokens_by_password(username, password)
-          return Failure(status: 400, code: :username_or_password_is_empty) if username.nil? || password.nil?
+          if username.nil? || password.nil?
+            return Failure(code: :username_or_password_is_empty,
+                           context: { caller: caller })
+          end
 
           result = tokens_gateway.post(
             urls.token_endpoint,
@@ -55,7 +58,7 @@ module Hydra
             if result['active']
               Success(result)
             else
-              Failure(status: 400, code: :token_not_active)
+              Failure(code: :token_not_active, caller: caller)
             end
           end
         end
@@ -65,15 +68,9 @@ module Hydra
             urls.token_endpoint,
             urls.refresh_request_body(refresh_token)
           ).bind do |result|
-            if result['error']
-              Failure(status: 400, code: :token_refreshing_error)
-            else
-              Success({
-                        access_token: ::Hydra::Keycloak::Token.new(result['access_token']),
-                        id_token: ::Hydra::Keycloak::Token.new(result['id_token']),
-                        refresh_token: ::Hydra::Keycloak::Token.new(result['refresh_token'])
-                      })
-            end
+            Success({ access_token: ::Hydra::Keycloak::Token.new(result['access_token']),
+                      id_token: ::Hydra::Keycloak::Token.new(result['id_token']),
+                      refresh_token: ::Hydra::Keycloak::Token.new(result['refresh_token']) })
           end
         end
       end

data/lib/hydra/keycloak/version.rb

@@ -2,6 +2,6 @@
 
 module Hydra
   module Keycloak
-    VERSION = '0.1.17'
+    VERSION = '0.1.19'
   end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: hydra-keycloak-client
 version: !ruby/object:Gem::Version
-  version: 0.1.17
+  version: 0.1.19
 platform: ruby
 authors:
 - Fedor Kosolapov
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2023-02-20 00:00:00.000000000 Z
+date: 2023-07-28 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: jwt