workato-connector-sdk 1.1.0 → 1.3.0

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

@@ -11,29 +11,34 @@ module Workato
         extend T::Sig
         using BlockInvocationRefinements
 
+        include Dsl::ReinvokeAfter
+
         RETRY_DEFAULT_CODES = T.let([429, 500, 502, 503, 504, 507].freeze, T::Array[Integer])
         RETRY_DEFAULT_METHODS = T.let(%i[get head].freeze, T::Array[Symbol])
         RETRY_DELAY = T.let(5, Integer) # seconds
+        RETRY_DELAY_EXP_BASE = T.let(2, Integer)
         MAX_RETRIES = 3
 
-        MAX_REINVOKES = 5
-
         sig do
           params(
             action: SorbetTypes::SourceHash,
             methods: SorbetTypes::SourceHash,
             connection: Connection,
-            object_definitions: T.nilable(ObjectDefinitions)
+            object_definitions: T.nilable(ObjectDefinitions),
+            streams: Streams
           ).void
         end
-        def initialize(action:, methods: {}, connection: Connection.new, object_definitions: nil)
+        def initialize(action:, methods: {}, connection: Connection.new, object_definitions: nil,
+                       streams: ProhibitedStreams.new)
           super(
             operation: action,
             connection: connection,
             methods: methods,
-            object_definitions: object_definitions
+            object_definitions: object_definitions,
+            streams: streams
           )
 
+          @retry_delay_factor = T.let(1, Integer)
           @retries_left = T.let(0, Integer)
           @retry_codes = T.let([], T::Array[Integer])
           @retry_methods = T.let([], T::Array[String])
@@ -58,33 +63,21 @@ module Workato
                     &block)
           raise InvalidDefinitionError, "'execute' block is required for action" unless block || action[:execute]
 
-          loop do
-            if @reinvokes_remaining&.zero?
-              raise "Max number of reinvokes on SDK Gem reached. Current limit is #{reinvoke_limit}"
-            end
-
-            reinvoke_sleep if @reinvoke_after
-
-            reinvoke_reset
-
-            result = super(
+          loop_reinvoke_after(continue) do |next_continue|
+            return super(
               settings,
               input,
               extended_input_schema,
               extended_output_schema,
-              continue,
+              next_continue,
               &(block || action[:execute])
             )
-
-            break result unless @reinvoke_after
-
-            continue = @reinvoke_after.continue
           end
-        rescue RequestError => e
+        rescue RequestFailedError => e
           raise e unless retry?(e)
 
           @retries_left -= 1
-          sleep(RETRY_DELAY)
+          retry_sleep
           retry
         end
 
@@ -100,32 +93,6 @@ module Workato
           apply_output_schema(output, output_schema)
         end
 
-        sig do
-          params(
-            continue: T::Hash[T.untyped, T.untyped],
-            temp_output: T.nilable(T::Hash[T.untyped, T.untyped])
-          ).void
-        end
-        def checkpoint!(continue:, temp_output: nil)
-          # no-op
-        end
-
-        sig do
-          params(
-            seconds: Integer,
-            continue: T::Hash[T.untyped, T.untyped],
-            temp_output: T.nilable(T::Hash[T.untyped, T.untyped])
-          ).void
-        end
-        def reinvoke_after(seconds:, continue:, temp_output: nil) # rubocop:disable Lint/UnusedMethodArgument
-          @reinvokes_remaining = T.let(@reinvokes_remaining, T.nilable(Integer))
-          @reinvokes_remaining = (@reinvokes_remaining ? @reinvokes_remaining - 1 : reinvoke_limit)
-          @reinvoke_after = ReinvokeAfter.new(
-            seconds: seconds,
-            continue: continue
-          )
-        end
-
         private
 
         sig { returns(T::Array[T.any(Symbol, String, Regexp, Integer)]) }
@@ -150,10 +117,10 @@ module Workato
           retry_on_response.each { |m| m.is_a?(::Integer) ? @retry_codes << m : @retry_matchers << m }
           @retry_codes = RETRY_DEFAULT_CODES if @retry_codes.empty?
           @retry_methods = (retry_on_request.presence || RETRY_DEFAULT_METHODS).map(&:to_s).map(&:downcase)
-          @retries_left = [[max_retries.is_a?(::Integer) && max_retries || MAX_RETRIES, MAX_RETRIES].min, 0].max
+          @retries_left = [[(max_retries.is_a?(::Integer) && max_retries) || MAX_RETRIES, MAX_RETRIES].min, 0].max
         end
 
-        sig { params(exception: RequestError).returns(T::Boolean) }
+        sig { params(exception: RequestFailedError).returns(T::Boolean) }
         def retry?(exception)
           return false unless @retries_left.positive?
           return false unless @retry_codes.include?(exception.code.to_i)
@@ -165,28 +132,11 @@ module Workato
         end
 
         sig { void }
-        def reinvoke_sleep
-          sleep((ENV['WAIT_REINVOKE_AFTER'].presence || T.must(@reinvoke_after).seconds).to_f)
-        end
-
-        sig { returns(Integer) }
-        def reinvoke_limit
-          @reinvoke_limit = T.let(@reinvoke_limit, T.nilable(Integer))
-          @reinvoke_limit ||= (ENV['MAX_REINVOKES'].presence || MAX_REINVOKES).to_i
-        end
-
-        sig { void }
-        def reinvoke_reset
-          @reinvoke_after = T.let(nil, T.nilable(ReinvokeAfter))
+        def retry_sleep
+          sleep(@retry_delay_factor * RETRY_DELAY)
+          @retry_delay_factor *= RETRY_DELAY_EXP_BASE
         end
 
-        class ReinvokeAfter < T::Struct
-          prop :seconds, T.any(Float, Integer)
-          prop :continue, T::Hash[T.untyped, T.untyped]
-        end
-
-        private_constant :ReinvokeAfter
-
         alias action operation
       end
     end

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

@@ -6,25 +6,17 @@ module Workato
     module Sdk
       # match proc's arguments, even if it's a lambda.
       module BlockInvocationRefinements
-        module CallRefinement
+        refine Proc do
           def call(*args, &block)
             super(*args.take(parameters.length), &block)
           end
         end
 
-        refine Proc do
-          prepend CallRefinement
-        end
-
-        module InstanceExecRefinement
+        refine BasicObject do
           def instance_exec(*args, &block)
             super(*args.take(block.parameters.length), &block)
           end
         end
-
-        refine BasicObject do
-          prepend InstanceExecRefinement
-        end
       end
     end
   end

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

@@ -3,18 +3,44 @@
 
 require_relative './block_invocation_refinements'
 
+using Workato::Extension::HashWithIndifferentAccess
+
 module Workato
   module Connector
     module Sdk
+      module SorbetTypes
+        AcquireOutput = T.type_alias do
+          T.any(
+            # oauth2
+            [
+              HashWithIndifferentAccess, # tokens
+              T.untyped, # resource_owner_id
+              T.nilable(HashWithIndifferentAccess) # settings
+            ],
+            [
+              HashWithIndifferentAccess, # tokens
+              T.untyped # resource_owner_id
+            ],
+            [
+              HashWithIndifferentAccess # tokens
+            ],
+            # custom_auth
+            HashWithIndifferentAccess
+          )
+        end
+      end
+
       class Connection
         extend T::Sig
+        include MonitorMixin
 
         using BlockInvocationRefinements
 
         sig { returns(HashWithIndifferentAccess) }
         attr_reader :source
 
-        cattr_accessor :on_settings_update
+        class_attribute :on_settings_update, instance_predicate: false
+        class_attribute :multi_auth_selected_fallback, instance_predicate: false
 
         sig do
           params(
@@ -24,8 +50,9 @@ module Workato
           ).void
         end
         def initialize(connection: {}, methods: {}, settings: {})
-          @methods_source = T.let(methods.with_indifferent_access, HashWithIndifferentAccess)
-          @source = T.let(connection.with_indifferent_access, HashWithIndifferentAccess)
+          super()
+          @methods_source = T.let(HashWithIndifferentAccess.wrap(methods), HashWithIndifferentAccess)
+          @source = T.let(HashWithIndifferentAccess.wrap(connection), HashWithIndifferentAccess)
           @settings = T.let(settings, SorbetTypes::SettingsHash)
         end
 
@@ -37,7 +64,10 @@ module Workato
         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
+          # always return a new copy
+          synchronize do
+            @settings.with_indifferent_access
+          end
         end
 
         sig { params(settings: SorbetTypes::SettingsHash).returns(SorbetTypes::SettingsHash) }
@@ -64,16 +94,20 @@ module Workato
 
         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)
+          return unless source[:base_uri]
+
+          merge_settings!(settings) if settings
+          global_dsl_context.execute(self.settings, &source['base_uri'])
         end
 
         sig do
           params(
             message: String,
+            settings_before: SorbetTypes::SettingsHash,
             refresher: T.proc.returns(T.nilable(SorbetTypes::SettingsHash))
           ).returns(T::Boolean)
         end
-        def update_settings!(message, &refresher)
+        def update_settings!(message, settings_before, &refresher)
           updater = lambda do
             new_settings = refresher.call
             next unless new_settings
@@ -81,16 +115,18 @@ module Workato
             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
+          synchronize do
+            new_settings = if on_settings_update
+                             T.must(on_settings_update).call(message, settings_before, updater)
+                           else
+                             updater.call
+                           end
+            return false unless new_settings
 
-          merge_settings!(new_settings)
+            merge_settings!(new_settings)
 
-          true
+            true
+          end
         end
 
         private
@@ -98,12 +134,14 @@ module Workato
         sig { returns(HashWithIndifferentAccess) }
         attr_reader :methods_source
 
+        sig { returns(Dsl::WithDsl) }
+        def global_dsl_context
+          Dsl::WithDsl.new(self)
+        end
+
         class Authorization
           extend T::Sig
 
-          sig { returns(HashWithIndifferentAccess) }
-          attr_reader :source
-
           sig do
             params(
               connection: Connection,
@@ -123,6 +161,16 @@ module Workato
             (source[:type].presence || 'none').to_s
           end
 
+          sig { returns(T::Boolean) }
+          def oauth2?
+            !!(/oauth2/i =~ type)
+          end
+
+          sig { returns(T::Boolean) }
+          def multi?
+            @source[:type].to_s == 'multi'
+          end
+
           sig { returns(T::Array[T.any(String, Symbol, Regexp, Integer)]) }
           def refresh_on
             Array.wrap(source[:refresh_on]).compact
@@ -135,11 +183,11 @@ module Workato
 
           sig { params(settings: T.nilable(SorbetTypes::SettingsHash)).returns(T.nilable(String)) }
           def client_id(settings = nil)
+            @connection.merge_settings!(settings) if settings
             client_id = source[:client_id]
 
             if client_id.is_a?(Proc)
-              @connection.merge_settings!(settings) if settings
-              Dsl::WithDsl.execute(@connection, @connection.settings, &client_id)
+              global_dsl_context.execute(@connection.settings, &client_id)
             else
               client_id
             end
@@ -147,11 +195,11 @@ module Workato
 
           sig { params(settings: T.nilable(SorbetTypes::SettingsHash)).returns(T.nilable(String)) }
           def client_secret(settings = nil)
+            @connection.merge_settings!(settings) if settings
             client_secret_source = source[:client_secret]
 
             if client_secret_source.is_a?(Proc)
-              @connection.merge_settings!(settings) if settings
-              Dsl::WithDsl.execute(@connection, @connection.settings, &client_secret_source)
+              global_dsl_context.execute(@connection.settings, &client_secret_source)
             else
               client_secret_source
             end
@@ -159,12 +207,18 @@ module Workato
 
           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)
+            @connection.merge_settings!(settings) if settings
+            return unless source[:authorization_url]
+
+            global_dsl_context.execute(@connection.settings, &source[:authorization_url])
           end
 
           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)
+            @connection.merge_settings!(settings) if settings
+            return unless source[:token_url]
+
+            global_dsl_context.execute(@connection.settings, &source[:token_url])
           end
 
           sig do
@@ -172,9 +226,10 @@ module Workato
               settings: T.nilable(SorbetTypes::SettingsHash),
               oauth2_code: T.nilable(String),
               redirect_url: T.nilable(String)
-            ).returns(HashWithIndifferentAccess)
+            ).returns(T.nilable(SorbetTypes::AcquireOutput))
           end
           def acquire(settings = nil, oauth2_code = nil, redirect_url = nil)
+            @connection.merge_settings!(settings) if settings
             acquire_proc = source[:acquire]
             raise InvalidDefinitionError, "Expect 'acquire' block" unless acquire_proc
 
@@ -202,11 +257,11 @@ module Workato
             ).returns(T::Boolean)
           end
           def refresh?(http_code, http_body, exception)
-            return false unless /oauth2/i =~ type || source[:acquire].present?
+            return false unless oauth2? || source[:acquire].present?
 
             refresh_on = self.refresh_on
             refresh_on.blank? || refresh_on.any? do |pattern|
-              pattern.is_a?(::Integer) && pattern == http_code ||
+              (pattern.is_a?(::Integer) && pattern == http_code) ||
                 pattern === exception&.to_s ||
                 pattern === http_body
             end
@@ -214,10 +269,10 @@ module Workato
 
           sig { params(settings: HashWithIndifferentAccess).returns(T.nilable(HashWithIndifferentAccess)) }
           def refresh!(settings)
-            if /oauth2/i =~ type
+            if oauth2?
               refresh_oauth2_token(settings)
             elsif source[:acquire].present?
-              acquire(settings)
+              T.cast(acquire(settings), T.nilable(HashWithIndifferentAccess))
             end
           end
 
@@ -230,6 +285,7 @@ module Workato
             )
           end
           def refresh(settings = nil, refresh_token = nil)
+            @connection.merge_settings!(settings) if settings
             refresh_proc = source[:refresh]
             raise InvalidDefinitionError, "Expect 'refresh' block" unless refresh_proc
 
@@ -244,6 +300,27 @@ module Workato
             end
           end
 
+          sig { returns(HashWithIndifferentAccess) }
+          def source
+            return @source unless multi?
+
+            unless @source[:selected]
+              raise InvalidMultiAuthDefinition, "Multi-auth connection must define 'selected' block"
+            end
+
+            if @source[:options].blank?
+              raise InvalidMultiAuthDefinition, "Multi-auth connection must define 'options' list"
+            end
+
+            selected_auth_key = @source[:selected].call(@connection.settings)
+            selected_auth_key ||= @connection.multi_auth_selected_fallback&.call(@source[:options])
+            selected_auth_value = @source.dig(:options, selected_auth_key)
+
+            raise UnresolvedMultiAuthOptionError, selected_auth_key unless selected_auth_value
+
+            selected_auth_value
+          end
+
           private
 
           sig { returns(HashWithIndifferentAccess) }
@@ -266,14 +343,17 @@ module Workato
           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 || {})
+            new_tokens = HashWithIndifferentAccess.wrap(new_tokens)
+            return new_tokens unless new_settings
+
+            new_tokens.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'
+                                         'Use workato oauth2 command to acquire access_token and refresh_token'
             end
 
             response = RestClient::Request.execute(
@@ -295,6 +375,11 @@ module Workato
               refresh_token: tokens['refresh_token'].presence || settings[:refresh_token]
             }.with_indifferent_access
           end
+
+          sig { returns(Dsl::WithDsl) }
+          def global_dsl_context
+            Dsl::WithDsl.new(@connection)
+          end
         end
 
         private_constant :Authorization