workato-connector-sdk 1.0.3 → 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

@@ -6,12 +6,62 @@ module Workato
     module Sdk
       InvalidDefinitionError = Class.new(StandardError)
 
-      InvalidSchemaError = Class.new(StandardError)
+      class UnexpectedMethodDefinitionError < InvalidDefinitionError
+        attr_reader :name
+        attr_reader :definition
+
+        def initialize(name, definition)
+          super("Expected lambda for method '#{name}' definition, got: #{definition.class.name}")
+          @name = name
+          @definition = definition
+        end
+      end
+
+      class UndefinedMethodError < InvalidDefinitionError
+        attr_reader :name
+
+        def initialize(name)
+          super("Method '#{name}' does not exists")
+          @name = name
+        end
+      end
+
+      InvalidSchemaError = Class.new(InvalidDefinitionError)
 
       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
+        attr_reader :name
+
+        def initialize(name)
+          super("Cannot find object definition for '#{name}'")
+          @name = name
+        end
+      end
+
+      class CircleReferenceObjectDefinitionError < StandardError
+        attr_reader :name
+
+        def initialize(name, backtrace = [])
+          super("Infinite recursion occurred in object definition for '#{name}'")
+          set_backtrace(backtrace)
+          @name = name
+        end
+      end
+
       class RequestError < StandardError
         attr_reader :method
         attr_reader :code
@@ -41,6 +91,24 @@ module Workato
           super(message)
         end
       end
+
+      RequestTLSCertificateFormatError = Class.new(StandardError)
+
+      RequestPayloadFormatError = Class.new(StandardError)
+
+      JSONRequestFormatError = Class.new(RequestPayloadFormatError)
+
+      JSONResponseFormatError = Class.new(RequestPayloadFormatError)
+
+      XMLRequestFormatError = Class.new(RequestPayloadFormatError)
+
+      XMLResponseFormatError = Class.new(RequestPayloadFormatError)
+
+      WWWFormURLEncodedRequestFormatError = Class.new(RequestPayloadFormatError)
+
+      MultipartFormRequestFormatError = Class.new(RequestPayloadFormatError)
+
+      RAWResponseFormatError = Class.new(RequestPayloadFormatError)
     end
   end
 end

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/object_definitions.rb

@@ -18,16 +18,22 @@ module Workato
 
         def lazy(settings = nil, config_fields = {})
           DupHashWithIndifferentAccess.new do |object_definitions, name|
-            fields_proc = object_definitions_source[name][:fields]
-            object_definitions[name] = Action.new(
-              action: {
-                execute: lambda do |connection, input|
-                  instance_exec(connection, input, object_definitions, &fields_proc)
-                end
-              },
-              methods: methods_source,
-              connection: connection
-            ).execute(settings, config_fields)
+            fields_proc = object_definitions_source.dig(name, :fields)
+            raise Workato::Connector::Sdk::UnresolvedObjectDefinitionError, name unless fields_proc
+
+            begin
+              object_definitions[name] = Action.new(
+                action: {
+                  execute: lambda do |connection, input|
+                    instance_exec(connection, input, object_definitions, &fields_proc)
+                  end
+                },
+                methods: methods_source,
+                connection: connection
+              ).execute(settings, config_fields)
+            rescue SystemStackError => e
+              raise Workato::Connector::Sdk::CircleReferenceObjectDefinitionError.new(name, e.backtrace)
+            end
           end
         end
 

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,12 @@ require 'gyoku'
 require 'net/http'
 require 'net/http/digest_auth'
 
+require 'workato/utilities/encoding'
+require 'workato/utilities/xml'
 require_relative './block_invocation_refinements'
 
+using Workato::Extension::HashWithIndifferentAccess
+
 module Workato
   module Connector
     module Sdk
@@ -27,10 +31,10 @@ module Workato
           @action = action
           @headers = {}
           @case_sensitive_headers = {}
-          @params = {}.with_indifferent_access
           @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)
-              within_action_context(response.code, parsed_response, response.headers, &@after_response)
-            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)
@@ -81,7 +73,12 @@ module Workato
         end
 
         def params(params)
-          @params.merge!(params)
+          if params.is_a?(Hash)
+            @params ||= HashWithIndifferentAccess.new
+            @params.merge!(params)
+          else
+            @params = params
+          end
           self
         end
 
@@ -142,13 +139,17 @@ module Workato
 
         def request_format_json
           @content_type_header = :json
-          @render_request = ->(payload) { ActiveSupport::JSON.encode(payload) if payload }
+          @render_request = lambda_with_error_wrap(JSONRequestFormatError) do |payload|
+            ActiveSupport::JSON.encode(payload) if payload
+          end
           self
         end
 
         def response_format_json
           @accept_header = :json
-          @parse_response = ->(payload) { ActiveSupport::JSON.decode(payload.presence || '{}') }
+          @parse_response = lambda_with_error_wrap(JSONResponseFormatError) do |payload|
+            ActiveSupport::JSON.decode(payload.presence || '{}')
+          end
           self
         end
 
@@ -158,17 +159,19 @@ module Workato
 
         def request_format_xml(root_element_name, namespaces = {})
           @content_type_header = :xml
-          @render_request = Kernel.lambda { |payload|
+          @render_request = lambda_with_error_wrap(XMLRequestFormatError) do |payload|
             next unless payload
 
             Gyoku.xml({ root_element_name => payload.merge(namespaces).deep_symbolize_keys }, key_converter: :none)
-          }
+          end
           self
         end
 
         def response_format_xml(strip_response_namespaces: false)
           @accept_header = :xml
-          @parse_response = ->(payload) { Xml.parse_xml_to_hash(payload, strip_namespaces: strip_response_namespaces) }
+          @parse_response = lambda_with_error_wrap(XMLResponseFormatError) do |payload|
+            Workato::Utilities::Xml.parse_xml_to_hash(payload, strip_namespaces: strip_response_namespaces)
+          end
           self
         end
 
@@ -179,7 +182,7 @@ module Workato
         end
 
         def response_format_raw
-          @parse_response = Kernel.lambda do |payload|
+          @parse_response = lambda_with_error_wrap(RAWResponseFormatError) do |payload|
             payload.body.force_encoding(::Encoding::BINARY)
             payload.body.valid_encoding? ? payload.body : payload.body.force_encoding(::Encoding::BINARY)
           end
@@ -189,7 +192,7 @@ module Workato
         def request_format_multipart_form
           @content_type_header = nil
 
-          @render_request = Kernel.lambda do |payload|
+          @render_request = lambda_with_error_wrap(MultipartFormRequestFormatError) do |payload|
             payload&.each_with_object({}) do |(name, (value, content_type, original_filename)), rendered|
               rendered[name] = if content_type.present?
                                  Part.new(name, content_type, original_filename || ::File.basename(name), value.to_s)
@@ -204,7 +207,7 @@ module Workato
 
         def request_format_www_form_urlencoded
           @content_type_header = 'application/x-www-form-urlencoded'
-          @render_request = Kernel.lambda { |payload| payload.to_param }
+          @render_request = lambda_with_error_wrap(WWWFormURLEncodedRequestFormatError, &:to_param)
           self
         end
 
@@ -228,6 +231,8 @@ module Workato
             OpenSSL::X509::Certificate.new(intermediate)
           end
           self
+        rescue OpenSSL::OpenSSLError => e
+          Kernel.raise(RequestTLSCertificateFormatError, e)
         end
 
         def tls_server_certs(certificates:, strict: true)
@@ -237,17 +242,47 @@ module Workato
             @ssl_cert_store.add_cert(OpenSSL::X509::Certificate.new(certificate))
           end
           self
+        rescue OpenSSL::OpenSSLError => e
+          Kernel.raise(RequestTLSCertificateFormatError, e)
         end
 
         def puts(*args)
           ::Kernel.puts(*args)
         end
 
+        def try(*args, &block)
+          execute!.try(*args, &block)
+        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_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
@@ -266,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
 
@@ -295,14 +327,14 @@ module Workato
                   URI.parse(@uri)
                 end
 
-          return uri.to_s unless @params.any? || @user || @password
+          return uri.to_s unless @params || @user || @password
 
           unless @digest_auth
             uri.user = URI.encode_www_form_component(@user) if @user
             uri.password = URI.encode_www_form_component(@password) if @password
           end
 
-          return uri.to_s unless @params.any?
+          return uri.to_s unless @params
 
           query = uri.query.to_s.split('&').select(&:present?).join('&').presence
           params = @params.to_param.presence
@@ -354,12 +386,19 @@ 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
           )
         end
 
+        def apply_after_response(code, parsed_response, headers)
+          encoded_headers = (headers || {}).each_with_object(HashWithIndifferentAccess.new) do |(k, v), h|
+            h[k] = Workato::Utilities::Encoding.force_best_encoding!(v.to_s)
+          end
+          within_action_context(code, parsed_response, encoded_headers, &@after_response)
+        end
+
         def within_action_context(*args, &block)
           (@action || self).instance_exec(*args, &block)
         end
@@ -378,13 +417,13 @@ 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)
             end
             yield
-          rescue StandardError => e
+          rescue RestClient::Exception, CustomRequestError => e
             Kernel.raise e unless first
             Kernel.raise e unless refresh_authorization!(e.try(:http_code), e.try(:http_body), e.message)
 
@@ -413,6 +452,16 @@ module Workato
           T.must(@connection)
         end
 
+        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
+          end
+        end
+
         class Part < StringIO
           def initialize(path, content_type, original_filename, *args)
             super(*args)
@@ -425,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