workato-connector-sdk 0.1.0

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

@@ -0,0 +1,88 @@
+# frozen_string_literal: true
+
+require_relative './operation'
+require_relative './block_invocation_refinements'
+
+module Workato
+  module Connector
+    module Sdk
+      class Action < Operation
+        using BlockInvocationRefinements
+
+        RETRY_DEFAULT_CODES = [429, 500, 502, 503, 504, 507].freeze
+        RETRY_DEFAULT_METHODS = %i[get head].freeze
+        RETRY_DELAY = 5.seconds
+        MAX_RETRIES = 3
+
+        def initialize(action:, connection: {}, methods: {}, settings: {}, object_definitions: nil)
+          super(
+            operation: action,
+            connection: connection,
+            methods: methods,
+            settings: settings,
+            object_definitions: object_definitions
+          )
+
+          initialize_retry
+        end
+
+        def execute(settings = nil, input = {}, extended_input_schema = [], extended_output_schema = [], &block)
+          raise InvalidDefinitionError, "'execute' block is required for action" unless block || action[:execute]
+
+          super(settings, input, extended_input_schema, extended_output_schema, &(block || action[:execute]))
+        rescue RequestError => e
+          raise e unless retry?(e)
+
+          @retries_left -= 1
+          sleep(RETRY_DELAY) && retry
+        end
+
+        def checkpoint!(continue:, temp_output: nil)
+          raise NotImplementedError
+        end
+
+        def reinvoke_after(seconds:, continue:, temp_output: nil)
+          raise NotImplementedError
+        end
+
+        private
+
+        def retry_on_response
+          Array(action[:retry_on_response])
+        end
+
+        def retry_on_request
+          Array(action[:retry_on_request])
+        end
+
+        def max_retries
+          action[:max_retries]
+        end
+
+        def initialize_retry
+          @retries_left = 0
+          return if retry_on_response.blank?
+
+          @retry_codes = []
+          @retry_matchers = []
+          retry_on_response.each { |m| m.is_a?(::Integer) ? @retry_codes << m : @retry_matchers << m }
+          @retry_codes = RETRY_DEFAULT_CODES if @retry_codes.empty?
+          @retry_methods = (retry_on_request.presence || RETRY_DEFAULT_METHODS).map(&:to_s).map(&:downcase)
+          @retries_left = [[max_retries.is_a?(::Integer) && max_retries || MAX_RETRIES, MAX_RETRIES].min, 0].max
+        end
+
+        def retry?(exception)
+          return unless @retries_left.positive?
+          return unless @retry_codes.include?(exception.code.to_i)
+          return unless @retry_matchers.empty? || @retry_matchers.any? do |m|
+            m === exception.message || m === exception.response
+          end
+
+          @retry_methods.include?(exception.method.to_s.downcase)
+        end
+
+        alias action operation
+      end
+    end
+  end
+end

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

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+module Workato
+  module Connector
+    module Sdk
+      # match proc's arguments, even if it's a lambda.
+      module BlockInvocationRefinements
+        module CallRefinement
+          def call(*args, &block)
+            super(*args.take(parameters.length), &block)
+          end
+        end
+
+        refine Proc do
+          prepend CallRefinement
+        end
+
+        module InstanceExecRefinement
+          def instance_exec(*args, &block)
+            super(*args.take(block.parameters.length), &block)
+          end
+        end
+
+        refine BasicObject do
+          prepend InstanceExecRefinement
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,230 @@
+# frozen_string_literal: true
+
+module Workato
+  module Connector
+    module Sdk
+      class Connector
+        attr_reader :source
+
+        def self.from_file(path_to_source_code = DEFAULT_CONNECTOR_PATH, settings = {})
+          new(eval(File.read(path_to_source_code), binding, path_to_source_code), settings) # rubocop:disable Security/Eval
+        end
+
+        def initialize(definition, settings = {})
+          @source = definition.with_indifferent_access
+          @settings = settings.with_indifferent_access
+          @connection_source = @source[:connection] || {}
+          @methods_source = @source[:methods] || {}
+        end
+
+        def title
+          @source[:title]
+        end
+
+        def actions
+          @actions ||= ActionsProxy.new(
+            actions: source[:actions].presence || {},
+            object_definitions: object_definitions,
+            methods: methods_source,
+            connection: connection_source,
+            settings: settings
+          )
+        end
+
+        def methods
+          @methods ||= MethodsProxy.new(
+            methods: methods_source,
+            connection: connection_source,
+            settings: settings
+          )
+        end
+
+        def test(settings = nil)
+          @test ||= Action.new(
+            action: {
+              execute: source[:test]
+            },
+            methods: methods_source,
+            connection: connection_source,
+            settings: send(:settings)
+          ).execute(settings)
+        end
+
+        def triggers
+          @triggers ||= TriggersProxy.new(
+            triggers: source[:triggers].presence || {},
+            object_definitions: object_definitions,
+            methods: methods_source,
+            connection: connection_source,
+            settings: settings
+          )
+        end
+
+        def object_definitions
+          @object_definitions ||= ObjectDefinitions.new(
+            object_definitions: source[:object_definitions].presence || {},
+            methods: methods_source,
+            connection: connection_source,
+            settings: settings
+          )
+        end
+
+        def pick_lists
+          @pick_lists ||= PickListsProxy.new(
+            pick_lists: source[:pick_lists].presence || {},
+            methods: methods_source,
+            connection: connection_source,
+            settings: settings
+          )
+        end
+
+        private
+
+        attr_reader :methods_source,
+                    :connection_source,
+                    :settings
+      end
+
+      class ActionsProxy
+        def initialize(actions:, object_definitions:, methods:, connection:, settings:)
+          @methods = methods
+          @connection = connection
+          @object_definitions = object_definitions
+          @settings = settings
+          define_action_methods(actions)
+        end
+
+        def [](action)
+          public_send(action)
+        end
+
+        private
+
+        attr_reader :methods,
+                    :connection,
+                    :object_definitions,
+                    :settings
+
+        def define_action_methods(actions)
+          actions.each do |action, definition|
+            define_singleton_method(action) do
+              @actions ||= {}
+              @actions[action] ||= Action.new(
+                action: definition,
+                object_definitions: object_definitions,
+                methods: methods,
+                connection: connection,
+                settings: settings
+              )
+            end
+          end
+        end
+      end
+
+      class MethodsProxy
+        def initialize(methods:, connection:, settings:)
+          @methods = methods
+          @connection = connection
+          @settings = settings
+          define_action_methods
+        end
+
+        private
+
+        attr_reader :methods,
+                    :connection,
+                    :settings
+
+        def define_action_methods
+          methods.each do |method, _definition|
+            define_singleton_method(method) do |*args|
+              @actions ||= {}
+              @actions[method] ||= Action.new(
+                action: {
+                  execute: -> { call(method, *args) }
+                },
+                methods: methods,
+                connection: connection,
+                settings: settings
+              )
+              @actions[method].execute
+            end
+          end
+        end
+      end
+
+      class PickListsProxy
+        def initialize(pick_lists:, methods:, connection:, settings:)
+          @methods = methods
+          @connection = connection
+          @settings = settings
+          define_action_methods(pick_lists)
+        end
+
+        private
+
+        attr_reader :methods,
+                    :connection,
+                    :settings
+
+        def define_action_methods(pick_lists)
+          pick_lists.each do |pick_list, pick_list_proc|
+            define_singleton_method(pick_list) do |settings = nil, args = {}|
+              @actions ||= {}
+              @actions[pick_list] ||= Action.new(
+                action: {
+                  execute: lambda do |connection, input|
+                    case pick_list_proc.parameters.length
+                    when 0
+                      instance_exec(&pick_list_proc)
+                    when 1
+                      instance_exec(connection, &pick_list_proc)
+                    else
+                      instance_exec(connection, **input.symbolize_keys, &pick_list_proc)
+                    end
+                  end
+                },
+                methods: methods,
+                connection: connection,
+                settings: send(:settings)
+              )
+              @actions[pick_list].execute(settings, args)
+            end
+          end
+        end
+      end
+
+      class TriggersProxy
+        def initialize(triggers:, object_definitions:, methods:, connection:, settings:)
+          @methods = methods
+          @connection = connection
+          @object_definitions = object_definitions
+          @settings = settings
+          @triggers = {}
+          define_trigger_methods(triggers)
+        end
+
+        private
+
+        attr_reader :methods,
+                    :connection,
+                    :object_definitions,
+                    :settings
+
+        def define_trigger_methods(triggers)
+          triggers.each do |trigger, definition|
+            define_singleton_method(trigger) do
+              @triggers[trigger] ||= Trigger.new(
+                trigger: definition,
+                object_definitions: object_definitions,
+                methods: methods,
+                connection: connection,
+                settings: settings
+              )
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+module Workato
+  module Connector
+    module Sdk
+      module Dsl
+        module AccountProperty
+          def account_property(name)
+            AccountProperties.get(name)
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+module Workato
+  module Connector
+    module Sdk
+      module Dsl
+        module Call
+          def call(method, *args)
+            raise InvalidDefinitionError, "method '#{method}' does not exists" unless @_methods[method]
+
+            instance_exec(*args, &@_methods[method])
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+module Workato
+  module Connector
+    module Sdk
+      module Dsl
+        module Error
+          def error(message)
+            raise message
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,60 @@
+# frozen_string_literal: true
+
+module Workato
+  module Connector
+    module Sdk
+      module Dsl
+        # https://docs.workato.com/developing-connectors/sdk/sdk-reference/http.html#http-methods
+        module HTTP
+          def get(url, params = {})
+            http_request(url, method: 'GET').params(params).response_format_json
+          end
+
+          def options(url, params = {})
+            http_request(url, method: 'OPTIONS').params(params).response_format_json
+          end
+
+          def head(url, params = {})
+            http_request(url, method: 'HEAD').params(params).response_format_json
+          end
+
+          def post(url, payload = nil)
+            http_request(url, method: 'POST').payload(payload).format_json
+          end
+
+          def patch(url, payload = nil)
+            http_request(url, method: 'PATCH').payload(payload).format_json
+          end
+
+          def put(url, payload = nil)
+            http_request(url, method: 'PUT').payload(payload).format_json
+          end
+
+          def delete(url, payload = nil)
+            http_request(url, method: 'DELETE').payload(payload).format_json
+          end
+
+          def copy(url, payload = nil)
+            http_request(url, method: 'COPY').payload(payload).format_json
+          end
+
+          def move(url, payload = nil)
+            http_request(url, method: 'MOVE').payload(payload).format_json
+          end
+
+          private
+
+          def http_request(url, method:)
+            Request.new(
+              url,
+              method: method,
+              connection: connection,
+              settings: settings,
+              action: self
+            )
+          end
+        end
+      end
+    end
+  end
+end