hydra-keycloak-client 0.1.16 → 0.1.18

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: e21882cde2f44b50a21259216097d6f101429189476d7c8e672a45376445639e
-  data.tar.gz: 109d00d611d0755b8a8ef9d1ddc564d0b05203bbf52fe09b2bf50d41c58cf62d
+  metadata.gz: 0a2e948b3a20ed2ba3bbbfa11c0d8095d1d2668ab7b84ab9c84ee141b4ffd858
+  data.tar.gz: 470d447468b40bb7f22ba97126702a7c99952cf9038005097b44651ce900a0c3
 SHA512:
-  metadata.gz: 66ece7983e4ed5731233f41ad9d15e4bf6fcb1c55f8e2aa708b3317031ff89f201e9cdf3ec7bc94fc7e5855f9b95b78ed7c53ddfcac085108053893719072b27
-  data.tar.gz: a1edbad85e6397ae3ea3f1f6e66c3f0cecc16648e4b344d900ac16c71a2904ac450041615cc022319421380b39837a93abd4e5765ec3c6dcc1e196e70483785e
+  metadata.gz: ce821ea5c0d68d23c1e57c5696013b4a3cdec84e4bd70e1ad484c2c394e1fa5699f7b685311732c4ed8d176406faeece9b78e722cb53fae7666c69e77cb9dfa5
+  data.tar.gz: fdb9094dd2861753b689f2a83b367116460b49f0a3817d2ba01b1c2fcf5ea705d2e4c7f903b6131c6d137c2785a8e5572ed9c80f74959447a37e9238a2eadecb

data/.gitignore

@@ -1,3 +1,6 @@
 .rspec_status
 coverage
 .bundle
+.DS_Store
+.idea
+.ruby-version

data/Gemfile.lock

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

data/lib/hydra/keycloak/client.rb

@@ -127,7 +127,12 @@ module Hydra
     class Client
       extend ::Hydra::Keycloak::Mixin
       include ::Dry::Monads[:result, :do]
-      inject['urls', 'tokens_repo', 'store', 'code_verifier']
+      inject[
+        'urls',
+        'tokens_repo',
+        'store',
+        'code_verifier'
+      ]
 
       def auth_url
         code_verifier.generate
@@ -171,17 +176,17 @@ 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')
+          .or(Failure(code: :not_authenticated,
+                      context: { args: { session_state: session_state } }))
       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')
+                       .or(Failure(code: :not_authenticated,
+                                   context: { args: { session_state: session_state } }))
         if token_expired?(access_token)
-          refresh_tokens(session_state)
+          yield refresh_tokens(session_state)
 
           access_token = yield fetch_token(session_state, 'access_token')
         end
@@ -190,17 +195,17 @@ 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')
+          .either(->(token) { Success(token[:jti]) },
+                  ->(_) { Failure(code: :not_authenticated, context: { args: { session_state: session_state } }) })
       end
 
       def logout!(session_state)
-        fetch_token(session_state, 'id_token').bind do |id_token|
-          clear_tokens(session_state)
+        id_token = yield fetch_token(session_state, 'id_token')
 
-          urls.end_session_url(id_token.source)
-        end
+        yield clear_tokens(session_state)
+
+        Success(urls.end_session_url(id_token.source))
       end
 
       def introspect_token(token)
@@ -218,15 +223,22 @@ 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 } })
           end
         end
       end
 
       def clear_tokens(session_state)
-        store.delete("#{session_state}_access_token")
-        store.delete("#{session_state}_id_token")
-        store.delete("#{session_state}_refresh_token")
+        Dry::Monads::List[
+          "#{session_state}_access_token",
+          "#{session_state}_id_token",
+          "#{session_state}_refresh_token"
+        ]
+          .fmap { |x| store.delete(x) }
+          .typed(Dry::Monads::Result)
+          .traverse
       end
 
       def token_expired?(token)
@@ -240,6 +252,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,22 @@ 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 })
         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 })
         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 })
         end
       end
     end

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

@@ -15,22 +15,22 @@ 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 })
         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 })
         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 })
         end
       end
     end

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

@@ -25,19 +25,45 @@ 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) },
+                               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 })
+        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 })
+        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) unless auth_code
 
           result = tokens_gateway.post(
             urls.token_endpoint,
@@ -31,7 +31,7 @@ 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?
+          return Failure(code: :username_or_password_is_empty) if username.nil? || password.nil?
 
           result = tokens_gateway.post(
             urls.token_endpoint,
@@ -55,7 +55,7 @@ module Hydra
             if result['active']
               Success(result)
             else
-              Failure(status: 400, code: :token_not_active)
+              Failure(code: :token_not_active)
             end
           end
         end
@@ -65,15 +65,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.16'
+    VERSION = '0.1.18'
   end
 end

metadata

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