workato-connector-sdk 0.1.0 → 0.3.0

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,9 +72,9 @@ 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
@@ -85,6 +88,23 @@ module Workato
 
         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

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

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+require_relative './convertors'
+
+module Workato
+  module Connector
+    module Sdk
+      class Schema
+        module Field
+          class DateTime < SimpleDelegator
+            include Convertors
+
+            DEFAULT_ATTRIBUTES = {
+              type: 'date_time',
+              control_type: 'date_time',
+              render_input: 'date_time_conversion',
+              parse_output: 'date_time_conversion'
+            }.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/integer.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+require_relative './convertors'
+
+module Workato
+  module Connector
+    module Sdk
+      class Schema
+        module Field
+          class Integer < SimpleDelegator
+            include Convertors
+
+            DEFAULT_ATTRIBUTES = {
+              type: 'integer',
+              control_type: 'number',
+              parse_output: 'integer_conversion'
+            }.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/number.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+require_relative './convertors'
+
+module Workato
+  module Connector
+    module Sdk
+      class Schema
+        module Field
+          class Number < SimpleDelegator
+            include Convertors
+
+            DEFAULT_ATTRIBUTES = {
+              type: 'number',
+              control_type: 'number',
+              parse_output: 'float_conversion'
+            }.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/object.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+require_relative './convertors'
+
+module Workato
+  module Connector
+    module Sdk
+      class Schema
+        module Field
+          class Object < SimpleDelegator
+            include Convertors
+
+            DEFAULT_ATTRIBUTES = {
+              type: 'object'
+            }.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/string.rb

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+require_relative './convertors'
+
+module Workato
+  module Connector
+    module Sdk
+      class Schema
+        module Field
+          class String < SimpleDelegator
+            include Convertors
+
+            DEFAULT_ATTRIBUTES = {
+              type: 'string',
+              control_type: 'text'
+            }.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/type/time.rb

@@ -0,0 +1,53 @@
+# frozen_string_literal: true
+
+require 'time'
+
+module Workato
+  module Connector
+    module Sdk
+      class Schema
+        module Type
+          class Time < ::Time
+            PRECISION = 6
+
+            def to_s(*args)
+              if args.present?
+                super
+              else
+                xmlschema(PRECISION)
+              end
+            end
+
+            def self.from_time(value)
+              new(
+                value.year,
+                value.month,
+                value.day,
+                value.hour,
+                value.min,
+                value.sec + Rational(value.nsec, 1_000_000_000),
+                value.utc_offset
+              )
+            end
+
+            def self.from_date_time(value)
+              new(
+                value.year,
+                value.month,
+                value.day,
+                value.hour,
+                value.min,
+                value.sec + Rational(value.nsec, 1_000_000_000),
+                value.zone
+              )
+            end
+
+            def self.xmlschema(str)
+              from_time(super(str))
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

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