workato-connector-sdk 1.2.0 → 1.3.1

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

@@ -4,7 +4,13 @@
 module Workato
   module Connector
     module Sdk
-      InvalidDefinitionError = Class.new(StandardError)
+      Error = Class.new(StandardError)
+
+      DetectOnUnauthorizedRequestError = Class.new(Error)
+
+      RuntimeError = Class.new(Error)
+
+      InvalidDefinitionError = Class.new(Error)
 
       class UnexpectedMethodDefinitionError < InvalidDefinitionError
         attr_reader :name
@@ -28,8 +34,6 @@ module Workato
 
       InvalidSchemaError = Class.new(InvalidDefinitionError)
 
-      CustomRequestError = Class.new(StandardError)
-
       InvalidMultiAuthDefinition = Class.new(InvalidDefinitionError)
 
       class UnresolvedMultiAuthOptionError < InvalidMultiAuthDefinition
@@ -41,9 +45,7 @@ module Workato
         end
       end
 
-      RuntimeError = Class.new(StandardError)
-
-      class UnresolvedObjectDefinitionError < StandardError
+      class UnresolvedObjectDefinitionError < InvalidDefinitionError
         attr_reader :name
 
         def initialize(name)
@@ -52,7 +54,7 @@ module Workato
         end
       end
 
-      class CircleReferenceObjectDefinitionError < StandardError
+      class CircleReferenceObjectDefinitionError < InvalidDefinitionError
         attr_reader :name
 
         def initialize(name, backtrace = [])
@@ -62,7 +64,11 @@ module Workato
         end
       end
 
-      class RequestError < StandardError
+      RequestError = Class.new(RuntimeError)
+
+      RequestTimeoutError = Class.new(RequestError)
+
+      class RequestFailedError < RequestError
         attr_reader :method
         attr_reader :code
         attr_reader :response
@@ -81,7 +87,7 @@ module Workato
         end
       end
 
-      class MissingRequiredInput < StandardError
+      class MissingRequiredInput < RuntimeError
         def initialize(label, toggle_label)
           message = if toggle_label && label != toggle_label
                       "Either '#{label}' or '#{toggle_label}' must be present"
@@ -92,9 +98,9 @@ module Workato
         end
       end
 
-      RequestTLSCertificateFormatError = Class.new(StandardError)
+      RequestTLSCertificateFormatError = Class.new(RequestError)
 
-      RequestPayloadFormatError = Class.new(StandardError)
+      RequestPayloadFormatError = Class.new(RequestError)
 
       JSONRequestFormatError = Class.new(RequestPayloadFormatError)
 
@@ -109,6 +115,17 @@ module Workato
       MultipartFormRequestFormatError = Class.new(RequestPayloadFormatError)
 
       RAWResponseFormatError = Class.new(RequestPayloadFormatError)
+
+      class UndefinedStdLibMethodError < RuntimeError
+        attr_reader :name
+        attr_reader :package
+
+        def initialize(name, package)
+          @name = name
+          @package = package
+          super("Undefined method '#{name}' for \"#{package}\" namespace")
+        end
+      end
     end
   end
 end

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

@@ -1,4 +1,4 @@
-# typed: true
+# typed: strict
 # frozen_string_literal: true
 
 require_relative './block_invocation_refinements'
@@ -6,31 +6,45 @@ require_relative './block_invocation_refinements'
 module Workato
   module Connector
     module Sdk
+      module SorbetTypes
+        ObjectDefinitionOutput = T.type_alias { T::Array[HashWithIndifferentAccess] }
+      end
+
       class ObjectDefinitions
+        extend T::Sig
+
         using BlockInvocationRefinements
 
+        sig do
+          params(
+            object_definitions: SorbetTypes::SourceHash,
+            connection: Connection,
+            methods: SorbetTypes::SourceHash
+          ).void
+        end
         def initialize(object_definitions:, connection:, methods:)
           @object_definitions_source = object_definitions
           @methods_source = methods
           @connection = connection
-          define_object_definition_methods(object_definitions)
+          @object_definitions = T.let({}, T::Hash[T.any(String, Symbol), ObjectDefinition])
+          define_object_definition_methods
         end
 
+        sig do
+          params(
+            settings: T.nilable(SorbetTypes::SettingsHash),
+            config_fields: SorbetTypes::OperationInputHash
+          ).returns(HashWithIndifferentAccess)
+        end
         def lazy(settings = nil, config_fields = {})
           DupHashWithIndifferentAccess.new do |object_definitions, name|
             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)
+              object_definitions[name] = create_operation.execute(settings, config_fields) do |connection, input|
+                instance_exec(connection, input, object_definitions, &fields_proc)
+              end
             rescue SystemStackError => e
               raise Workato::Connector::Sdk::CircleReferenceObjectDefinitionError.new(name, e.backtrace)
             end
@@ -39,40 +53,67 @@ module Workato
 
         private
 
+        sig { returns(SorbetTypes::SourceHash) }
         attr_reader :methods_source
+
+        sig { returns(Connection) }
         attr_reader :connection
-        attr_reader :settings
+
+        sig { returns(SorbetTypes::SourceHash) }
         attr_reader :object_definitions_source
 
-        def define_object_definition_methods(object_definitions)
-          object_definitions.each do |(object, _definition)|
+        sig { void }
+        def define_object_definition_methods
+          object_definitions_source.each do |(object, _definition)|
             define_singleton_method(object) do
-              @object_definitions ||= {}
               @object_definitions[object] ||= ObjectDefinition.new(name: object, object_definitions: self)
             end
           end
         end
 
+        sig { returns(Operation) }
+        def create_operation
+          Operation.new(methods: methods_source, connection: connection)
+        end
+
         class ObjectDefinition
+          extend T::Sig
+
+          sig { params(name: T.any(String, Symbol), object_definitions: ObjectDefinitions).void }
           def initialize(name:, object_definitions:)
-            @object_definitions = object_definitions
             @name = name
+            @object_definitions = object_definitions
           end
 
+          sig do
+            params(
+              settings: T.nilable(SorbetTypes::SettingsHash),
+              config_fields: SorbetTypes::OperationInputHash
+            ).returns(SorbetTypes::ObjectDefinitionOutput)
+          end
           def fields(settings = nil, config_fields = {})
             object_definitions_lazy_hash = @object_definitions.lazy(settings, config_fields)
             object_definitions_lazy_hash[@name]
           end
         end
 
+        private_constant :ObjectDefinition
+
         class DupHashWithIndifferentAccess < HashWithIndifferentAccess
+          extend T::Sig
+          extend T::Generic
+
+          K = type_member { { fixed: T.any(String, Symbol) } }
+          V = type_member { { fixed: T.untyped } }
+          Elem = type_member { { fixed: T.untyped } }
+
+          sig { params(name: K).returns(V) }
           def [](name)
             super.deep_dup
           end
         end
 
-        private_constant 'ObjectDefinition'
-        private_constant 'DupHashWithIndifferentAccess'
+        private_constant :DupHashWithIndifferentAccess
       end
     end
   end

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

@@ -44,6 +44,7 @@ module Workato
         extend T::Sig
 
         include Dsl::Global
+        include Dsl::AWS
         include Dsl::HTTP
         include Dsl::Call
         include Dsl::Error
@@ -51,18 +52,24 @@ module Workato
 
         using BlockInvocationRefinements
 
+        sig { override.returns(Streams) }
+        attr_reader :streams
+
         sig do
           params(
             operation: SorbetTypes::SourceHash,
             methods: SorbetTypes::SourceHash,
             connection: Connection,
+            streams: Streams,
             object_definitions: T.nilable(ObjectDefinitions)
           ).void
         end
-        def initialize(operation: {}, methods: {}, connection: Connection.new, object_definitions: nil)
+        def initialize(operation: {}, methods: {}, connection: Connection.new, streams: ProhibitedStreams.new,
+                       object_definitions: nil)
           @operation = T.let(HashWithIndifferentAccess.wrap(operation), HashWithIndifferentAccess)
           @_methods = T.let(HashWithIndifferentAccess.wrap(methods), HashWithIndifferentAccess)
           @connection = T.let(connection, Connection)
+          @streams = T.let(streams, Streams)
           @object_definitions = T.let(object_definitions, T.nilable(ObjectDefinitions))
         end
 
@@ -218,7 +225,7 @@ module Workato
         def resolve_request(request_or_result)
           case request_or_result
           when Request
-            resolve_request(request_or_result.execute!)
+            resolve_request(request_or_result.response!)
           when ::Array
             request_or_result.each_with_index.inject(request_or_result) do |acc, (item, index)|
               response_item = resolve_request(item)
@@ -262,7 +269,7 @@ module Workato
         sig { returns(HashWithIndifferentAccess) }
         attr_reader :operation
 
-        sig { returns(Connection) }
+        sig { override.returns(Connection) }
         attr_reader :connection
       end
     end

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

@@ -7,6 +7,7 @@ require 'json'
 require 'gyoku'
 require 'net/http'
 require 'net/http/digest_auth'
+require 'active_support/json'
 
 require 'workato/utilities/encoding'
 require 'workato/utilities/xml'
@@ -37,18 +38,20 @@ module Workato
           @callstack_before_request = Array.wrap(Kernel.caller)
         end
 
-        def method_missing(*args, &block)
-          execute!.send(*args, &block)
+        def method_missing(...)
+          response!.send(...)
         end
 
-        def execute!
+        def response!
           __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(
+          Kernel.raise RequestFailedError.new(
             response: e.response,
             message: e.message,
             method: current_verb,
@@ -250,8 +253,8 @@ module Workato
           ::Kernel.puts(*args)
         end
 
-        def try(*args, &block)
-          execute!.try(*args, &block)
+        def try(...)
+          response!.try(...)
         end
 
         private
@@ -275,9 +278,9 @@ module Workato
               request = RestClientRequest.new(rest_request_params)
               response = execute_request(request)
             end
-            detect_error!(response.body)
+            detect_auth_error!(response.body)
             parsed_response = @parse_response.call(response)
-            detect_error!(parsed_response)
+            detect_auth_error!(parsed_response)
             apply_after_response(response.code, parsed_response, response.headers)
           end
         end
@@ -322,7 +325,7 @@ module Workato
 
         def build_url
           uri = if @base_uri
-                  URI.parse(@base_uri).merge(@uri)
+                  merge_uris(@base_uri, @uri)
                 else
                   URI.parse(@uri)
                 end
@@ -347,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 }
@@ -358,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)
@@ -399,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) }
@@ -418,14 +425,14 @@ module Workato
           begin
             settings = connection.settings
             if connection.authorization.oauth2?
-              instance_exec(settings, settings[:access_token], @auth_type, &apply)
+              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
@@ -434,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
 
@@ -454,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
 
@@ -475,6 +513,8 @@ module Workato
           attr_reader :original_filename
         end
 
+        private_constant :Part
+
         class RestClientRequest < ::RestClient::Request
           def initialize(args)
             super
@@ -502,6 +542,7 @@ module Workato
             net
           end
         end
+
         private_constant :RestClientRequest
       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.rb

@@ -101,17 +101,17 @@ 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, Workato::Types::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)
+            return Workato::Types::UnicodeString.new(value)
           else
             if value.respond_to?(:to_time)
               return Type::Time.from_time(value.to_time)
@@ -119,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
 
@@ -127,6 +127,8 @@ module Workato
         end
       end
 
+      private_constant :Schema
+
       class Fields < ::Array
         def initialize(fields)
           ::Array.wrap(fields).each do |field|
@@ -178,7 +180,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
@@ -230,4 +234,3 @@ require_relative './schema/field/object'
 require_relative './schema/field/string'
 
 require_relative './schema/type/time'
-require_relative './schema/type/unicode_string'

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

@@ -82,7 +82,7 @@ module Workato
 
         def read_plain_file
           all_settings = File.open(path) do |f|
-            YAML.safe_load(f.read, [::Symbol]).to_hash.with_indifferent_access
+            YAML.safe_load(f.read, permitted_classes: [::Symbol]).to_hash.with_indifferent_access
           end
 
           (name ? all_settings.fetch(name) : all_settings) || {}
@@ -123,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,
@@ -135,6 +135,17 @@ 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
+
+      private_constant :FixedEncryptedConfiguration
     end
   end
 end