workato-connector-sdk 0.1.1 → 0.4.0

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/settings.rb

@@ -45,6 +45,8 @@ module Workato
             begin
               @encrypted = false
               read_plain_file
+            rescue KeyError
+              raise
             rescue StandardError
               @encrypted = true
               read_encrypted_file
@@ -76,7 +78,7 @@ module Workato
             YAML.safe_load(f.read, [::Symbol]).to_hash.with_indifferent_access
           end
 
-          name ? all_settings.fetch(name) : all_settings
+          (name ? all_settings.fetch(name) : all_settings) || {}
         end
 
         def update_plain_file(new_settings)
@@ -93,7 +95,7 @@ module Workato
         def read_encrypted_file
           all_settings = encrypted_configuration.config.with_indifferent_access
 
-          name ? all_settings.fetch(name) : all_settings
+          (name ? all_settings.fetch(name) : all_settings) || {}
         end
 
         def update_encrypted_file(new_settings)
@@ -106,7 +108,8 @@ module Workato
 
         def merge_settings(all_settings, new_settings)
           if name
-            all_settings[name] = new_settings
+            all_settings[name] ||= {}
+            all_settings[name].merge!(new_settings)
           else
             all_settings.merge!(new_settings)
           end

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.1.1'
+      VERSION = '0.4.0'
     end
   end
 end

data/lib/workato/connector/sdk.rb

@@ -43,6 +43,7 @@ require_relative '../extension/time'
 
 require_relative './sdk/account_properties'
 require_relative './sdk/action'
+require_relative './sdk/connection'
 require_relative './sdk/connector'
 require_relative './sdk/dsl'
 require_relative './sdk/errors'

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
@@ -117,22 +117,32 @@ module Workato
         ::ERB::Util.url_encode(self)
       end
 
+      def decode_url
+        CGI.unescape(self)
+      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 +150,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 +238,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/lib/workato/web/app.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+module Workato
+  module Web
+    class App
+      CODE_PATH = '/code'
+      CALLBACK_PATH = '/oauth/callback'
+
+      def call(env)
+        req = Rack::Request.new(env)
+        case req.path_info
+        when /#{CODE_PATH}/
+          [200, { 'Content-Type' => 'text/plain' }, [@code.to_s]]
+        when /#{CALLBACK_PATH}/
+          @code = req.params['code']
+          [200, { 'Content-Type' => 'text/plain' }, ['We stored response code. Now you can close the browser window']]
+        else
+          [404, { 'Content-Type' => 'text/plain' }, ['404: Not Found']]
+        end
+      end
+    end
+  end
+end

data/templates/Gemfile.erb

@@ -5,6 +5,7 @@ source 'https://rubygems.org'
 gem 'byebug'
 gem 'rspec'
 gem 'timecop'
+gem 'tzinfo-data', platforms: %i[mingw mswin x64_mingw jruby]
 gem 'vcr'
 gem 'webmock'
 gem 'workato-connector-sdk'

data/templates/spec/action_spec.rb.erb

@@ -5,13 +5,19 @@ 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
-    subject(:output) { action.execute(settings, input, extended_input_schema, extended_output_schema) }
+    subject(:output) { action.execute(settings, input, extended_input_schema, extended_output_schema, continue) }
 
     pending 'add some examples'
   end

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