Class: Workato::Connector::Sdk::Operation

Inherits:
Object
  • Object
show all
Extended by:
T::Sig
Includes:
Dsl::AWS, Dsl::Call, Dsl::Error, Dsl::ExecutionContext, Dsl::Global, Dsl::HTTP
Defined in:
lib/workato/connector/sdk/operation.rb

Direct Known Subclasses

Action, Stream, Trigger

Instance Attribute Summary collapse

Instance Method Summary collapse

Methods included from Dsl::ExecutionContext

#execution_context, #recipe_id!

Methods included from Dsl::Error

#error

Methods included from Dsl::HTTP

#copy, #delete, #get, #head, #move, #options, #parallel, #patch, #post, #put

Methods included from Dsl::AWS

#aws

Methods included from Dsl::Global

#blank, #clear, #decrypt, #encrypt, #null, #puts, #skip, #sleep, #workato

Methods included from Dsl::WorkatoSchema

#workato_schema

Methods included from Dsl::LookupTable

#lookup

Methods included from Dsl::AccountProperty

#account_property

Methods included from Dsl::Time

#now, #today

Constructor Details

#initialize(operation: {}, methods: {}, connection: Connection.new, streams: ProhibitedStreams.new, object_definitions: nil) ⇒ void

Parameters:



65
66
67
68
69
70
71
72
73
74
75
76
77
78
 
# File 'lib/workato/connector/sdk/operation.rb', line 65

def initialize(operation: {}, methods: {}, connection: Connection.new, streams: ProhibitedStreams.new,
               object_definitions: nil)
  @operation = T.let(
    Utilities::HashWithIndifferentAccess.wrap(operation),
    ActiveSupport::HashWithIndifferentAccess
  )
  @_methods = T.let(
    Utilities::HashWithIndifferentAccess.wrap(methods),
    ActiveSupport::HashWithIndifferentAccess
  )
  @connection = T.let(connection, Connection)
  @streams = T.let(streams, Streams)
  @object_definitions = T.let(object_definitions, T.nilable(ObjectDefinitions))
end

Instance Attribute Details

#streams ⇒ Streams (readonly)

Returns:



54
55
56
 
# File 'lib/workato/connector/sdk/operation.rb', line 54

def streams
  @streams
end

Instance Method Details

#execute(settings = nil, input = {}, extended_input_schema = [], extended_output_schema = [], continue = {}, &block) ⇒ T.untyped

Parameters:

Returns:

  • (T.untyped) 


92
93
94
95
96
97
98
99
100
101
102
103
104
105
 
# File 'lib/workato/connector/sdk/operation.rb', line 92

def execute(settings = nil, input = {}, extended_input_schema = [], extended_output_schema = [], continue = {},
            &block)
  connection.merge_settings!(settings) if settings
  request_or_result = T.unsafe(self).instance_exec(
    connection.settings,
    Utilities::HashWithIndifferentAccess.wrap(input),
    Array.wrap(extended_input_schema).map { |i| Utilities::HashWithIndifferentAccess.wrap(i) },
    Array.wrap(extended_output_schema).map { |i| Utilities::HashWithIndifferentAccess.wrap(i) },
    Utilities::HashWithIndifferentAccess.wrap(continue),
    &block
  )
  result = resolve_request(request_or_result)
  try_convert_to_hash_with_indifferent_access(result)
end

#extended_schema(settings = nil, config_fields = {}) ⇒ ActiveSupport::HashWithIndifferentAccess

Parameters:

Returns:

  • (ActiveSupport::HashWithIndifferentAccess) 


115
116
117
118
119
120
121
122
123
 
# File 'lib/workato/connector/sdk/operation.rb', line 115

def extended_schema(settings = nil, config_fields = {})
  object_definitions_hash = object_definitions.lazy(settings, config_fields)
  {
    input: Array.wrap(
      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

#input_fields(settings = nil, config_fields = {}) ⇒ SorbetTypes::OperationSchema

Parameters:

Returns:



133
134
135
136
 
# File 'lib/workato/connector/sdk/operation.rb', line 133

def input_fields(settings = nil, config_fields = {})
  object_definitions_hash = object_definitions.lazy(settings, config_fields)
  Array.wrap(schema_fields(object_definitions_hash, settings, config_fields, &operation[:input_fields]))
end

#output_fields(settings = nil, config_fields = {}) ⇒ SorbetTypes::OperationSchema?

Parameters:

Returns:



146
147
148
149
150
151
152
 
# File 'lib/workato/connector/sdk/operation.rb', line 146

def output_fields(settings = nil, config_fields = {})
  object_definitions_hash = object_definitions.lazy(settings, config_fields)
  T.cast(
    schema_fields(object_definitions_hash, settings, config_fields, &operation[:output_fields]),
    T.nilable(SorbetTypes::OperationSchema)
  )
end

#sample_output(settings = nil, input = {}) ⇒ T.untyped

Parameters:

Returns:

  • (T.untyped) 


172
173
174
 
# File 'lib/workato/connector/sdk/operation.rb', line 172

def sample_output(settings = nil, input = {})
  execute(settings, input, &operation[:sample_output])
end

#summarize_input(input = {}) ⇒ T.untyped

Parameters:

Returns:

  • (T.untyped) 


155
156
157
 
# File 'lib/workato/connector/sdk/operation.rb', line 155

def summarize_input(input = {})
  summarize(input, operation[:summarize_input])
end

#summarize_output(output = {}) ⇒ T.untyped

Parameters:

Returns:

  • (T.untyped) 


160
161
162
 
# File 'lib/workato/connector/sdk/operation.rb', line 160

def summarize_output(output = {})
  summarize(output, operation[:summarize_output])
end