workato-connector-sdk 0.1.0

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

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+module Workato
+  module Connector
+    module Sdk
+      module Dsl
+        module LookupTable
+          def lookup(lookup_table_id, *args)
+            LookupTables.lookup(lookup_table_id, *args)
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+module Workato
+  module Connector
+    module Sdk
+      module Dsl
+        module Time
+          def now
+            ::Time.zone.now
+          end
+
+          def today
+            ::Time.zone.today
+          end
+        end
+      end
+    end
+  end
+end
+
+::Time.zone = Workato::Connector::Sdk::DEFAULT_TIME_ZONE

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

@@ -0,0 +1,105 @@
+# frozen_string_literal: true
+
+require 'jwt'
+
+module Workato
+  module Connector
+    module Sdk
+      module Dsl
+        module WorkatoCodeLib
+          JWT_ALGORITHMS = %w[RS256 RS384 RS512].freeze
+          JWT_RSA_KEY_MIN_LENGTH = 2048
+
+          def workato
+            WorkatoCodeLib
+          end
+
+          def parse_json(source)
+            WorkatoCodeLib.parse_json(source)
+          end
+
+          class << self
+            def jwt_encode_rs256(payload, key, header_fields = {})
+              jwt_encode(payload, key, 'RS256', header_fields)
+            end
+
+            def jwt_encode(payload, key, algorithm, header_fields = {})
+              algorithm = algorithm.to_s.upcase
+              unless JWT_ALGORITHMS.include?(algorithm)
+                raise "Unsupported signing method. Supports only #{JWT_ALGORITHMS.join(', ')}. Got: '#{algorithm}'"
+              end
+
+              rsa_private = OpenSSL::PKey::RSA.new(key)
+              if rsa_private.n.num_bits < JWT_RSA_KEY_MIN_LENGTH
+                raise "A RSA key of size #{JWT_RSA_KEY_MIN_LENGTH} bits or larger MUST be used with JWT."
+              end
+
+              header_fields = header_fields.present? ? header_fields.with_indifferent_access.except(:typ, :alg) : {}
+              ::JWT.encode(payload, rsa_private, algorithm, header_fields)
+            end
+
+            def parse_yaml(yaml)
+              ::Psych.safe_load(yaml)
+            rescue ::Psych::DisallowedClass => e
+              raise e.message
+            end
+
+            def render_yaml(obj)
+              ::Psych.dump(obj)
+            end
+
+            def parse_json(source)
+              JSON.parse(source)
+            end
+
+            def uuid
+              SecureRandom.uuid
+            end
+
+            RANDOM_SIZE = 32
+
+            def random_bytes(len)
+              unless (len.is_a? ::Integer) && (len <= RANDOM_SIZE)
+                raise "The requested length or random bytes sequence should be <= #{RANDOM_SIZE}"
+              end
+
+              String::Binary.new(::OpenSSL::Random.random_bytes(len))
+            end
+
+            ALLOWED_KEY_SIZES = [128, 192, 256].freeze
+
+            def aes_cbc_encrypt(string, key, init_vector = nil)
+              key_size = key.bytesize * 8
+              unless ALLOWED_KEY_SIZES.include?(key_size)
+                raise 'Incorrect key size for AES'
+              end
+
+              cipher = ::OpenSSL::Cipher.new("AES-#{key_size}-CBC")
+              cipher.encrypt
+              cipher.key = key
+              cipher.iv = init_vector if init_vector.present?
+              String::Binary.new(cipher.update(string) + cipher.final)
+            end
+
+            def aes_cbc_decrypt(string, key, init_vector = nil)
+              key_size = key.bytesize * 8
+              unless ALLOWED_KEY_SIZES.include?(key_size)
+                raise 'Incorrect key size for AES'
+              end
+
+              cipher = ::OpenSSL::Cipher.new("AES-#{key_size}-CBC")
+              cipher.decrypt
+              cipher.key = key
+              cipher.iv = init_vector if init_vector.present?
+              String::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))
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+module Workato
+  module Connector
+    module Sdk
+      module Dsl
+        module WorkatoSchema
+          def workato_schema(id)
+            WorkatoSchemas.find(id)
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,46 @@
+# frozen_string_literal: true
+
+require_relative './block_invocation_refinements'
+
+require_relative './dsl/http'
+require_relative './dsl/call'
+require_relative './dsl/error'
+require_relative './dsl/account_property'
+require_relative './dsl/lookup_table'
+require_relative './dsl/workato_code_lib'
+require_relative './dsl/workato_schema'
+require_relative './dsl/time'
+
+module Workato
+  module Connector
+    module Sdk
+      module Dsl
+        module Global
+          include Time
+          include AccountProperty
+          include LookupTable
+          include WorkatoCodeLib
+          include WorkatoSchema
+
+          def sleep(seconds)
+            ::Kernel.sleep(seconds.presence || 0)
+          end
+        end
+
+        class WithDsl
+          include Global
+
+          using BlockInvocationRefinements
+
+          def execute(*args, &block)
+            instance_exec(*args, &block)
+          end
+
+          def self.execute(*args, &block)
+            WithDsl.new.execute(*args, &block)
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+module Workato
+  module Connector
+    module Sdk
+      InvalidDefinitionError = Class.new(StandardError)
+
+      CustomRequestError = Class.new(StandardError)
+
+      class RequestError < StandardError
+        attr_reader :method,
+                    :code,
+                    :response
+
+        def initialize(message:, method:, code:, response:)
+          super(message)
+          @method = method
+          @code = code
+          @response = response
+        end
+      end
+
+      class NotImplementedError < RuntimeError
+        def initialize(msg = 'This part of Connector SDK is not implemented in workato-connector-sdk yet')
+          super
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,62 @@
+# frozen_string_literal: true
+
+require 'csv'
+require 'singleton'
+
+module Workato
+  module Connector
+    module Sdk
+      class LookupTables
+        include Singleton
+
+        def self.from_yaml(path = DEFAULT_LOOKUP_TABLES_PATH)
+          instance.load_data(YAML.load_file(path))
+        end
+
+        def self.from_csv(table_id, table_name, path)
+          rows = CSV.foreach(path, headers: true, return_headers: false).map(&:to_h)
+          instance.load_data(table_name => { id: table_id, rows: rows })
+        end
+
+        class << self
+          delegate :load_data,
+                   :lookup,
+                   to: :instance
+        end
+
+        def lookup(table_name_or_id, *args)
+          table = find_table(table_name_or_id)
+          return {} unless table
+
+          condition = args.extract_options!
+          row = table.lazy.where(condition).first
+          return {} unless row
+
+          row.to_hash.with_indifferent_access
+        end
+
+        def load_data(data = {})
+          @table_by_id ||= {}
+          @table_by_name ||= {}
+          data.each do |name, table|
+            table = table.with_indifferent_access
+            rows = table['rows'].freeze
+            @table_by_id[table['id'].to_i] = rows
+            @table_by_name[name] = rows
+          end
+        end
+
+        private
+
+        def find_table(table_name_or_id)
+          unless @table_by_id
+            raise 'Lookup Tables are not initialized. ' \
+                  'Init data by calling LookupTable.from_file or LookupTable.load_data'
+          end
+
+          (table_name_or_id.is_int? && @table_by_id[table_name_or_id.to_i]) || @table_by_name[table_name_or_id]
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,74 @@
+# frozen_string_literal: true
+
+require_relative './block_invocation_refinements'
+
+module Workato
+  module Connector
+    module Sdk
+      class ObjectDefinitions
+        using BlockInvocationRefinements
+
+        def initialize(object_definitions:, connection:, methods:, settings:)
+          @object_definitions_source = object_definitions
+          @methods = methods
+          @connection = connection
+          @settings = settings
+          define_object_definition_methods(object_definitions)
+        end
+
+        def lazy(settings = nil, config_fields = {})
+          object_definitions_lazy_hash = DupHashWithIndifferentAccess.new do |h, name|
+            fields_proc = @object_definitions_source[name][:fields]
+            h[name] = Action.new(
+              action: {
+                execute: lambda do |connection, input|
+                  instance_exec(connection, input, object_definitions_lazy_hash, &fields_proc)
+                end
+              },
+              methods: @methods,
+              connection: @connection,
+              settings: @settings
+            ).execute(settings, config_fields)
+          end
+        end
+
+        private
+
+        attr_reader :methods,
+                    :connection,
+                    :objects,
+                    :settings
+
+        def define_object_definition_methods(object_definitions)
+          object_definitions.each do |(object, _definition)|
+            define_singleton_method(object) do
+              @object_definitions ||= {}
+              @object_definitions[object] ||= ObjectDefinition.new(name: object, object_definitions: self)
+            end
+          end
+        end
+
+        class ObjectDefinition
+          def initialize(name:, object_definitions:)
+            @object_definitions = object_definitions
+            @name = name
+          end
+
+          def fields(settings = nil, config_fields = {})
+            object_definitions_lazy_hash = @object_definitions.lazy(settings, config_fields)
+            object_definitions_lazy_hash[@name]
+          end
+        end
+
+        class DupHashWithIndifferentAccess < HashWithIndifferentAccess
+          def [](name)
+            super.deep_dup
+          end
+        end
+
+        private_constant 'ObjectDefinition'
+        private_constant 'DupHashWithIndifferentAccess'
+      end
+    end
+  end
+end

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

@@ -0,0 +1,217 @@
+# frozen_string_literal: true
+
+require_relative './dsl'
+require_relative './block_invocation_refinements'
+
+module Workato
+  module Connector
+    module Sdk
+      class Operation
+        include Dsl::Global
+        include Dsl::HTTP
+        include Dsl::Call
+        include Dsl::Error
+
+        using BlockInvocationRefinements
+
+        cattr_accessor :on_settings_updated
+
+        def initialize(operation:, connection: {}, methods: {}, settings: {}, object_definitions: nil)
+          @settings = settings.with_indifferent_access
+          @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)
+          @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),
+            &block
+          )
+          resolve_request(request_or_result)
+        end
+
+        def extended_schema(settings = nil, config_fields = {})
+          object_definitions_hash = object_definitions.lazy(settings, config_fields)
+          {
+            input: schema_fields(object_definitions_hash, settings, config_fields, &operation[:input_fields]),
+            output: schema_fields(object_definitions_hash, settings, config_fields, &operation[:output_fields])
+          }.with_indifferent_access
+        end
+
+        def input_fields(settings = nil, config_fields = {})
+          object_definitions_hash = object_definitions.lazy(settings, config_fields)
+          schema_fields(object_definitions_hash, settings, config_fields, &operation[:input_fields])
+        end
+
+        def output_fields(settings = nil, config_fields = {})
+          object_definitions_hash = object_definitions.lazy(settings, config_fields)
+          schema_fields(object_definitions_hash, settings, config_fields, &operation[:output_fields])
+        end
+
+        def summarize_input(input = {})
+          summarize(input, operation[:summarize_input])
+        end
+
+        def summarize_output(output = {})
+          summarize(output, operation[:summarize_output])
+        end
+
+        def sample_output(settings = nil, input = {})
+          execute(settings, input, &operation[:sample_output])
+        end
+
+        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]
+                           refresh_oauth2_token(settings)
+                         elsif connection[:authorization][:acquire]
+                           acquire_token(settings)
+                         end
+          return unless new_settings
+
+          settings.merge!(new_settings)
+
+          on_settings_updated&.call(http_body, http_code, exception, settings)
+
+          settings
+        end
+
+        private
+
+        def summarize(data, paths)
+          return data unless paths.present?
+
+          Summarize.new(data: data, paths: paths).call
+        end
+
+        def schema_fields(object_definitions_hash, settings, config_fields, &schema_proc)
+          return {} unless schema_proc
+
+          execute(settings, config_fields) do |connection, input|
+            instance_exec(
+              object_definitions_hash,
+              connection,
+              input,
+              &schema_proc
+            )
+          end
+        end
+
+        def resolve_request(request_or_result)
+          case request_or_result
+          when Request
+            resolve_request(request_or_result.execute!)
+          when ::Array
+            request_or_result.each_with_index.inject(request_or_result) do |acc, (item, index)|
+              response_item = resolve_request(item)
+              if response_item.equal?(item)
+                acc
+              else
+                (acc == request_or_result ? acc.dup : acc).tap { |a| a[index] = response_item }
+              end
+            end
+          when ::Hash
+            request_or_result.inject(request_or_result.with_indifferent_access) do |acc, (key, value)|
+              response_value = resolve_request(value)
+              if response_value.equal?(value)
+                acc
+              else
+                (acc == request_or_result ? acc.dup : acc).tap { |h| h[key] = response_value }
+              end
+            end
+          else
+            request_or_result
+          end
+        end
+
+        def refresh_auth?(http_code, http_body, exception)
+          refresh_on = Array.wrap(connection[:authorization][:refresh_on]).compact
+          refresh_on.blank? || refresh_on.any? do |pattern|
+            pattern.is_a?(::Integer) && pattern == http_code ||
+              pattern === exception&.to_s ||
+              pattern === http_body
+          end
+        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)
+        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.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'
+          end
+
+          response = RestClient::Request.execute(
+            url: connection[:authorization][:token_url].call(settings),
+            method: :post,
+            payload: {
+              client_id: connection[:authorization][:client_id].call(settings),
+              client_secret: connection[:authorization][:client_secret].call(settings),
+              grant_type: :refresh_token,
+              refresh_token: settings[:refresh_token]
+            },
+            headers: {
+              accept: :json
+            }
+          )
+          tokens = JSON.parse(response.body)
+          {
+            access_token: tokens['access_token'],
+            refresh_token: tokens['refresh_token'].presence || settings[:refresh_token]
+          }.with_indifferent_access
+        end
+
+        def refresh_oauth2_token(settings)
+          if connection[:authorization][:refresh]
+            refresh_oauth2_token_using_refresh(settings)
+          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"
+          end
+        end
+
+        attr_reader :operation,
+                    :connection,
+                    :settings,
+                    :object_definitions
+      end
+    end
+  end
+end