workato-connector-sdk 0.2.0 → 0.3.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
-SHA1:
-  metadata.gz: 1b501416ca8344b57fb05ebc9b48b3f1b19a4f4e
-  data.tar.gz: 47666c7e297ead213ca1228c38d3ed15dfbd699d
+SHA256:
+  metadata.gz: b958407bc907daf631e2bd91ecb5c002f911906e3bf8a88c00aedd612fe80bbe
+  data.tar.gz: 1445969d82d648667e1de62809722625d06e40a30bb4bec565f56f1b7ce113da
 SHA512:
-  metadata.gz: 266afec14bd2e2b5dcb4104df330d9cb8f96bac11a1d8d6e9199ca3bbd0576c35ff35475ef7b661610cdeef9292d36c4091cd744cac095a8d067a42dc2ccd7da
-  data.tar.gz: c1c1437158f46a43ab50102ce55d2846f76310d417fc130ca8d6aae1c0e34b7d962f26687929466cb94eb1859e5ab82d596c5eab736dd08e87ff0ae2dfdeeef7
+  metadata.gz: 4ad8b4ef4ed273ad65573acb5a4e45dd1e0772b24a4de82cc4c40a3fe0a926c8f93f067eab0df2a6f23b0f94317f2d4bcaad588d203f9323417d7a973084a1fe
+  data.tar.gz: 879463eea7f3e0b9ef01ce1a5019eafbc8af18610306541ff97f6b62520869e0db8d1de1c0a61b9bb3c233c0932dc780e1ec04fd61704350ece80e9fbf9c764d

data/exe/workato

@@ -2,4 +2,15 @@
 # frozen_string_literal: true
 
 require 'workato/cli/main'
-Workato::CLI::Main.start
+
+begin
+  Workato::CLI::Main.start
+rescue Workato::CLI::ExecCommand::DebugExceptionError => e
+  raise e.cause
+rescue SystemExit, SignalException
+  raise
+rescue Exception => e # rubocop:disable Lint/RescueException
+  puts ''
+  puts e.message
+  exit(false)
+end

data/lib/workato/cli/edit_command.rb

@@ -28,7 +28,7 @@ module Workato
 
         puts 'File encrypted and saved.'
       rescue ActiveSupport::MessageEncryptor::InvalidMessage
-        puts "Couldn't decrypt #{encrypted_file_path}. Perhaps you passed the wrong key?"
+        raise "Couldn't decrypt #{encrypted_file_path}. Perhaps you passed the wrong key?"
       end
 
       private
@@ -63,8 +63,6 @@ module Workato
         yield
       rescue Interrupt
         puts 'Aborted changing file: nothing saved.'
-      rescue ActiveSupport::EncryptedFile::MissingKeyError => e
-        puts e.message
       end
     end
   end

data/lib/workato/cli/exec_command.rb

@@ -7,6 +7,8 @@ module Workato
     class ExecCommand
       include Thor::Shell
 
+      DebugExceptionError = Class.new(StandardError)
+
       def initialize(path:, options:)
         @path = path
         @options = options
@@ -122,16 +124,25 @@ module Workato
         methods = path.split('.')
         method = methods.pop
         object = methods.inject(params[:connector]) { |obj, m| obj.public_send(m) }
+        output = invoke_method(object, method)
+        if output.respond_to?(:invoke)
+          invoke_method(output, :invoke)
+        else
+          output
+        end
+      rescue Exception => e # rubocop:disable Lint/RescueException
+        raise DebugExceptionError, e if options[:debug]
+
+        raise
+      end
+
+      def invoke_method(object, method)
         parameters = object.method(method).parameters.reject { |p| p[0] == :block }.map(&:second)
         args = params.values_at(*parameters)
         if parameters.last == :args
           args = args.take(args.length - 1) + Array.wrap(args.last).flatten(1)
         end
         object.public_send(method, *args)
-      rescue Exception => e # rubocop:disable Lint/RescueException
-        raise e if options[:debug]
-
-        e.message
       end
 
       def show_output(output)

data/lib/workato/cli/generate_command.rb

@@ -70,8 +70,7 @@ module Workato
       def ensure_connector_source
         return if connector
 
-        error "Can't find connector source code"
-        exit
+        raise "Can't find connector source code"
       end
 
       def create_spec_file(type, name)

data/lib/workato/cli/oauth2_command.rb

@@ -32,7 +32,7 @@ module Workato
 
         say_status :success, "Open #{authorize_url} in browser"
         Launchy.open(authorize_url) do |exception|
-          raise(Error, "Attempted to open #{authorize_url} and failed because #{exception}")
+          raise "Attempted to open #{authorize_url} and failed because #{exception}"
         end
 
         code = await_code
@@ -45,11 +45,9 @@ module Workato
         settings_store.update(tokens)
         say_status :success, 'Update settings file'
       rescue Timeout::Error
-        say "Have not received callback from OAuth2 provider in #{AWAIT_CODE_TIMEOUT_INTERVAL} seconds. Aborting!"
+        raise "Have not received callback from OAuth2 provider in #{AWAIT_CODE_TIMEOUT_INTERVAL} seconds. Aborting!"
       rescue Errno::EADDRINUSE
-        say "Port #{port} already in use. Try to use different port with --port=#{rand(10_000..65_664)}"
-      rescue StandardError => e
-        say e.message
+        raise "Port #{port} already in use. Try to use different port with --port=#{rand(10_000..65_664)}"
       ensure
         stop_webrick
       end

data/lib/workato/cli/push_command.rb

@@ -49,13 +49,9 @@ module Workato
         say_status :waiting, 'Process package' if verbose?
 
         result = await_import(import_id)
-        if result.fetch('status') == 'failed'
-          say result.fetch('error').gsub("#{PACKAGE_ENTRY_NAME}.json: ", '')
-        else
-          say "Connector was successfully uploaded to #{api_base_url}"
-        end
-      rescue StandardError => e
-        say e.message
+        raise human_friendly_error(result) if result.fetch('status') == 'failed'
+
+        say "Connector was successfully uploaded to #{api_base_url}"
       ensure
         FileUtils.rm_f(zip_file_path) if zip_file_path
       end
@@ -208,6 +204,10 @@ module Workato
           end
       end
 
+      def human_friendly_error(result)
+        result.fetch('error').gsub("#{PACKAGE_ENTRY_NAME}.json: ", '')
+      end
+
       private_constant :IMPORT_IN_PROGRESS,
                        :API_USER_PATH,
                        :API_IMPORT_PATH,

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

@@ -61,6 +61,17 @@ module Workato
           sleep(RETRY_DELAY) && retry
         end
 
+        def invoke(input = {})
+          extended_schema = extended_schema(nil, input)
+          config_schema = Schema.new(schema: config_fields_schema)
+          input_schema = Schema.new(schema: extended_schema[:input])
+          output_schema = Schema.new(schema: extended_schema[:output])
+
+          input = apply_input_schema(input, config_schema + input_schema)
+          output = execute(nil, input, input_schema, output_schema)
+          apply_output_schema(output, output_schema)
+        end
+
         def checkpoint!(continue:, temp_output: nil)
           # no-op
         end

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

@@ -115,7 +115,7 @@ module Workato
 
         def define_action_methods(actions)
           actions.each do |action, definition|
-            define_singleton_method(action) do
+            define_singleton_method(action) do |input_ = nil|
               @actions ||= {}
               @actions[action] ||= Action.new(
                 action: definition,
@@ -124,6 +124,9 @@ module Workato
                 connection: connection,
                 settings: settings
               )
+              return @actions[action] if input_.nil?
+
+              @actions[action].invoke(input_)
             end
           end
         end
@@ -221,7 +224,7 @@ module Workato
 
         def define_trigger_methods(triggers)
           triggers.each do |trigger, definition|
-            define_singleton_method(trigger) do
+            define_singleton_method(trigger) do |input_ = nil, payload = {}, headers = {}, params = {}|
               @triggers[trigger] ||= Trigger.new(
                 trigger: definition,
                 object_definitions: object_definitions,
@@ -229,6 +232,10 @@ module Workato
                 connection: connection,
                 settings: settings
               )
+
+              return @triggers[trigger] if input_.nil?
+
+              @triggers[trigger].invoke(input_, payload, headers, params)
             end
           end
         end

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

@@ -63,7 +63,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 +78,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 +91,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/errors.rb

@@ -5,6 +5,8 @@ module Workato
     module Sdk
       InvalidDefinitionError = Class.new(StandardError)
 
+      InvalidSchemaError = Class.new(StandardError)
+
       CustomRequestError = Class.new(StandardError)
 
       class RequestError < StandardError
@@ -25,6 +27,17 @@ module Workato
           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/operation.rb

@@ -2,6 +2,7 @@
 
 require_relative './dsl'
 require_relative './block_invocation_refinements'
+require_relative './schema'
 
 module Workato
   module Connector
@@ -18,7 +19,7 @@ module Workato
 
         def initialize(connection:, operation: {}, methods: {}, settings: {}, object_definitions: nil)
           @connection = connection
-          @settings = settings.with_indifferent_access
+          @settings = settings
           @operation = operation.with_indifferent_access
           @_methods = methods.with_indifferent_access
           @object_definitions = object_definitions
@@ -87,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?
 
@@ -94,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(

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

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

@@ -0,0 +1,230 @@
+# frozen_string_literal: true
+
+module Workato
+  module Connector
+    module Sdk
+      class Schema < SimpleDelegator
+        def initialize(schema: [])
+          super(Fields.new(::Array.wrap(schema).map(&:with_indifferent_access)))
+        end
+
+        def trim(input)
+          input.with_indifferent_access.keep_if { |property_name| includes_property?(property_name) }
+        end
+
+        def apply(input, enforce_required:, &block)
+          input.with_indifferent_access.tap do |input_with_indifferent_access|
+            apply_to_hash(self, input_with_indifferent_access, enforce_required: enforce_required, &block)
+          end
+        end
+
+        def +(other)
+          if other.is_a?(Schema)
+            Schema.new.tap do |schema|
+              schema.__setobj__(__getobj__ + other.__getobj__)
+            end
+          else
+            Schema.new(schema: __getobj__ + other)
+          end
+        end
+
+        private
+
+        def includes_property?(name)
+          find_property_by_name(name).present?
+        end
+
+        def find_property_by_name(name)
+          find do |property|
+            (property[:name].to_s == name.to_s) || (property.dig(:toggle_field, :name).to_s == name.to_s)
+          end
+        end
+
+        def apply_to_hash(properties, object, enforce_required: false, &block)
+          return if properties.blank? || object.nil?
+
+          properties.each do |property|
+            apply_to_value(property, object, property[:name], object[property[:name]], &block)
+            if (toggle_property = property[:toggle_field])
+              apply_to_value(toggle_property, object, toggle_property[:name], object[toggle_property[:name]], &block)
+            end
+
+            next unless enforce_required
+            next if optional_or_present?(property, object) || optional_or_present?(property[:toggle_field], object)
+
+            raise MissingRequiredInput.new(property[:label], property.dig(:toggle_field, :label))
+          end
+        end
+
+        def optional_or_present?(property, object)
+          property.present? && (
+            property[:optional] ||
+              property[:runtime_optional] ||
+              (value = object[property[:name]]).present? ||
+              value.is_a?(FalseClass) ||
+              (value.is_a?(::String) && !value.empty?)
+          )
+        end
+
+        def apply_to_array(property, array, &block)
+          array.each_with_index do |item, index|
+            apply_to_value(property, array, index, item, &block)
+          end
+        end
+
+        def apply_to_value(property, container, index, value, &block)
+          return unless property.present? && value.present?
+
+          if value.respond_to?(:each_key)
+            apply_to_hash(property[:properties], value, &block)
+          elsif value.respond_to?(:each_with_index)
+            apply_to_array(property, value, &block)
+          end
+
+          container[index] = if !value.nil? && block
+                               normalize_value(yield(value, property))
+                             else
+                               normalize_value(value)
+                             end
+        end
+
+        def normalize_value(value)
+          return value if value.blank?
+
+          case value
+          when ::Time
+            return Type::Time.from_time(value)
+          when ::DateTime
+            return Type::Time.from_date_time(value)
+          when ::Date
+            return value.to_date
+          when ::Numeric, ::TrueClass, ::FalseClass, Workato::Extension::Binary, Type::UnicodeString,
+            ::Array, ::Hash
+            return value
+          when Extension::Array::ArrayWhere
+            return value.to_a
+          when ::String
+            if value.encoding == Encoding::ASCII_8BIT
+              return Workato::Extension::Binary.new(value)
+            end
+
+            return Type::UnicodeString.new(value)
+          else
+            if value.respond_to?(:to_time)
+              return Type::Time.from_time(value.to_time)
+            end
+
+            if value.respond_to?(:read) && value.respond_to?(:rewind)
+              value.rewind
+              return Workato::Extension::Binary.new(value.read.force_encoding(Encoding::ASCII_8BIT))
+            end
+          end
+
+          raise ArgumentError, "Unsupported data type: #{value.class}"
+        end
+      end
+
+      class Fields < ::Array
+        def initialize(fields)
+          ::Array.wrap(fields).each do |field|
+            field = prepare_attributes(field)
+            self << field_with_defaults(field)
+          end
+        end
+
+        private
+
+        def prepare_attributes(field)
+          if (render_input = field.delete(:convert_input) || field[:render_input])
+            field[:render_input] = render_input.is_a?(Proc) ? nil : render_input
+          end
+          if (parse_output = field.delete(:convert_output) || field[:parse_output])
+            field[:parse_output] = parse_output.is_a?(Proc) ? nil : parse_output
+          end
+          field[:optional] = true unless field.key?(:optional)
+          field[:label] ||= field[:name].labelize
+
+          clean_values(field)
+
+          if (toggle_field = field[:toggle_field]).present?
+            raise InvalidSchemaError, 'toggle_hint not present' if field[:toggle_hint].blank?
+
+            unless toggle_field[:name].present? && toggle_field[:type].present?
+              raise InvalidSchemaError, 'toggle_field not complete'
+            end
+
+            if toggle_field[:optional].present? && (toggle_field[:optional] != field[:optional])
+              raise InvalidSchemaError, 'toggle field cannot change optional attribute'
+            end
+
+            field[:toggle_field] = field_with_defaults(field[:toggle_field]).tap do |tg_field|
+              tg_field.except!(:render_input, :parse_output, :control_type)
+              tg_field[:control_type] = toggle_field[:control_type]
+              clean_values(tg_field)
+            end
+          end
+
+          if field[:control_type].try(:start_with?, 'small-')
+            field[:control_type].remove!(/^small-/)
+          elsif field[:control_type].try(:start_with?, 'medium-')
+            field[:control_type].remove!(/^medium-/)
+          end
+
+          field
+        end
+
+        def clean_values(field)
+          field.transform_values! do |value|
+            value.presence && (value.is_a?(::Symbol) && value.to_s || value)
+          end
+          field.compact!
+          field
+        end
+
+        def field_with_defaults(field)
+          type = field.delete(:type).to_s
+
+          case type
+          when 'integer'
+            Schema::Field::Integer.new(field)
+          when 'number', 'boolean'
+            Schema::Field::Number.new(field)
+          when 'date_time', 'timestamp'
+            Schema::Field::DateTime.new(field)
+          when 'date'
+            Schema::Field::Date.new(field)
+          when 'object'
+            field[:properties] = Fields.new(field[:properties])
+            field.delete(:control_type)
+            Schema::Field::Object.new(field)
+          when 'array'
+            of = field[:of] = (field[:of] || 'object').to_s
+            if of == 'object'
+              field[:properties] = Fields.new(field[:properties])
+            else
+              field.merge(
+                field_with_defaults(field.merge(type: of)).except(:render_input, :parse_output)
+              )
+            end
+            Schema::Field::Array.new(field)
+          else
+            Schema::Field::String.new(field)
+          end
+        end
+      end
+
+      private_constant :Fields
+    end
+  end
+end
+
+require_relative './schema/field/array'
+require_relative './schema/field/date'
+require_relative './schema/field/date_time'
+require_relative './schema/field/integer'
+require_relative './schema/field/number'
+require_relative './schema/field/object'
+require_relative './schema/field/string'
+
+require_relative './schema/type/time'
+require_relative './schema/type/unicode_string'

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

@@ -89,7 +89,32 @@ module Workato
           end
         end
 
+        def invoke(input = {}, payload = {}, headers = {}, params = {})
+          extended_schema = extended_schema(nil, input)
+          config_schema = Schema.new(schema: config_fields_schema)
+          input_schema = Schema.new(schema: extended_schema[:input])
+          output_schema = Schema.new(schema: extended_schema[:output])
+
+          input = apply_input_schema(input, config_schema + input_schema)
+          output = if webhook_notification?
+                     webhook_notification(input, payload, input_schema, output_schema, headers, params)
+                   else
+                     poll(nil, input, nil, input_schema, output_schema)
+                   end
+          output[:events].each do |event|
+            apply_output_schema(event, output_schema)
+          end
+
+          output
+        end
+
+        private
+
         alias trigger operation
+
+        def webhook_notification?
+          trigger[:webhook_notification].present?
+        end
       end
     end
   end

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

@@ -3,7 +3,7 @@
 module Workato
   module Connector
     module Sdk
-      VERSION = '0.2.0'
+      VERSION = '0.3.0'
     end
   end
 end

data/lib/workato/extension/string.rb

@@ -98,7 +98,7 @@ module Workato
       alias encode_hex to_hex
 
       def decode_hex
-        Binary.new([self].pack('H*'))
+        Extension::Binary.new([self].pack('H*'))
       end
 
       def encode_base64
@@ -106,7 +106,7 @@ module Workato
       end
 
       def decode_base64
-        Binary.new(Base64.decode64(self))
+        Extension::Binary.new(Base64.decode64(self))
       end
 
       def encode_urlsafe_base64
@@ -118,21 +118,27 @@ module Workato
       end
 
       def decode_urlsafe_base64
-        Binary.new(Base64.urlsafe_decode64(self))
+        Extension::Binary.new(Base64.urlsafe_decode64(self))
       end
 
       def encode_sha256
-        Binary.new(::Digest::SHA256.digest(self))
+        Extension::Binary.new(::Digest::SHA256.digest(self))
       end
 
       def hmac_sha256(key)
         digest = ::OpenSSL::Digest.new('sha256')
-        Binary.new(::OpenSSL::HMAC.digest(digest, key, self))
+        Extension::Binary.new(::OpenSSL::HMAC.digest(digest, key, self))
       end
 
       def hmac_sha512(key)
         digest = ::OpenSSL::Digest.new('sha512')
-        Binary.new(::OpenSSL::HMAC.digest(digest, key, self))
+        Extension::Binary.new(::OpenSSL::HMAC.digest(digest, key, self))
+      end
+
+      def rsa_sha256(key)
+        digest = ::OpenSSL::Digest.new('sha256')
+        private_key = ::OpenSSL::PKey::RSA.new(key)
+        Workato::Extension::Binary.new(private_key.sign(digest, self))
       end
 
       def md5_hexdigest
@@ -140,17 +146,17 @@ module Workato
       end
 
       def sha1
-        Binary.new(::Digest::SHA1.digest(self))
+        Extension::Binary.new(::Digest::SHA1.digest(self))
       end
 
       def hmac_sha1(key)
         digest = ::OpenSSL::Digest.new('sha1')
-        Binary.new(::OpenSSL::HMAC.digest(digest, key, self))
+        Extension::Binary.new(::OpenSSL::HMAC.digest(digest, key, self))
       end
 
       def hmac_md5(key)
         digest = ::OpenSSL::Digest.new('md5')
-        Binary.new(::OpenSSL::HMAC.digest(digest, key, self))
+        Extension::Binary.new(::OpenSSL::HMAC.digest(digest, key, self))
       end
 
       def from_xml
@@ -228,7 +234,7 @@ module Workato
       end
 
       def as_string(encoding)
-        String.new(self, encoding: encoding).encode(encoding, invalid: :replace, undef: :replace)
+        ::String.new(self, encoding: encoding).encode(encoding, invalid: :replace, undef: :replace)
       end
 
       def as_utf8

data/templates/spec/action_spec.rb.erb

@@ -5,9 +5,15 @@ RSpec.describe 'actions/<%= name %>', :vcr do
   # Spec describes the most commons blocks of an action. Remove describes that you don't need.
   # Learn more: https://docs.workato.com/developing-connectors/sdk/cli/reference/rspec-commands.html
 
+  subject(:output) { connector.actions.<%= name %>(input) }
+
   let(:connector) { Workato::Connector::Sdk::Connector.from_file('connector.rb', settings) }
   let(:settings) { Workato::Connector::Sdk::Settings.from_default_file }
+  let(:input) { {} }
+
+  pending 'add some examples for action output'
 
+  # Or add more fine grained tests for each action definition block
   let(:action) { connector.actions.<%= name %> }
 
   describe 'execute' do

data/templates/spec/trigger_spec.rb.erb

@@ -6,9 +6,15 @@ RSpec.describe 'triggers/<%= name %>', :vcr do
   # Depending on the type of your trigger remove describes that you don't need.
   # Learn more: https://docs.workato.com/developing-connectors/sdk/cli/reference/rspec-commands.html
 
+  subject(:output) { connector.triggers.<%= name %>(input) }
+
   let(:connector) { Workato::Connector::Sdk::Connector.from_file('connector.rb', settings) }
   let(:settings) { Workato::Connector::Sdk::Settings.from_default_file }
+  let(:input) { {} }
+
+  pending 'add some examples for trigger output'
 
+  # Or add more fine grained tests for each trigger definition block
   let(:trigger) { connector.triggers.<%= name %> }
 
   describe 'webhook_subscribe' do

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: workato-connector-sdk
 version: !ruby/object:Gem::Version
-  version: 0.2.0
+  version: 0.3.0
 platform: ruby
 authors:
 - Pavel Abolmasov
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2021-10-20 00:00:00.000000000 Z
+date: 2021-12-14 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activesupport
@@ -386,6 +386,17 @@ files:
 - lib/workato/connector/sdk/object_definitions.rb
 - lib/workato/connector/sdk/operation.rb
 - lib/workato/connector/sdk/request.rb
+- lib/workato/connector/sdk/schema.rb
+- lib/workato/connector/sdk/schema/field/array.rb
+- lib/workato/connector/sdk/schema/field/convertors.rb
+- lib/workato/connector/sdk/schema/field/date.rb
+- lib/workato/connector/sdk/schema/field/date_time.rb
+- lib/workato/connector/sdk/schema/field/integer.rb
+- lib/workato/connector/sdk/schema/field/number.rb
+- lib/workato/connector/sdk/schema/field/object.rb
+- lib/workato/connector/sdk/schema/field/string.rb
+- lib/workato/connector/sdk/schema/type/time.rb
+- lib/workato/connector/sdk/schema/type/unicode_string.rb
 - lib/workato/connector/sdk/settings.rb
 - lib/workato/connector/sdk/summarize.rb
 - lib/workato/connector/sdk/trigger.rb
@@ -442,8 +453,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubyforge_project:
-rubygems_version: 2.6.14.4
+rubygems_version: 3.2.3
 signing_key:
 specification_version: 4
 summary: Gem for running adapter's code outside Workato infrastructure