workato-connector-sdk 0.1.1 → 0.4.0

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

@@ -6,6 +6,10 @@ module Workato
       module Dsl
         # https://docs.workato.com/developing-connectors/sdk/sdk-reference/http.html#http-methods
         module HTTP
+          PARALLEL_SUCCESS_INDEX = 0
+          PARALLEL_RESULTS_INDEX = 1
+          PARALLEL_ERRORS_INDEX = 2
+
           def get(url, params = {})
             http_request(url, method: 'GET').params(params).response_format_json
           end
@@ -42,6 +46,21 @@ module Workato
             http_request(url, method: 'MOVE').payload(payload).format_json
           end
 
+          def parallel(requests = [], threads: 1, rpm: nil, requests_per_period: nil, period: 1.minute.to_i) # rubocop:disable Lint/UnusedMethodArgument
+            requests.each.with_object([true, [], []]) do |request, result|
+              response = nil
+              exception = nil
+              begin
+                response = request.execute!
+              rescue RequestError, RuntimeError => e
+                exception = e.to_s
+              end
+              result[PARALLEL_SUCCESS_INDEX] &&= exception.nil?
+              result[PARALLEL_RESULTS_INDEX] << response
+              result[PARALLEL_ERRORS_INDEX] << exception
+            end
+          end
+
           private
 
           def http_request(url, method:)

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

@@ -18,4 +18,11 @@ module Workato
   end
 end
 
-::Time.zone = Workato::Connector::Sdk::DEFAULT_TIME_ZONE
+begin
+  ::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_code_lib.rb

@@ -10,6 +10,8 @@ module Workato
           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
@@ -38,6 +40,21 @@ module Workato
               ::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
@@ -63,7 +80,7 @@ module Workato
                 raise "The requested length or random bytes sequence should be <= #{RANDOM_SIZE}"
               end
 
-              String::Binary.new(::OpenSSL::Random.random_bytes(len))
+              Extension::Binary.new(::OpenSSL::Random.random_bytes(len))
             end
 
             ALLOWED_KEY_SIZES = [128, 192, 256].freeze
@@ -78,7 +95,7 @@ module Workato
               cipher.encrypt
               cipher.key = key
               cipher.iv = init_vector if init_vector.present?
-              String::Binary.new(cipher.update(string) + cipher.final)
+              Extension::Binary.new(cipher.update(string) + cipher.final)
             end
 
             def aes_cbc_decrypt(string, key, init_vector = nil)
@@ -91,11 +108,11 @@ module Workato
               cipher.decrypt
               cipher.key = key
               cipher.iv = init_vector if init_vector.present?
-              String::Binary.new(cipher.update(string) + cipher.final)
+              Extension::Binary.new(cipher.update(string) + cipher.final)
             end
 
             def pbkdf2_hmac_sha1(string, salt, iterations = 1000, key_len = 16)
-              String::Binary.new(::OpenSSL::PKCS5.pbkdf2_hmac_sha1(string, salt, iterations, key_len))
+              Extension::Binary.new(::OpenSSL::PKCS5.pbkdf2_hmac_sha1(string, salt, iterations, key_len))
             end
           end
         end

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

@@ -10,6 +10,7 @@ require_relative './dsl/lookup_table'
 require_relative './dsl/workato_code_lib'
 require_relative './dsl/workato_schema'
 require_relative './dsl/time'
+require_relative './dsl/aws'
 
 module Workato
   module Connector
@@ -21,6 +22,7 @@ module Workato
           include LookupTable
           include WorkatoCodeLib
           include WorkatoSchema
+          include AWS
 
           def sleep(seconds)
             ::Kernel.sleep(seconds.presence || 0)

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

@@ -5,8 +5,12 @@ module Workato
     module Sdk
       InvalidDefinitionError = Class.new(StandardError)
 
+      InvalidSchemaError = Class.new(StandardError)
+
       CustomRequestError = Class.new(StandardError)
 
+      RuntimeError = Class.new(StandardError)
+
       class RequestError < StandardError
         attr_reader :method,
                     :code,
@@ -20,11 +24,22 @@ module Workato
         end
       end
 
-      class NotImplementedError < RuntimeError
+      class NotImplementedError < StandardError
         def initialize(msg = 'This part of Connector SDK is not implemented in workato-connector-sdk yet')
           super
         end
       end
+
+      class MissingRequiredInput < StandardError
+        def initialize(label, toggle_label)
+          message = if toggle_label && label != toggle_label
+                      "Either '#{label}' or '#{toggle_label}' must be present"
+                    else
+                      "'#{label}' must be present"
+                    end
+          super(message)
+        end
+      end
     end
   end
 end

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

@@ -10,23 +10,23 @@ module Workato
 
         def initialize(object_definitions:, connection:, methods:, settings:)
           @object_definitions_source = object_definitions
-          @methods = methods
+          @methods_source = methods
           @connection = connection
           @settings = settings
           define_object_definition_methods(object_definitions)
         end
 
         def lazy(settings = nil, config_fields = {})
-          object_definitions_lazy_hash = DupHashWithIndifferentAccess.new do |h, name|
-            fields_proc = @object_definitions_source[name][:fields]
-            h[name] = Action.new(
+          DupHashWithIndifferentAccess.new do |object_definitions, name|
+            fields_proc = object_definitions_source[name][:fields]
+            object_definitions[name] = Action.new(
               action: {
                 execute: lambda do |connection, input|
-                  instance_exec(connection, input, object_definitions_lazy_hash, &fields_proc)
+                  instance_exec(connection, input, object_definitions, &fields_proc)
                 end
               },
-              methods: @methods,
-              connection: @connection,
+              methods: methods_source,
+              connection: connection,
               settings: @settings
             ).execute(settings, config_fields)
           end
@@ -34,10 +34,10 @@ module Workato
 
         private
 
-        attr_reader :methods,
+        attr_reader :methods_source,
                     :connection,
-                    :objects,
-                    :settings
+                    :settings,
+                    :object_definitions_source
 
         def define_object_definition_methods(object_definitions)
           object_definitions.each do |(object, _definition)|

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

@@ -2,6 +2,7 @@
 
 require_relative './dsl'
 require_relative './block_invocation_refinements'
+require_relative './schema'
 
 module Workato
   module Connector
@@ -16,21 +17,23 @@ module Workato
 
         cattr_accessor :on_settings_updated
 
-        def initialize(operation:, connection: {}, methods: {}, settings: {}, object_definitions: nil)
-          @settings = settings.with_indifferent_access
+        def initialize(connection:, operation: {}, methods: {}, settings: {}, object_definitions: nil)
+          @connection = connection
+          @settings = settings
           @operation = operation.with_indifferent_access
-          @connection = connection.with_indifferent_access
           @_methods = methods.with_indifferent_access
           @object_definitions = object_definitions
         end
 
-        def execute(settings = nil, input = {}, extended_input_schema = [], extended_output_schema = [], &block)
+        def execute(settings = nil, input = {}, extended_input_schema = [], extended_output_schema = [], continue = {},
+                    &block)
           @settings = settings.with_indifferent_access if settings # is being used in request for refresh tokens
           request_or_result = instance_exec(
             @settings.with_indifferent_access, # a copy of settings hash is being used in executable blocks
             input.with_indifferent_access,
             Array.wrap(extended_input_schema).map(&:with_indifferent_access),
             Array.wrap(extended_output_schema).map(&:with_indifferent_access),
+            continue.with_indifferent_access,
             &block
           )
           resolve_request(request_or_result)
@@ -69,22 +72,39 @@ module Workato
         def refresh_authorization!(http_code, http_body, exception, settings = {})
           return unless refresh_auth?(http_code, http_body, exception)
 
-          new_settings = if /oauth2/i =~ connection[:authorization][:type]
+          new_settings = if /oauth2/i =~ connection.authorization.type
                            refresh_oauth2_token(settings)
-                         elsif connection[:authorization][:acquire]
+                         elsif connection.authorization.acquire?
                            acquire_token(settings)
                          end
           return unless new_settings
 
           settings.merge!(new_settings)
 
-          on_settings_updated&.call(http_body, http_code, exception, settings)
+          on_settings_updated&.call("Refresh token triggered on response \"#{exception}\"", settings)
 
           settings
         end
 
         private
 
+        def apply_input_schema(input, schema)
+          input = schema.trim(input)
+          schema.apply(input, enforce_required: true) do |value, field|
+            field.render_input(value, @_methods[field[:render_input]])
+          end
+        end
+
+        def apply_output_schema(output, schema)
+          schema.apply(output, enforce_required: false) do |value, field|
+            field.parse_output(value, @_methods[field[:parse_output]])
+          end
+        end
+
+        def config_fields_schema
+          operation[:config_fields] || []
+        end
+
         def summarize(data, paths)
           return data unless paths.present?
 
@@ -92,7 +112,7 @@ module Workato
         end
 
         def schema_fields(object_definitions_hash, settings, config_fields, &schema_proc)
-          return {} unless schema_proc
+          return [] unless schema_proc
 
           execute(settings, config_fields) do |connection, input|
             instance_exec(
@@ -132,7 +152,7 @@ module Workato
         end
 
         def refresh_auth?(http_code, http_body, exception)
-          refresh_on = Array.wrap(connection[:authorization][:refresh_on]).compact
+          refresh_on = connection.authorization.refresh_on
           refresh_on.blank? || refresh_on.any? do |pattern|
             pattern.is_a?(::Integer) && pattern == http_code ||
               pattern === exception&.to_s ||
@@ -141,48 +161,26 @@ module Workato
         end
 
         def acquire_token(settings)
-          acquire = connection[:authorization][:acquire]
-          raise InvalidDefinitionError, "'acquire' block is required for authorization" unless acquire
-
-          Action.new(
-            action: {
-              execute: ->(connection) { instance_exec(connection, &acquire) }
-            },
-            connection: connection.merge(
-              authorization: connection[:authorization].merge(
-                apply: nil
-              )
-            ),
-            methods: @_methods
-          ).execute(settings)
+          connection.authorization.acquire(settings)
         end
 
         def refresh_oauth2_token_using_refresh(settings)
-          refresh = connection[:authorization][:refresh]
-          new_tokens, new_settings = Action.new(
-            action: {
-              execute: lambda do |connection|
-                instance_exec(connection, connection[:refresh_token], &refresh)
-              end
-            },
-            methods: @_methods
-          ).execute(settings)
-
+          new_tokens, new_settings = connection.authorization.refresh(settings, settings[:refresh_token])
           new_tokens.with_indifferent_access.merge(new_settings || {})
         end
 
         def refresh_oauth2_token_using_token_url(settings)
           if settings[:refresh_token].blank?
-            raise NotImplementedError, 'workato-connector-sdk does not support OAuth2 authorization process. '\
-                                       'Use Workato Debugger UI to acquire access_token and refresh_token'
+            raise NotImplementedError, 'refresh_token is empty. ' \
+                                       'Use workato oauth2 command to acquire access_token and refresh_token'
           end
 
           response = RestClient::Request.execute(
-            url: connection[:authorization][:token_url].call(settings),
+            url: connection.authorization.token_url(settings),
             method: :post,
             payload: {
-              client_id: connection[:authorization][:client_id].call(settings),
-              client_secret: connection[:authorization][:client_secret].call(settings),
+              client_id: connection.authorization.client_id(settings),
+              client_secret: connection.authorization.client_secret(settings),
               grant_type: :refresh_token,
               refresh_token: settings[:refresh_token]
             },
@@ -198,9 +196,9 @@ module Workato
         end
 
         def refresh_oauth2_token(settings)
-          if connection[:authorization][:refresh]
+          if connection.authorization.refresh?
             refresh_oauth2_token_using_refresh(settings)
-          elsif connection[:authorization][:token_url]
+          elsif connection.authorization.token_url?
             refresh_oauth2_token_using_token_url(settings)
           else
             raise InvalidDefinitionError, "'refresh' block or 'token_url' is required for refreshing the token"

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

@@ -15,13 +15,13 @@ module Workato
       class Request < SimpleDelegator
         using BlockInvocationRefinements
 
-        def initialize(uri, method: 'GET', connection: {}, settings: {}, action: nil)
+        def initialize(uri, method: 'GET', settings: {}, connection: nil, action: nil)
           super(nil)
           @uri = uri
-          @authorization = (connection[:authorization] || {}).with_indifferent_access
-          @settings = settings
-          @base_uri = connection[:base_uri]&.call(settings.with_indifferent_access)
           @method = method
+          @settings = settings
+          @authorization = connection&.authorization
+          @base_uri = connection&.base_uri(settings)
           @action = action
           @headers = {}
           @case_sensitive_headers = {}
@@ -321,7 +321,9 @@ module Workato
         end
 
         def detect_error!(response)
-          error_patterns = Array.wrap(@authorization[:detect_on])
+          return unless @authorization
+
+          error_patterns = @authorization.detect_on
           return unless error_patterns.any? { |pattern| pattern === response rescue false }
 
           Kernel.raise(CustomRequestError, response.to_s)
@@ -357,13 +359,15 @@ module Workato
         end
 
         def authorized
-          apply = @authorization[:apply] || @authorization[:credentials]
+          return yield unless @authorization
+
+          apply = @authorization.source[:apply] || @authorization.source[:credentials]
           return yield unless apply
 
           first = true
           begin
             settings = @settings.with_indifferent_access
-            if /oauth2/i =~ @authorization[:type]
+            if /oauth2/i =~ @authorization.type
               instance_exec(settings, settings[:access_token], @auth_type, &apply)
             else
               instance_exec(settings, @auth_type, &apply)

data/lib/workato/connector/sdk/schema/field/array.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+require_relative './convertors'
+
+module Workato
+  module Connector
+    module Sdk
+      class Schema
+        module Field
+          class Array < SimpleDelegator
+            include Convertors
+
+            DEFAULT_ATTRIBUTES = {
+              type: 'array'
+            }.with_indifferent_access.freeze
+
+            def initialize(field)
+              super(DEFAULT_ATTRIBUTES.merge(field))
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/workato/connector/sdk/schema/field/convertors.rb

@@ -0,0 +1,189 @@
+# frozen_string_literal: true
+
+module Workato
+  module Connector
+    module Sdk
+      class Schema
+        module Field
+          module Convertors
+            def render_input(value, custom_convertor = nil)
+              apply_convertor(value, self[:render_input], custom_convertor)
+            end
+
+            def parse_output(value, custom_convertor = nil)
+              apply_convertor(value, self[:parse_output], custom_convertor)
+            end
+
+            private
+
+            def apply_convertor(value, builtin_convertor, custom_convertor)
+              return value unless builtin_convertor || custom_convertor
+              return send(builtin_convertor, value) if builtin_convertor && respond_to?(builtin_convertor, true)
+              return custom_convertor.call(value) if custom_convertor.is_a?(Proc)
+
+              raise ArgumentError, "Cannot find converter '#{builtin_convertor}'."
+            end
+
+            def integer_conversion(value)
+              value.try(:is_number?) && value.to_i || value
+            end
+
+            def boolean_conversion(value)
+              value.try(:is_true?)
+            end
+
+            def float_conversion(value)
+              value.try(:is_number?) && value.to_f || value
+            end
+
+            def item_array_wrap(items)
+              ::Array.wrap(items).presence&.flatten(1)
+            end
+
+            def date_conversion(value)
+              parse_date(value)
+            end
+
+            def date_iso8601_conversion(value)
+              parse_date(value)&.iso8601
+            end
+
+            def date_time_conversion(value)
+              parse_date_time(value)
+            end
+
+            def date_time_iso8601_conversion(value)
+              parse_date_time(value)&.iso8601
+            end
+
+            def convert_to_datetime(value)
+              value.try(:to_datetime) || value
+            end
+
+            def convert_to_datetime_wo_tz(value)
+              value.try(:to_datetime).strftime('%Y-%m-%d %H:%M:%S') || value
+            end
+
+            def parse_date_output(value)
+              value.try(:to_date) || value
+            end
+
+            def render_date_input(value)
+              try_in_time_zone(value).try(:to_date)
+            end
+
+            def convert_date_time(value)
+              try_in_time_zone(value)
+            end
+
+            def parse_date_time_epoch_millis(value)
+              if value.is_a?(::Time)
+                value
+              else
+                value.is_a?(Numeric) && ::Time.at(value.to_f / 1000)
+              end
+            end
+
+            def render_date_time_epoch_millis(value)
+              value.try(:to_f).try(:*, 1000).try(:to_i)
+            end
+
+            def parse_iso8601_timestamp(value)
+              if value.is_a?(::Time)
+                value
+              else
+                value.try(:to_time)
+              end
+            end
+
+            def render_iso8601_timestamp(value)
+              value.try(:to_time).try(:iso8601)
+            end
+
+            def parse_iso8601_date(value)
+              if value.is_a?(::Date)
+                value
+              else
+                value.try(:to_date)
+              end
+            end
+
+            def render_iso8601_date(value)
+              value.try(:to_date).try(:iso8601)
+            end
+
+            def parse_epoch_time(value)
+              if value.is_a?(::Time)
+                value
+              else
+                (value.is_a?(Numeric).presence || value.try(:is_number?).presence) && ::Time.zone.at(value.to_i)
+              end
+            end
+
+            def render_epoch_time(value)
+              value.try(:to_time).try(:to_i)
+            end
+
+            def parse_float_epoch_time(value)
+              if value.is_a?(::Time)
+                value
+              else
+                (value.is_a?(Numeric) || value.try(:is_number?)) && ::Time.zone.at(value.to_f)
+              end
+            end
+
+            def render_float_epoch_time(value)
+              value.try(:to_time).try(:to_f)
+            end
+
+            def implicit_utc_time(value)
+              value&.in_time_zone('UTC')
+            end
+
+            def implicit_utc_iso8601_time(value)
+              value&.in_time_zone('UTC')&.iso8601
+            end
+
+            # Helpers
+            #
+            def try_in_time_zone(value)
+              value.try(:in_time_zone, local_time_zone || ::Time.zone) || value
+            end
+
+            def local_time_zone
+              ENV['WORKATO_TIME_ZONE'] || Workato::Connector::Sdk::DEFAULT_TIME_ZONE
+            end
+
+            def parse_date(value)
+              if value.blank? || value.is_a?(::Date)
+                value.presence
+              elsif value.is_a?(::Time)
+                value.to_date
+              else
+                parse_time_string(value).to_date
+              end
+            end
+
+            def parse_date_time(value)
+              if value.blank? || value.is_a?(::Time)
+                value.presence
+              elsif value.is_a?(::Date)
+                value.in_time_zone(local_time_zone)
+              else
+                parse_time_string(value)
+              end
+            end
+
+            def parse_time_string(value)
+              value_time = ::Time.parse(value)
+              user_time = ActiveSupport::TimeZone[local_time_zone].parse(value)
+
+              # equal means value had its own offset/TZ or defaulted to system TZ with same offset as user's.
+              value_time == user_time ? value_time : user_time
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/workato/connector/sdk/schema/field/date.rb

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+require_relative './convertors'
+
+module Workato
+  module Connector
+    module Sdk
+      class Schema
+        module Field
+          class Date < SimpleDelegator
+            include Convertors
+
+            DEFAULT_ATTRIBUTES = {
+              type: 'date_time',
+              control_type: 'date',
+              render_input: 'date_conversion',
+              parse_output: 'date_conversion'
+            }.with_indifferent_access.freeze
+
+            def initialize(field)
+              super(DEFAULT_ATTRIBUTES.merge(field))
+            end
+          end
+        end
+      end
+    end
+  end
+end