workato-connector-sdk 1.2.0 → 1.3.1

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

@@ -0,0 +1,133 @@
+# typed: strict
+# frozen_string_literal: true
+
+require 'csv'
+
+module Workato
+  module Connector
+    module Sdk
+      CsvError = Class.new(Sdk::RuntimeError)
+
+      CsvFormatError = Class.new(CsvError)
+
+      class CsvFileTooBigError < CsvError
+        extend T::Sig
+
+        sig { returns(Integer) }
+        attr_reader :size
+
+        sig { returns(Integer) }
+        attr_reader :max
+
+        sig { params(size: Integer, max: Integer).void }
+        def initialize(size, max)
+          super("CSV file is too big. Max allowed: #{max.to_s(:human_size)}, got: #{size.to_s(:human_size)}")
+          @size = T.let(size, Integer)
+          @max = T.let(max, Integer)
+        end
+      end
+
+      class CsvFileTooManyLinesError < CsvError
+        extend T::Sig
+
+        sig { returns(Integer) }
+        attr_reader :max
+
+        sig { params(max: Integer).void }
+        def initialize(max)
+          super("CSV file has too many lines. Max allowed: #{max}")
+          @max = T.let(max, Integer)
+        end
+      end
+
+      module Dsl
+        class CsvPackage
+          extend T::Sig
+
+          MAX_FILE_SIZE_FOR_PARSE = T.let(30.megabytes, Integer)
+          private_constant :MAX_FILE_SIZE_FOR_PARSE
+
+          MAX_LINES_FOR_PARSE = 65_000
+          private_constant :MAX_LINES_FOR_PARSE
+
+          sig do
+            params(
+              str: String,
+              headers: T.any(T::Boolean, T::Array[String], String),
+              col_sep: T.nilable(String),
+              row_sep: T.nilable(String),
+              quote_char: T.nilable(String),
+              skip_blanks: T.nilable(T::Boolean),
+              skip_first_line: T::Boolean
+            ).returns(
+              T::Array[T::Hash[String, T.untyped]]
+            )
+          end
+          def parse(str, headers:, col_sep: nil, row_sep: nil, quote_char: nil, skip_blanks: nil,
+                    skip_first_line: false)
+            if str.bytesize > MAX_FILE_SIZE_FOR_PARSE
+              raise CsvFileTooBigError.new(str.bytesize, MAX_FILE_SIZE_FOR_PARSE)
+            end
+
+            index = 0
+            options = { col_sep: col_sep, row_sep: row_sep, quote_char: quote_char, headers: headers,
+                        skip_blanks: skip_blanks }.compact
+            Enumerator.new do |consumer|
+              CSV.parse(str, **options) do |row|
+                if index.zero? && skip_first_line
+                  index += 1
+                  next
+                end
+                if index == MAX_LINES_FOR_PARSE
+                  raise CsvFileTooManyLinesError, MAX_LINES_FOR_PARSE
+                end
+
+                index += 1
+                consumer.yield(T.cast(row, CSV::Row).to_hash)
+              end
+            end.to_a
+          rescue CSV::MalformedCSVError => e
+            raise CsvFormatError, e
+          rescue ArgumentError => e
+            raise Sdk::RuntimeError, e.message
+          end
+
+          sig do
+            params(
+              str: T.nilable(String),
+              headers: T.nilable(T::Array[String]),
+              col_sep: T.nilable(String),
+              row_sep: T.nilable(String),
+              quote_char: T.nilable(String),
+              force_quotes: T.nilable(T::Boolean),
+              blk: T.proc.params(csv: CSV).void
+            ).returns(
+              String
+            )
+          end
+          def generate(str = nil, headers: nil, col_sep: nil, row_sep: nil, quote_char: nil, force_quotes: nil, &blk)
+            options = { col_sep: col_sep, row_sep: row_sep, quote_char: quote_char, headers: headers,
+                        force_quotes: force_quotes }.compact
+            options[:write_headers] = options[:headers].present?
+
+            ::CSV.generate(str || String.new, **options, &blk)
+          rescue ArgumentError => e
+            raise Sdk::RuntimeError, e.message
+          end
+
+          private
+
+          T::Sig::WithoutRuntime.sig { params(symbol: T.any(String, Symbol), _args: T.untyped).void }
+          def method_missing(symbol, *_args)
+            raise UndefinedStdLibMethodError.new(symbol.to_s, 'workato.csv')
+          end
+
+          T::Sig::WithoutRuntime.sig { params(_args: T.untyped).returns(T::Boolean) }
+          def respond_to_missing?(*_args)
+            false
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -6,6 +6,8 @@ module Workato
     module Sdk
       module Dsl
         module Error
+          # @param message [String]
+          # @raise [Workato::Connector::Sdk::RuntimeError]
           def error(message)
             raise Sdk::RuntimeError, message
           end

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

@@ -2,6 +2,7 @@
 # frozen_string_literal: true
 
 require 'securerandom'
+require 'active_support/core_ext/class/attribute'
 
 module Workato
   module Connector
@@ -37,6 +38,8 @@ module Workato
               T.unsafe(self).recipe_id.reverse
             end
           end
+
+          private_constant :ClassMethods
         end
       end
     end

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

@@ -8,8 +8,13 @@ module Workato
         # https://docs.workato.com/developing-connectors/sdk/sdk-reference/http.html#http-methods
         module HTTP
           PARALLEL_SUCCESS_INDEX = 0
+          private_constant :PARALLEL_SUCCESS_INDEX
+
           PARALLEL_RESULTS_INDEX = 1
+          private_constant :PARALLEL_RESULTS_INDEX
+
           PARALLEL_ERRORS_INDEX = 2
+          private_constant :PARALLEL_ERRORS_INDEX
 
           def get(url, params = {})
             http_request(url, method: 'GET').params(params).response_format_json
@@ -52,8 +57,8 @@ module Workato
               response = nil
               exception = nil
               begin
-                response = request.execute!
-              rescue RequestError, RuntimeError => e
+                response = request.response!
+              rescue StandardError => e
                 exception = e.to_s
               end
               result[PARALLEL_SUCCESS_INDEX] &&= exception.nil?

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

@@ -0,0 +1,84 @@
+# typed: strict
+# frozen_string_literal: true
+
+module Workato
+  module Connector
+    module Sdk
+      module Dsl
+        module ReinvokeAfter
+          extend T::Sig
+
+          sig do
+            params(
+              continue: T::Hash[T.untyped, T.untyped],
+              temp_output: T.nilable(T::Hash[T.untyped, T.untyped])
+            ).void
+          end
+          def checkpoint!(continue:, temp_output: nil)
+            # no-op
+          end
+
+          sig do
+            params(
+              seconds: T.any(Integer, Float),
+              continue: T::Hash[T.untyped, T.untyped],
+              temp_output: T.nilable(T::Hash[T.untyped, T.untyped])
+            ).void
+          end
+          def reinvoke_after(seconds:, continue:, temp_output: nil) # rubocop:disable Lint/UnusedMethodArgument
+            Kernel.throw REINVOKE_AFTER_SIGNAL, ReinvokeParams.new(
+              seconds: seconds,
+              continue: continue
+            )
+          end
+
+          private
+
+          MAX_REINVOKES = 5
+          private_constant :MAX_REINVOKES
+
+          REINVOKE_AFTER_SIGNAL = :reinvoke_after
+          private_constant :REINVOKE_AFTER_SIGNAL
+
+          class ReinvokeParams < T::Struct
+            prop :seconds, T.any(Float, Integer)
+            prop :continue, T::Hash[T.untyped, T.untyped]
+          end
+          private_constant :ReinvokeParams
+
+          sig { params(continue: T::Hash[T.any(Symbol, String), T.untyped], _blk: Proc).returns(T.untyped) }
+          def loop_reinvoke_after(continue, &_blk)
+            reinvokes_remaining = T.let(reinvoke_limit, Integer)
+
+            Kernel.loop do
+              reinvoke_after = Kernel.catch(REINVOKE_AFTER_SIGNAL) do
+                return yield(continue)
+              end
+
+              if reinvokes_remaining.zero?
+                Kernel.raise "Max number of reinvokes on SDK Gem reached. Current limit is #{reinvoke_limit}"
+              end
+
+              reinvokes_remaining -= 1
+
+              reinvoke_after = T.cast(reinvoke_after, ReinvokeParams)
+              reinvoke_sleep(reinvoke_after.seconds)
+              continue = reinvoke_after.continue
+            end
+          end
+
+          sig { params(seconds: T.any(Float, Integer)).void }
+          def reinvoke_sleep(seconds)
+            Kernel.sleep((ENV['WAIT_REINVOKE_AFTER'].presence || seconds).to_f)
+          end
+
+          sig { returns(Integer) }
+          def reinvoke_limit
+            @reinvoke_limit = T.let(@reinvoke_limit, T.nilable(Integer))
+            @reinvoke_limit ||= (ENV['MAX_REINVOKES'].presence || MAX_REINVOKES).to_i
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,59 @@
+# typed: strict
+# frozen_string_literal: true
+
+module Workato
+  module Connector
+    module Sdk
+      module Dsl
+        class StreamPackage
+          extend T::Sig
+
+          sig { params(streams: Streams, connection: Connection).void }
+          def initialize(streams:, connection:)
+            @streams = streams
+            @connection = connection
+          end
+
+          sig do
+            params(
+              stream: T.any(Stream::Proxy, String, T::Hash[T.untyped, T.untyped]),
+              from: T.nilable(Integer),
+              frame_size: T.nilable(Integer),
+              blk: SorbetTypes::StreamInProc
+            ).returns(T.untyped)
+          end
+          def in(stream, from: nil, frame_size: nil, &blk)
+            if stream.is_a?(Hash) && stream[:__stream__] && stream[:chunks].nil?
+              stream = out(stream[:name], stream[:input] || {})
+            end
+
+            Stream.each_chunk(stream: stream, from: from, frame_size: frame_size, &blk)
+          end
+
+          sig { params(stream_name: String, input: SorbetTypes::StreamInputHash).returns(Stream::Proxy) }
+          def out(stream_name, input = {})
+            Stream::Proxy.new(input: input, name: stream_name, stream: streams[stream_name])
+          end
+
+          private
+
+          T::Sig::WithoutRuntime.sig { params(symbol: T.any(String, Symbol), _args: T.untyped).void }
+          def method_missing(symbol, *_args)
+            raise UndefinedStdLibMethodError.new(symbol.to_s, 'workato.stream')
+          end
+
+          T::Sig::WithoutRuntime.sig { params(_args: T.untyped).returns(T::Boolean) }
+          def respond_to_missing?(*_args)
+            false
+          end
+
+          sig { returns(Connection) }
+          attr_reader :connection
+
+          sig { returns(Streams) }
+          attr_reader :streams
+        end
+      end
+    end
+  end
+end

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

@@ -18,17 +18,3 @@ module Workato
     end
   end
 end
-
-begin
-  if ENV['TZ'].present? && ENV['TZ'] != 'UTC'
-    warn "WARNING: TZ environment variable is set to '#{ENV['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/connector/sdk/dsl/workato_package.rb

@@ -0,0 +1,152 @@
+# typed: true
+# frozen_string_literal: true
+
+require 'jwt'
+require_relative './csv_package'
+require_relative './stream_package'
+
+using Workato::Extension::HashWithIndifferentAccess
+
+module Workato
+  module Connector
+    module Sdk
+      module Dsl
+        class WorkatoPackage
+          JWT_ALGORITHMS = %w[RS256 RS384 RS512].freeze
+          private_constant :JWT_ALGORITHMS
+
+          JWT_RSA_KEY_MIN_LENGTH = 2048
+          private_constant :JWT_RSA_KEY_MIN_LENGTH
+
+          VERIFY_RCA_ALGORITHMS = %w[SHA SHA1 SHA224 SHA256 SHA384 SHA512].freeze
+          private_constant :VERIFY_RCA_ALGORITHMS
+
+          RANDOM_SIZE = 32
+          private_constant :RANDOM_SIZE
+
+          ALLOWED_KEY_SIZES = [128, 192, 256].freeze
+          private_constant :ALLOWED_KEY_SIZES
+
+          def initialize(streams:, connection:)
+            @streams = streams
+            @connection = connection
+          end
+
+          def jwt_encode_rs256(payload, key, header_fields = {})
+            jwt_encode(payload, key, 'RS256', header_fields)
+          end
+
+          def jwt_encode(payload, key, algorithm, header_fields = {})
+            algorithm = algorithm.to_s.upcase
+            unless JWT_ALGORITHMS.include?(algorithm)
+              raise "Unsupported signing method. Supports only #{JWT_ALGORITHMS.join(', ')}. Got: '#{algorithm}'"
+            end
+
+            rsa_private = OpenSSL::PKey::RSA.new(key)
+            if rsa_private.n.num_bits < JWT_RSA_KEY_MIN_LENGTH
+              raise "A RSA key of size #{JWT_RSA_KEY_MIN_LENGTH} bits or larger MUST be used with JWT."
+            end
+
+            header_fields = HashWithIndifferentAccess.wrap(header_fields).except(:typ, :alg)
+            ::JWT.encode(payload, rsa_private, algorithm, header_fields)
+          end
+
+          def verify_rsa(payload, certificate, signature, algorithm = 'SHA256')
+            algorithm = algorithm.to_s.upcase
+            unless VERIFY_RCA_ALGORITHMS.include?(algorithm)
+              raise "Unsupported signing method. Supports only #{VERIFY_RCA_ALGORITHMS.join(', ')}. Got: '#{algorithm}'"
+            end
+
+            cert = OpenSSL::X509::Certificate.new(certificate)
+            digest = OpenSSL::Digest.new(algorithm)
+            cert.public_key.verify(digest, signature, payload)
+          rescue OpenSSL::PKey::PKeyError
+            raise 'An error occurred during signature verification. Check arguments'
+          rescue OpenSSL::X509::CertificateError
+            raise 'Invalid certificate format'
+          end
+
+          def parse_yaml(yaml)
+            ::Psych.safe_load(yaml)
+          rescue ::Psych::DisallowedClass => e
+            raise e.message
+          end
+
+          def render_yaml(obj)
+            ::Psych.dump(obj)
+          end
+
+          def parse_json(source)
+            JSON.parse(source)
+          rescue JSON::ParserError => e
+            raise JSONResponseFormatError, e
+          end
+
+          def uuid
+            SecureRandom.uuid
+          end
+
+          def random_bytes(len)
+            unless (len.is_a? ::Integer) && (len <= RANDOM_SIZE)
+              raise "The requested length or random bytes sequence should be <= #{RANDOM_SIZE}"
+            end
+
+            Types::Binary.new(::OpenSSL::Random.random_bytes(len))
+          end
+
+          def aes_cbc_encrypt(string, key, init_vector = nil)
+            key_size = key.bytesize * 8
+            unless ALLOWED_KEY_SIZES.include?(key_size)
+              raise 'Incorrect key size for AES'
+            end
+
+            cipher = ::OpenSSL::Cipher.new("AES-#{key_size}-CBC")
+            cipher.encrypt
+            cipher.key = key
+            cipher.iv = init_vector if init_vector.present?
+            Types::Binary.new(cipher.update(string) + cipher.final)
+          end
+
+          def aes_cbc_decrypt(string, key, init_vector = nil)
+            key_size = key.bytesize * 8
+            unless ALLOWED_KEY_SIZES.include?(key_size)
+              raise 'Incorrect key size for AES'
+            end
+
+            cipher = ::OpenSSL::Cipher.new("AES-#{key_size}-CBC")
+            cipher.decrypt
+            cipher.key = key
+            cipher.iv = init_vector if init_vector.present?
+            Types::Binary.new(cipher.update(string) + cipher.final)
+          end
+
+          def pbkdf2_hmac_sha1(string, salt, iterations = 1000, key_len = 16)
+            Types::Binary.new(::OpenSSL::PKCS5.pbkdf2_hmac_sha1(string, salt, iterations, key_len))
+          end
+
+          def csv
+            @csv ||= CsvPackage.new
+          end
+
+          def stream
+            @stream ||= StreamPackage.new(streams: streams, connection: connection)
+          end
+
+          private
+
+          def method_missing(symbol, *_args)
+            raise UndefinedStdLibMethodError.new(symbol.to_s, 'workato')
+          end
+
+          def respond_to_missing?(*)
+            false
+          end
+
+          attr_reader :streams
+
+          attr_reader :connection
+        end
+      end
+    end
+  end
+end

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

@@ -5,10 +5,11 @@ require_relative './block_invocation_refinements'
 
 require_relative './dsl/http'
 require_relative './dsl/call'
+require_relative './dsl/reinvoke_after'
 require_relative './dsl/error'
 require_relative './dsl/account_property'
 require_relative './dsl/lookup_table'
-require_relative './dsl/workato_code_lib'
+require_relative './dsl/workato_package'
 require_relative './dsl/workato_schema'
 require_relative './dsl/time'
 require_relative './dsl/aws'
@@ -19,12 +20,31 @@ module Workato
     module Sdk
       module Dsl
         module Global
+          extend T::Sig
+          extend T::Helpers
+
+          abstract!
+
+          # @api private
+          sig { abstract.returns(Streams) }
+          def streams; end
+
+          # @api private
+          sig { abstract.returns(Connection) }
+          def connection; end
+
           include Time
           include AccountProperty
           include LookupTable
-          include WorkatoCodeLib
           include WorkatoSchema
-          include AWS
+
+          delegate :parse_json,
+                   :uuid,
+                   to: :workato
+
+          def workato
+            @workato ||= WorkatoPackage.new(streams: streams, connection: connection)
+          end
 
           def sleep(seconds)
             ::Kernel.sleep(seconds.presence || 0)
@@ -33,6 +53,39 @@ module Workato
           def puts(*args)
             T.unsafe(::Kernel).puts(*args)
           end
+
+          def encrypt(text, key)
+            ::Kernel.require('ruby_rncryptor')
+
+            enc_text = ::RubyRNCryptor.encrypt(text, key)
+            ::Base64.strict_encode64(enc_text)
+          end
+
+          def decrypt(text, key)
+            ::Kernel.require('ruby_rncryptor')
+
+            text = ::Base64.decode64(text)
+            dec_text = ::RubyRNCryptor.decrypt(text, key)
+            Workato::Types::Binary.new(dec_text)
+          rescue Exception => e # rubocop:disable Lint/RescueException
+            message = e.message.to_s
+            case message
+            when /Password may be incorrect/
+              ::Kernel.raise 'invalid/corrupt input or key'
+            when /RubyRNCryptor only decrypts version/
+              ::Kernel.raise 'invalid/corrupt input'
+            else
+              ::Kernel.raise
+            end
+          end
+
+          def blank; end
+
+          def clear; end
+
+          def null; end
+
+          def skip; end
         end
 
         class WithDsl
@@ -42,21 +95,23 @@ module Workato
 
           using BlockInvocationRefinements
 
-          sig { params(connection: Connection, args: T.untyped, block: T.untyped).returns(T.untyped) }
-          def execute(connection, *args, &block)
+          sig { params(connection: Connection, streams: Streams).void }
+          def initialize(connection = Connection.new, streams = ProhibitedStreams.new)
             @connection = connection
-            T.unsafe(self).instance_exec(*args, &block)
+            @streams = streams
           end
 
-          sig { params(connection: Connection, args: T.untyped, block: T.untyped).returns(T.untyped) }
-          def self.execute(connection, *args, &block)
-            T.unsafe(WithDsl.new).execute(connection, *args, &block)
+          def execute(...)
+            T.unsafe(self).instance_exec(...)
           end
 
           private
 
-          sig { returns(Connection) }
+          sig { override.returns(Connection) }
           attr_reader :connection
+
+          sig { override.returns(Streams) }
+          attr_reader :streams
         end
       end
     end