workato-connector-sdk 1.2.0 → 1.3.1

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

@@ -0,0 +1,262 @@
+# 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 << self
+          extend T::Sig
+
+          sig do
+            params(
+              stream: T.any(Proxy, T::Hash[T.untyped, T.untyped], String),
+              from: T.nilable(Integer),
+              frame_size: T.nilable(Integer),
+              blk: SorbetTypes::StreamInProc
+            ).void
+          end
+          def each_chunk(stream:, from:, frame_size: nil, &blk)
+            Reader.new(stream: stream, from: from, frame_size: frame_size).each_chunk(&blk)
+          end
+        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
+
+        private_constant :Reader
+
+        # @api private
+        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::Hash[T.any(Integer, String), T.untyped]).void }
+          def initialize(chunks:)
+            @chunks = T.let(chunks.transform_keys(&:to_i), T::Hash[Integer, T.untyped])
+          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,72 @@
+# 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
+
+      # @api private
+      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)
@@ -57,6 +57,8 @@ module Workato
           end
         end
       end
+
+      private_constant :Summarize
     end
   end
 end

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

data/lib/workato/connector/sdk.rb

@@ -2,41 +2,14 @@
 # frozen_string_literal: true
 
 require 'sorbet-runtime'
-::Method.prepend(T::CompatibilityPatches::MethodExtensions)
-
-module Workato
-  module Connector
-    module Sdk
-      DEFAULT_MASTER_KEY_ENV = 'WORKATO_CONNECTOR_MASTER_KEY'
-      DEFAULT_MASTER_KEY_PATH = 'master.key'
-
-      DEFAULT_CONNECTOR_PATH = 'connector.rb'
-
-      DEFAULT_SETTINGS_PATH = 'settings.yaml'
-      DEFAULT_ENCRYPTED_SETTINGS_PATH = 'settings.yaml.enc'
-
-      DEFAULT_ACCOUNT_PROPERTIES_PATH = 'account_properties.yaml'
-      DEFAULT_ENCRYPTED_ACCOUNT_PROPERTIES_PATH = 'account_properties.yaml.enc'
-
-      DEFAULT_LOOKUP_TABLES_PATH = 'lookup_tables.yaml'
-
-      DEFAULT_TIME_ZONE = 'Pacific Time (US & Canada)'
-
-      DEFAULT_SCHEMAS_PATH = 'workato_schemas.json'
-
-      WORKATO_API_EMAIL_ENV = 'WORKATO_API_EMAIL'
-      WORKATO_API_TOKEN_ENV = 'WORKATO_API_TOKEN'
-
-      WORKATO_BASE_URL_ENV = 'WORKATO_BASE_URL'
-      DEFAULT_WORKATO_BASE_URL = 'https://app.workato.com'
-      WORKATO_BASE_URL = T.let(ENV.fetch(WORKATO_BASE_URL_ENV, DEFAULT_WORKATO_BASE_URL), String)
-    end
-  end
-end
 
 # Global libs and monkey patches
 require 'active_support/all'
 require 'active_support/json'
+
+require_relative '../types/binary'
+require_relative '../types/unicode_string'
+
 require_relative '../extension/array'
 require_relative '../extension/case_sensitive_headers'
 require_relative '../extension/content_encoding_decoder'
@@ -54,18 +27,19 @@ 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/lookup_tables'
-require_relative './sdk/object_definitions'
-require_relative './sdk/operation'
-require_relative './sdk/request'
-require_relative './sdk/settings'
-require_relative './sdk/summarize'
-require_relative './sdk/trigger'
-require_relative './sdk/version'
-require_relative './sdk/workato_schemas'
+require_relative './sdk/core'
+
+begin
+  tz = ENV.fetch('TZ', nil)
+  if tz.present? && tz != 'UTC'
+    warn "WARNING: TZ environment variable is set to '#{tz}'. Set TZ=UTC for consistency with Workato platform'"
+  else
+    ENV['TZ'] = 'UTC'
+  end
+  Time.zone = Workato::Connector::Sdk::DEFAULT_TIME_ZONE
+rescue TZInfo::DataSourceNotFound
+  puts ''
+  puts "tzinfo-data is not present. Please install gem 'tzinfo-data' by 'gem install tzinfo-data'"
+  puts ''
+  exit!
+end

data/lib/workato/extension/array.rb

@@ -1,6 +1,8 @@
 # typed: false
 # frozen_string_literal: true
 
+require 'delegate'
+
 module Workato
   module Extension
     module Array

data/lib/workato/extension/case_sensitive_headers.rb

@@ -1,7 +1,6 @@
 # typed: false
 # frozen_string_literal: true
 
-require 'rest-client'
 require 'net/http'
 
 module Workato

data/lib/workato/extension/content_encoding_decoder.rb

@@ -1,6 +1,8 @@
 # typed: false
 # frozen_string_literal: true
 
+require 'rest-client'
+
 module Workato
   module Extension
     module ContentEncodingDecoder

data/lib/workato/extension/currency/countries.rb

@@ -0,0 +1,79 @@
+# typed: true
+# frozen_string_literal: true
+
+module Workato
+  module Extension
+    module Currency
+      class Countries
+        extend T::Sig
+
+        include Singleton
+
+        class << self
+          extend T::Sig
+
+          sig { params(value: ::String).returns(T.nilable(Country)) }
+          def find_country(value)
+            instance.find_country(value)
+          end
+        end
+
+        class State < T::Struct
+          const :name, ::String
+          const :names, T::Array[::String]
+        end
+
+        private_constant :State
+
+        class Country < T::Struct
+          const :name, ::String
+          const :names, T::Array[::String]
+          const :states, T::Hash[::String, State]
+          const :alpha2, ::String
+          const :alpha3, ::String
+          const :number, ::String
+          const :currency_code, T.nilable(::String)
+        end
+
+        private_constant :Country
+
+        def initialize
+          @countries = load_countries
+        end
+
+        sig { params(value: ::String).returns(T.nilable(Country)) }
+        def find_country(value)
+          value = value.upcase
+          countries.find do |c|
+            c.alpha2 == value || c.alpha3 == value || c.number == value || # already in upper case
+              c.name.upcase == value || c.names.any? { |name| name.upcase == value }
+          end
+        end
+
+        private
+
+        sig { returns(T::Array[Country]) }
+        attr_reader :countries
+
+        sig { returns(T::Array[Country]) }
+        def load_countries
+          YAML.load_file(File.expand_path('./countries.yml', __dir__)).map do |data|
+            Country.new(
+              name: data['name'].freeze,
+              names: data['names'].map!(&:freeze).freeze,
+              alpha2: data['alpha2'].freeze,
+              alpha3: data['alpha3'].freeze,
+              number: data['number'].freeze,
+              currency_code: data['currency']&.freeze,
+              states: data['states'].transform_values do |s|
+                State.new(name: s['name'].freeze, names: ::Array.wrap(s['names']).map!(&:freeze).freeze)
+              end.freeze
+            ).freeze
+          end.freeze
+        end
+      end
+
+      private_constant :Countries
+    end
+  end
+end