connector.rb in workato-connector-sdk-1.3.6

- old
+ new

@@ -1,61 +1,77 @@
 # typed: strict
 # frozen_string_literal: true
 
-using Workato::Extension::HashWithIndifferentAccess
-
 module Workato
   module Connector
     module Sdk
       module SorbetTypes
-        SourceHash = T.type_alias { T.any(HashWithIndifferentAccess, T::Hash[T.any(Symbol, String), T.untyped]) }
+        SourceHash = T.type_alias do
+          T.any(ActiveSupport::HashWithIndifferentAccess, T::Hash[T.any(Symbol, String), T.untyped])
+        end
       end
 
       class Connector
         extend T::Sig
 
         # @api private
-        sig { returns(HashWithIndifferentAccess) }
+        sig { returns(ActiveSupport::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 = T.let(HashWithIndifferentAccess.wrap(definition), HashWithIndifferentAccess)
-          @settings = T.let(HashWithIndifferentAccess.wrap(settings), HashWithIndifferentAccess)
-          @connection_source = T.let(HashWithIndifferentAccess.wrap(@source[:connection]), HashWithIndifferentAccess)
-          @methods_source = T.let(HashWithIndifferentAccess.wrap(@source[:methods]), HashWithIndifferentAccess)
+          @source = T.let(
+            Utilities::HashWithIndifferentAccess.wrap(definition),
+            ActiveSupport::HashWithIndifferentAccess
+          )
+          @settings = T.let(
+            Utilities::HashWithIndifferentAccess.wrap(settings),
+            ActiveSupport::HashWithIndifferentAccess
+          )
+          @connection_source = T.let(
+            Utilities::HashWithIndifferentAccess.wrap(@source[:connection]),
+            ActiveSupport::HashWithIndifferentAccess
+          )
+          @methods_source = T.let(
+            Utilities::HashWithIndifferentAccess.wrap(@source[:methods]),
+            ActiveSupport::HashWithIndifferentAccess
+          )
         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,
-            streams: streams
+          @actions ||= T.let(
+            ActionsProxy.new(
+              actions: source[:actions].presence || {},
+              methods: methods_source,
+              object_definitions: object_definitions,
+              connection: connection,
+              streams: streams
+            ),
+            T.nilable(ActionsProxy)
           )
         end
 
         sig { returns(MethodsProxy) }
         def methods
-          @methods = T.let(@methods, T.nilable(MethodsProxy))
-          @methods ||= MethodsProxy.new(
-            methods: methods_source,
-            connection: connection,
-            streams: streams
+          @methods ||= T.let(
+            MethodsProxy.new(
+              methods: methods_source,
+              connection: connection,
+              streams: streams
+            ),
+            T.nilable(MethodsProxy)
           )
         end
 
         sig { params(settings: T.nilable(SorbetTypes::SettingsHash)).returns(T.untyped) }
         def test(settings = nil)
@@ -70,82 +86,92 @@
           @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,
-            streams: streams
+          @triggers ||= T.let(
+            TriggersProxy.new(
+              triggers: source[:triggers].presence || {},
+              methods: methods_source,
+              connection: connection,
+              object_definitions: object_definitions,
+              streams: streams
+            ),
+            T.nilable(TriggersProxy)
           )
         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
+          @object_definitions ||= T.let(
+            ObjectDefinitions.new(
+              object_definitions: source[:object_definitions].presence || {},
+              methods: methods_source,
+              connection: connection
+            ),
+            T.nilable(ObjectDefinitions)
           )
         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
+          @pick_lists ||= T.let(
+            PickListsProxy.new(
+              pick_lists: source[:pick_lists].presence || {},
+              methods: methods_source,
+              connection: connection
+            ),
+            T.nilable(PickListsProxy)
           )
         end
 
         sig { returns(Connection) }
         def connection
-          @connection = T.let(@connection, T.nilable(Connection))
-          @connection ||= Connection.new(
-            methods: methods_source,
-            connection: connection_source,
-            settings: settings
+          @connection ||= T.let(
+            Connection.new(
+              methods: methods_source,
+              connection: connection_source,
+              settings: settings
+            ),
+            T.nilable(Connection)
           )
         end
 
         sig { returns(Streams) }
         def streams
-          @streams = T.let(@streams, T.nilable(Streams))
-          @streams ||= Streams.new(
-            streams: streams_sources,
-            methods: methods_source,
-            connection: connection
+          @streams ||= T.let(
+            Streams.new(
+              streams: streams_sources,
+              methods: methods_source,
+              connection: connection
+            ),
+            T.nilable(Streams)
           )
         end
 
         private
 
-        sig { returns(HashWithIndifferentAccess) }
+        sig { returns(ActiveSupport::HashWithIndifferentAccess) }
         def streams_sources
-          @streams_sources = T.let(@streams_sources, T.nilable(HashWithIndifferentAccess))
+          @streams_sources = T.let(@streams_sources, T.nilable(ActiveSupport::HashWithIndifferentAccess))
           return @streams_sources if @streams_sources
 
-          @streams_sources = HashWithIndifferentAccess.new
+          @streams_sources = ActiveSupport::HashWithIndifferentAccess.new
           @streams_sources.merge!(source[:streams].presence || {})
           (source[:actions] || {}).values.map do |action|
             @streams_sources.merge!(action[:streams] || {})
           end
           (source[:trigger] || {}).values.map do |trigger|
             @streams_sources.merge!(trigger[:streams] || {})
           end
           @streams_sources
         end
 
-        sig { returns(HashWithIndifferentAccess) }
+        sig { returns(ActiveSupport::HashWithIndifferentAccess) }
         attr_reader :methods_source
 
-        sig { returns(HashWithIndifferentAccess) }
+        sig { returns(ActiveSupport::HashWithIndifferentAccess) }
         attr_reader :connection_source
 
         sig { returns(SorbetTypes::SettingsHash) }
         attr_reader :settings
       end
@@ -153,13 +179,13 @@
       class ActionsProxy
         extend T::Sig
 
         sig do
           params(
-            actions: HashWithIndifferentAccess,
+            actions: ActiveSupport::HashWithIndifferentAccess,
             object_definitions: ObjectDefinitions,
-            methods: HashWithIndifferentAccess,
+            methods: ActiveSupport::HashWithIndifferentAccess,
             connection: Connection,
             streams: Streams
           ).void
         end
         def initialize(actions:, object_definitions:, methods:, connection:, streams:)
@@ -176,11 +202,11 @@
           public_send(action)
         end
 
         private
 
-        sig { returns(HashWithIndifferentAccess) }
+        sig { returns(ActiveSupport::HashWithIndifferentAccess) }
         attr_reader :methods
 
         sig { returns(Connection) }
         attr_reader :connection
 
@@ -188,11 +214,11 @@
         attr_reader :streams
 
         sig { returns(ObjectDefinitions) }
         attr_reader :object_definitions
 
-        sig { params(actions_source: HashWithIndifferentAccess).void }
+        sig { params(actions_source: ActiveSupport::HashWithIndifferentAccess).void }
         def define_action_methods(actions_source)
           actions_source.each do |action, definition|
             define_singleton_method(action) do |input_ = nil|
               @actions[action] ||= Action.new(
                 action: definition,
@@ -214,11 +240,11 @@
       class MethodsProxy
         extend T::Sig
 
         sig do
           params(
-            methods: HashWithIndifferentAccess,
+            methods: ActiveSupport::HashWithIndifferentAccess,
             connection: Connection,
             streams: Streams
           ).void
         end
         def initialize(methods:, connection:, streams:)
@@ -229,11 +255,11 @@
           define_action_methods
         end
 
         private
 
-        sig { returns(HashWithIndifferentAccess) }
+        sig { returns(ActiveSupport::HashWithIndifferentAccess) }
         attr_reader :methods
 
         sig { returns(Connection) }
         attr_reader :connection
 
@@ -263,12 +289,12 @@
       class PickListsProxy
         extend T::Sig
 
         sig do
           params(
-            pick_lists: HashWithIndifferentAccess,
-            methods: HashWithIndifferentAccess,
+            pick_lists: ActiveSupport::HashWithIndifferentAccess,
+            methods: ActiveSupport::HashWithIndifferentAccess,
             connection: Connection
           ).void
         end
         def initialize(pick_lists:, methods:, connection:)
           @methods = methods
@@ -277,17 +303,17 @@
           define_action_methods(pick_lists)
         end
 
         private
 
-        sig { returns(HashWithIndifferentAccess) }
+        sig { returns(ActiveSupport::HashWithIndifferentAccess) }
         attr_reader :methods
 
         sig { returns(Connection) }
         attr_reader :connection
 
-        sig { params(pick_lists_source: HashWithIndifferentAccess).void }
+        sig { params(pick_lists_source: ActiveSupport::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[pick_list] ||= Action.new(
                 action: {
@@ -316,13 +342,13 @@
       class TriggersProxy
         extend T::Sig
 
         sig do
           params(
-            triggers: HashWithIndifferentAccess,
+            triggers: ActiveSupport::HashWithIndifferentAccess,
             object_definitions: ObjectDefinitions,
-            methods: HashWithIndifferentAccess,
+            methods: ActiveSupport::HashWithIndifferentAccess,
             connection: Connection,
             streams: Streams
           ).void
         end
         def initialize(triggers:, object_definitions:, methods:, connection:, streams:)
@@ -339,11 +365,11 @@
           public_send(trigger)
         end
 
         private
 
-        sig { returns(HashWithIndifferentAccess) }
+        sig { returns(ActiveSupport::HashWithIndifferentAccess) }
         attr_reader :methods
 
         sig { returns(Connection) }
         attr_reader :connection
 
@@ -351,10 +377,10 @@
         attr_reader :streams
 
         sig { returns(ObjectDefinitions) }
         attr_reader :object_definitions
 
-        sig { params(triggers_source: HashWithIndifferentAccess).void }
+        sig { params(triggers_source: ActiveSupport::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,