workato-connector-sdk 0.1.0

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

@@ -0,0 +1,61 @@
+# frozen_string_literal: true
+
+module Workato
+  module Connector
+    module Sdk
+      class Summarize
+        ARRAY_SUMMARIZATION_LIMIT = 100
+        STRING_SUMMARIZATION_LIMIT = 1024
+
+        def initialize(data:, paths:)
+          @paths = paths
+          @data = data
+        end
+
+        def call
+          return data if paths.blank?
+
+          summarized = data
+          paths.each do |path|
+            steps = path.split('.')
+            if above_summarization_limit?(summarized.dig(*steps))
+              summarized = data.deep_dup if summarized.equal?(data)
+              apply_summarization_limit(summarized, steps)
+            end
+          end
+
+          summarized
+        end
+
+        private
+
+        attr_reader :data,
+                    :paths
+
+        def above_summarization_limit?(candidate)
+          candidate.is_a?(::Array) && candidate.length > ARRAY_SUMMARIZATION_LIMIT ||
+            candidate.is_a?(::String) && candidate.length > STRING_SUMMARIZATION_LIMIT
+        end
+
+        def apply_summarization_limit(summarized, steps)
+          container = if steps.length > 1
+                        summarized.dig(*steps[0..-2])
+                      else
+                        summarized
+                      end
+          candidate = container[steps.last]
+          case candidate
+          when Array
+            candidate[(ARRAY_SUMMARIZATION_LIMIT - 2)..-2] =
+              "... #{candidate.length - ARRAY_SUMMARIZATION_LIMIT} items ..."
+          when String
+            candidate[(STRING_SUMMARIZATION_LIMIT - 1)..-1] =
+              "... #{candidate.length - STRING_SUMMARIZATION_LIMIT} characters ..."
+          else
+            candidate
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,96 @@
+# frozen_string_literal: true
+
+require 'securerandom'
+
+module Workato
+  module Connector
+    module Sdk
+      class Trigger < Operation
+        using BlockInvocationRefinements
+
+        def initialize(trigger:, connection: {}, methods: {}, settings: {}, object_definitions: nil)
+          super(
+            operation: trigger,
+            connection: connection,
+            methods: methods,
+            settings: settings,
+            object_definitions: object_definitions
+          )
+        end
+
+        def poll_page(settings = nil, input = {}, closure = nil, extended_input_schema = [],
+                      extended_output_schema = [])
+          poll_proc = trigger[:poll]
+          output = execute(
+            settings,
+            { input: input, closure: closure },
+            extended_input_schema,
+            extended_output_schema
+          ) do |connection, payload, eis, eos|
+            instance_exec(connection, payload[:input], payload[:closure], eis, eos, &poll_proc)
+          end
+          output[:events] = ::Array.wrap(output[:events]).reverse!.uniq(&trigger[:dedup])
+          output[:next_poll] = output[:next_poll].presence || closure
+          output
+        end
+
+        def poll(settings = nil, input = {}, closure = nil, extended_input_schema = [], extended_output_schema = [])
+          events = []
+
+          loop do
+            output = poll_page(settings, input, closure, extended_input_schema, extended_output_schema)
+            events = output[:events] + events
+            closure = output[:next_poll]
+
+            break unless output[:can_poll_more]
+          end
+
+          {
+            events: events.uniq(&trigger[:dedup]),
+            can_poll_more: false,
+            next_poll: closure
+          }.with_indifferent_access
+        end
+
+        def dedup(input = {})
+          trigger[:dedup].call(input)
+        end
+
+        def webhook_notification(input = {}, payload = {}, extended_input_schema = [],
+                                 extended_output_schema = [], headers = {}, params = {})
+          Dsl::WithDsl.execute(
+            input.with_indifferent_access,
+            payload.with_indifferent_access,
+            extended_input_schema.map(&:with_indifferent_access),
+            extended_output_schema.map(&:with_indifferent_access),
+            headers.with_indifferent_access,
+            params.with_indifferent_access,
+            &trigger[:webhook_notification]
+          )
+        end
+
+        def webhook_subscribe(webhook_url = '', settings = nil, input = {}, recipe_id = SecureRandom.uuid)
+          webhook_subscribe_proc = trigger[:webhook_subscribe]
+          execute(settings, { input: input, webhook_url: webhook_url, recipe_id: recipe_id }) do |connection, payload|
+            instance_exec(
+              payload[:webhook_url],
+              connection,
+              payload[:input],
+              payload[:recipe_id],
+              &webhook_subscribe_proc
+            )
+          end
+        end
+
+        def webhook_unsubscribe(webhook_subscribe_output = {})
+          webhook_unsubscribe_proc = trigger[:webhook_unsubscribe]
+          execute(nil, webhook_subscribe_output) do |_connection, input|
+            instance_exec(input, &webhook_unsubscribe_proc)
+          end
+        end
+
+        alias trigger operation
+      end
+    end
+  end
+end

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

@@ -0,0 +1,9 @@
+# frozen_string_literal: true
+
+module Workato
+  module Connector
+    module Sdk
+      VERSION = '0.1.0'
+    end
+  end
+end

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

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+
+require 'json'
+
+module Workato
+  module Connector
+    module Sdk
+      class WorkatoSchemas
+        include Singleton
+
+        class << self
+          def from_json(path = DEFAULT_SCHEMAS_PATH)
+            load_data(JSON.parse(File.read(path)))
+          end
+
+          delegate :find,
+                   :load_data,
+                   to: :instance
+        end
+
+        def load_data(data)
+          @schemas_by_id ||= {}.with_indifferent_access
+          @schemas_by_id.merge!(data.stringify_keys)
+        end
+
+        def find(id)
+          unless @schemas_by_id
+            raise 'Workato Schemas are not initialized. ' \
+                  'Init data by calling WorkatoSchemas.from_json or WorkatoSchemas.load_data'
+          end
+
+          @schemas_by_id.fetch(id.to_s)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+
+require 'nokogiri'
+
+module Workato
+  module Connector
+    module Sdk
+      module Xml
+        def self.parse_xml_to_hash(payload, strip_namespaces: false)
+          parse_options = Nokogiri::XML::ParseOptions.new.nonet
+          lazy_reader = Nokogiri::XML::Reader(payload, nil, nil, parse_options).to_enum.lazy
+          lazy_reader.each_with_object([{}]) do |node, ancestors|
+            ancestors.shift while ancestors.count > node.depth + 1
+            case node.node_type
+            when Nokogiri::XML::Reader::TYPE_ELEMENT
+              element = HashWithIndifferentAccess.new
+              node.attributes&.each do |name, value|
+                element["@#{strip_namespaces ? name[/(?:^xmlns:)?[^:]+$/] : name}"] = value
+              end
+              (ancestors.first[strip_namespaces ? node.name[/[^:]+$/] : node.name] ||= []).push(element)
+              ancestors.unshift(element)
+            when Nokogiri::XML::Reader::TYPE_TEXT, Nokogiri::XML::Reader::TYPE_CDATA
+              element = ancestors.first
+              if element.key?(:content!)
+                element[:content!] += node.value
+              else
+                element[:content!] = node.value
+              end
+            end
+          end.last
+        end
+      end
+    end
+  end
+end

data/lib/workato/connector/sdk.rb

@@ -0,0 +1,58 @@
+# frozen_string_literal: true
+
+module Workato
+  module Connector
+    module Sdk
+      DEFAULT_MASTER_KEY_ENV = 'WORKATO_CONNECTOR_MASTER_KEY'
+      DEFAULT_MASTER_KEY_PATH = 'master.key'
+
+      DEFAULT_CONNECTOR_PATH = 'connector.rb'
+
+      DEFAULT_SETTINGS_PATH = 'settings.yaml'
+      DEFAULT_ENCRYPTED_SETTINGS_PATH = 'settings.yaml.enc'
+
+      DEFAULT_ACCOUNT_PROPERTIES_PATH = 'account_properties.yaml'
+      DEFAULT_ENCRYPTED_ACCOUNT_PROPERTIES_PATH = 'account_properties.yaml.enc'
+
+      DEFAULT_LOOKUP_TABLES_PATH = 'lookup_tables.yaml'
+
+      DEFAULT_TIME_ZONE = 'Pacific Time (US & Canada)'
+
+      DEFAULT_SCHEMAS_PATH = 'workato_schemas.json'
+    end
+  end
+end
+
+# Global libs and monkey patches
+require 'active_support/all'
+require 'active_support/json'
+require_relative '../extension/array'
+require_relative '../extension/case_sensitive_headers'
+require_relative '../extension/currency'
+require_relative '../extension/date'
+require_relative '../extension/enumerable'
+require_relative '../extension/extra_chain_cert'
+require_relative '../extension/hash'
+require_relative '../extension/integer'
+require_relative '../extension/nil_class'
+require_relative '../extension/object'
+require_relative '../extension/phone'
+require_relative '../extension/string'
+require_relative '../extension/symbol'
+require_relative '../extension/time'
+
+require_relative './sdk/account_properties'
+require_relative './sdk/action'
+require_relative './sdk/connector'
+require_relative './sdk/dsl'
+require_relative './sdk/errors'
+require_relative './sdk/lookup_tables'
+require_relative './sdk/object_definitions'
+require_relative './sdk/operation'
+require_relative './sdk/request'
+require_relative './sdk/settings'
+require_relative './sdk/summarize'
+require_relative './sdk/trigger'
+require_relative './sdk/version'
+require_relative './sdk/workato_schemas'
+require_relative './sdk/xml'

data/lib/workato/extension/array.rb

@@ -0,0 +1,124 @@
+# frozen_string_literal: true
+
+module Workato
+  module Extension
+    module Array
+      def to_csv(options = {})
+        options ||= {}
+        multi_line = options[:multi_line]
+        multi_line = true if multi_line.nil?
+        options = options.dup
+
+        if multi_line && first.is_a?(::Array)
+          options[:multi_line] = false
+          map { |r| r.to_csv(options) }.join
+        else
+          options.delete(:multi_line)
+          super(options)
+        end
+      end
+
+      def ignored(*names)
+        reject { |field| names.include?(field[:name]) }
+      end
+
+      def only(*names)
+        select { |field| names.include?(field[:name]) }
+      end
+
+      def required(*names)
+        map { |field| names.include?(field[:name]) ? field.merge(optional: false) : field }
+      end
+
+      class ArrayWhere < SimpleDelegator
+        def initialize(list, options = {})
+          @_list = list
+          @_operations = []
+          @_resolved = false
+          where(options || {})
+        end
+
+        def where(options = {})
+          @_operations << [options] if options.present?
+          self
+        end
+
+        def not(options = {})
+          if options.present?
+            where(options)
+            @_operations.last << true
+          end
+          self
+        end
+
+        def self.parse_operation(key)
+          operation = key.to_s.match(/ *[><=!]={0,1} *\Z/)
+          stripped_key, operation = if operation.present?
+                                      [operation.pre_match, operation.to_s.strip]
+                                    else
+                                      [key.to_s, nil]
+                                    end
+          keys = stripped_key.split_strip_compact('.')
+          keys = keys.map(&:to_sym) if key.is_a?(::Symbol)
+          [keys, operation]
+        end
+
+        def self.coerce_operands(lhs_name, lhs, rhs, operation)
+          if operation == 'include?'
+            lhs, rhs = rhs, lhs
+          end
+
+          if operation.match?(/[><]/) || %w[match? include?].include?(operation)
+            raise "The '#{lhs_name}' is nil" if lhs.nil?
+            raise "Can't compare '#{lhs_name}' with nil" if rhs.nil?
+          end
+
+          if lhs.is_a?(::Numeric) && rhs.try(:is_number?)
+            rhs = rhs.is_int? ? rhs.to_i : rhs.to_f
+          elsif rhs.is_a?(::Numeric) && lhs.try(:is_number?)
+            lhs = lhs.is_int? ? lhs.to_i : lhs.to_f
+          end
+          [lhs, rhs]
+        end
+
+        def self.nested_attr(item, keys)
+          keys.reduce(item) do |obj, key|
+            obj[key] unless obj.nil?
+          end
+        end
+
+        def self.match?(operations, item)
+          operations.all? do |args, negate|
+            result = args.all? do |key, value|
+              keys, operation = parse_operation(key)
+              compared = nested_attr(item, keys)
+              if operation.blank?
+                operation = case value
+                            when ::Array, Range
+                              'include?'
+                            when Regexp
+                              'match?'
+                            else
+                              '=='
+                            end
+              end
+              lhs, rhs = coerce_operands(keys.join('.'), compared, value, operation)
+              lhs.send(operation, rhs)
+            end
+            negate ? !result : result
+          end
+        end
+
+        def __getobj__
+          return super if @_resolved
+
+          filtered = @_list.select { |item| self.class.match?(@_operations, item) }
+          @_resolved = true
+          __setobj__(filtered)
+        end
+      end
+    end
+  end
+end
+
+Array.prepend(Workato::Extension::Array)

data/lib/workato/extension/case_sensitive_headers.rb

@@ -0,0 +1,51 @@
+# frozen_string_literal: true
+
+require 'rest-client'
+require 'net/http'
+
+module Workato
+  module Extension
+    module CaseSensitiveHeaders
+      module Net
+        module HTTPHeader
+          attr_accessor :case_sensitive_headers
+
+          def capitalize(modified_name)
+            return super if case_sensitive_headers.blank?
+
+            original_name = case_sensitive_headers.keys.find { |name| name.downcase == modified_name }
+            original_name.presence || super
+          end
+        end
+      end
+
+      ::Net::HTTPHeader.prepend Net::HTTPHeader
+      ::Net::HTTPGenericRequest.prepend Net::HTTPHeader
+
+      module RestClient
+        module Request
+          attr_accessor :case_sensitive_headers
+
+          def processed_headers
+            return @processed_headers if case_sensitive_headers.blank?
+            return case_sensitive_headers if @processed_headers.blank?
+
+            @processed_headers.merge(case_sensitive_headers)
+          end
+
+          def execute(&block)
+            # With 2.0.0+, net/http accepts URI objects in requests and handles wrapping
+            # IPv6 addresses in [] for use in the Host request header.
+            net_http_request = net_http_request_class(method).new(uri, processed_headers)
+            net_http_request.case_sensitive_headers = case_sensitive_headers
+            transmit(uri, net_http_request, payload, &block)
+          ensure
+            payload&.close
+          end
+        end
+      end
+
+      ::RestClient::Request.prepend RestClient::Request
+    end
+  end
+end