workato-connector-sdk 1.2.0 → 1.3.1

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

@@ -1,125 +0,0 @@
-# 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
-        module Csv
-          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
-
-          class << self
-            extend T::Sig
-
-            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
-          end
-        end
-      end
-    end
-  end
-end

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

@@ -1,167 +0,0 @@
-# typed: true
-# frozen_string_literal: true
-
-require 'jwt'
-require_relative './csv'
-
-using Workato::Extension::HashWithIndifferentAccess
-
-module Workato
-  module Connector
-    module Sdk
-      module Dsl
-        module WorkatoCodeLib
-          JWT_ALGORITHMS = %w[RS256 RS384 RS512].freeze
-          JWT_RSA_KEY_MIN_LENGTH = 2048
-
-          VERIFY_RCA_ALGORITHMS = %w[SHA SHA1 SHA224 SHA256 SHA384 SHA512].freeze
-
-          def workato
-            WorkatoCodeLib
-          end
-
-          def parse_json(source)
-            WorkatoCodeLib.parse_json(source)
-          end
-
-          def uuid
-            WorkatoCodeLib.uuid
-          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::Extension::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
-
-          class << self
-            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}'" # rubocop:disable Layout/LineLength
-              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)
-            end
-
-            def uuid
-              SecureRandom.uuid
-            end
-
-            RANDOM_SIZE = 32
-
-            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
-
-              Extension::Binary.new(::OpenSSL::Random.random_bytes(len))
-            end
-
-            ALLOWED_KEY_SIZES = [128, 192, 256].freeze
-
-            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?
-              Extension::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?
-              Extension::Binary.new(cipher.update(string) + cipher.final)
-            end
-
-            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
-    end
-  end
-end

data/lib/workato/connector/sdk/schema/type/unicode_string.rb

@@ -1,23 +0,0 @@
-# typed: true
-# frozen_string_literal: true
-
-module Workato
-  module Connector
-    module Sdk
-      class Schema
-        module Type
-          class UnicodeString < ::String
-            def initialize(str)
-              super(str, {})
-              encode!('UTF-8')
-            end
-
-            def binary?
-              false
-            end
-          end
-        end
-      end
-    end
-  end
-end