workato-connector-sdk 1.0.1 → 1.0.2

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

@@ -1,84 +1,109 @@
+# typed: strict
 # frozen_string_literal: true
 
 module Workato
   module Connector
     module Sdk
+      module SorbetTypes
+        SourceHash = T.type_alias { T.any(HashWithIndifferentAccess, T::Hash[T.any(Symbol, String), T.untyped]) }
+      end
+
       class Connector
+        extend T::Sig
+
+        sig { returns(HashWithIndifferentAccess) }
         attr_reader :source
 
+        sig { params(path_to_source_code: String, settings: SorbetTypes::SettingsHash).returns(Connector) }
         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
 
+        sig { params(definition: SorbetTypes::SourceHash, settings: SorbetTypes::SettingsHash).void }
         def initialize(definition, settings = {})
-          @source = definition.with_indifferent_access
-          @settings = settings.with_indifferent_access
-          @connection_source = @source[:connection] || {}
-          @methods_source = @source[:methods] || {}
+          @source = T.let(definition.with_indifferent_access, HashWithIndifferentAccess)
+          @settings = T.let(settings.with_indifferent_access, HashWithIndifferentAccess)
+          @connection_source = T.let(@source[:connection] || {}.with_indifferent_access, HashWithIndifferentAccess)
+          @methods_source = T.let(@source[:methods] || {}.with_indifferent_access, HashWithIndifferentAccess)
         end
 
+        sig { params(path: String, params: T::Hash[Symbol, T.untyped]).returns(T.untyped) }
+        def invoke(path, params = {})
+          InvokePath.new(path: path, connector: self, params: params).call
+        end
+
+        sig { returns(T.nilable(String)) }
         def title
           @source[:title]
         end
 
+        sig { returns(ActionsProxy) }
         def actions
+          @actions = T.let(@actions, T.nilable(ActionsProxy))
           @actions ||= ActionsProxy.new(
             actions: source[:actions].presence || {},
             methods: methods_source,
             object_definitions: object_definitions,
-            connection: connection,
-            settings: settings
+            connection: connection
           )
         end
 
+        sig { returns(MethodsProxy) }
         def methods
+          @methods = T.let(@methods, T.nilable(MethodsProxy))
           @methods ||= MethodsProxy.new(
             methods: methods_source,
-            connection: connection,
-            settings: settings
+            connection: connection
           )
         end
 
+        sig { params(settings: T.nilable(SorbetTypes::SettingsHash)).returns(T.untyped) }
         def test(settings = nil)
+          @test = T.let(@test, T.nilable(Action))
           @test ||= Action.new(
             action: {
               execute: source[:test]
             },
             methods: methods_source,
-            connection: connection,
-            settings: send(:settings)
-          ).execute(settings)
+            connection: connection
+          )
+          @test.execute(settings)
         end
 
+        sig { returns(TriggersProxy) }
         def triggers
+          @triggers = T.let(@triggers, T.nilable(TriggersProxy))
           @triggers ||= TriggersProxy.new(
             triggers: source[:triggers].presence || {},
             methods: methods_source,
             connection: connection,
-            object_definitions: object_definitions,
-            settings: settings
+            object_definitions: object_definitions
           )
         end
 
+        sig { returns(ObjectDefinitions) }
         def object_definitions
+          @object_definitions = T.let(@object_definitions, T.nilable(ObjectDefinitions))
           @object_definitions ||= ObjectDefinitions.new(
             object_definitions: source[:object_definitions].presence || {},
             methods: methods_source,
-            connection: connection,
-            settings: settings
+            connection: connection
           )
         end
 
+        sig { returns(PickListsProxy) }
         def pick_lists
+          @pick_lists = T.let(@pick_lists, T.nilable(PickListsProxy))
           @pick_lists ||= PickListsProxy.new(
             pick_lists: source[:pick_lists].presence || {},
             methods: methods_source,
-            connection: connection,
-            settings: settings
+            connection: connection
           )
         end
 
+        sig { returns(Connection) }
         def connection
+          @connection = T.let(@connection, T.nilable(Connection))
           @connection ||= Connection.new(
             methods: methods_source,
             connection: connection_source,
@@ -88,100 +113,139 @@ module Workato
 
         private
 
-        attr_reader :methods_source,
-                    :connection_source,
-                    :settings
+        sig { returns(HashWithIndifferentAccess) }
+        attr_reader :methods_source
+
+        sig { returns(HashWithIndifferentAccess) }
+        attr_reader :connection_source
+
+        sig { returns(SorbetTypes::SettingsHash) }
+        attr_reader :settings
       end
 
       class ActionsProxy
-        def initialize(actions:, object_definitions:, methods:, connection:, settings:)
+        extend T::Sig
+
+        sig do
+          params(
+            actions: HashWithIndifferentAccess,
+            object_definitions: ObjectDefinitions,
+            methods: HashWithIndifferentAccess,
+            connection: Connection
+          ).void
+        end
+        def initialize(actions:, object_definitions:, methods:, connection:)
           @methods = methods
           @connection = connection
           @object_definitions = object_definitions
-          @settings = settings
+          @actions = T.let({}, T::Hash[T.any(Symbol, String), Action])
           define_action_methods(actions)
         end
 
+        sig { params(action: T.any(Symbol, String)).returns(T.untyped) }
         def [](action)
           public_send(action)
         end
 
         private
 
-        attr_reader :methods,
-                    :connection,
-                    :object_definitions,
-                    :settings
+        sig { returns(HashWithIndifferentAccess) }
+        attr_reader :methods
+
+        sig { returns(Connection) }
+        attr_reader :connection
+
+        sig { returns(ObjectDefinitions) }
+        attr_reader :object_definitions
 
-        def define_action_methods(actions)
-          actions.each do |action, definition|
+        sig { params(actions_source: HashWithIndifferentAccess).void }
+        def define_action_methods(actions_source)
+          actions_source.each do |action, definition|
             define_singleton_method(action) do |input_ = nil|
-              @actions ||= {}
               @actions[action] ||= Action.new(
                 action: definition,
                 object_definitions: object_definitions,
                 methods: methods,
-                connection: connection,
-                settings: settings
+                connection: connection
               )
               return @actions[action] if input_.nil?
 
-              @actions[action].invoke(input_)
+              T.must(@actions[action]).invoke(input_)
             end
           end
         end
       end
 
       class MethodsProxy
-        def initialize(methods:, connection:, settings:)
+        extend T::Sig
+
+        sig do
+          params(
+            methods: HashWithIndifferentAccess,
+            connection: Connection
+          ).void
+        end
+        def initialize(methods:, connection:)
           @methods = methods
           @connection = connection
-          @settings = settings
+          @actions = T.let({}, T::Hash[T.any(Symbol, String), Action])
           define_action_methods
         end
 
         private
 
-        attr_reader :methods,
-                    :connection,
-                    :settings
+        sig { returns(HashWithIndifferentAccess) }
+        attr_reader :methods
+
+        sig { returns(Connection) }
+        attr_reader :connection
 
+        sig { void }
         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) }
+                  execute: -> { T.unsafe(self).call(method, *args) }
                 },
                 methods: methods,
-                connection: connection,
-                settings: settings
+                connection: connection
               )
-              @actions[method].execute
+              T.must(@actions[method]).execute
             end
           end
         end
       end
 
       class PickListsProxy
-        def initialize(pick_lists:, methods:, connection:, settings:)
+        extend T::Sig
+
+        sig do
+          params(
+            pick_lists: HashWithIndifferentAccess,
+            methods: HashWithIndifferentAccess,
+            connection: Connection
+          ).void
+        end
+        def initialize(pick_lists:, methods:, connection:)
           @methods = methods
           @connection = connection
-          @settings = settings
+          @actions = T.let({}, T::Hash[T.any(Symbol, String), Action])
           define_action_methods(pick_lists)
         end
 
         private
 
-        attr_reader :methods,
-                    :connection,
-                    :settings
+        sig { returns(HashWithIndifferentAccess) }
+        attr_reader :methods
+
+        sig { returns(Connection) }
+        attr_reader :connection
 
-        def define_action_methods(pick_lists)
-          pick_lists.each do |pick_list, pick_list_proc|
+        sig { params(pick_lists_source: HashWithIndifferentAccess).void }
+        def define_action_methods(pick_lists_source)
+          pick_lists_source.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|
@@ -196,50 +260,121 @@ module Workato
                   end
                 },
                 methods: methods,
-                connection: connection,
-                settings: send(:settings)
+                connection: connection
               )
-              @actions[pick_list].execute(settings, args)
+              T.must(@actions[pick_list]).execute(settings, args)
             end
           end
         end
       end
 
       class TriggersProxy
-        def initialize(triggers:, object_definitions:, methods:, connection:, settings:)
+        extend T::Sig
+
+        sig do
+          params(
+            triggers: HashWithIndifferentAccess,
+            object_definitions: ObjectDefinitions,
+            methods: HashWithIndifferentAccess,
+            connection: Connection
+          ).void
+        end
+        def initialize(triggers:, object_definitions:, methods:, connection:)
           @methods = methods
           @connection = connection
           @object_definitions = object_definitions
-          @settings = settings
-          @triggers = {}
+          @triggers = T.let({}, T::Hash[T.any(Symbol, String), Trigger])
           define_trigger_methods(triggers)
         end
 
         private
 
-        attr_reader :methods,
-                    :connection,
-                    :object_definitions,
-                    :settings
+        sig { returns(HashWithIndifferentAccess) }
+        attr_reader :methods
 
-        def define_trigger_methods(triggers)
-          triggers.each do |trigger, definition|
+        sig { returns(Connection) }
+        attr_reader :connection
+
+        sig { returns(ObjectDefinitions) }
+        attr_reader :object_definitions
+
+        sig { params(triggers_source: HashWithIndifferentAccess).void }
+        def define_trigger_methods(triggers_source)
+          triggers_source.each do |trigger, definition|
             define_singleton_method(trigger) do |input_ = nil, payload = {}, headers = {}, params = {}|
               @triggers[trigger] ||= Trigger.new(
                 trigger: definition,
                 object_definitions: object_definitions,
                 methods: methods,
-                connection: connection,
-                settings: settings
+                connection: connection
               )
 
               return @triggers[trigger] if input_.nil?
 
-              @triggers[trigger].invoke(input_, payload, headers, params)
+              T.must(@triggers[trigger]).invoke(input_, payload, headers, params)
             end
           end
         end
       end
+
+      class InvokePath
+        extend T::Sig
+
+        sig do
+          params(
+            path: String,
+            connector: Connector,
+            params: T::Hash[Symbol, T.untyped]
+          ).void
+        end
+        def initialize(path:, connector:, params:)
+          @path = T.let(path, String)
+          @connector = T.let(connector, Connector)
+          @params = T.let(params, T::Hash[Symbol, T.untyped])
+        end
+
+        sig { returns(T.untyped) }
+        def call
+          invoke_path
+        end
+
+        private
+
+        sig { returns(String) }
+        attr_reader :path
+
+        sig { returns(Connector) }
+        attr_reader :connector
+
+        sig { returns(T::Hash[Symbol, T.untyped]) }
+        attr_reader :params
+
+        sig { returns(T.untyped) }
+        def invoke_path
+          methods = path.split('.')
+          method = methods.pop
+          raise ArgumentError, 'path is not found' unless method
+
+          object = methods.inject(connector) { |obj, m| obj.public_send(m) }
+          output = invoke_method(object, method)
+          if output.respond_to?(:invoke)
+            invoke_method(output, :invoke)
+          else
+            output
+          end
+        end
+
+        sig { params(object: T.untyped, method: T.any(Symbol, String)).returns(T.untyped) }
+        def invoke_method(object, method)
+          parameters = object.method(method).parameters.reject { |p| p[0] == :block }.map(&:second)
+          args = params.values_at(*parameters)
+          if parameters.last == :args
+            args = args.take(args.length - 1) + Array.wrap(args.last).flatten(1)
+          end
+          object.public_send(method, *args)
+        end
+      end
+      private_constant :InvokePath
     end
   end
 end

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

@@ -1,3 +1,4 @@
+# typed: true
 # frozen_string_literal: true
 
 module Workato

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

@@ -1,3 +1,4 @@
+# typed: false
 # frozen_string_literal: true
 
 require 'aws-sigv4'
@@ -19,10 +20,14 @@ module Workato
           WWW_FORM_CONTENT_TYPE = 'application/x-www-form-urlencoded; charset=utf-8'
 
           def aws
-            AWS
+            @aws ||= Private.new(connection: connection)
           end
 
-          class << self
+          class Private
+            def initialize(connection:)
+              @connection = connection
+            end
+
             def generate_signature(connection:,
                                    service:,
                                    region:,
@@ -61,27 +66,25 @@ module Workato
             end
 
             def iam_external_id
-              settings[:aws_external_id] || DUMMY_AWS_IAM_EXTERNAL_ID
+              @connection.settings[:aws_external_id] || DUMMY_AWS_IAM_EXTERNAL_ID
             end
 
             def workato_account_id
-              settings[:aws_workato_account_id] || AMAZON_ROLE_CLIENT_ID || DUMMY_AWS_WORKATO_ACCOUNT_ID
+              @connection.settings[:aws_workato_account_id] || AMAZON_ROLE_CLIENT_ID || DUMMY_AWS_WORKATO_ACCOUNT_ID
             end
 
             private
 
-            def on_settings_updated
-              Workato::Connector::Sdk::Operation.on_settings_updated
-            end
-
             def role_based_auth(settings:)
-              settings[:aws_external_id] ||= iam_external_id
-              temp_credentials = settings[:temp_credentials] || {}
+              temp_credentials = settings[:temp_credentials] || @connection.settings[:temp_credentials] || {}
 
               # Refresh temp token that will expire within 60 seconds.
               expiration = temp_credentials[:expiration]&.to_time(:utc)
               if !expiration || expiration <= TEMP_CREDENTIALS_REFRESH_TIMEOUT.seconds.from_now
-                temp_credentials = refresh_temp_credentials(settings)
+                @connection.update_settings!('Refresh AWS temporary credentials') do
+                  { temp_credentials: refresh_temp_credentials(settings) }
+                end
+                temp_credentials = @connection.settings[:temp_credentials]
               end
               {
                 access_key_id: temp_credentials[:api_key],
@@ -91,6 +94,7 @@ module Workato
             end
 
             def refresh_temp_credentials(settings)
+              aws_external_id = settings[:aws_external_id] || iam_external_id
               sts_credentials = {
                 access_key_id: amazon_role_client_key(settings),
                 secret_access_key: amazon_role_client_secret(settings)
@@ -101,7 +105,7 @@ module Workato
                 'Action' => 'AssumeRole',
                 'RoleSessionName' => 'workato',
                 'RoleArn' => settings[:aws_assume_role],
-                'ExternalId' => settings[:aws_external_id].presence
+                'ExternalId' => aws_external_id.presence
               }.compact
 
               sts_auth_url, sts_auth_headers = create_signature(
@@ -116,24 +120,14 @@ module Workato
                 }
               )
 
-              request_temp_credentials(url: sts_auth_url, headers: sts_auth_headers).tap do |temp_credentials|
-                update_settings(settings, temp_credentials)
-              end
+              request_temp_credentials(url: sts_auth_url, headers: sts_auth_headers)
             rescue StandardError => e
-              raise e if settings[:aws_external_id].blank?
+              raise e if aws_external_id.blank?
 
-              settings[:aws_external_id] = nil
+              aws_external_id = nil
               retry
             end
 
-            def update_settings(settings, temp_credentials)
-              settings.merge!(temp_credentials: temp_credentials)
-              Workato::Connector::Sdk::Operation.on_settings_updated&.call(
-                'Refresh AWS temporary credentials',
-                settings
-              )
-            end
-
             def request_temp_credentials(url:, headers:)
               response = RestClient::Request.execute(
                 url: url,
@@ -213,13 +207,15 @@ module Workato
             end
 
             def amazon_role_client_key(settings)
-              settings[:access_key_id] || AMAZON_ROLE_CLIENT_KEY
+              settings[:access_key_id] || @connection.settings[:access_key_id] || AMAZON_ROLE_CLIENT_KEY
             end
 
             def amazon_role_client_secret(settings)
-              settings[:secret_access_key] || AMAZON_ROLE_CLIENT_SECRET
+              settings[:secret_access_key] || @connection.settings[:access_key_id] || AMAZON_ROLE_CLIENT_SECRET
             end
           end
+
+          private_constant :Private
         end
       end
     end

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

@@ -1,3 +1,4 @@
+# typed: false
 # frozen_string_literal: true
 
 module Workato

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

@@ -1,3 +1,4 @@
+# typed: false
 # frozen_string_literal: true
 
 module Workato

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

@@ -1,3 +1,4 @@
+# typed: false
 # frozen_string_literal: true
 
 module Workato
@@ -64,13 +65,7 @@ module Workato
           private
 
           def http_request(url, method:)
-            Request.new(
-              url,
-              method: method,
-              connection: connection,
-              settings: settings,
-              action: self
-            )
+            Request.new(url, method: method, connection: connection, action: self)
           end
         end
       end

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

@@ -1,3 +1,4 @@
+# typed: false
 # frozen_string_literal: true
 
 module Workato

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

@@ -1,3 +1,4 @@
+# typed: true
 # frozen_string_literal: true
 
 module Workato
@@ -19,6 +20,11 @@ module Workato
 end
 
 begin
+  if ENV['TZ'].present? && ENV['TZ'] != 'UTC'
+    warn "WARNING: TZ environment variable is set to '#{ENV['TZ']}'. Set TZ=UTC for consistency with Workato platform'"
+  else
+    ENV['TZ'] = 'UTC'
+  end
   ::Time.zone = Workato::Connector::Sdk::DEFAULT_TIME_ZONE
 rescue TZInfo::DataSourceNotFound
   puts ''

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

@@ -1,3 +1,4 @@
+# typed: true
 # frozen_string_literal: true
 
 require 'jwt'
@@ -20,6 +21,43 @@ module Workato
             WorkatoCodeLib.parse_json(source)
           end
 
+          def uuid
+            WorkatoCodeLib.uuid
+          end
+
+          def encrypt(text, key)
+            ::Kernel.require('ruby_rncryptor')
+
+            enc_text = ::RubyRNCryptor.encrypt(text, key)
+            ::Base64.strict_encode64(enc_text)
+          end
+
+          def decrypt(text, key)
+            ::Kernel.require('ruby_rncryptor')
+
+            text = ::Base64.decode64(text)
+            dec_text = ::RubyRNCryptor.decrypt(text, key)
+            Workato::Extension::Binary.new(dec_text)
+          rescue Exception => e # rubocop:disable Lint/RescueException
+            message = e.message.to_s
+            case message
+            when /Password may be incorrect/
+              ::Kernel.raise 'invalid/corrupt input or key'
+            when /RubyRNCryptor only decrypts version/
+              ::Kernel.raise 'invalid/corrupt input'
+            else
+              ::Kernel.raise
+            end
+          end
+
+          def blank; end
+
+          def clear; end
+
+          def null; end
+
+          def skip; end
+
           class << self
             def jwt_encode_rs256(payload, key, header_fields = {})
               jwt_encode(payload, key, 'RS256', header_fields)

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

@@ -1,3 +1,4 @@
+# typed: true
 # frozen_string_literal: true
 
 module Workato