workato-connector-sdk 1.2.0 → 1.3.0

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(...)
+          execute!.send(...)
         end
 
         def execute!
           __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(...)
+          execute!.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
 

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

@@ -101,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)
@@ -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
 
@@ -178,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

@@ -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,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

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

@@ -0,0 +1,243 @@
+# typed: strict
+# frozen_string_literal: true
+
+using Workato::Extension::HashWithIndifferentAccess
+
+module Workato
+  module Connector
+    module Sdk
+      module SorbetTypes
+        StreamProc = T.type_alias do
+          T.proc.params(
+            input: SorbetTypes::StreamInputHash,
+            from: Integer,
+            to: Integer,
+            frame_size: Integer
+          ).returns(SorbetTypes::StreamOutput)
+        end
+
+        StreamInProc = T.type_alias do
+          T.proc.params(
+            data: T.untyped,
+            from: Integer,
+            to: T.nilable(Integer),
+            eof: T::Boolean,
+            next_from: T.nilable(Integer)
+          ).void
+        end
+
+        StreamInputHash = T.type_alias { T::Hash[T.any(Symbol, String), T.untyped] }
+
+        StreamOutput = T.type_alias { [T.untyped, T::Boolean] }
+      end
+
+      class Stream < Operation
+        extend T::Sig
+
+        DEFAULT_FRAME_SIZE = T.let(10.megabytes, Integer)
+
+        using BlockInvocationRefinements
+        include Dsl::ReinvokeAfter
+
+        sig do
+          params(
+            stream: SorbetTypes::StreamProc,
+            methods: SorbetTypes::SourceHash,
+            connection: Connection
+          ).void
+        end
+        def initialize(stream:, methods: {}, connection: Connection.new)
+          super(methods: methods, connection: connection)
+          @stream_proc = stream
+        end
+
+        sig do
+          params(
+            input: SorbetTypes::StreamInputHash,
+            from: Integer,
+            to: Integer,
+            frame_size: Integer
+          ).returns(SorbetTypes::StreamOutput)
+        end
+        def chunk(input = {}, from = 0, to = from + DEFAULT_FRAME_SIZE, frame_size = DEFAULT_FRAME_SIZE)
+          raise "'frame_size' must be a positive integer number" unless frame_size.positive?
+
+          stream_proc = @stream_proc
+          execute(nil, { input: input, from: from, to: to, size: frame_size }) do |_, input| # rubocop:disable Lint/ShadowingOuterLocalVariable
+            T.unsafe(self).instance_exec(input['input'], input['from'], input['to'], input['size'], &stream_proc)
+          end
+        end
+
+        sig { params(input: SorbetTypes::StreamInputHash, frame_size: Integer).returns(T.untyped) }
+        def invoke(input = {}, frame_size = DEFAULT_FRAME_SIZE)
+          proxy = Proxy.new(name: '', input: input, stream: self)
+          reader = Reader.new(stream: proxy, frame_size: frame_size)
+          data = T.let(nil, T.untyped)
+          reader.each_chunk do |chunk|
+            data = data.nil? ? chunk : data + chunk
+          end
+          data
+        end
+
+        class Reader
+          extend T::Sig
+
+          ProxyReadProc = T.type_alias do
+            T.proc.params(
+              data: T.untyped,
+              from: Integer,
+              eof: T::Boolean,
+              next_from: T.nilable(Integer)
+            ).void
+          end
+
+          sig do
+            params(
+              stream: T.any(Proxy, T::Hash[T.untyped, T.untyped], String),
+              from: T.nilable(Integer),
+              frame_size: T.nilable(Integer)
+            ).void
+          end
+          def initialize(stream:, from: nil, frame_size: nil)
+            @stream = T.let(
+              stream.is_a?(Hash) && stream[:__stream__] ? from_mock(stream) : stream,
+              T.any(Proxy, Mock, T::Hash[T.untyped, T.untyped], String)
+            )
+            @from = T.let(from || 0, Integer)
+            @frame_size = T.let(frame_size || DEFAULT_FRAME_SIZE, Integer)
+          end
+
+          sig { params(_blk: SorbetTypes::StreamInProc).void }
+          def each_chunk(&_blk)
+            case @stream
+            when Proxy, Mock
+              @stream.read(from: @from, frame_size: @frame_size) do |chunk, from, eof, next_from|
+                yield(chunk, from, calculate_byte_to(chunk, from), eof, next_from)
+              end
+            when Hash
+              chunk = @stream[:data][@from..]
+              yield(chunk, @from, calculate_byte_to(chunk, @from), @stream[:eof], nil)
+            else
+              chunk = @stream[@from..]
+              yield(@stream[@from..], @from, calculate_byte_to(chunk, @from), true, nil)
+            end
+          end
+
+          private
+
+          sig { params(chunk: T.untyped, from: Integer).returns(T.nilable(Integer)) }
+          def calculate_byte_to(chunk, from)
+            (chunk_size = chunk.try(:bytesize) || 0).zero? ? nil : from + chunk_size - 1
+          end
+
+          sig { params(hash: T::Hash[T.untyped, T.untyped]).returns(T.any(Proxy, Mock)) }
+          def from_mock(hash)
+            case hash[:chunks]
+            when Proc
+              Proxy.new(
+                name: hash[:name],
+                input: HashWithIndifferentAccess.wrap(hash[:input] || {}),
+                stream: Stream.new(
+                  stream: hash[:chunks],
+                  connection: Connection.new(
+                    connection: hash[:connection] || {},
+                    settings: hash[:settings] || {}
+                  )
+                )
+              )
+            when Hash
+              Mock.new(chunks: hash[:chunks])
+            else
+              raise 'Mock streams with Proc or Hash. Read spec/examples/stream/connector_spec.rb for examples'
+            end
+          end
+        end
+
+        class Proxy
+          extend T::Sig
+
+          sig { params(name: String, input: SorbetTypes::StreamInputHash, stream: Stream).void }
+          def initialize(name:, input:, stream:)
+            @name = name
+            @input = input
+            @stream = stream
+          end
+
+          sig { params(_options: T.untyped).returns(T::Hash[String, T.untyped]) }
+          def as_json(_options = nil)
+            {
+              __stream__: true,
+              name: name,
+              input: input
+            }
+          end
+
+          sig { params(from: Integer, frame_size: Integer, _blk: Reader::ProxyReadProc).void }
+          def read(from:, frame_size:, &_blk)
+            next_from = from
+            loop do
+              res = read_chunk(next_from, frame_size)
+              yield(res.data, res.from, res.eof, res.next_from)
+              break if res.eof
+
+              next_from = T.must(res.next_from)
+            end
+          end
+
+          private
+
+          sig { returns(String) }
+          attr_reader :name
+
+          sig { returns(SorbetTypes::StreamInputHash) }
+          attr_reader :input
+
+          class Chunk < T::Struct
+            const :data, T.untyped
+            const :from, Integer
+            const :eof, T::Boolean
+            const :next_from, T.nilable(Integer)
+          end
+          private_constant :Chunk
+
+          sig { params(from: Integer, frame_size: Integer).returns(Chunk) }
+          def read_chunk(from, frame_size)
+            data, eof = @stream.chunk(input, from, from + frame_size - 1, frame_size)
+            next_from = from + (data&.length || 0)
+            next_from = nil if eof
+            Chunk.new(data: data, from: from, eof: eof, next_from: next_from)
+          end
+        end
+
+        class Mock
+          extend T::Sig
+
+          sig { params(chunks: T.untyped).void }
+          def initialize(chunks:)
+            @chunks = chunks
+          end
+
+          sig { params(from: Integer, frame_size: Integer, _blk: Reader::ProxyReadProc).void }
+          def read(from:, frame_size:, &_blk)
+            last_from = chunks.keys.last
+            chunks.each do |chunk_from, data|
+              next if chunk_from < from
+
+              eof = chunk_from == last_from
+              next_from = eof ? nil : chunk_from + frame_size
+
+              yield(data, chunk_from, eof, next_from)
+            end
+          end
+
+          private
+
+          sig { returns(T.untyped) }
+          attr_reader :chunks
+        end
+
+        private_constant :Mock
+      end
+    end
+  end
+end

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

@@ -0,0 +1,71 @@
+# typed: strict
+# frozen_string_literal: true
+
+using Workato::Extension::HashWithIndifferentAccess
+
+module Workato
+  module Connector
+    module Sdk
+      class Streams
+        extend T::Sig
+
+        sig do
+          params(
+            streams: SorbetTypes::SourceHash,
+            methods: SorbetTypes::SourceHash,
+            connection: Connection
+          ).void
+        end
+        def initialize(streams: {}, methods: {}, connection: Connection.new)
+          @methods_source = methods
+          @connection = connection
+          @streams = T.let({}, T::Hash[T.any(Symbol, String), Stream])
+          @streams_source = streams
+          define_action_methods(streams)
+        end
+
+        sig { params(stream: T.any(String, Symbol)).returns(Stream) }
+        def [](stream)
+          @streams[stream] ||= Stream.new(
+            stream: @streams_source.fetch(stream),
+            methods: methods_source,
+            connection: connection
+          )
+        end
+
+        private
+
+        sig { params(streams_source: SorbetTypes::SourceHash).void }
+        def define_action_methods(streams_source)
+          streams_source.each do |stream, _stream_proc|
+            define_singleton_method(stream) do |input = {}, from = 0, to = nil, frame_size = Stream::DEFAULT_FRAME_SIZE|
+              to ||= from + frame_size
+              self[stream].chunk(input, from, to, frame_size)
+            end
+
+            define_singleton_method("#{stream}!") do |input = {}, frame_size = Stream::DEFAULT_FRAME_SIZE|
+              self[stream].invoke(input, frame_size)
+            end
+          end
+        end
+
+        sig { returns(SorbetTypes::SourceHash) }
+        attr_reader :methods_source
+
+        sig { returns(Connection) }
+        attr_reader :connection
+      end
+
+      class ProhibitedStreams < Streams
+        extend T::Sig
+
+        sig { void }
+        def initialize
+          @streams = Hash.new do
+            raise 'Streams are not available in this context. Access streams in actions or triggers'
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -34,8 +34,8 @@ module Workato
         attr_reader :paths
 
         def above_summarization_limit?(candidate)
-          candidate.is_a?(::Array) && candidate.length > ARRAY_SUMMARIZATION_LIMIT ||
-            candidate.is_a?(::String) && candidate.length > STRING_SUMMARIZATION_LIMIT
+          (candidate.is_a?(::Array) && candidate.length > ARRAY_SUMMARIZATION_LIMIT) ||
+            (candidate.is_a?(::String) && candidate.length > STRING_SUMMARIZATION_LIMIT)
         end
 
         def apply_summarization_limit(summarized, steps)

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

@@ -34,15 +34,18 @@ module Workato
             trigger: SorbetTypes::SourceHash,
             methods: SorbetTypes::SourceHash,
             connection: Connection,
-            object_definitions: T.nilable(ObjectDefinitions)
+            object_definitions: T.nilable(ObjectDefinitions),
+            streams: Streams
           ).void
         end
-        def initialize(trigger:, methods: {}, connection: Connection.new, object_definitions: nil)
+        def initialize(trigger:, methods: {}, connection: Connection.new, object_definitions: nil,
+                       streams: ProhibitedStreams.new)
           super(
             operation: trigger,
             connection: connection,
             methods: methods,
-            object_definitions: object_definitions
+            object_definitions: object_definitions,
+            streams: streams
           )
         end
 
@@ -118,7 +121,7 @@ module Workato
             headers: T::Hash[T.any(String, Symbol), T.untyped],
             params: T::Hash[T.any(String, Symbol), T.untyped],
             settings: T.nilable(SorbetTypes::SettingsHash),
-            webhook_subscribe_output: SorbetTypes::WebhookSubscribeOutputHash
+            webhook_subscribe_output: T.nilable(SorbetTypes::WebhookSubscribeOutputHash)
           ).returns(
             SorbetTypes::WebhookNotificationOutputHash
           )
@@ -134,8 +137,7 @@ module Workato
           webhook_subscribe_output = {}
         )
           connection.merge_settings!(settings) if settings
-          output = Dsl::WithDsl.execute(
-            connection,
+          output = global_dsl_context.execute(
             HashWithIndifferentAccess.wrap(input),
             payload,
             Array.wrap(extended_input_schema).map { |i| HashWithIndifferentAccess.wrap(i) },
@@ -190,7 +192,7 @@ module Workato
             payload: T::Hash[T.any(String, Symbol), T.untyped],
             headers: T::Hash[T.any(String, Symbol), T.untyped],
             params: T::Hash[T.any(String, Symbol), T.untyped],
-            webhook_subscribe_output: SorbetTypes::WebhookSubscribeOutputHash
+            webhook_subscribe_output: T.nilable(SorbetTypes::WebhookSubscribeOutputHash)
           ).returns(
             T.any(SorbetTypes::WebhookNotificationOutputHash, SorbetTypes::PollOutputHash)
           )
@@ -232,6 +234,11 @@ module Workato
         def webhook_notification?
           trigger[:webhook_notification].present?
         end
+
+        sig { returns(Dsl::WithDsl) }
+        def global_dsl_context
+          Dsl::WithDsl.new(connection, streams)
+        end
       end
     end
   end

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

@@ -4,7 +4,7 @@
 module Workato
   module Connector
     module Sdk
-      VERSION = '1.2.0'
+      VERSION = T.let(File.read(File.expand_path('../../../../VERSION', __dir__)).strip, String)
     end
   end
 end