workato-connector-sdk 1.0.1 → 1.0.2

data/lib/workato/connector/sdk/connection.rb

@@ -1,3 +1,4 @@
+# typed: strict
 # frozen_string_literal: true
 
 require_relative './block_invocation_refinements'
@@ -6,95 +7,174 @@ module Workato
   module Connector
     module Sdk
       class Connection
+        extend T::Sig
+
         using BlockInvocationRefinements
 
+        sig { returns(HashWithIndifferentAccess) }
         attr_reader :source
 
+        cattr_accessor :on_settings_update
+
+        sig do
+          params(
+            connection: SorbetTypes::SourceHash,
+            methods: SorbetTypes::SourceHash,
+            settings: SorbetTypes::SettingsHash
+          ).void
+        end
         def initialize(connection: {}, methods: {}, settings: {})
-          @methods_source = methods.with_indifferent_access
-          @source = connection.with_indifferent_access
-          @settings = settings
+          @methods_source = T.let(methods.with_indifferent_access, HashWithIndifferentAccess)
+          @source = T.let(connection.with_indifferent_access, HashWithIndifferentAccess)
+          @settings = T.let(settings, SorbetTypes::SettingsHash)
+        end
+
+        sig { returns(SorbetTypes::SettingsHash) }
+        def settings!
+          @settings
+        end
+
+        sig { returns(HashWithIndifferentAccess) }
+        def settings
+          # we can't freeze or memoise because some developers modify it for storing something temporary in it.
+          @settings.with_indifferent_access
+        end
+
+        sig { params(settings: SorbetTypes::SettingsHash).returns(SorbetTypes::SettingsHash) }
+        def merge_settings!(settings)
+          @settings.merge!(settings)
         end
 
+        sig { returns(T::Boolean) }
+        def authorization?
+          source[:authorization].present?
+        end
+
+        sig { returns(Authorization) }
         def authorization
+          raise ::NotImplementedError, 'define authorization: before use' if source[:authorization].blank?
+
+          @authorization = T.let(@authorization, T.nilable(Authorization))
           @authorization ||= Authorization.new(
-            connection: source,
-            methods: methods_source,
-            settings: @settings
+            connection: self,
+            authorization: source[:authorization],
+            methods: methods_source
           )
         end
 
-        def base_uri(settings = {})
-          source[:base_uri]&.call(settings.with_indifferent_access)
+        sig { params(settings: T.nilable(SorbetTypes::SettingsHash)).returns(T.nilable(String)) }
+        def base_uri(settings = nil)
+          source[:base_uri]&.call(settings ? settings.with_indifferent_access.freeze : self.settings)
+        end
+
+        sig do
+          params(
+            message: String,
+            refresher: T.proc.returns(T.nilable(SorbetTypes::SettingsHash))
+          ).returns(T::Boolean)
+        end
+        def update_settings!(message, &refresher)
+          updater = lambda do
+            new_settings = refresher.call
+            next unless new_settings
+
+            settings.merge(new_settings)
+          end
+
+          new_settings = if on_settings_update
+                           on_settings_update.call(message, &updater)
+                         else
+                           updater.call
+                         end
+          return false unless new_settings
+
+          merge_settings!(new_settings)
+
+          true
         end
 
         private
 
+        sig { returns(HashWithIndifferentAccess) }
         attr_reader :methods_source
 
         class Authorization
-          attr_reader :source
-
-          def initialize(connection: {}, methods: {}, settings: {})
-            @connection_source = connection.with_indifferent_access
-            @source = (connection[:authorization] || {}).with_indifferent_access
-            @methods_source = methods.with_indifferent_access
-            @settings = settings
-          end
+          extend T::Sig
 
-          def token_url?
-            source[:token_url].present?
-          end
+          sig { returns(HashWithIndifferentAccess) }
+          attr_reader :source
 
-          def acquire?
-            source[:acquire].present?
+          sig do
+            params(
+              connection: Connection,
+              authorization: HashWithIndifferentAccess,
+              methods: HashWithIndifferentAccess
+            ).void
           end
-
-          def refresh?
-            source[:refresh].present?
+          def initialize(connection:, authorization:, methods:)
+            @connection = T.let(connection, Connection)
+            @connection_source = T.let(connection.source, HashWithIndifferentAccess)
+            @source = T.let(authorization, HashWithIndifferentAccess)
+            @methods_source = T.let(methods, HashWithIndifferentAccess)
           end
 
+          sig { returns(String) }
           def type
-            source[:type]
+            (source[:type].presence || 'none').to_s
           end
 
+          sig { returns(T::Array[T.any(String, Symbol, Regexp, Integer)]) }
           def refresh_on
             Array.wrap(source[:refresh_on]).compact
           end
 
+          sig { returns(T::Array[T.any(String, Symbol, Regexp, Integer)]) }
           def detect_on
             Array.wrap(source[:detect_on]).compact
           end
 
-          def client_id(settings = {})
+          sig { params(settings: T.nilable(SorbetTypes::SettingsHash)).returns(T.nilable(String)) }
+          def client_id(settings = nil)
             client_id = source[:client_id]
 
             if client_id.is_a?(Proc)
-              Dsl::WithDsl.execute(settings.with_indifferent_access, &client_id)
+              @connection.merge_settings!(settings) if settings
+              Dsl::WithDsl.execute(@connection, @connection.settings, &client_id)
             else
               client_id
             end
           end
 
-          def client_secret(settings = {})
+          sig { params(settings: T.nilable(SorbetTypes::SettingsHash)).returns(T.nilable(String)) }
+          def client_secret(settings = nil)
             client_secret_source = source[:client_secret]
 
             if client_secret_source.is_a?(Proc)
-              Dsl::WithDsl.execute(settings.with_indifferent_access, &client_secret_source)
+              @connection.merge_settings!(settings) if settings
+              Dsl::WithDsl.execute(@connection, @connection.settings, &client_secret_source)
             else
               client_secret_source
             end
           end
 
-          def authorization_url(settings = {})
-            source[:authorization_url]&.call(settings.with_indifferent_access)
+          sig { params(settings: T.nilable(SorbetTypes::SettingsHash)).returns(T.nilable(String)) }
+          def authorization_url(settings = nil)
+            source[:authorization_url]&.call(settings&.with_indifferent_access || @connection.settings)
           end
 
-          def token_url(settings = {})
-            source[:token_url]&.call(settings.with_indifferent_access)
+          sig { params(settings: T.nilable(SorbetTypes::SettingsHash)).returns(T.nilable(String)) }
+          def token_url(settings = nil)
+            source[:token_url]&.call(settings&.with_indifferent_access || @connection.settings)
           end
 
-          def acquire(settings = {}, oauth2_code = nil, redirect_url = nil)
+          sig do
+            params(
+              settings: T.nilable(SorbetTypes::SettingsHash),
+              oauth2_code: T.nilable(String),
+              redirect_url: T.nilable(String)
+            ).returns(HashWithIndifferentAccess)
+          end
+          def acquire(settings = nil, oauth2_code = nil, redirect_url = nil)
             acquire_proc = source[:acquire]
             raise InvalidDefinitionError, "Expect 'acquire' block" unless acquire_proc
 
@@ -102,30 +182,61 @@ module Workato
               connection: Connection.new(
                 connection: connection_source.merge(
                   authorization: source.merge(
-                    apply: nil
+                    apply: nil # only skip apply authorization for re-authorization request
                   )
                 ),
                 methods: methods_source,
-                settings: @settings
+                settings: @connection.settings!
               ),
-              methods: methods_source,
-              settings: @settings
+              methods: methods_source
             ).execute(settings, { auth_code: oauth2_code, redirect_url: redirect_url }) do |connection, input|
               instance_exec(connection, input[:auth_code], input[:redirect_url], &acquire_proc)
             end
           end
 
-          def refresh(settings = {}, refresh_token = nil)
+          sig do
+            params(
+              http_code: T.nilable(Integer),
+              http_body: T.nilable(String),
+              exception: T.nilable(String)
+            ).returns(T::Boolean)
+          end
+          def refresh?(http_code, http_body, exception)
+            refresh_on = self.refresh_on
+            refresh_on.blank? || refresh_on.any? do |pattern|
+              pattern.is_a?(::Integer) && pattern == http_code ||
+                pattern === exception&.to_s ||
+                pattern === http_body
+            end
+          end
+
+          sig { params(settings: HashWithIndifferentAccess).returns(T.nilable(HashWithIndifferentAccess)) }
+          def refresh!(settings)
+            if /oauth2/i =~ type
+              refresh_oauth2_token(settings)
+            elsif source[:acquire].present?
+              acquire(settings)
+            end
+          end
+
+          sig do
+            params(
+              settings: T.nilable(SorbetTypes::SettingsHash),
+              refresh_token: T.nilable(String)
+            ).returns(
+              T.any([HashWithIndifferentAccess, T.nilable(String)], HashWithIndifferentAccess)
+            )
+          end
+          def refresh(settings = nil, refresh_token = nil)
             refresh_proc = source[:refresh]
             raise InvalidDefinitionError, "Expect 'refresh' block" unless refresh_proc
 
             Workato::Connector::Sdk::Operation.new(
               connection: Connection.new(
                 methods: methods_source,
-                settings: @settings
+                settings: @connection.settings!
               ),
-              methods: methods_source,
-              settings: @settings
+              methods: methods_source
             ).execute(settings, { refresh_token: refresh_token }) do |connection, input|
               instance_exec(connection, input[:refresh_token], &refresh_proc)
             end
@@ -133,8 +244,55 @@ module Workato
 
           private
 
-          attr_reader :connection_source,
-                      :methods_source
+          sig { returns(HashWithIndifferentAccess) }
+          attr_reader :connection_source
+
+          sig { returns(HashWithIndifferentAccess) }
+          attr_reader :methods_source
+
+          sig { params(settings: HashWithIndifferentAccess).returns(HashWithIndifferentAccess) }
+          def refresh_oauth2_token(settings)
+            if source[:refresh].present?
+              refresh_oauth2_token_using_refresh(settings)
+            elsif source[:token_url].present?
+              refresh_oauth2_token_using_token_url(settings)
+            else
+              raise InvalidDefinitionError, "'refresh' block or 'token_url' is required for refreshing the token"
+            end
+          end
+
+          sig { params(settings: HashWithIndifferentAccess).returns(HashWithIndifferentAccess) }
+          def refresh_oauth2_token_using_refresh(settings)
+            new_tokens, new_settings = refresh(settings, settings[:refresh_token])
+            new_tokens.with_indifferent_access.merge(new_settings || {})
+          end
+
+          sig { params(settings: HashWithIndifferentAccess).returns(HashWithIndifferentAccess) }
+          def refresh_oauth2_token_using_token_url(settings)
+            if settings[:refresh_token].blank?
+              raise NotImplementedError, 'refresh_token is empty. ' \
+                                       'Use workato oauth2 command to acquire access_token and refresh_token'
+            end
+
+            response = RestClient::Request.execute(
+              url: token_url(settings),
+              method: :post,
+              payload: {
+                client_id: client_id(settings),
+                client_secret: client_secret(settings),
+                grant_type: :refresh_token,
+                refresh_token: settings[:refresh_token]
+              },
+              headers: {
+                accept: :json
+              }
+            )
+            tokens = JSON.parse(response.body)
+            {
+              access_token: tokens['access_token'],
+              refresh_token: tokens['refresh_token'].presence || settings[:refresh_token]
+            }.with_indifferent_access
+          end
         end
 
         private_constant :Authorization