workato-connector-sdk 1.0.3 → 1.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
-SHA1:
-  metadata.gz: 4348a5f43c1aca0d39967b9b90c04b17d158a74c
-  data.tar.gz: befa5442c5eca5641824e0e426cbec67c6a2dc77
+SHA256:
+  metadata.gz: b49034b5762b2b44d0987d72eb74327e379284347b793714149d85d354a5bb57
+  data.tar.gz: 1be17d19381fe42689ef4a157a56eca0fb8c61a9c0e90e981e5a373305ed771f
 SHA512:
-  metadata.gz: d74275e1a04b3a90059971dc048256ef3f720bbf09db590678353cc920e133ec4627a7870c5832663f1f793e9b8e47d2cfa19f3cdab81bd7c5abf2f0021c5db3
-  data.tar.gz: ebbf0c161b5fcb932db95dac377408ab01b237bc1541a27e2e19c2b2cf9e2dbea60934a2cd1b37ebd56955c1d531e91656342d14904dbcdf66109fe99f7fe14f
+  metadata.gz: 5bcc365d25ec713df12b75d9d6d5fb8a6a73266b94cf012829e4a2c98af955f1fcfa7b0d0f7e69861a4ee6cb54af24ed8952bbb590553e93a37fcf2933c69459
+  data.tar.gz: 1da6193b9a1b04e3d3e2c6fb34fcd0eeec7666908c61df5c7ec386381ba8f33207b50b8ffc1e9d581fecb599fc423f84f9f79867120322356aa4d645b9b7da5e

data/README.md

@@ -16,6 +16,7 @@ This guide below showcases how you can do the following things:
 2. Choose between Ruby versions `2.4.10` `2.5.X` or `2.7.X`. Our preferred version is `2.7.X`.
 3. Verify you're running a valid ruby version. Do this by running either `ruby -v` or the commands within your version manager. i.e., `rvm current` if you have installed RVM.
 4. For Windows you need tzinfo-data gem installed as well. `gem install tzinfo-data`
+5. SDK depends on `charlock_holmes` gem. Check [gem's documentation](https://github.com/brianmario/charlock_holmes#installing) if you have troubles when install this dependency. Additional [details for Windows](https://github.com/brianmario/charlock_holmes/issues/84#issuecomment-652877605)
    
 ```bash
 ruby -v

data/lib/workato/cli/exec_command.rb

@@ -2,11 +2,13 @@
 # frozen_string_literal: true
 
 require 'thor'
+require_relative './multi_auth_selected_fallback'
 
 module Workato
   module CLI
     class ExecCommand
       include Thor::Shell
+      include MultiAuthSelectedFallback
 
       DebugExceptionError = Class.new(StandardError)
 
@@ -63,7 +65,7 @@ module Workato
           oauth2_code: options[:oauth2_code],
           redirect_url: options[:redirect_url],
           refresh_token: options[:refresh_token],
-          recipe_id: SecureRandom.uuid
+          recipe_id: Workato::Connector::Sdk::Operation.recipe_id!
         }
       end
 
@@ -84,13 +86,21 @@ module Workato
         )
         @settings = settings_store.read
 
+        Workato::Connector::Sdk::Connection.multi_auth_selected_fallback = lambda do |options|
+          next @selected_auth_type if @selected_auth_type
+
+          with_user_interaction do
+            @selected_auth_type = multi_auth_selected_fallback(options)
+          end
+        end
+
         Workato::Connector::Sdk::Connection.on_settings_update = lambda do |message, &refresher|
-          begin
-            $stdout.pause if verbose?
-            say('')
-            say(message)
-            new_settings = refresher.call
+          new_settings = refresher.call
+          break unless new_settings
+
+          with_user_interaction do
             loop do
+              say(message)
               answer = ask('Updated settings file with new connection attributes? (Yes or No)').to_s.downcase
               break new_settings if %w[n no].include?(answer)
               next unless %w[y yes].include?(answer)
@@ -98,8 +108,6 @@ module Workato
               settings_store.update(new_settings)
               break new_settings
             end
-          ensure
-            $stdout.resume if verbose?
           end
         end
 
@@ -128,6 +136,11 @@ module Workato
 
       def execute_path
         connector.invoke(path, params)
+      rescue Workato::Connector::Sdk::InvalidMultiAuthDefinition => e
+        raise "#{e.message}. Please ensure:\n"\
+              "- 'selected' block is defined and returns value from 'options' list\n" \
+              "- settings file contains value expected by 'selected' block\n\n"\
+              'See more: https://docs.workato.com/developing-connectors/sdk/guides/authentication/multi_auth.html'
       rescue Exception => e # rubocop:disable Lint/RescueException
         raise DebugExceptionError, e if options[:debug]
 
@@ -178,6 +191,16 @@ module Workato
         output
       end
 
+      def with_user_interaction
+        $stdout.pause if verbose?
+        say('')
+
+        yield
+      ensure
+        say('')
+        $stdout.resume if verbose?
+      end
+
       class ProgressLogger < SimpleDelegator
         def initialize(progress)
           super($stdout)

data/lib/workato/cli/multi_auth_selected_fallback.rb

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+module Workato
+  module CLI
+    module MultiAuthSelectedFallback
+      private
+
+      def multi_auth_selected_fallback(options)
+        say('Please select current auth type for multi-auth connector:')
+        options = options.keys
+        options.each_with_index do |option, idx|
+          say "[#{idx + 1}] #{option}"
+        end
+        say '[q] <exit>'
+        say('')
+
+        multi_auth_selected_fallback = loop do
+          answer = ask('Your choice:').to_s.downcase
+          break if answer == 'q'
+          next unless /\d+/ =~ answer && options[answer.to_i - 1]
+
+          break options[answer.to_i - 1]
+        end
+        return unless multi_auth_selected_fallback
+
+        say('')
+        say('Put selected auth type in your settings file to avoid this message in future')
+
+        multi_auth_selected_fallback
+      end
+    end
+  end
+end

data/lib/workato/cli/oauth2_command.rb

@@ -3,11 +3,13 @@
 
 require 'securerandom'
 require 'workato/web/app'
+require_relative './multi_auth_selected_fallback'
 
 module Workato
   module CLI
     class OAuth2Command
       include Thor::Shell
+      include MultiAuthSelectedFallback
 
       AWAIT_CODE_TIMEOUT_INTERVAL = 180 # seconds
       AWAIT_CODE_SLEEP_INTERVAL = 5 # seconds
@@ -24,6 +26,7 @@ module Workato
       end
 
       def call
+        ensure_oauth2_type
         require_gems
         start_webrick
 
@@ -94,16 +97,31 @@ module Workato
       end
 
       def stop_webrick
+        return unless @thread
+
         Rack::Handler::WEBrick.shutdown
         @thread.exit
       end
 
+      def ensure_oauth2_type
+        unless connector.connection.authorization.oauth2?
+          raise 'Authorization type is not OAuth2. '\
+                'For multi-auth connector ensure correct auth type was used. '\
+                "Expected: 'oauth2', got: '#{connector.connection.authorization.type}''"
+        end
+      rescue Workato::Connector::Sdk::InvalidMultiAuthDefinition => e
+        raise "#{e.message}. Please ensure:\n"\
+              "- 'selected' block is defined and returns value from 'options' list\n" \
+              "- settings file contains value expected by 'selected' block\n\n"\
+              'See more: https://docs.workato.com/developing-connectors/sdk/guides/authentication/multi_auth.html'
+      end
+
       def client
         @client ||= OAuth2::Client.new(
-          connector.connection.authorization.client_id(settings),
-          connector.connection.authorization.client_secret(settings),
-          site: connector.connection.base_uri(settings),
-          token_url: connector.connection.authorization.token_url(settings),
+          connector.connection.authorization.client_id,
+          connector.connection.authorization.client_secret,
+          site: connector.connection.base_uri,
+          token_url: connector.connection.authorization.token_url,
           redirect_uri: redirect_url
         )
       end
@@ -112,14 +130,14 @@ module Workato
         return @authorize_url if defined?(@authorize_url)
 
         @authorize_url =
-          if (authorization_url = connector.connection.authorization.authorization_url(settings))
+          if (authorization_url = connector.connection.authorization.authorization_url)
             params = {
               state: SecureRandom.hex(8),
-              client_id: connector.connection.authorization.client_id(settings),
+              client_id: connector.connection.authorization.client_id,
               redirect_uri: redirect_url
-            }
+            }.with_indifferent_access
             uri = URI(authorization_url)
-            uri.query = params.with_indifferent_access.merge(Rack::Utils.parse_nested_query(uri.query || '')).to_param
+            uri.query = params.merge(Rack::Utils.parse_nested_query(uri.query || '')).to_param
             uri.to_s
           end
       end
@@ -133,12 +151,25 @@ module Workato
       end
 
       def settings
-        @settings ||= settings_store.read
+        return @settings if defined?(@settings)
+
+        @settings = settings_store.read
+
+        Workato::Connector::Sdk::Connection.multi_auth_selected_fallback = lambda do |options|
+          next @selected_auth_type if @selected_auth_type
+
+          with_user_interaction do
+            @selected_auth_type = multi_auth_selected_fallback(options)
+          end
+        end
+
+        @settings
       end
 
       def connector
         @connector ||= Workato::Connector::Sdk::Connector.from_file(
-          options[:connector] || Workato::Connector::Sdk::DEFAULT_CONNECTOR_PATH
+          options[:connector] || Workato::Connector::Sdk::DEFAULT_CONNECTOR_PATH,
+          settings
         )
       end
 
@@ -156,8 +187,8 @@ module Workato
       end
 
       def acquire_token(code)
-        if connector.source.dig(:connection, :authorization, :acquire)
-          tokens, _, extra_settings = connector.connection.authorization.acquire(settings, await_code, redirect_url)
+        if connector.connection.authorization.source[:acquire]
+          tokens, _, extra_settings = connector.connection.authorization.acquire(nil, code, redirect_url)
           tokens ||= {}
           extra_settings ||= {}
           extra_settings.merge(tokens)
@@ -178,6 +209,13 @@ module Workato
         response = http.request(request)
         response.body
       end
+
+      def with_user_interaction
+        say('')
+        yield
+      ensure
+        say('')
+      end
     end
   end
 end

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

@@ -3,9 +3,33 @@
 
 require_relative './block_invocation_refinements'
 
+using Workato::Extension::HashWithIndifferentAccess
+
 module Workato
   module Connector
     module Sdk
+      module SorbetTypes
+        AcquireOutput = T.type_alias do
+          T.any(
+            # oauth2
+            [
+              HashWithIndifferentAccess, # tokens
+              T.untyped, # resource_owner_id
+              T.nilable(HashWithIndifferentAccess) # settings
+            ],
+            [
+              HashWithIndifferentAccess, # tokens
+              T.untyped # resource_owner_id
+            ],
+            [
+              HashWithIndifferentAccess # tokens
+            ],
+            # custom_auth
+            HashWithIndifferentAccess
+          )
+        end
+      end
+
       class Connection
         extend T::Sig
 
@@ -15,6 +39,7 @@ module Workato
         attr_reader :source
 
         cattr_accessor :on_settings_update
+        cattr_accessor :multi_auth_selected_fallback
 
         sig do
           params(
@@ -24,8 +49,8 @@ module Workato
           ).void
         end
         def initialize(connection: {}, methods: {}, settings: {})
-          @methods_source = T.let(methods.with_indifferent_access, HashWithIndifferentAccess)
-          @source = T.let(connection.with_indifferent_access, HashWithIndifferentAccess)
+          @methods_source = T.let(HashWithIndifferentAccess.wrap(methods), HashWithIndifferentAccess)
+          @source = T.let(HashWithIndifferentAccess.wrap(connection), HashWithIndifferentAccess)
           @settings = T.let(settings, SorbetTypes::SettingsHash)
         end
 
@@ -37,6 +62,7 @@ module Workato
         sig { returns(HashWithIndifferentAccess) }
         def settings
           # we can't freeze or memoise because some developers modify it for storing something temporary in it.
+          # always return a new copy
           @settings.with_indifferent_access
         end
 
@@ -64,7 +90,10 @@ module Workato
 
         sig { params(settings: T.nilable(SorbetTypes::SettingsHash)).returns(T.nilable(String)) }
         def base_uri(settings = nil)
-          source[:base_uri]&.call(settings ? settings.with_indifferent_access.freeze : self.settings)
+          return unless source[:base_uri]
+
+          merge_settings!(settings) if settings
+          Dsl::WithDsl.execute(self, self.settings, &source[:base_uri])
         end
 
         sig do
@@ -101,9 +130,6 @@ module Workato
         class Authorization
           extend T::Sig
 
-          sig { returns(HashWithIndifferentAccess) }
-          attr_reader :source
-
           sig do
             params(
               connection: Connection,
@@ -123,6 +149,16 @@ module Workato
             (source[:type].presence || 'none').to_s
           end
 
+          sig { returns(T::Boolean) }
+          def oauth2?
+            !!(/oauth2/i =~ type)
+          end
+
+          sig { returns(T::Boolean) }
+          def multi?
+            @source[:type].to_s == 'multi'
+          end
+
           sig { returns(T::Array[T.any(String, Symbol, Regexp, Integer)]) }
           def refresh_on
             Array.wrap(source[:refresh_on]).compact
@@ -135,10 +171,10 @@ module Workato
 
           sig { params(settings: T.nilable(SorbetTypes::SettingsHash)).returns(T.nilable(String)) }
           def client_id(settings = nil)
+            @connection.merge_settings!(settings) if settings
             client_id = source[:client_id]
 
             if client_id.is_a?(Proc)
-              @connection.merge_settings!(settings) if settings
               Dsl::WithDsl.execute(@connection, @connection.settings, &client_id)
             else
               client_id
@@ -147,10 +183,10 @@ module Workato
 
           sig { params(settings: T.nilable(SorbetTypes::SettingsHash)).returns(T.nilable(String)) }
           def client_secret(settings = nil)
+            @connection.merge_settings!(settings) if settings
             client_secret_source = source[:client_secret]
 
             if client_secret_source.is_a?(Proc)
-              @connection.merge_settings!(settings) if settings
               Dsl::WithDsl.execute(@connection, @connection.settings, &client_secret_source)
             else
               client_secret_source
@@ -159,12 +195,18 @@ module Workato
 
           sig { params(settings: T.nilable(SorbetTypes::SettingsHash)).returns(T.nilable(String)) }
           def authorization_url(settings = nil)
-            source[:authorization_url]&.call(settings&.with_indifferent_access || @connection.settings)
+            @connection.merge_settings!(settings) if settings
+            return unless source[:authorization_url]
+
+            Dsl::WithDsl.execute(@connection, @connection.settings, &source[:authorization_url])
           end
 
           sig { params(settings: T.nilable(SorbetTypes::SettingsHash)).returns(T.nilable(String)) }
           def token_url(settings = nil)
-            source[:token_url]&.call(settings&.with_indifferent_access || @connection.settings)
+            @connection.merge_settings!(settings) if settings
+            return unless source[:token_url]
+
+            Dsl::WithDsl.execute(@connection, @connection.settings, &source[:token_url])
           end
 
           sig do
@@ -172,9 +214,10 @@ module Workato
               settings: T.nilable(SorbetTypes::SettingsHash),
               oauth2_code: T.nilable(String),
               redirect_url: T.nilable(String)
-            ).returns(HashWithIndifferentAccess)
+            ).returns(T.nilable(SorbetTypes::AcquireOutput))
           end
           def acquire(settings = nil, oauth2_code = nil, redirect_url = nil)
+            @connection.merge_settings!(settings) if settings
             acquire_proc = source[:acquire]
             raise InvalidDefinitionError, "Expect 'acquire' block" unless acquire_proc
 
@@ -202,6 +245,8 @@ module Workato
             ).returns(T::Boolean)
           end
           def refresh?(http_code, http_body, exception)
+            return false unless oauth2? || source[:acquire].present?
+
             refresh_on = self.refresh_on
             refresh_on.blank? || refresh_on.any? do |pattern|
               pattern.is_a?(::Integer) && pattern == http_code ||
@@ -212,10 +257,10 @@ module Workato
 
           sig { params(settings: HashWithIndifferentAccess).returns(T.nilable(HashWithIndifferentAccess)) }
           def refresh!(settings)
-            if /oauth2/i =~ type
+            if oauth2?
               refresh_oauth2_token(settings)
             elsif source[:acquire].present?
-              acquire(settings)
+              T.cast(acquire(settings), T.nilable(HashWithIndifferentAccess))
             end
           end
 
@@ -228,6 +273,7 @@ module Workato
             )
           end
           def refresh(settings = nil, refresh_token = nil)
+            @connection.merge_settings!(settings) if settings
             refresh_proc = source[:refresh]
             raise InvalidDefinitionError, "Expect 'refresh' block" unless refresh_proc
 
@@ -242,6 +288,27 @@ module Workato
             end
           end
 
+          sig { returns(HashWithIndifferentAccess) }
+          def source
+            return @source unless multi?
+
+            unless @source[:selected]
+              raise InvalidMultiAuthDefinition, "Multi-auth connection must define 'selected' block"
+            end
+
+            if @source[:options].blank?
+              raise InvalidMultiAuthDefinition, "Multi-auth connection must define 'options' list"
+            end
+
+            selected_auth_key = @source[:selected].call(@connection.settings)
+            selected_auth_key ||= @connection.multi_auth_selected_fallback&.call(@source[:options])
+            selected_auth_value = @source.dig(:options, selected_auth_key)
+
+            raise UnresolvedMultiAuthOptionError, selected_auth_key unless selected_auth_value
+
+            selected_auth_value
+          end
+
           private
 
           sig { returns(HashWithIndifferentAccess) }
@@ -264,7 +331,10 @@ module Workato
           sig { params(settings: HashWithIndifferentAccess).returns(HashWithIndifferentAccess) }
           def refresh_oauth2_token_using_refresh(settings)
             new_tokens, new_settings = refresh(settings, settings[:refresh_token])
-            new_tokens.with_indifferent_access.merge(new_settings || {})
+            new_tokens = HashWithIndifferentAccess.wrap(new_tokens)
+            return new_tokens unless new_settings
+
+            new_tokens.merge(new_settings)
           end
 
           sig { params(settings: HashWithIndifferentAccess).returns(HashWithIndifferentAccess) }

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

@@ -1,6 +1,8 @@
 # typed: strict
 # frozen_string_literal: true
 
+using Workato::Extension::HashWithIndifferentAccess
+
 module Workato
   module Connector
     module Sdk
@@ -21,10 +23,10 @@ module Workato
 
         sig { params(definition: SorbetTypes::SourceHash, settings: SorbetTypes::SettingsHash).void }
         def initialize(definition, settings = {})
-          @source = T.let(definition.with_indifferent_access, HashWithIndifferentAccess)
-          @settings = T.let(settings.with_indifferent_access, HashWithIndifferentAccess)
-          @connection_source = T.let(@source[:connection] || {}.with_indifferent_access, HashWithIndifferentAccess)
-          @methods_source = T.let(@source[:methods] || {}.with_indifferent_access, HashWithIndifferentAccess)
+          @source = T.let(HashWithIndifferentAccess.wrap(definition), HashWithIndifferentAccess)
+          @settings = T.let(HashWithIndifferentAccess.wrap(settings), HashWithIndifferentAccess)
+          @connection_source = T.let(HashWithIndifferentAccess.wrap(@source[:connection]), HashWithIndifferentAccess)
+          @methods_source = T.let(HashWithIndifferentAccess.wrap(@source[:methods]), HashWithIndifferentAccess)
         end
 
         sig { params(path: String, params: T::Hash[Symbol, T.untyped]).returns(T.untyped) }

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

@@ -2,6 +2,9 @@
 # frozen_string_literal: true
 
 require 'aws-sigv4'
+require 'workato/utilities/xml'
+
+using Workato::Extension::HashWithIndifferentAccess
 
 module Workato
   module Connector
@@ -55,7 +58,7 @@ module Workato
                 method: method,
                 path: path,
                 params: params,
-                headers: (headers || {}).with_indifferent_access,
+                headers: HashWithIndifferentAccess.wrap(headers),
                 payload: payload
               )
 
@@ -134,7 +137,7 @@ module Workato
                 headers: headers,
                 method: :get
               )
-              response = Workato::Connector::Sdk::Xml.parse_xml_to_hash(response.body)
+              response = Workato::Utilities::Xml.parse_xml_to_hash(response.body)
 
               temp_credentials = response.dig('AssumeRoleResponse', 0, 'AssumeRoleResult', 0, 'Credentials', 0)
               {

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

@@ -7,9 +7,12 @@ module Workato
       module Dsl
         module Call
           def call(method, *args)
-            raise InvalidDefinitionError, "method '#{method}' does not exists" unless @_methods[method]
+            method_proc = @_methods[method]
 
-            instance_exec(*args, &@_methods[method])
+            raise UndefinedMethodError, method unless method_proc
+            raise UnexpectedMethodDefinitionError.new(method, method_proc) unless method_proc.is_a?(Proc)
+
+            instance_exec(*args, &method_proc)
           end
         end
       end

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

@@ -0,0 +1,125 @@
+# 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