workato-connector-sdk 1.1.0 → 1.2.0

data/lib/workato/connector/sdk/dsl/execution_context.rb

@@ -0,0 +1,44 @@
+# typed: true
+# frozen_string_literal: true
+
+require 'securerandom'
+
+module Workato
+  module Connector
+    module Sdk
+      module Dsl
+        module ExecutionContext
+          extend T::Sig
+          extend T::Helpers
+          extend ActiveSupport::Concern
+
+          included do
+            T.bind(self, Class)
+
+            # encrypted safe recipe_id
+            class_attribute :recipe_id, instance_predicate: false, default: SecureRandom.hex(32)
+          end
+
+          sig { returns(T::Hash[Symbol, T.untyped]) }
+          def execution_context
+            @execution_context ||= {
+              recipe_id: recipe_id
+            }.compact
+          end
+
+          # mock unencrypted recipe_id for testing only
+          def recipe_id!
+            recipe_id.reverse
+          end
+
+          module ClassMethods
+            # mock unencrypted recipe_id for testing only
+            def recipe_id!
+              T.unsafe(self).recipe_id.reverse
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/workato/connector/sdk/dsl/workato_code_lib.rb

@@ -2,6 +2,9 @@
 # frozen_string_literal: true
 
 require 'jwt'
+require_relative './csv'
+
+using Workato::Extension::HashWithIndifferentAccess
 
 module Workato
   module Connector
@@ -74,7 +77,7 @@ module Workato
                 raise "A RSA key of size #{JWT_RSA_KEY_MIN_LENGTH} bits or larger MUST be used with JWT."
               end
 
-              header_fields = header_fields.present? ? header_fields.with_indifferent_access.except(:typ, :alg) : {}
+              header_fields = HashWithIndifferentAccess.wrap(header_fields).except(:typ, :alg)
               ::JWT.encode(payload, rsa_private, algorithm, header_fields)
             end
 
@@ -152,6 +155,10 @@ module Workato
             def pbkdf2_hmac_sha1(string, salt, iterations = 1000, key_len = 16)
               Extension::Binary.new(::OpenSSL::PKCS5.pbkdf2_hmac_sha1(string, salt, iterations, key_len))
             end
+
+            def csv
+              Csv
+            end
           end
         end
       end

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

@@ -12,6 +12,7 @@ require_relative './dsl/workato_code_lib'
 require_relative './dsl/workato_schema'
 require_relative './dsl/time'
 require_relative './dsl/aws'
+require_relative './dsl/execution_context'
 
 module Workato
   module Connector

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

@@ -30,6 +30,17 @@ module Workato
 
       CustomRequestError = Class.new(StandardError)
 
+      InvalidMultiAuthDefinition = Class.new(InvalidDefinitionError)
+
+      class UnresolvedMultiAuthOptionError < InvalidMultiAuthDefinition
+        attr_reader :name
+
+        def initialize(name)
+          super("Cannot find multi-auth definition for '#{name}'")
+          @name = name
+        end
+      end
+
       RuntimeError = Class.new(StandardError)
 
       class UnresolvedObjectDefinitionError < StandardError

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

@@ -4,6 +4,8 @@
 require 'csv'
 require 'singleton'
 
+using Workato::Extension::HashWithIndifferentAccess
+
 module Workato
   module Connector
     module Sdk
@@ -40,7 +42,7 @@ module Workato
           @table_by_id ||= {}
           @table_by_name ||= {}
           data.each do |name, table|
-            table = table.with_indifferent_access
+            table = HashWithIndifferentAccess.wrap(table)
             rows = table['rows'].freeze
             @table_by_id[table['id'].to_i] = rows
             @table_by_name[name] = rows

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

@@ -5,6 +5,8 @@ require_relative './dsl'
 require_relative './block_invocation_refinements'
 require_relative './schema'
 
+using Workato::Extension::HashWithIndifferentAccess
+
 module Workato
   module Connector
     module Sdk
@@ -45,6 +47,7 @@ module Workato
         include Dsl::HTTP
         include Dsl::Call
         include Dsl::Error
+        include Dsl::ExecutionContext
 
         using BlockInvocationRefinements
 
@@ -57,8 +60,8 @@ module Workato
           ).void
         end
         def initialize(operation: {}, methods: {}, connection: Connection.new, object_definitions: nil)
-          @operation = T.let(operation.with_indifferent_access, HashWithIndifferentAccess)
-          @_methods = T.let(methods.with_indifferent_access, HashWithIndifferentAccess)
+          @operation = T.let(HashWithIndifferentAccess.wrap(operation), HashWithIndifferentAccess)
+          @_methods = T.let(HashWithIndifferentAccess.wrap(methods), HashWithIndifferentAccess)
           @connection = T.let(connection, Connection)
           @object_definitions = T.let(object_definitions, T.nilable(ObjectDefinitions))
         end
@@ -80,13 +83,14 @@ module Workato
           connection.merge_settings!(settings) if settings
           request_or_result = T.unsafe(self).instance_exec(
             connection.settings,
-            input.with_indifferent_access,
-            Array.wrap(extended_input_schema).map(&:with_indifferent_access),
-            Array.wrap(extended_output_schema).map(&:with_indifferent_access),
-            continue.with_indifferent_access,
+            HashWithIndifferentAccess.wrap(input),
+            Array.wrap(extended_input_schema).map { |i| HashWithIndifferentAccess.wrap(i) },
+            Array.wrap(extended_output_schema).map { |i| HashWithIndifferentAccess.wrap(i) },
+            HashWithIndifferentAccess.wrap(continue),
             &block
           )
-          resolve_request(request_or_result)
+          result = resolve_request(request_or_result)
+          try_convert_to_hash_with_indifferent_access(result)
         end
 
         sig do
@@ -225,7 +229,7 @@ module Workato
               end
             end
           when ::Hash
-            request_or_result.inject(request_or_result.with_indifferent_access) do |acc, (key, value)|
+            request_or_result.inject(request_or_result) do |acc, (key, value)|
               response_value = resolve_request(value)
               if response_value.equal?(value)
                 acc
@@ -238,6 +242,18 @@ module Workato
           end
         end
 
+        sig { params(value: T.untyped).returns(T.untyped) }
+        def try_convert_to_hash_with_indifferent_access(value)
+          case value
+          when ::Hash
+            HashWithIndifferentAccess.wrap(value)
+          when ::Array
+            value.map! { |i| try_convert_to_hash_with_indifferent_access(i) }
+          else
+            value
+          end
+        end
+
         sig { returns(ObjectDefinitions) }
         def object_definitions
           T.must(@object_definitions)

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

@@ -8,8 +8,11 @@ require 'gyoku'
 require 'net/http'
 require 'net/http/digest_auth'
 
+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,6 +34,7 @@ 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)
@@ -38,36 +42,24 @@ module Workato
         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::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 RequestError.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 +170,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
@@ -266,7 +258,31 @@ module Workato
 
         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_error!(response.body)
+            parsed_response = @parse_response.call(response)
+            detect_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,25 +301,22 @@ 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
 
@@ -373,7 +386,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
           )
@@ -404,7 +417,7 @@ module Workato
           first = true
           begin
             settings = connection.settings
-            if /oauth2/i =~ connection.authorization.type
+            if connection.authorization.oauth2?
               instance_exec(settings, settings[:access_token], @auth_type, &apply)
             else
               instance_exec(settings, @auth_type, &apply)
@@ -461,6 +474,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.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

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)
 

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

@@ -3,6 +3,8 @@
 
 require 'securerandom'
 
+using Workato::Extension::HashWithIndifferentAccess
+
 module Workato
   module Connector
     module Sdk
@@ -66,7 +68,6 @@ module Workato
           ) do |connection, payload, eis, eos|
             instance_exec(connection, payload[:input], payload[:closure], eis, eos, &poll_proc)
           end
-          output.with_indifferent_access
           output[:events] = Array.wrap(output[:events])
                                  .reverse!
                                  .map! { |event| ::Hash.try_convert(event) || event }
@@ -135,14 +136,14 @@ module Workato
           connection.merge_settings!(settings) if settings
           output = Dsl::WithDsl.execute(
             connection,
-            input.with_indifferent_access,
+            HashWithIndifferentAccess.wrap(input),
             payload,
-            Array.wrap(extended_input_schema).map(&:with_indifferent_access),
-            Array.wrap(extended_output_schema).map(&:with_indifferent_access),
-            headers.with_indifferent_access,
-            params.with_indifferent_access,
+            Array.wrap(extended_input_schema).map { |i| HashWithIndifferentAccess.wrap(i) },
+            Array.wrap(extended_output_schema).map { |i| HashWithIndifferentAccess.wrap(i) },
+            HashWithIndifferentAccess.wrap(headers),
+            HashWithIndifferentAccess.wrap(params),
             connection.settings,
-            webhook_subscribe_output.with_indifferent_access,
+            HashWithIndifferentAccess.wrap(webhook_subscribe_output),
             &trigger[:webhook_notification]
           )
           if output.is_a?(::Array)
@@ -162,7 +163,7 @@ module Workato
             SorbetTypes::WebhookSubscribeOutputHash
           )
         end
-        def webhook_subscribe(webhook_url = '', settings = nil, input = {}, recipe_id = SecureRandom.uuid)
+        def webhook_subscribe(webhook_url = '', settings = nil, input = {}, recipe_id = recipe_id!)
           webhook_subscribe_proc = trigger[:webhook_subscribe]
           execute(settings, { input: input, webhook_url: webhook_url, recipe_id: recipe_id }) do |connection, payload|
             instance_exec(

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

@@ -4,7 +4,7 @@
 module Workato
   module Connector
     module Sdk
-      VERSION = '1.1.0'
+      VERSION = '1.2.0'
     end
   end
 end

data/lib/workato/connector/sdk.rb

@@ -39,11 +39,13 @@ require 'active_support/all'
 require 'active_support/json'
 require_relative '../extension/array'
 require_relative '../extension/case_sensitive_headers'
+require_relative '../extension/content_encoding_decoder'
 require_relative '../extension/currency'
 require_relative '../extension/date'
 require_relative '../extension/enumerable'
 require_relative '../extension/extra_chain_cert'
 require_relative '../extension/hash'
+require_relative '../extension/hash_with_indifferent_access'
 require_relative '../extension/integer'
 require_relative '../extension/nil_class'
 require_relative '../extension/object'
@@ -52,12 +54,12 @@ require_relative '../extension/string'
 require_relative '../extension/symbol'
 require_relative '../extension/time'
 
+require_relative './sdk/errors'
 require_relative './sdk/account_properties'
 require_relative './sdk/action'
 require_relative './sdk/connection'
 require_relative './sdk/connector'
 require_relative './sdk/dsl'
-require_relative './sdk/errors'
 require_relative './sdk/lookup_tables'
 require_relative './sdk/object_definitions'
 require_relative './sdk/operation'
@@ -67,4 +69,3 @@ require_relative './sdk/summarize'
 require_relative './sdk/trigger'
 require_relative './sdk/version'
 require_relative './sdk/workato_schemas'
-require_relative './sdk/xml'

data/lib/workato/extension/case_sensitive_headers.rb

@@ -22,31 +22,6 @@ module Workato
 
       ::Net::HTTPHeader.prepend Net::HTTPHeader
       ::Net::HTTPGenericRequest.prepend Net::HTTPHeader
-
-      module RestClient
-        module Request
-          attr_accessor :case_sensitive_headers
-
-          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 execute(&block)
-            # With 2.0.0+, net/http accepts URI objects in requests and handles wrapping
-            # IPv6 addresses in [] for use in the Host request header.
-            net_http_request = net_http_request_class(method).new(uri, processed_headers)
-            net_http_request.case_sensitive_headers = case_sensitive_headers
-            transmit(uri, net_http_request, payload, &block)
-          ensure
-            payload&.close
-          end
-        end
-      end
-
-      ::RestClient::Request.prepend RestClient::Request
     end
   end
 end

data/lib/workato/extension/content_encoding_decoder.rb

@@ -0,0 +1,67 @@
+# typed: false
+# frozen_string_literal: true
+
+module Workato
+  module Extension
+    module ContentEncodingDecoder
+      module RestClient
+        module Response
+          def create(body, net_http_res, request, start_time)
+            body = decode_content_encoding(net_http_res, body)
+            super(body, net_http_res, request, start_time)
+          end
+
+          private
+
+          def decode_content_encoding(response, body)
+            content_encoding = response['content-encoding']
+
+            case content_encoding&.downcase
+            when 'deflate', 'gzip', 'x-gzip'
+              response.delete 'content-encoding'
+              return body if body.blank?
+
+              deflate_string(body).force_encoding(Encoding.default_external)
+            when 'none', 'identity'
+              response.delete 'content-encoding'
+              body
+            else
+              body
+            end
+          end
+
+          def deflate_string(body)
+            # Decodes all deflate, gzip or x-gzip
+            zstream = Zlib::Inflate.new(Zlib::MAX_WBITS + 32)
+
+            zstream.inflate(body) + zstream.finish
+          rescue Zlib::DataError
+            # No luck with Zlib decompression. Let's try with raw deflate,
+            # like some broken web servers do. This part isn't compatible with Net::HTTP content-decoding
+            zstream.close
+
+            zstream = Zlib::Inflate.new(-Zlib::MAX_WBITS)
+            zstream.inflate(body) + zstream.finish
+          ensure
+            zstream.close
+          end
+        end
+      end
+
+      ::RestClient::Response.singleton_class.prepend(RestClient::Response)
+
+      ::RestClient::Request.prepend(
+        Module.new do
+          def default_headers
+            # Should pass this header to be compatible with rest-client 2.0.2 version
+            # and rely on decode_content_encoding patch
+            # since net/http does not decompress response body if Content-Range is specified
+            # (see https://github.com/ruby/ruby/blob/27f6ad737b13062339df0a0c80449cf0dbc92ba5/lib/net/http/response.rb#L254)
+            # while the previous version of rest-client does.
+            super.tap { |headers| headers[:accept_encoding] = 'gzip;q=1.0,deflate;q=0.6,identity;q=0.3' }
+          end
+        end
+      )
+    end
+  end
+end

data/lib/workato/extension/extra_chain_cert.rb

@@ -22,20 +22,6 @@ module Workato
       end
 
       ::Net::HTTP.include Net::HTTP
-
-      module RestClient
-        module Request
-          attr_accessor :extra_chain_cert
-
-          def net_http_object(hostname, port)
-            net = super(hostname, port)
-            net.extra_chain_cert = extra_chain_cert if extra_chain_cert
-            net
-          end
-        end
-      end
-
-      ::RestClient::Request.prepend RestClient::Request
     end
   end
 end