workato-connector-sdk 0.1.0 → 0.3.0

data/lib/workato/cli/push_command.rb

@@ -3,6 +3,7 @@
 require 'uri'
 require 'ruby-progressbar'
 require 'zip'
+require 'fileutils'
 
 module Workato
   module CLI
@@ -19,6 +20,7 @@ module Workato
         'live-eu' => 'https://app.eu.workato.com'
       }.freeze
 
+      API_USER_PATH = '/api/users/me'
       API_IMPORT_PATH = '/api/packages/import'
       API_PACKAGE_PATH = '/api/packages'
       IMPORT_IN_PROGRESS = 'in_progress'
@@ -30,38 +32,33 @@ module Workato
       AWAIT_IMPORT_SLEEP_INTERVAL = 15 # seconds
       AWAIT_IMPORT_TIMEOUT_INTERVAL = 120 # seconds
 
-      def initialize(folder:, options:)
-        @folder_id = folder
+      def initialize(options:)
         @options = options
         @api_base_url = ENVIRONMENTS.fetch(options[:environment])
         @api_email = options[:api_email] || ENV[WORKATO_API_EMAIL_ENV]
         @api_token = options[:api_token] || ENV[WORKATO_API_TOKEN_ENV]
+        @folder_id = options[:folder]
       end
 
       def call
-        zip_file = build_package
+        zip_file_path = build_package
         say_status :success, 'Build package' if verbose?
 
-        import_id = import_package(zip_file)
+        import_id = import_package(zip_file_path)
         say_status :success, 'Upload package' if verbose?
         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
-        zip_file&.close(true)
+        FileUtils.rm_f(zip_file_path) if zip_file_path
       end
 
       private
 
       attr_reader :options,
-                  :folder_id,
                   :api_token,
                   :api_email,
                   :api_base_url
@@ -78,16 +75,13 @@ module Workato
       end
 
       def build_package
-        zip_file = Tempfile.new(['connector', '.zip'])
-
-        ::Zip::OutputStream.open(zip_file.path) { |_| 'no-op' }
-        ::Zip::File.open(zip_file.path, ::Zip::File::CREATE) do |archive|
-          add_connector(archive)
-          add_manifest(archive)
-          add_logo(archive)
+        ::Dir::Tmpname.create(['connector', '.zip']) do |path|
+          ::Zip::File.open(path, ::Zip::File::CREATE) do |archive|
+            add_connector(archive)
+            add_manifest(archive)
+            add_logo(archive)
+          end
         end
-
-        zip_file
       end
 
       def add_connector(archive)
@@ -110,11 +104,11 @@ module Workato
         end
       end
 
-      def import_package(zip_file)
+      def import_package(zip_file_path)
         url = "#{api_base_url}#{API_IMPORT_PATH}/#{folder_id}"
         response = RestClient.post(
           url,
-          File.open(zip_file.path),
+          File.open(zip_file_path),
           auth_headers.merge(
             'Content-Type' => 'application/zip'
           )
@@ -197,7 +191,25 @@ module Workato
         }
       end
 
+      def folder_id
+        @folder_id ||=
+          begin
+            url = "#{api_base_url}#{API_USER_PATH}"
+            response = RestClient.get(url, auth_headers)
+
+            json = JSON.parse(response.body)
+            json.fetch('root_folder_id').tap do |folder_id|
+              say_status :success, "Fetch root folder ID: #{folder_id}" if verbose?
+            end
+          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,
                        :API_PACKAGE_PATH,
                        :PACKAGE_ENTRY_NAME,

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

@@ -14,6 +14,8 @@ module Workato
         RETRY_DELAY = 5.seconds
         MAX_RETRIES = 3
 
+        MAX_REINVOKES = 5
+
         def initialize(action:, connection: {}, methods: {}, settings: {}, object_definitions: nil)
           super(
             operation: action,
@@ -26,10 +28,32 @@ module Workato
           initialize_retry
         end
 
-        def execute(settings = nil, input = {}, extended_input_schema = [], extended_output_schema = [], &block)
+        def execute(settings = nil, input = {}, extended_input_schema = [], extended_output_schema = [], continue = {},
+                    &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]))
+          loop do
+            if @reinvokes_remaining&.zero?
+              raise "Max number of reinvokes on SDK Gem reached. Current limit is #{reinvoke_limit}"
+            end
+
+            reinvoke_sleep if @reinvoke_after
+
+            @reinvoke_after = nil
+
+            result = super(
+              settings,
+              input,
+              extended_input_schema,
+              extended_output_schema,
+              continue,
+              &(block || action[:execute])
+            )
+
+            break result unless @reinvoke_after
+
+            continue = @reinvoke_after[:continue]
+          end
         rescue RequestError => e
           raise e unless retry?(e)
 
@@ -37,12 +61,28 @@ 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)
-          raise NotImplementedError
+          # no-op
         end
 
         def reinvoke_after(seconds:, continue:, temp_output: nil)
-          raise NotImplementedError
+          @reinvokes_remaining = (@reinvokes_remaining ? @reinvokes_remaining - 1 : reinvoke_limit)
+          @reinvoke_after = {
+            seconds: seconds,
+            continue: continue,
+            temp_output: temp_output
+          }
         end
 
         private
@@ -81,6 +121,14 @@ module Workato
           @retry_methods.include?(exception.method.to_s.downcase)
         end
 
+        def reinvoke_sleep
+          sleep((ENV['WAIT_REINVOKE_AFTER'].presence || @reinvoke_after[:seconds]).to_f)
+        end
+
+        def reinvoke_limit
+          @reinvoke_limit ||= (ENV['MAX_REINVOKES'].presence || MAX_REINVOKES).to_i
+        end
+
         alias action operation
       end
     end

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

@@ -0,0 +1,144 @@
+# frozen_string_literal: true
+
+require_relative './block_invocation_refinements'
+
+module Workato
+  module Connector
+    module Sdk
+      class Connection
+        using BlockInvocationRefinements
+
+        attr_reader :source
+
+        def initialize(connection: {}, methods: {}, settings: {})
+          @methods_source = methods.with_indifferent_access
+          @source = connection.with_indifferent_access
+          @settings = settings
+        end
+
+        def authorization
+          @authorization ||= Authorization.new(
+            connection: source,
+            methods: methods_source,
+            settings: @settings
+          )
+        end
+
+        def base_uri(settings = {})
+          source[:base_uri]&.call(settings.with_indifferent_access)
+        end
+
+        private
+
+        attr_reader :methods_source
+
+        class Authorization
+          attr_reader :source
+
+          def initialize(connection: {}, methods: {}, settings: {})
+            @connection_source = connection.with_indifferent_access
+            @source = (connection[:authorization] || {}).with_indifferent_access
+            @methods_source = methods.with_indifferent_access
+            @settings = settings
+          end
+
+          def token_url?
+            source[:token_url].present?
+          end
+
+          def acquire?
+            source[:acquire].present?
+          end
+
+          def refresh?
+            source[:refresh].present?
+          end
+
+          def type
+            source[:type]
+          end
+
+          def refresh_on
+            Array.wrap(source[:refresh_on]).compact
+          end
+
+          def detect_on
+            Array.wrap(source[:detect_on]).compact
+          end
+
+          def client_id(settings = {})
+            client_id = source[:client_id]
+
+            if client_id.is_a?(Proc)
+              Dsl::WithDsl.execute(settings.with_indifferent_access, &client_id)
+            else
+              client_id
+            end
+          end
+
+          def client_secret(settings = {})
+            client_secret_source = source[:client_secret]
+
+            if client_secret_source.is_a?(Proc)
+              Dsl::WithDsl.execute(settings.with_indifferent_access, &client_secret_source)
+            else
+              client_secret_source
+            end
+          end
+
+          def authorization_url(settings = {})
+            source[:authorization_url]&.call(settings.with_indifferent_access)
+          end
+
+          def token_url(settings = {})
+            source[:token_url]&.call(settings.with_indifferent_access)
+          end
+
+          def acquire(settings = {}, oauth2_code = nil, redirect_url = nil)
+            acquire_proc = source[:acquire]
+            raise InvalidDefinitionError, "Expect 'acquire' block" unless acquire_proc
+
+            Workato::Connector::Sdk::Operation.new(
+              connection: Connection.new(
+                connection: connection_source.merge(
+                  authorization: source.merge(
+                    apply: nil
+                  )
+                ),
+                methods: methods_source,
+                settings: @settings
+              ),
+              methods: methods_source,
+              settings: @settings
+            ).execute(settings, { auth_code: oauth2_code, redirect_url: redirect_url }) do |connection, input|
+              instance_exec(connection, input[:auth_code], input[:redirect_url], &acquire_proc)
+            end
+          end
+
+          def refresh(settings = {}, refresh_token = nil)
+            refresh_proc = source[:refresh]
+            raise InvalidDefinitionError, "Expect 'refresh' block" unless refresh_proc
+
+            Workato::Connector::Sdk::Operation.new(
+              connection: Connection.new(
+                methods: methods_source,
+                settings: @settings
+              ),
+              methods: methods_source,
+              settings: @settings
+            ).execute(settings, { refresh_token: refresh_token }) do |connection, input|
+              instance_exec(connection, input[:refresh_token], &refresh_proc)
+            end
+          end
+
+          private
+
+          attr_reader :connection_source,
+                      :methods_source
+        end
+
+        private_constant :Authorization
+      end
+    end
+  end
+end

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

@@ -24,9 +24,9 @@ module Workato
         def actions
           @actions ||= ActionsProxy.new(
             actions: source[:actions].presence || {},
-            object_definitions: object_definitions,
             methods: methods_source,
-            connection: connection_source,
+            object_definitions: object_definitions,
+            connection: connection,
             settings: settings
           )
         end
@@ -34,7 +34,7 @@ module Workato
         def methods
           @methods ||= MethodsProxy.new(
             methods: methods_source,
-            connection: connection_source,
+            connection: connection,
             settings: settings
           )
         end
@@ -45,7 +45,7 @@ module Workato
               execute: source[:test]
             },
             methods: methods_source,
-            connection: connection_source,
+            connection: connection,
             settings: send(:settings)
           ).execute(settings)
         end
@@ -53,9 +53,9 @@ module Workato
         def triggers
           @triggers ||= TriggersProxy.new(
             triggers: source[:triggers].presence || {},
-            object_definitions: object_definitions,
             methods: methods_source,
-            connection: connection_source,
+            connection: connection,
+            object_definitions: object_definitions,
             settings: settings
           )
         end
@@ -64,7 +64,7 @@ module Workato
           @object_definitions ||= ObjectDefinitions.new(
             object_definitions: source[:object_definitions].presence || {},
             methods: methods_source,
-            connection: connection_source,
+            connection: connection,
             settings: settings
           )
         end
@@ -72,6 +72,14 @@ module Workato
         def pick_lists
           @pick_lists ||= PickListsProxy.new(
             pick_lists: source[:pick_lists].presence || {},
+            methods: methods_source,
+            connection: connection,
+            settings: settings
+          )
+        end
+
+        def connection
+          @connection ||= Connection.new(
             methods: methods_source,
             connection: connection_source,
             settings: settings
@@ -107,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,
@@ -116,6 +124,9 @@ module Workato
                 connection: connection,
                 settings: settings
               )
+              return @actions[action] if input_.nil?
+
+              @actions[action].invoke(input_)
             end
           end
         end
@@ -213,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,
@@ -221,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/time.rb

@@ -18,4 +18,11 @@ module Workato
   end
 end
 
-::Time.zone = Workato::Connector::Sdk::DEFAULT_TIME_ZONE
+begin
+  ::Time.zone = Workato::Connector::Sdk::DEFAULT_TIME_ZONE
+rescue TZInfo::DataSourceNotFound
+  puts ''
+  puts "tzinfo-data is not present. Please install gem 'tzinfo-data' by 'gem install tzinfo-data'"
+  puts ''
+  exit!
+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/object_definitions.rb

@@ -10,23 +10,23 @@ module Workato
 
         def initialize(object_definitions:, connection:, methods:, settings:)
           @object_definitions_source = object_definitions
-          @methods = methods
+          @methods_source = 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(
+          DupHashWithIndifferentAccess.new do |object_definitions, name|
+            fields_proc = object_definitions_source[name][:fields]
+            object_definitions[name] = Action.new(
               action: {
                 execute: lambda do |connection, input|
-                  instance_exec(connection, input, object_definitions_lazy_hash, &fields_proc)
+                  instance_exec(connection, input, object_definitions, &fields_proc)
                 end
               },
-              methods: @methods,
-              connection: @connection,
+              methods: methods_source,
+              connection: connection,
               settings: @settings
             ).execute(settings, config_fields)
           end
@@ -34,10 +34,10 @@ module Workato
 
         private
 
-        attr_reader :methods,
+        attr_reader :methods_source,
                     :connection,
-                    :objects,
-                    :settings
+                    :settings,
+                    :object_definitions_source
 
         def define_object_definition_methods(object_definitions)
           object_definitions.each do |(object, _definition)|