Workato Connector SDK

https://github.com/workato/workato-connector-sdk
Admin
A Ruby gem for building and testing connectors for the Workato integration platform with support for...
Tokens:66,525
Snippets:715
Trust Score:8.3
License:MIT
Update:2 months ago
Show doc for...
Tokens:
Raw
### Create Connection with OAuth2 Example

Source: https://github.com/workato/workato-connector-sdk/blob/master/_autodocs/api-reference/connection.md

Example demonstrating how to create a Connection instance with OAuth2 authorization and custom settings.

```ruby
connection_def = {
  base_uri: ->(settings) { settings[:api_url] },
  authorization: {
    type: 'oauth2',
    client_id: 'xxx',
    client_secret: 'yyy',
    token_url: -> { 'https://api.example.com/oauth/token' }
  }
}

settings = {
  api_url: 'https://api.example.com',
  access_token: 'token123'
}

connection = Workato::Connector::Sdk::Connection.new(
  connection: connection_def,
  settings: settings
)
```

--------------------------------

### Dynamic Base URI Configuration Example

Source: https://github.com/workato/workato-connector-sdk/blob/master/_autodocs/api-reference/connection.md

Example showing how to define a base URI dynamically based on settings, such as an environment variable.

```ruby
connection_def = {
  base_uri: ->(settings) do
    if settings[:environment] == 'sandbox'
      'https://sandbox.api.example.com'
    else
      'https://api.example.com'
    end
  end
}

connection = Workato::Connector::Sdk::Connection.new(
  connection: connection_def,
  settings: { environment: 'production' }
)

uri = connection.base_uri
# => 'https://api.example.com'
```

--------------------------------

### Structure Examples for RefreshOutput

Source: https://github.com/workato/workato-connector-sdk/blob/master/_autodocs/types.md

Provides examples of the different formats for the RefreshOutput type, showing variations with and without settings.

```ruby
# Format 1: [tokens, settings]
[
  { access_token: 'new_token123', expires_in: 3600 },
  { expiration_time: Time.now + 1.hour }
]

# Format 2: [tokens]
[{ access_token: 'new_token123' }]

# Format 3: tokens hash
{ access_token: 'new_token123', expires_at: '2024-12-31T00:00:00Z' }
```

--------------------------------

### Update Connection Settings Example

Source: https://github.com/workato/workato-connector-sdk/blob/master/_autodocs/api-reference/connection.md

Example of merging new settings, such as an updated access token and expiry time, into the connection.

```ruby
connection.merge_settings!({
  access_token: 'new_token_123',
  expires_at: Time.now + 1.hour
})
```

--------------------------------

### Perform GET Request with Parameters

Source: https://github.com/workato/workato-connector-sdk/blob/master/_autodocs/api-reference/dsl.md

Example of making a GET request to retrieve a list of users, including query parameters for filtering and limiting results. Uses `.response_format_json.response!` to get the formatted response body.

```ruby
# GET with params
response = get(
  "#{connection[:api_url]}/users",
  name: "John",
  limit: 100
).response_format_json.response!
```

--------------------------------

### HTTP Method DSL Examples

Source: https://github.com/workato/workato-connector-sdk/blob/master/_autodocs/api-reference/request.md

Convenience methods for common HTTP operations like GET, POST, PUT, PATCH, DELETE, HEAD, and OPTIONS. All these methods return Request objects.

```ruby
# GET request
get(url, params)

# POST request
post(url, payload)

# PUT request
put(url, payload)

# PATCH request
patch(url, payload)

# DELETE request
delete(url, payload)

# HEAD request
head(url, params)

# OPTIONS request
options(url, params)
```

```ruby
# All return Request objects
get('https://api.example.com/users').response_format_json
post('https://api.example.com/users', { name: 'John' }).format_json
put('https://api.example.com/users/123', { name: 'Jane' }).format_json
delete('https://api.example.com/users/123').format_json
```

--------------------------------

### Example Usage of SettingsHash

Source: https://github.com/workato/workato-connector-sdk/blob/master/_autodocs/types.md

Demonstrates how to define and use a settings hash for connector operations.

```ruby
settings = {
  api_key: 'key123',
  api_url: 'https://api.example.com',
  access_token: 'token456'
}

connector.test(settings)
```

--------------------------------

### Structure Examples for AcquireOutput

Source: https://github.com/workato/workato-connector-sdk/blob/master/_autodocs/types.md

Illustrates the different structural formats for the AcquireOutput type, including variations for OAuth2 and custom authentication.

```ruby
# Format 1: [tokens, resource_owner_id, settings]
[
  { access_token: 'token123', refresh_token: 'refresh456', expires_in: 3600 },
  'user_789',
  { updated_field: 'value' }
]

# Format 2: [tokens, resource_owner_id]
[
  { access_token: 'token123', refresh_token: 'refresh456' },
  'user_789'
]

# Format 3: [tokens]
[{ access_token: 'token123' }]

# Format 4: tokens hash (custom auth)
{ access_token: 'token123', access_key: 'key123' }
```

--------------------------------

### Install Workato Connector SDK Gem

Source: https://github.com/workato/workato-connector-sdk/blob/master/README.md

Install the latest version of the Workato Connector SDK gem from rubygems.org.

```bash
gem install workato-connector-sdk
```

--------------------------------

### Get Workato Connector SDK Gem Location

Source: https://github.com/workato/workato-connector-sdk/blob/master/README.md

Find the exact installation path of the Workato Connector SDK gem on your system.

```bash
gem which workato-connector-sdk
```

--------------------------------

### PollOutputHash Example

Source: https://github.com/workato/workato-connector-sdk/blob/master/_autodocs/types.md

Provides an example of the expected return value from a poll block, demonstrating the structure with sample events, next poll state, and a flag for further polling.

```ruby
{
  'events' => [
    { id: 'evt_1', name: 'Event 1' },
    { id: 'evt_2', name: 'Event 2' }
  ],
  'next_poll' => 'evt_2',
  'can_poll_more' => false
}
```

--------------------------------

### Perform POST Request with Payload

Source: https://github.com/workato/workato-connector-sdk/blob/master/_autodocs/api-reference/dsl.md

Example of making a POST request to create a new user, sending a JSON payload in the request body. Uses `.format_json.response!` to send JSON and get the response body.

```ruby
# POST with payload
result = post(
  "#{connection[:api_url]}/users",
  { name: "Jane", email: "jane@example.com" }
).format_json.response!
```

--------------------------------

### Sample Method Arguments Input

Source: https://github.com/workato/workato-connector-sdk/blob/master/README.md

Example JSON structure for providing arguments to the 'sample_method'. The array indices correspond to the method's arguments.

```json
[
    "hello",
    "world"
]

```

--------------------------------

### Get help for a specific Workato CLI command

Source: https://github.com/workato/workato-connector-sdk/blob/master/README.md

To get detailed information about a specific command, use 'workato help [command]'. This provides usage, options, and descriptions for the specified command.

```bash
workato help [command]

[ Help for specific Workato gem command ]
```

--------------------------------

### Test Connection with Settings

Source: https://github.com/workato/workato-connector-sdk/blob/master/_autodocs/api-reference/connector.md

Example of testing a connection with specific API key and URL settings. This demonstrates how to pass overrides to the test method.

```ruby
result = connector.test({
  api_key: 'test_key',
  api_url: 'https://test.example.com'
})

puts result  # => { status: 'ok' } or error
```

--------------------------------

### Instantiate an Action

Source: https://github.com/workato/workato-connector-sdk/blob/master/README.md

Get a specific action from the connector, such as `copy_asset`, for testing purposes.

```ruby
let(:action) { connector.actions.copy_asset }
```

--------------------------------

### Conditional Authorization Handling

Source: https://github.com/workato/workato-connector-sdk/blob/master/_autodocs/api-reference/connection.md

Example showing how to check for authorization and proceed with OAuth flow if it's defined.

```ruby
if connection.authorization?
  # Handle OAuth flow
  auth = connection.authorization
end
```

--------------------------------

### Example .gitignore for Workato Connector Project

Source: https://github.com/workato/workato-connector-sdk/blob/master/README.md

A sample .gitignore file to exclude sensitive files and build artifacts from version control. Includes master.key for encrypted settings.

```gitignore
/.bundle/
/.yardoc
/_yardoc/
/coverage/
/doc/
/pkg/
/spec/reports/
/tmp/
master.key

# rspec failure tracking
.rspec_status
```

--------------------------------

### Plain Text Settings File Format

Source: https://github.com/workato/workato-connector-sdk/blob/master/_autodocs/api-reference/settings.md

Example of a plain text YAML file for storing connector settings. Supports simple key-value pairs or multi-environment configurations.

```yaml
# Simple settings (all environments)
api_key: sk_test_123456
api_url: https://api.example.com
username: admin@example.com
webhook_url: https://hooks.example.com

# Or multi-environment:
development:
  api_key: sk_dev_789
  api_url: https://dev.api.example.com
  username: dev@example.com

staging:
  api_key: sk_staging_456
  api_url: https://staging.api.example.com
  username: staging@example.com

production:
  api_key: sk_prod_123
  api_url: https://api.example.com
  username: admin@example.com
```

--------------------------------

### Account Properties File Format

Source: https://github.com/workato/workato-connector-sdk/blob/master/_autodocs/api-reference/account-properties.md

Example YAML file format for storing account properties, showing key-value pairs for different accounts.

```yaml
account_123:
  organization_id: 'org_abc'
  sync_mode: 'realtime'
  webhook_secret: 'secret_key_xyz'

account_456:
  organization_id: 'org_def'
  sync_mode: 'scheduled'
```

--------------------------------

### Workato New Connector File Generation Example

Source: https://github.com/workato/workato-connector-sdk/blob/master/README.md

Illustrates the typical file structure created by the 'workato new' command, including Gemfile, connector.rb, and .rspec.

```bash
      create  
      create  Gemfile
      create  connector.rb
      create  .rspec
```

--------------------------------

### OAuth 2.0 Setup with Token Acquisition and Refresh

Source: https://github.com/workato/workato-connector-sdk/blob/master/_autodocs/README.md

Provides a comprehensive configuration for OAuth 2.0, including client details, URLs, and custom logic for acquiring and refreshing tokens, along with detection and refresh conditions.

```ruby
{
  connection: {
    authorization: {
      type: 'oauth2',
      client_id: 'from_env',
      client_secret: 'from_env',
      authorization_url: -> { 'https://auth.example.com/oauth/authorize' },
      token_url: -> { 'https://auth.example.com/oauth/token' },
      
      acquire: ->(code, redirect_url, pkce_verifier, query_params) do
        response = post('https://auth.example.com/oauth/token', {
          grant_type: 'authorization_code',
          code: code,
          client_id: client_id,
          client_secret: client_secret,
          redirect_uri: redirect_url
        }).format_json.response!
        
        [response]  # Return tokens
      end,
      
      refresh: ->(refresh_token) do
        response = post('https://auth.example.com/oauth/token', {
          grant_type: 'refresh_token',
          refresh_token: refresh_token,
          client_id: client_id,
          client_secret: client_secret
        }).format_json.response!
        
        [response]
      end,
      
      detect_on: [401, /Unauthorized/],
      refresh_on: [401]
    }
  }
}
```

--------------------------------

### Stream Data in Chunks

Source: https://github.com/workato/workato-connector-sdk/blob/master/_autodocs/api-reference/connector.md

Example of streaming data in chunks, specifically downloading a file in 1MB chunks. This demonstrates efficient handling of large data transfers.

```ruby
# Stream data in chunks of 1MB
Stream.each_chunk(stream: connector.streams.download_file({ id: 'file_id' }),
                  from: 0,
                  frame_size: 1.megabyte) do |chunk, from, to, eof, next_from|
  # Process chunk of data
end
```

--------------------------------

### Log Processing Information

Source: https://github.com/workato/workato-connector-sdk/blob/master/_autodocs/api-reference/dsl.md

Example of using the `puts` function to log information about the current processing step, such as the user's name.

```ruby
puts "Processing user: #{input[:name]}"
```

--------------------------------

### Example of MissingRequiredInput Usage

Source: https://github.com/workato/workato-connector-sdk/blob/master/_autodocs/errors.md

Illustrates how to catch a MissingRequiredInput error when applying a schema with `enforce_required: true` and a required field is absent. The example shows how to print the error message.

```ruby
begin
  schema.apply(input, enforce_required: true)
rescue Workato::Connector::Sdk::MissingRequiredInput => e
  puts e.message  # => "'email' must be present"
end
```

--------------------------------

### Verify Ruby Version

Source: https://github.com/workato/workato-connector-sdk/blob/master/README.md

Check if a compatible Ruby version is installed on your system.

```bash
ruby -v
Output:
ruby 2.7.X
```

--------------------------------

### Get Blank String

Source: https://github.com/workato/workato-connector-sdk/blob/master/_autodocs/api-reference/index.md

Return an empty string.

```ruby
blank
```

--------------------------------

### Examples for WebhookSubscribeOutput

Source: https://github.com/workato/workato-connector-sdk/blob/master/_autodocs/types.md

Illustrates the two possible return formats for the WebhookSubscribeOutput type: a simple closure hash and a closure hash with an expiration time.

```ruby
# Simple subscription closure
{ webhook_id: 'wh_123' }

# With expiration time
[
  { webhook_id: 'wh_123' },
  Time.now + 24.hours
]
```

--------------------------------

### Define Select Field with Options

Source: https://github.com/workato/workato-connector-sdk/blob/master/_autodocs/api-reference/account-properties.md

Example of defining a select field for account properties, allowing users to choose from a predefined list of options.

```ruby
# Select field with options
{
  environment: {
    label: 'Environment',
    control_type: 'select',
    pick_list: [
      { label: 'Development', value: 'dev' },
      { label: 'Production', value: 'prod' }
    ],
    default: 'dev'
  }
}
```

--------------------------------

### Conditional Flow Control Example

Source: https://github.com/workato/workato-connector-sdk/blob/master/_autodocs/api-reference/dsl.md

Illustrates how to use `skip` to bypass processing for a record if a condition is met, and `blank` to return an empty string if another condition is met.

```ruby
execute: ->(connection, input) do
  if input[:skip_processing]
    return skip  # Skip this record
  end
  
  if input[:name].blank?
    return blank  # Return empty string
  end
end
```

--------------------------------

### Example Workato Connector RSpec Test Suite

Source: https://github.com/workato/workato-connector-sdk/blob/master/README.md

A sample connector_spec.rb file demonstrating how to instantiate a connector and define tests for connection and response validation. It includes tests for both valid and invalid credentials.

```ruby
# frozen_string_literal: true

RSpec.describe 'connector', :vcr do
  let(:connector) { Workato::Connector::Sdk::Connector.from_file('connector.rb', settings) }
  let(:settings) { Workato::Connector::Sdk::Settings.from_default_file }

  it { expect(connector).to be_present }

  describe 'test' do
    subject(:output) { connector.test(settings) }

    context 'given valid credentials' do
      it 'establishes valid connection' do
        expect(output).to be_truthy
      end

      it 'returns response that is not excessively large' do
        # large Test responses might also cause connections to be evaluated wrongly
        expect(output.to_s.length).to be < 5000
      end
    end

    context 'given invalid credentials' do
      let(:settings) { Workato::Connector::Sdk::Settings.from_encrypted_file('invalid_settings.yaml.enc'}

      it 'establishes invalid connection' do
        expect { output }
          .to raise_error('500 Internal Server Error')
      end
    end
  end
end
```

--------------------------------

### Initialize New Connector Project

Source: https://github.com/workato/workato-connector-sdk/blob/master/_autodocs/configuration.md

Use the 'workato new' command to create a new connector project with a standard directory structure and essential files.

```bash
workato new my-connector

# Creates:
# my-connector/
#   .github/
#   .gitignore
#   .rspec
#   Gemfile
#   README.md
#   connector.rb
#   master.key
#   spec/
#     connector_spec.rb
#     spec_helper.rb
```

--------------------------------

### Get Single Stream Chunk

Source: https://github.com/workato/workato-connector-sdk/blob/master/_autodocs/api-reference/index.md

The `chunk` instance method retrieves a single chunk of data from a stream. Specify the input, start, end, and frame size.

```ruby
stream.chunk(input, from, to, frame_size)
```

--------------------------------

### Display all Workato CLI commands

Source: https://github.com/workato/workato-connector-sdk/blob/master/README.md

Use 'workato help' to list all available commands and their brief descriptions. This is the entry point for understanding the CLI's capabilities.

```bash
workato help

Commands:
  workato edit <PATH>            # Edit encrypted file, e.g. settings.yaml.enc
  workato exec <PATH>            # Execute connector defined block
  workato generate <SUBCOMMAND>  # Generates code from template
  workato help [COMMAND]         # Describe available commands or one specific command
  workato new <CONNECTOR_PATH>   # Inits new connector folder
  workato oauth2                 # Implements OAuth Authorization Code flow
  workato push                   # Upload and release connector's code

Options:
  [--verbose], [--no-verbose]  
```

--------------------------------

### Initialize Connection Instance

Source: https://github.com/workato/workato-connector-sdk/blob/master/_autodocs/api-reference/connection.md

Use this to create a new Connection instance. It requires connection definition, custom methods, and settings.

```ruby
def initialize(connection: {}, methods: {}, settings: {})
end
```

--------------------------------

### Workato::Connector::Sdk::Settings Class and Instance Methods

Source: https://github.com/workato/workato-connector-sdk/blob/master/_autodocs/api-reference/index.md

Methods for managing credential and configuration files.

```APIDOC
## Workato::Connector::Sdk::Settings

### Description
Manages credential and configuration file loading and updating.

### Class Methods

- `from_file(path, name)` — Load plain-text settings from a file.
- `from_encrypted_file(path, key_path, name)` — Load encrypted settings from a file.
- `from_default_file(name)` — Auto-detect and load settings from a default file.

### Instance Methods

- `read` — Load settings from the configured file.
- `update(new_settings)` — Save updated settings to the file.
```

--------------------------------

### HTTP GET Request

Source: https://github.com/workato/workato-connector-sdk/blob/master/_autodocs/api-reference/index.md

Build and execute an HTTP GET request with specified URL and parameters.

```ruby
get(url, params)
```

--------------------------------

### Manage OAuth Properties and Refresh Token

Source: https://github.com/workato/workato-connector-sdk/blob/master/_autodocs/api-reference/connection.md

Example of accessing OAuth properties like client ID and token URL, and refreshing the access token using the Authorization object.

```ruby
auth = connection.authorization

# Access OAuth properties
client_id = auth.client_id
client_secret = auth.client_secret
authorization_url = auth.authorization_url
token_url = auth.token_url

# Refresh OAuth token
new_settings = auth.refresh!(settings)
```

--------------------------------

### Instantiate Settings from Default File

Source: https://github.com/workato/workato-connector-sdk/blob/master/README.md

Use `from_default_file` to load settings from `settings.yaml.enc` or `settings.yaml`. This is the standard way to load settings.

```ruby
let(:settings) { Workato::Connector::Sdk::Settings.from_default_file }
```

--------------------------------

### HTTP GET Request with Parameters

Source: https://github.com/workato/workato-connector-sdk/blob/master/_autodocs/README.md

Performs an HTTP GET request with query parameters and specifies JSON response format.

```ruby
response = get('https://api.example.com/users')
  .params({ limit: 100 })
  .response_format_json
  .response!
```

--------------------------------

### Workato New Connector Command Usage

Source: https://github.com/workato/workato-connector-sdk/blob/master/README.md

Details the 'workato new' command for creating a new Workato connector with a default directory structure. Includes an example of specifying the connector path.

```bash
workato help new

Usage:
  workato new <CONNECTOR_PATH>

Options:
  [--verbose], [--no-verbose]

Description:
  The 'workato new' command creates a new Workato connector with a default directory structure and configuration at the path you specify.

  Example: workato new ~/dev/workato/random

  This generates a skeletal custom connector in ~/dev/workato/random.
```

--------------------------------

### Directly Initialize Settings Object

Source: https://github.com/workato/workato-connector-sdk/blob/master/_autodocs/api-reference/settings.md

Instantiate a settings object by providing file path, encryption status, name, and master key path. This is useful for explicitly defining settings configuration.

```ruby
def initialize(path: nil, encrypted: nil, name: nil, key_path: nil)
end
```

```ruby
# Create settings object
settings_obj = Workato::Connector::Sdk::Settings.new(
  path: 'config/settings.yaml',
  encrypted: false,
  name: 'production'
)

# Read settings
settings = settings_obj.read
```

--------------------------------

### Example Webhook Subscription State

Source: https://github.com/workato/workato-connector-sdk/blob/master/_autodocs/types.md

An example of the state hash returned by a webhook subscribe block, including webhook ID and event type.

```ruby
{
  webhook_id: 'wh_123abc',
  event_type: 'contact.created',
  url: 'https://app.workato.com/webhook/receive/xyz'
}
```

--------------------------------

### Populate Pick Lists from Lookup Tables

Source: https://github.com/workato/workato-connector-sdk/blob/master/_autodocs/api-reference/lookup-tables.md

Dynamically populate `select` control types in input fields by mapping lookup table data. This example shows creating a `countries_list` for a country selection.

```ruby
{
  pick_lists: {
    countries_list: ->(connection) do
      lookup_table(:countries).map { |c| [c['name'], c['id']] }
      # => [
      #      ['United States', 1],
      #      ['Canada', 2]
      #    ]
    end
  },
  
  actions: {
    create_order: {
      input_fields: ->(connection) do
        [
          {
            name: 'country',
            label: 'Country',
            control_type: 'select',
            pick_list: 'countries_list'
          }
        ]
      end,
      
      execute: ->(connection, input) do
        # input[:country] will be the ID (1, 2, etc.)
        country_name = lookup_table(:countries).find { |c| c['id'] == input[:country] }['name']
        
        post("#{connection[:api_url]}/orders", {
          country: country_name,
          ...input
        })
      end
    }
  }
}
```

--------------------------------

### Initialize Connector with Settings

Source: https://github.com/workato/workato-connector-sdk/blob/master/_autodocs/configuration.md

Settings are passed to the Connector constructor and contain credentials and configuration. Settings can be accessed using indifferent access.

```ruby
settings = {
  api_key: 'key123',
  api_url: 'https://api.example.com',
  username: 'user@example.com',
  password: 'secret',
  access_token: 'token456',
  # Any connector-specific settings
}

connector = Workato::Connector::Sdk::Connector.from_file(
  'connector.rb',
  settings
)
```

--------------------------------

### Get Pick Lists Proxy

Source: https://github.com/workato/workato-connector-sdk/blob/master/_autodocs/api-reference/connector.md

Retrieves a PickListsProxy for accessing pick list options. This is used to get available choices for fields that use predefined lists.

```ruby
def pick_lists
  @pick_lists ||= PickListsProxy.new(...)
end
```

--------------------------------

### Instantiate Settings from Alternative File

Source: https://github.com/workato/workato-connector-sdk/blob/master/README.md

Use `from_encrypted_file` or `from_file` to load settings from a specific file path when the default file is not used.

```ruby
let(:settings) { Workato::Connector::Sdk::Settings.from_encrypted_file('invalid_settings.yaml.enc') }
```

--------------------------------

### Run OAuth2 Authorization Code Flow

Source: https://github.com/workato/workato-connector-sdk/blob/master/README.md

This bash command initiates the OAuth2 Authorization Code flow, which typically involves a browser popup for user authentication. Use this to test your connection setup.

```bash
workato oauth2 
```

--------------------------------

### Example Trigger Event

Source: https://github.com/workato/workato-connector-sdk/blob/master/_autodocs/types.md

An example of a single event object that might be returned by a trigger poll, including fields like ID, name, email, and creation timestamp.

```ruby
{
  id: 'contact_123',
  name: 'John Doe',
  email: 'john@example.com',
  created_at: '2024-01-15T10:30:00Z'
}
```

--------------------------------

### Example of InvalidTriggerPollOutputError Usage

Source: https://github.com/workato/workato-connector-sdk/blob/master/_autodocs/errors.md

Demonstrates a scenario where a poll block incorrectly returns an array instead of a hash, triggering the InvalidTriggerPollOutputError. The example shows how to rescue this error and access its details.

```ruby
# Poll block returns array instead of hash
{
  poll: ->(connection, input, closure) do
    [{ id: 1 }, { id: 2 }]  # Wrong! Should be { events: [...] }
  end
}

begin
  trigger.poll_page
rescue Workato::Connector::Sdk::InvalidTriggerPollOutputError => e
  puts e.sdk_reference
  # => "https://docs.workato.com/developing-connectors/sdk/..."
end
```

--------------------------------

### StreamOutput Type Definition and Example

Source: https://github.com/workato/workato-connector-sdk/blob/master/_autodocs/types.md

Defines the return value for stream lambdas as a tuple containing a data chunk and a boolean indicating if more data is available. An example shows a string chunk and 'true' for more data.

```ruby
StreamOutput = T.type_alias do
  [T.untyped, T::Boolean]  # [data, has_more]
end
```

```ruby
[
  "chunk of data...",
  true  # More data available
]
```

--------------------------------

### Loading a Connector

Source: https://github.com/workato/workato-connector-sdk/blob/master/_autodocs/README.md

Demonstrates how to load connector settings from a file and then load the connector definition itself using the Workato Connector SDK. It also shows how to test the connection.

```APIDOC
## Loading a Connector

### Description
Loads connector settings and the connector definition from files, then tests the connection.

### Method
Ruby SDK methods

### Endpoint
N/A

### Parameters
None

### Request Example
```ruby
require 'workato-connector-sdk'

# Load settings
settings = Workato::Connector::Sdk::Settings.from_file

# Load connector from file
connector = Workato::Connector::Sdk::Connector.from_file('connector.rb', settings)

# Test the connection
result = connector.test(settings)
puts result
```

### Response
#### Success Response
Output of the test method.

#### Response Example
(Output depends on the connector's test implementation)
```

--------------------------------

### Get Current Date

Source: https://github.com/workato/workato-connector-sdk/blob/master/_autodocs/api-reference/index.md

Retrieve the current date.

```ruby
today
```

--------------------------------

### Connection.new

Source: https://github.com/workato/workato-connector-sdk/blob/master/_autodocs/api-reference/connection.md

Creates a Connection instance with provided connection definition, custom methods, and settings.

```APIDOC
## Connection.new(connection, methods, settings)

### Description
Creates a Connection instance.

### Parameters
#### Parameters
- **connection** (Hash) - Required - Connection definition with `:authorization` and `:base_uri`
- **methods** (Hash) - Optional - Custom methods available in the connection
- **settings** (Hash) - Optional - Connection settings (credentials, tokens)

### Returns
`Connection` — A new Connection instance

### Example
```ruby
connection_def = {
  base_uri: ->(settings) { settings[:api_url] },
  authorization: {
    type: 'oauth2',
    client_id: 'xxx',
    client_secret: 'yyy',
    token_url: -> { 'https://api.example.com/oauth/token' }
  }
}

settings = {
  api_url: 'https://api.example.com',
  access_token: 'token123'
}

connection = Workato::Connector::Sdk::Connection.new(
  connection: connection_def,
  settings: settings
)
```
```

--------------------------------

### Get Current Time

Source: https://github.com/workato/workato-connector-sdk/blob/master/_autodocs/api-reference/index.md

Retrieve the current date and time.

```ruby
now
```

--------------------------------

### Action Initialization

Source: https://github.com/workato/workato-connector-sdk/blob/master/_autodocs/api-reference/action.md

Creates an Action instance with various optional parameters for defining its behavior and schema.

```ruby
def initialize(action:, methods: {}, connection: Connection.new, 
               object_definitions: nil, streams: ProhibitedStreams.new)
end
```

```ruby
action_def = {
  execute: ->(connection, input) do
    post("#{connection[:base_url]}/users", input)
  end,
  input_fields: ->(connection) { [{ name: 'email', label: 'Email' }] },
  output_fields: ->(connection) { [{ name: 'id' }, { name: 'name' }] }
}

action = Workato::Connector::Sdk::Action.new(
  action: action_def,
  connection: connection_obj
)
```

--------------------------------

### Handle UnexpectedMethodDefinitionError

Source: https://github.com/workato/workato-connector-sdk/blob/master/_autodocs/errors.md

Example of catching an UnexpectedMethodDefinitionError and accessing its details.

```ruby
begin
  call(:my_method)
rescue Workato::Connector::Sdk::UnexpectedMethodDefinitionError => e
  puts e.name        # => :my_method
  puts e.definition  # => "not a proc"
end
```

--------------------------------

### Integrate Settings with Connector

Source: https://github.com/workato/workato-connector-sdk/blob/master/_autodocs/api-reference/settings.md

Load settings from a default file and use them to instantiate a connector. Settings are accessible within connector execution blocks.

```ruby
settings = Workato::Connector::Sdk::Settings.from_default_file

connector = Workato::Connector::Sdk::Connector.from_file(
  'connector.rb',
  settings
)

# Access in blocks:
connector.actions['my_action'].execute(settings)
```

```ruby
execute: ->(connection, input) do
  api_key = connection.settings[:api_key]
  api_url = connection.settings[:api_url]
  
  get("#{api_url}/resource", {
    'Authorization' => "Bearer #{api_key}"
  })
end
```

--------------------------------

### Workato CLI Commands Overview

Source: https://github.com/workato/workato-connector-sdk/blob/master/README.md

View the available commands for the Workato CLI tool. Use `workato help <COMMAND>` for more details on specific commands.

```bash
Commands:
  workato edit <PATH>            # Edit encrypted file, e.g. settings.yaml.enc
  workato exec <PATH>            # Execute connector defined block
  workato generate <SUBCOMMAND>  # Generates code from template
  workato help [COMMAND]         # Describe available commands or one specific command
  workato new <CONNECTOR_PATH>   # Inits new connector folder
  workato oauth2                 # Implements OAuth Authorization Code flow
  workato push                   # Upload and release connector's code

Options:
  [--verbose], [--no-verbose]  
```

--------------------------------

### Get Nil Value (Null)

Source: https://github.com/workato/workato-connector-sdk/blob/master/_autodocs/api-reference/index.md

Return nil, representing a null value.

```ruby
null
```

--------------------------------

### Get Nil Value (Clear)

Source: https://github.com/workato/workato-connector-sdk/blob/master/_autodocs/api-reference/index.md

Return nil, effectively clearing a value.

```ruby
clear
```

--------------------------------

### Load Connector and Test Connection

Source: https://github.com/workato/workato-connector-sdk/blob/master/_autodocs/README.md

Loads connector settings and the connector definition from files, then tests the connection. Ensure 'workato-connector-sdk' is required.

```ruby
require 'workato-connector-sdk'

# Load settings
settings = Workato::Connector::Sdk::Settings.from_file

# Load connector from file
connector = Workato::Connector::Sdk::Connector.from_file('connector.rb', settings)

# Test the connection
result = connector.test(settings)
puts result
```

--------------------------------

### Handle UnresolvedMultiAuthOptionError

Source: https://github.com/workato/workato-connector-sdk/blob/master/_autodocs/errors.md

Example of catching an UnresolvedMultiAuthOptionError when a multi-auth option is referenced but not defined.

```ruby
# Definition has 'basic_auth' and 'oauth2' but connector references 'api_key'
begin
  connector.connection.authorization
rescue Workato::Connector::Sdk::UnresolvedMultiAuthOptionError => e
  puts e.name  # => 'api_key'
end
```

--------------------------------

### Handle UndefinedMethodError

Source: https://github.com/workato/workato-connector-sdk/blob/master/_autodocs/errors.md

Example of catching an UndefinedMethodError and accessing the name of the missing method.

```ruby
begin
  call(:nonexistent)
rescue Workato::Connector::Sdk::UndefinedMethodError => e
  puts e.name  # => :nonexistent
end
```

--------------------------------

### settings

Source: https://github.com/workato/workato-connector-sdk/blob/master/_autodocs/api-reference/connection.md

Returns a copy of the connection settings with indifferent key access.

```APIDOC
## settings

### Description
Returns a copy of the connection settings (with indifferent key access).

### Returns
`ActiveSupport::HashWithIndifferentAccess` — Connection settings

### Example
```ruby
api_key = connection.settings[:api_key]
api_key = connection.settings['api_key']  # Both work
```
```

--------------------------------

### Poll a Trigger

Source: https://github.com/workato/workato-connector-sdk/blob/master/_autodocs/README.md

Retrieves a specific trigger from the connector. This snippet is a starting point for polling-based triggers.

```ruby
trigger = connector.triggers['new_contact']


```

--------------------------------

### Basic Authentication Configuration

Source: https://github.com/workato/workato-connector-sdk/blob/master/_autodocs/README.md

Sets up Basic Authentication using a username and password.

```ruby
authorization: {
  type: 'basic',
  username: 'user',
  password: 'pass'
}
```

--------------------------------

### Get AWS Workato Account ID

Source: https://github.com/workato/workato-connector-sdk/blob/master/_autodocs/api-reference/index.md

Retrieve the AWS account ID for the current Workato account.

```ruby
aws.workato_account_id
```

--------------------------------

### Execute Method Lambda

Source: https://github.com/workato/workato-connector-sdk/blob/master/README.md

Command to execute the 'sample_method' lambda function. It specifies the path to the JSON file containing the arguments for the method.

```bash
workato exec methods.sample_method --args='fixtures/methods/sample_method/sample_method_input.json'  #The output of the lambda function should be shown.

```

--------------------------------

### Fixture Directory Structure

Source: https://github.com/workato/workato-connector-sdk/blob/master/README.md

Illustrates the sample structure for storing input and output JSONs within the fixtures folder for RSpec or CLI usage.

```bash
├── fixtures
│   ├── actions
│   │   └── search_customers
│   │       ├── input.json
│   │       └── output.json
│   ├── methods
│   │   └── sample_method
│   │       ├── input.json
│   │       └── output.json
│   ├── pick_lists
│   │   └── dependent
│   │       └── input.json
│   └── triggers
│       └── new_updated_object
│           ├── customer_config.json
│           ├── customer_input_poll.json
│           ├── customer_input_poll_page.json
│           ├── customer_output_fields.json
│           ├── customer_output_poll.json
│           └── customer_output_poll_page.json

```

--------------------------------

### Handle InvalidDefinitionError for Missing Execute Block

Source: https://github.com/workato/workato-connector-sdk/blob/master/_autodocs/errors.md

Example of catching an InvalidDefinitionError when an action is missing its 'execute' block.

```ruby
begin
  connector.actions['missing_execute'].invoke({})
rescue Workato::Connector::Sdk::InvalidDefinitionError => e
  puts e.message  # => "'execute' block is required for action"
end
```

--------------------------------

### Get AWS IAM External ID

Source: https://github.com/workato/workato-connector-sdk/blob/master/_autodocs/api-reference/index.md

Retrieve the AWS IAM external ID associated with the Workato account.

```ruby
aws.iam_external_id
```

--------------------------------

### HTTP Methods (DSL)

Source: https://github.com/workato/workato-connector-sdk/blob/master/_autodocs/api-reference/request.md

Convenience methods for common HTTP operations like GET, POST, PUT, DELETE, etc.

```APIDOC
## HTTP Methods (DSL)

The HTTP module provides convenience methods for common HTTP operations:

```ruby
# GET request
get(url, params)

# POST request
post(url, payload)

# PUT request
put(url, payload)

# PATCH request
patch(url, payload)

# DELETE request
delete(url, payload)

# HEAD request
head(url, params)

# OPTIONS request
options(url, params)
```

### Example

```ruby
# All return Request objects
get('https://api.example.com/users').response_format_json
post('https://api.example.com/users', { name: 'John' }).format_json
put('https://api.example.com/users/123', { name: 'Jane' }).format_json
delete('https://api.example.com/users/123').format_json
```
```

--------------------------------

### Ruby Proc/Lambda Syntax

Source: https://github.com/workato/workato-connector-sdk/blob/master/_autodocs/README.md

Illustrates equivalent ways to define Ruby Proc/lambda blocks for connector configuration.

```ruby
# All of these are equivalent:
execute: ->(connection, input) { ... }
execute: proc { |connection, input| ... }
execute: lambda { |connection, input| ... }

# Old Ruby keyword syntax (also supported):
execute: Proc.new { |connection, input| ... }
```

--------------------------------

### Retrieve Connection Settings

Source: https://github.com/workato/workato-connector-sdk/blob/master/_autodocs/api-reference/connection.md

Get a copy of the connection settings. This method ensures thread-safety and provides indifferent key access.

```ruby
def settings
  # Always returns new copy to allow temporary mutations
  synchronize { @settings.with_indifferent_access }
end
```

--------------------------------

### Access Connection Settings with Indifferent Keys

Source: https://github.com/workato/workato-connector-sdk/blob/master/_autodocs/api-reference/connection.md

Demonstrates accessing connection settings using either string or symbol keys, thanks to indifferent access.

```ruby
api_key = connection.settings[:api_key]
api_key = connection.settings['api_key']  # Both work
```

--------------------------------

### Workato CLI Commands

Source: https://github.com/workato/workato-connector-sdk/blob/master/_autodocs/README.md

Lists common Workato CLI commands for project creation, generation, execution, OAuth, editing settings, pushing to Workato, running tests, and building documentation.

```bash
# Create new connector project
workato new my-connector

# Generate from template
workato generate connector

# Execute connector blocks
workato exec lib/connector.rb '{ "id": 1 }'

# OAuth 2.0 flow
workato oauth2

# Edit encrypted files
workato edit settings.yaml.enc

# Push to Workato
workato push

# Run tests
rspec

# Build documentation
yard
```

--------------------------------

### Get OAuth Client ID

Source: https://github.com/workato/workato-connector-sdk/blob/master/_autodocs/api-reference/index.md

Retrieve the OAuth client ID from the authorization settings. This is necessary for OAuth 2.0 authentication flows.

```ruby
auth.client_id(settings)
```

--------------------------------

### Get Streams Object

Source: https://github.com/workato/workato-connector-sdk/blob/master/_autodocs/api-reference/connector.md

Retrieves a Streams object for accessing stream definitions. This is used for iterating over large datasets or data that is streamed.

```ruby
def streams
  @streams ||= Streams.new(...)
end
```

--------------------------------

### Stream.chunk

Source: https://github.com/workato/workato-connector-sdk/blob/master/_autodocs/api-reference/stream.md

Retrieves a single chunk of data from the stream. It executes the stream lambda with specified frame parameters to get a portion of the data.

```APIDOC
## Stream.chunk

### Description
Retrieves a single chunk of data from the stream. It executes the stream lambda with specified frame parameters to get a portion of the data.

### Method Signature
`chunk(input = {}, from = 0, to = from + DEFAULT_FRAME_SIZE, frame_size = DEFAULT_FRAME_SIZE)`

### Parameters
#### Parameters
- **input** (Hash) - Optional - Stream input parameters. Defaults to `{}`.
- **from** (Integer) - Optional - Starting byte/position. Defaults to `0`.
- **to** (Integer) - Optional - Ending byte/position. Defaults to `from + 10MB`.
- **frame_size** (Integer) - Optional - Size of chunk to return. Defaults to `10MB`.

### Returns
`Array` — `[data, has_more_data]` tuple

### Raises
- `ArgumentError` — If frame_size is not positive

### Example
```ruby
data, has_more = stream.chunk(
  { file_id: 'file123' },
  from: 0,
  to: 1.megabyte,
  frame_size: 1.megabyte
)

if has_more
  next_chunk = stream.chunk(
    { file_id: 'file123' },
    from: 1.megabyte,
    to: 2.megabytes
  )
end
```
```

--------------------------------

### Print Arguments

Source: https://github.com/workato/workato-connector-sdk/blob/master/_autodocs/api-reference/index.md

Print the provided arguments to the console.

```ruby
puts(*args)
```

--------------------------------

### Example of JSONParsingError Usage

Source: https://github.com/workato/workato-connector-sdk/blob/master/_autodocs/errors.md

Demonstrates how to handle a JSONParsingError by attempting to parse an invalid JSON string and rescuing the specific error, then printing its message.

```ruby
begin
  workato.parse_json('invalid json')
rescue Workato::Connector::Sdk::JSONParsingError => e
  puts "JSON parse error: #{e.message}"
end
```

--------------------------------

### Test Chargebee Method via CLI

Source: https://github.com/workato/workato-connector-sdk/blob/master/README.md

This snippet defines a Chargebee connector with a 'sample_method'. It demonstrates how to test this method's lambda function using the 'workato exec' command, specifying the arguments file.

```ruby
{
  title: "Chargebee",

  connection: {
      # Connection code found above
  },

  test: lambda do |connection|
    get("/api/v2/plans")
  end,

  methods: {
    
    sample_method: lambda do |string1, string2|
      string1 + string2
    end
  },
}

```

--------------------------------

### Load Connector from File

Source: https://github.com/workato/workato-connector-sdk/blob/master/_autodocs/api-reference/connector.md

Instantiates a Connector object by loading its definition from a Ruby source file. Use this when your connector definition is stored in a .rb file.

```ruby
def self.from_file(path_to_source_code = 'connector.rb', settings = {})
```

```ruby
connector = Workato::Connector::Sdk::Connector.from_file('connector.rb', {
  api_key: 'my_api_key',
  username: 'user@example.com'
})

result = connector.actions['create_contact'].invoke({
  name: 'John Doe',
  email: 'john@example.com'
})
```

--------------------------------

### Handle Request Timeout Error

Source: https://github.com/workato/workato-connector-sdk/blob/master/_autodocs/errors.md

Catch and handle errors that occur when an HTTP request times out. This example shows how to access the error message.

```ruby
begin
  get('https://example.com/slow-endpoint').response!
rescue Workato::Connector::Sdk::RequestTimeoutError => e
  puts "Request timed out: #{e.message}"
end
```

--------------------------------

### Create Connector Instance

Source: https://github.com/workato/workato-connector-sdk/blob/master/_autodocs/api-reference/index.md

Instantiate a `Connector` object directly using its definition hash and settings. This is an alternative to loading from a file.

```ruby
connector = Workato::Connector::Sdk::Connector.new(definition_hash, settings)
```

--------------------------------

### Access Connection Authorization

Source: https://github.com/workato/workato-connector-sdk/blob/master/_autodocs/api-reference/connector.md

Example of accessing authorization details, such as the client ID, from the connection object. This is useful for understanding how to interact with authenticated APIs.

```ruby
auth = connector.connection.authorization
client_id = auth.client_id
```

--------------------------------

### Workato New Connector HTTP Mocking Prompt

Source: https://github.com/workato/workato-connector-sdk/blob/master/README.md

Shows the prompt presented by 'workato new' for selecting default HTTP mocking behavior, with options for 'secure' and 'simple' modes.

```bash
Please select default HTTP mocking behavior suitable for your project?

1 - secure. Cause an error to be raised for any unknown requests, all request recordings are encrypted.
            To record a new cassette you need set VCR_RECORD_MODE environment variable

            Example: VCR_RECORD_MODE=once bundle exec rspec spec/actions/test_action_spec.rb

2 - simple. Record new interaction if it is a new request, requests are stored as plain text and expose secret tokens.
```

--------------------------------

### Workato::Connector::Sdk::AccountProperties Class Methods

Source: https://github.com/workato/workato-connector-sdk/blob/master/_autodocs/api-reference/index.md

Methods for loading user-specific connector configuration.

```APIDOC
## Workato::Connector::Sdk::AccountProperties

### Description
Manages user-specific connector configuration.

### Class Methods

- `from_file(path, name)` — Load account properties from a file.
- `from_encrypted_file(path, key_path, name)` — Load encrypted account properties from a file.
```

--------------------------------

### Define Simple Text Field

Source: https://github.com/workato/workato-connector-sdk/blob/master/_autodocs/api-reference/account-properties.md

Example of defining a simple text field for account properties, suitable for API keys or similar credentials.

```ruby
# Simple text field
{
  api_key: {
    label: 'API Key',
    hint: 'Your API key from the dashboard',
    control_type: 'password'
  }
}
```

--------------------------------

### Standard Connector Project Structure

Source: https://github.com/workato/workato-connector-sdk/blob/master/README.md

A recommended folder structure for a Workato connector project. This structure aids in organization and development.

```bash
. # Your connector's root folder
├── .github # Folder which stores information about your Github workflows if you're using github
├── .gitignore # Stores the information which should not be pushed via git
├── Gemfile # Store the dependencies of your project
├── Gemfile.lock # This will be automatically created. 
├── README.md # This will become your Connector's description
├── logo.png # The logo of your connector. Used when you push your connector to Workato.
├── connector.rb # Your actual connector code
├── master.key # Your master key if you're encrypting your files
├── settings.yaml.enc # Where you store your credentials for your connector
├── fixtures # Folder where your input and output JSONs are stored
├── tape_library # Folder where your VCR recordings are stored
├── .rspec
└── spec # Where you store your RSpec tests
    ├── connector_spec.rb
    ├── spec_helper.rb
    └── vcr_cassettes
```

--------------------------------

### Use Encrypt and Decrypt Functions

Source: https://github.com/workato/workato-connector-sdk/blob/master/_autodocs/api-reference/dsl.md

Demonstrates the usage of the `encrypt` and `decrypt` functions with a sensitive string and a secret key.

```ruby
encrypted = encrypt("sensitive data", "my_secret_key")
decrypted = decrypt(encrypted, "my_secret_key")
```

--------------------------------

### Get Object Definitions Proxy

Source: https://github.com/workato/workato-connector-sdk/blob/master/_autodocs/api-reference/connector.md

Retrieves an ObjectDefinitions proxy for accessing object schemas. Use this to understand the structure of data objects the connector can interact with.

```ruby
def object_definitions
  @object_definitions ||= ObjectDefinitions.new(...)
end
```

--------------------------------

### Stream File Chunks

Source: https://github.com/workato/workato-connector-sdk/blob/master/_autodocs/README.md

Defines a stream for downloading file chunks using the 'Range' header. Includes an example of processing a file chunk by chunk.

```ruby
{
  streams: {
    download_file: ->(connection, input, from, to, size) do
      # Return file chunk and whether more data exists
      response = get(
        "#{connection[:api_url]}/files/#{input[:file_id]}",
        headers: { 'Range' => "bytes=#{from}-#{to}" }
      ).response!
      
      has_more = response.status == 206
      [response.body, has_more]
    end
  },
  
  actions: {
    export_data: {
      execute: ->(connection, input) do
        # Download entire file
        file_data = stream(:download_file, { file_id: 'id123' })
        
        # Process chunk by chunk
        Stream.each_chunk(
          stream: stream(:download_file, { file_id: 'id123' }),
          from: 0,
          frame_size: 5.megabytes
        ) do |chunk, from, to, eof|
          # Process chunk
        end
      end
    }
  }
}
```

--------------------------------

### Test Chargebee Action via CLI

Source: https://github.com/workato/workato-connector-sdk/blob/master/README.md

This snippet defines a Chargebee connector with a 'search_customers' action. It demonstrates how to test this action's execute lambda function using the 'workato exec' command, specifying connection and input file.

```ruby
{
  title: "Chargebee",

  connection: {
      # Connection code found above
  },

  test: lambda do |connection|
    get("/api/v2/plans")
  end,

  actions: {
    
    search_customers: {
      title: "Search customers",
      subtitle: "Search for customers using name",
      description: "Search customer in Chargebee",
      
      input_fields: lambda do |object_definitions|
        [ 
          {
            name: "name",
            label: "Name to query by",
            hint: "Provide the name of the customer to query"
          },
          {
            name: "id",
            label: "Name to query by",
            hint: "Provide the name of the customer to query"
          }
        ]
      end,
      
      
      execute: lambda do |connection, input, input_schema, output_schema, closure|
        get("/api/v2/customers",input)
      end,
      
      
      output_fields: lambda do |object_definitions|
        [
          {
            name: "first_name"
          },
          {
            name: "last_name"
          },
          {
            name: "id"
          }
        ]
      end
    }
    
  },
}

```

--------------------------------

### Perform DELETE Request

Source: https://github.com/workato/workato-connector-sdk/blob/master/_autodocs/api-reference/dsl.md

Example of making a DELETE request to remove a specific user by their ID. Uses `.response!` to execute the request and retrieve the response.

```ruby
# DELETE
delete("#{connection[:api_url]}/users/123").response!
```

--------------------------------

### Load Settings from Plain Text File

Source: https://github.com/workato/workato-connector-sdk/blob/master/_autodocs/api-reference/settings.md

Loads connector settings from a specified plain text YAML file. It can load all settings or a specific named section for different environments.

```APIDOC
## Load Settings from Plain Text File

### Description
Loads connector settings from a specified plain text YAML file. It can load all settings or a specific named section for different environments.

### Method Signature
`self.from_file(path = 'settings.yaml', name = nil)`

### Parameters
#### Path Parameters
- **path** (String) - Optional - Path to settings file. Defaults to `'settings.yaml'`.
- **name** (String) - Optional - Named section in file (for multiple environments).

### Returns
`Hash` — Settings hash with indifferent key access.

### Example
```ruby
# Load all settings
all_settings = Workato::Connector::Sdk::Settings.from_file

# Load named settings
prod_settings = Workato::Connector::Sdk::Settings.from_file('settings.yaml', 'production')

# Load from custom path
settings = Workato::Connector::Sdk::Settings.from_file('config/api.yaml')
```
```

--------------------------------

### Execute Request and Get Response

Source: https://github.com/workato/workato-connector-sdk/blob/master/_autodocs/api-reference/request.md

The `response!` method executes the configured request and returns the response body. It handles timeouts and applies error response processing.

```ruby
def response!
  __getobj__ || __setobj__(response)
rescue RestClient::Exceptions::Timeout => e
  raise RequestTimeoutError, e
rescue RestClient::Exception => e
  # Handle errors, apply after_error_response
end
```

```ruby
response = get('https://api.example.com/users/123')
  .response!
# => { "id": 123, "name": "John" }
```

--------------------------------

### Get Base URI for API Requests

Source: https://github.com/workato/workato-connector-sdk/blob/master/_autodocs/api-reference/connection.md

Retrieve the base URI for API requests. This method can optionally merge new settings and executes a DSL context.

```ruby
def base_uri(settings = nil)
  return unless source[:base_uri]
  merge_settings!(settings) if settings
  global_dsl_context.execute(self.settings, &source['base_uri'])
end
```

--------------------------------

### Access Connector Settings in Execution Block

Source: https://github.com/workato/workato-connector-sdk/blob/master/_autodocs/configuration.md

Demonstrates how to access connector settings within an execution block. Supports both symbol and string keys for access.

```ruby
execute: ->(connection, input) do
  connection.settings[:api_key]       # Accessing settings
  connection.settings['api_key']      # Indifferent access
end
```
Tokens:
Raw