workato-connector-sdk 1.1.0 → 1.3.0

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

@@ -7,9 +7,13 @@ require 'json'
 require 'gyoku'
 require 'net/http'
 require 'net/http/digest_auth'
+require 'active_support/json'
 
+require 'workato/utilities/encoding'
+require 'workato/utilities/xml'
 require_relative './block_invocation_refinements'
-require_relative './../../utilities/encoding'
+
+using Workato::Extension::HashWithIndifferentAccess
 
 module Workato
   module Connector
@@ -31,43 +35,34 @@ module Workato
           @render_request = ->(payload) { payload }
           @parse_response = ->(payload) { payload }
           @after_response = ->(_response_code, parsed_response, _response_headers) { parsed_response }
+          @callstack_before_request = Array.wrap(Kernel.caller)
         end
 
-        def method_missing(*args, &block)
-          execute!.send(*args, &block)
+        def method_missing(...)
+          execute!.send(...)
         end
 
         def execute!
-          __getobj__ || __setobj__(
-            authorized do
-              begin
-                request = build_request
-                response = execute(request)
-              rescue RestClient::Unauthorized => e
-                Kernel.raise e unless @digest_auth
-
-                @digest_auth = false
-                headers('Authorization' => Net::HTTP::DigestAuth.new.auth_header(
-                  URI.parse(build_url),
-                  e.response.headers[:www_authenticate],
-                  method.to_s.upcase
-                ))
-                request = build_request
-                response = execute(request)
-              end
-              detect_error!(response.body)
-              parsed_response = @parse_response.call(response)
-              detect_error!(parsed_response)
-              apply_after_response(response.code, parsed_response, response.headers)
-            end
-          )
+          __getobj__ || __setobj__(response)
+        rescue RestClient::Exceptions::Timeout => e
+          Kernel.raise RequestTimeoutError, e
         rescue RestClient::Exception => e
           if after_error_response_matches?(e)
             return apply_after_error_response(e)
           end
 
-          Kernel.raise RequestError.new(response: e.response, message: e.message, method: current_verb,
-                                        code: e.http_code)
+          Kernel.raise RequestFailedError.new(
+            response: e.response,
+            message: e.message,
+            method: current_verb,
+            code: e.http_code
+          )
+        rescue StandardError => e
+          error_backtrace = Array.wrap(e.backtrace)
+          first_call_after_request_idx = error_backtrace.rindex { |s| s.start_with?(__FILE__) }
+          error_backtrace_after_request = error_backtrace[0..first_call_after_request_idx]
+          e.set_backtrace(error_backtrace_after_request + @callstack_before_request)
+          Kernel.raise e
         end
 
         def headers(headers)
@@ -178,7 +173,7 @@ module Workato
         def response_format_xml(strip_response_namespaces: false)
           @accept_header = :xml
           @parse_response = lambda_with_error_wrap(XMLResponseFormatError) do |payload|
-            Xml.parse_xml_to_hash(payload, strip_namespaces: strip_response_namespaces)
+            Workato::Utilities::Xml.parse_xml_to_hash(payload, strip_namespaces: strip_response_namespaces)
           end
           self
         end
@@ -258,15 +253,39 @@ module Workato
           ::Kernel.puts(*args)
         end
 
-        def try(*args, &block)
-          execute!.try(*args, &block)
+        def try(...)
+          execute!.try(...)
         end
 
         private
 
         attr_reader :method
 
-        def execute(request)
+        def response
+          authorized do
+            begin
+              request = RestClientRequest.new(rest_request_params)
+              response = execute_request(request)
+            rescue RestClient::Unauthorized => e
+              Kernel.raise e unless @digest_auth
+
+              @digest_auth = false
+              headers('Authorization' => Net::HTTP::DigestAuth.new.auth_header(
+                URI.parse(build_url),
+                e.response.headers[:www_authenticate],
+                method.to_s.upcase
+              ))
+              request = RestClientRequest.new(rest_request_params)
+              response = execute_request(request)
+            end
+            detect_auth_error!(response.body)
+            parsed_response = @parse_response.call(response)
+            detect_auth_error!(parsed_response)
+            apply_after_response(response.code, parsed_response, response.headers)
+          end
+        end
+
+        def execute_request(request)
           if @follow_redirection.nil?
             request.execute
           else
@@ -285,31 +304,28 @@ module Workato
           end
         end
 
-        def build_request
-          RestClient::Request.new(
-            {
-              method: method,
-              url: build_url,
-              headers: build_headers,
-              payload: @render_request.call(@payload)
-            }.tap do |request_hash|
-              if @ssl_client_cert.present? && @ssl_client_key.present?
-                request_hash[:ssl_client_cert] = @ssl_client_cert
-                request_hash[:ssl_client_key] = @ssl_client_key
+        def rest_request_params
+          {
+            method: method,
+            url: build_url,
+            headers: build_headers,
+            payload: @render_request.call(@payload),
+            case_sensitive_headers: @case_sensitive_headers.transform_keys(&:to_s)
+          }.tap do |request_hash|
+            if @ssl_client_cert.present? && @ssl_client_key.present?
+              request_hash[:ssl_client_cert] = @ssl_client_cert
+              request_hash[:ssl_client_key] = @ssl_client_key
+              if @ssl_client_intermediate_certs.present?
+                request_hash[:ssl_extra_chain_cert] = @ssl_client_intermediate_certs
               end
-              request_hash[:ssl_cert_store] = @ssl_cert_store if @ssl_cert_store
-            end
-          ).tap do |request|
-            request.case_sensitive_headers = @case_sensitive_headers.transform_keys(&:to_s)
-            if @ssl_client_intermediate_certs.present? && @ssl_client_cert.present? && @ssl_client_key.present?
-              request.extra_chain_cert = @ssl_client_intermediate_certs
             end
+            request_hash[:ssl_cert_store] = @ssl_cert_store if @ssl_cert_store
           end
         end
 
         def build_url
           uri = if @base_uri
-                  URI.parse(@base_uri).merge(@uri)
+                  merge_uris(@base_uri, @uri)
                 else
                   URI.parse(@uri)
                 end
@@ -334,9 +350,13 @@ module Workato
           uri.to_s
         end
 
+        def merge_uris(uri1, uri2)
+          (uri1.is_a?(::String) ? URI.parse(uri1) : uri1).merge(uri2)
+        end
+
         def build_headers
           headers = @headers
-          if @content_type_header.present? && headers.keys.none? { |key| /^content[\-_]type$/i =~ key }
+          if @content_type_header.present? && headers.keys.none? { |key| /^content[-_]type$/i =~ key }
             headers[:content_type] = @content_type_header
           end
           if @accept_header && headers.keys.none? { |key| /^accept$/i =~ key }
@@ -345,13 +365,13 @@ module Workato
           headers.compact
         end
 
-        def detect_error!(response)
+        def detect_auth_error!(response)
           return unless authorized?
 
           error_patterns = connection.authorization.detect_on
           return unless error_patterns.any? { |pattern| pattern === response rescue false }
 
-          Kernel.raise(CustomRequestError, response.to_s)
+          Kernel.raise(DetectOnUnauthorizedRequestError, response.to_s)
         end
 
         def after_error_response_matches?(exception)
@@ -373,7 +393,7 @@ module Workato
           within_action_context(
             exception.http_code,
             exception.http_body,
-            exception.http_headers&.with_indifferent_access || {},
+            HashWithIndifferentAccess.wrap(exception.http_headers),
             exception.message,
             &@after_error_response
           )
@@ -386,8 +406,8 @@ module Workato
           within_action_context(code, parsed_response, encoded_headers, &@after_response)
         end
 
-        def within_action_context(*args, &block)
-          (@action || self).instance_exec(*args, &block)
+        def within_action_context(...)
+          (@action || self).instance_exec(...)
         end
 
         sig { returns(T::Boolean) }
@@ -404,15 +424,15 @@ module Workato
           first = true
           begin
             settings = connection.settings
-            if /oauth2/i =~ connection.authorization.type
-              instance_exec(settings, settings[:access_token], @auth_type, &apply)
+            if connection.authorization.oauth2?
+              apply_oauth2(settings, settings[:access_token], @auth_type, &apply)
             else
-              instance_exec(settings, @auth_type, &apply)
+              apply_custom_auth(settings, @auth_type, &apply)
             end
             yield
-          rescue RestClient::Exception, CustomRequestError => e
+          rescue RestClient::Exception, DetectOnUnauthorizedRequestError => e
             Kernel.raise e unless first
-            Kernel.raise e unless refresh_authorization!(e.try(:http_code), e.try(:http_body), e.message)
+            Kernel.raise e unless refresh_authorization!(settings, e.try(:http_code), e.try(:http_body), e.message)
 
             first = false
             retry
@@ -421,16 +441,49 @@ module Workato
 
         sig do
           params(
+            settings: HashWithIndifferentAccess,
+            access_token: T.untyped,
+            auth_type: T.untyped,
+            apply_proc: T.proc.params(
+              settings: HashWithIndifferentAccess,
+              access_token: T.untyped,
+              auth_type: T.untyped
+            ).void
+          ).void
+        end
+        def apply_oauth2(settings, access_token, auth_type, &apply_proc)
+          instance_exec(settings, access_token, auth_type, &apply_proc)
+        end
+
+        sig do
+          params(
+            settings: HashWithIndifferentAccess,
+            auth_type: T.untyped,
+            apply_proc: T.proc.params(
+              settings: HashWithIndifferentAccess,
+              auth_type: T.untyped
+            ).void
+          ).void
+        end
+        def apply_custom_auth(settings, auth_type, &apply_proc)
+          instance_exec(settings, auth_type, &apply_proc)
+        end
+
+        sig do
+          params(
+            settings_before: HashWithIndifferentAccess,
             http_code: T.nilable(Integer),
             http_body: T.nilable(String),
             exception: T.nilable(String)
           ).returns(T::Boolean)
         end
-        def refresh_authorization!(http_code, http_body, exception)
+        def refresh_authorization!(settings_before, http_code, http_body, exception)
           return false unless connection.authorization.refresh?(http_code, http_body, exception)
 
-          connection.update_settings!("Refresh token triggered on response \"#{exception}\"") do
-            connection.authorization.refresh!(connection.settings)
+          connection.update_settings!("Refresh token triggered on response \"#{exception}\"", settings_before) do
+            next connection.settings unless connection.settings == settings_before
+
+            connection.authorization.refresh!(settings_before)
           end
         end
 
@@ -441,11 +494,9 @@ module Workato
 
         def lambda_with_error_wrap(error_type, &block)
           Kernel.lambda do |payload|
-            begin
-              block.call(payload)
-            rescue StandardError => e
-              Kernel.raise error_type.new(e)
-            end
+            block.call(payload)
+          rescue StandardError => e
+            Kernel.raise error_type.new(e)
           end
         end
 
@@ -461,6 +512,35 @@ module Workato
           attr_reader :content_type
           attr_reader :original_filename
         end
+
+        class RestClientRequest < ::RestClient::Request
+          def initialize(args)
+            super
+            @ssl_opts[:extra_chain_cert] = args[:ssl_extra_chain_cert] if args.key?(:ssl_extra_chain_cert)
+            @case_sensitive_headers = args[:case_sensitive_headers]
+            @before_execution_proc = proc do |net_http_request, _args|
+              net_http_request.case_sensitive_headers = args[:case_sensitive_headers]
+            end
+          end
+
+          def ssl_extra_chain_cert
+            @ssl_opts[:extra_chain_cert]
+          end
+
+          def processed_headers
+            return @processed_headers if @case_sensitive_headers.blank?
+            return @case_sensitive_headers if @processed_headers.blank?
+
+            @processed_headers.merge(@case_sensitive_headers)
+          end
+
+          def net_http_object(hostname, port)
+            net = super(hostname, port)
+            net.extra_chain_cert = ssl_extra_chain_cert if ssl_extra_chain_cert
+            net
+          end
+        end
+        private_constant :RestClientRequest
       end
     end
   end

data/lib/workato/connector/sdk/schema/field/convertors.rb

@@ -26,7 +26,7 @@ module Workato
             end
 
             def integer_conversion(value)
-              value.try(:is_number?) && value.to_i || value
+              (value.try(:is_number?) && value.to_i) || value
             end
 
             def boolean_conversion(value)
@@ -34,7 +34,7 @@ module Workato
             end
 
             def float_conversion(value)
-              value.try(:is_number?) && value.to_f || value
+              (value.try(:is_number?) && value.to_f) || value
             end
 
             def item_array_wrap(items)

data/lib/workato/connector/sdk/schema/type/unicode_string.rb

@@ -8,7 +8,7 @@ module Workato
         module Type
           class UnicodeString < ::String
             def initialize(str)
-              super(str, {})
+              super(str, **{})
               encode!('UTF-8')
             end
 

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

@@ -1,20 +1,22 @@
 # typed: false
 # frozen_string_literal: true
 
+using Workato::Extension::HashWithIndifferentAccess
+
 module Workato
   module Connector
     module Sdk
       class Schema < SimpleDelegator
         def initialize(schema: [])
-          super(Fields.new(::Array.wrap(schema).map(&:with_indifferent_access)))
+          super(Fields.new(::Array.wrap(schema).map { |i| HashWithIndifferentAccess.wrap(i) }))
         end
 
         def trim(input)
-          input.with_indifferent_access.keep_if { |property_name| includes_property?(property_name) }
+          HashWithIndifferentAccess.wrap(input).keep_if { |property_name| includes_property?(property_name) }
         end
 
         def apply(input, enforce_required:, &block)
-          input.with_indifferent_access.tap do |input_with_indifferent_access|
+          HashWithIndifferentAccess.wrap(input).tap do |input_with_indifferent_access|
             apply_to_hash(self, input_with_indifferent_access, enforce_required: enforce_required, &block)
           end
         end
@@ -99,14 +101,14 @@ module Workato
             return Type::Time.from_date_time(value)
           when ::Date
             return value.to_date
-          when ::Numeric, ::TrueClass, ::FalseClass, Workato::Extension::Binary, Type::UnicodeString,
-            ::Array, ::Hash
+          when ::Numeric, ::TrueClass, ::FalseClass, Workato::Types::Binary, Type::UnicodeString,
+            ::Array, ::Hash, Stream::Proxy
             return value
           when Extension::Array::ArrayWhere
             return value.to_a
           when ::String
             if value.encoding == Encoding::ASCII_8BIT
-              return Workato::Extension::Binary.new(value)
+              return Workato::Types::Binary.new(value)
             end
 
             return Type::UnicodeString.new(value)
@@ -117,7 +119,7 @@ module Workato
 
             if value.respond_to?(:read) && value.respond_to?(:rewind)
               value.rewind
-              return Workato::Extension::Binary.new(value.read.force_encoding(Encoding::ASCII_8BIT))
+              return Workato::Types::Binary.new(value.read.force_encoding(Encoding::ASCII_8BIT))
             end
           end
 
@@ -176,7 +178,9 @@ module Workato
 
         def clean_values(field)
           field.transform_values! do |value|
-            value.presence && (value.is_a?(::Symbol) && value.to_s || value)
+            next value if value.is_a?(FalseClass)
+
+            value.presence && ((value.is_a?(::Symbol) && value.to_s) || value)
           end
           field.compact!
           field

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

@@ -3,6 +3,8 @@
 
 require 'active_support/encrypted_configuration'
 
+using Workato::Extension::HashWithIndifferentAccess
+
 module Workato
   module Connector
     module Sdk
@@ -98,13 +100,13 @@ module Workato
         end
 
         def read_encrypted_file
-          all_settings = encrypted_configuration.config.with_indifferent_access
+          all_settings = HashWithIndifferentAccess.wrap(encrypted_configuration.config)
 
           (name ? all_settings.fetch(name) : all_settings) || {}
         end
 
         def update_encrypted_file(new_settings)
-          all_settings = encrypted_configuration.config.with_indifferent_access
+          all_settings = HashWithIndifferentAccess.wrap(encrypted_configuration.config)
 
           merge_settings(all_settings, new_settings)
 
@@ -121,7 +123,7 @@ module Workato
         end
 
         def encrypted_configuration
-          @encrypted_configuration ||= ActiveSupport::EncryptedConfiguration.new(
+          @encrypted_configuration ||= FixedEncryptedConfiguration.new(
             config_path: path,
             key_path: key_path || DEFAULT_MASTER_KEY_PATH,
             env_key: DEFAULT_MASTER_KEY_ENV,
@@ -133,6 +135,15 @@ module Workato
           YAML.dump(settings.to_hash)
         end
       end
+
+      class FixedEncryptedConfiguration < ActiveSupport::EncryptedConfiguration
+        private
+
+        def handle_missing_key
+          # Original methods incorectly passes constructor params
+          raise MissingKeyError.new(key_path: key_path, env_key: env_key) if raise_if_missing_key
+        end
+      end
     end
   end
 end