straddle 0.5.0 → 1.0.0

data/README.md

@@ -1,375 +1,148 @@
-# Straddle Ruby API library
+# Straddle API
 
-The Straddle Ruby library provides convenient access to the Straddle REST API from any Ruby 3.2.0+ application. It ships with comprehensive types & docstrings in Yard, RBS, and RBI – [see below](https://github.com/straddleio/straddle-ruby#Sorbet) for usage with Sorbet. The standard library's `net/http` is used as the HTTP transport, with connection pooling via the `connection_pool` gem.
+This library provides convenient access to the Straddle API from Ruby.
 
-It is generated with [Stainless](https://www.stainless.com/).
+The full API of this library can be found in [api.md](./api.md).
 
-## MCP Server
+<br />
 
-Use the Straddle MCP Server to enable AI assistants to interact with this API, allowing them to explore endpoints, make test requests, and use documentation to help integrate this SDK into your application.
+## Contents
 
-[![Add to Cursor](https://cursor.com/deeplink/mcp-install-dark.svg)](https://cursor.com/en-US/install-mcp?name=%40straddlecom%2Fstraddle-mcp&config=eyJuYW1lIjoiQHN0cmFkZGxlY29tL3N0cmFkZGxlLW1jcCIsInRyYW5zcG9ydCI6Imh0dHAiLCJ1cmwiOiJodHRwczovL3N0cmFkZGxlLnN0bG1jcC5jb20iLCJoZWFkZXJzIjp7Ingtc3RyYWRkbGUtYXBpLWtleSI6Ik15IEFQSSBLZXkifX0)
-[![Install in VS Code](https://img.shields.io/badge/_-Add_to_VS_Code-blue?style=for-the-badge&logo=data:image/svg%2bxml;base64,PHN2ZyB4bWxucz0iaHR0cDovL3d3dy53My5vcmcvMjAwMC9zdmciIGZpbGw9Im5vbmUiIHZpZXdCb3g9IjAgMCA0MCA0MCI+PHBhdGggZmlsbD0iI0VFRSIgZmlsbC1ydWxlPSJldmVub2RkIiBkPSJNMzAuMjM1IDM5Ljg4NGEyLjQ5MSAyLjQ5MSAwIDAgMS0xLjc4MS0uNzNMMTIuNyAyNC43OGwtMy40NiAyLjYyNC0zLjQwNiAyLjU4MmExLjY2NSAxLjY2NSAwIDAgMS0xLjA4Mi4zMzggMS42NjQgMS42NjQgMCAwIDEtMS4wNDYtLjQzMWwtMi4yLTJhMS42NjYgMS42NjYgMCAwIDEgMC0yLjQ2M0w3LjQ1OCAyMCA0LjY3IDE3LjQ1MyAxLjUwNyAxNC41N2ExLjY2NSAxLjY2NSAwIDAgMSAwLTIuNDYzbDIuMi0yYTEuNjY1IDEuNjY1IDAgMCAxIDIuMTMtLjA5N2w2Ljg2MyA1LjIwOUwyOC40NTIuODQ0YTIuNDg4IDIuNDg4IDAgMCAxIDEuODQxLS43MjljLjM1MS4wMDkuNjk5LjA5MSAxLjAxOS4yNDVsOC4yMzYgMy45NjFhMi41IDIuNSAwIDAgMSAxLjQxNSAyLjI1M3YuMDk5LS4wNDVWMzMuMzd2LS4wNDUuMDk1YTIuNTAxIDIuNTAxIDAgMCAxLTEuNDE2IDIuMjU3bC04LjIzNSAzLjk2MWEyLjQ5MiAyLjQ5MiAwIDAgMS0xLjA3Ny4yNDZabS43MTYtMjguOTQ3LTExLjk0OCA5LjA2MiAxMS45NTIgOS4wNjUtLjAwNC0xOC4xMjdaIi8+PC9zdmc+)](https://vscode.stainless.com/mcp/%7B%22name%22%3A%22%40straddlecom%2Fstraddle-mcp%22%2C%22type%22%3A%22http%22%2C%22url%22%3A%22https%3A%2F%2Fstraddle.stlmcp.com%22%2C%22headers%22%3A%7B%22x-straddle-api-key%22%3A%22My%20API%20Key%22%7D%7D)
+- [Installation](#installation)
+- [Usage](#usage)
+- [API Reference](./api.md)
+- [Authentication](#authentication)
+- [Errors](#errors)
+- [Client Options](#client-options)
+- [Request Options](#request-options)
+- [Retries and Timeouts](#retries-and-timeouts)
+- [Helpers](#helpers)
+- [Requirements](#requirements)
 
-> Note: You may need to set environment variables in your MCP client.
-
-## Documentation
-
-Documentation for releases of this gem can be found [on RubyDoc](https://gemdocs.org/gems/straddle).
-
-The REST API documentation can be found on [docs.straddle.com](https://docs.straddle.com).
+<br />
 
 ## Installation
 
-To use this gem, install via Bundler by adding the following to your application's `Gemfile`:
-
-<!-- x-release-please-start-version -->
+Add the gem to your application's `Gemfile`:
 
 ```ruby
-gem "straddle", "~> 0.5.0"
+gem "straddle", "~> 1.0.0" # x-release-please-version
 ```
 
-<!-- x-release-please-end -->
+Or install it directly:
+
+```sh
+gem install straddle
+```
+
+<br />
 
 ## Usage
 
 ```ruby
-require "bundler/setup"
 require "straddle"
 
-straddle = Straddle::Client.new(
-  api_key: ENV["STRADDLE_API_KEY"], # This is the default and can be omitted
-  environment: "production" # defaults to "sandbox"
-)
-
-charge_v1 = straddle.charges.create(
-  amount: 10000,
-  config: {balance_check: "required"},
-  consent_type: "internet",
-  currency: "currency",
-  description: "Monthly subscription fee",
-  device: {ip_address: "192.168.1.1"},
-  external_id: "external_id",
-  paykey: "paykey",
-  payment_date: "2019-12-27"
+client = Straddle::Client.new(
+  bearer: ENV["BEARER"], # defaults to the BEARER env var
 )
 
-puts(charge_v1.data)
-```
-
-### Pagination
+response = client.accounts.retrieve("7c9e6679-7425-40de-944b-e07fc1f90ae7")
 
-List methods in the Straddle API are paginated.
-
-This library provides auto-paginating iterators with each list response, so you do not have to request successive pages manually:
-
-```ruby
-page = straddle.payments.list
-
-# Fetch single item from page.
-payment = page.data[0]
-puts(payment.id)
-
-# Automatically fetches more pages as needed.
-page.auto_paging_each do |payment|
-  puts(payment.id)
-end
+puts response.inspect
 ```
 
-Alternatively, you can use the `#next_page?` and `#next_page` methods for more granular control working with pages.
+The examples in the following sections assume a `client` configured as shown above.
 
-```ruby
-if page.next_page?
-  new_page = page.next_page
-  puts(new_page.data[0].id)
-end
-```
+See the [API reference](./api.md) for every available operation.
 
-### File uploads
+<br />
 
-Request parameters that correspond to file uploads can be passed as raw contents, a [`Pathname`](https://rubyapi.org/3.2/o/pathname) instance, [`StringIO`](https://rubyapi.org/3.2/o/stringio), or more.
+## Authentication
 
-```ruby
-require "pathname"
+Pass credentials to the generated client constructor. Environment variables are read automatically when supported by the target runtime.
 
-# Use `Pathname` to send the filename and/or avoid paging a large file into memory:
-payout_v1 = straddle.payouts.upload_authorization_document(file: Pathname("/path/to/file"))
+| Option | Type | Default | Description |
+| --- | --- | --- | --- |
+| `bearer` | `String \| nil` | - | Send the API key as a bearer token in the `Authorization` header. Defaults to BEARER. |
 
-# Alternatively, pass file contents or a `StringIO` directly:
-payout_v1 = straddle.payouts.upload_authorization_document(file: File.read("/path/to/file"))
+Declared schemes:
 
-# Or, to control the filename and/or content type:
-File = Straddle::FilePart.new(File.read("/path/to/file"), filename: "/path/to/file", content_type: "…")
-payout_v1 = straddle.payouts.upload_authorization_document(file: File)
+- `Bearer` bearer token
 
-puts(payout_v1.data)
-```
+<br />
 
-Note that you can also pass a raw `IO` descriptor, but this disables retries, as the library can't be sure if the descriptor is a file or pipe (which cannot be rewound).
+## Errors
 
-### Handling errors
-
-When the library is unable to connect to the API, or if the API returns a non-success status code (i.e., 4xx or 5xx response), a subclass of `Straddle::Errors::APIError` will be thrown:
+Non-success responses throw generated API errors. Error objects expose status, headers, response body, and request metadata where the target runtime supports it.
 
 ```ruby
 begin
-  charge = straddle.charges.create(
-    amount: 10000,
-    config: {balance_check: "required"},
-    consent_type: "internet",
-    currency: "currency",
-    description: "Monthly subscription fee",
-    device: {ip_address: "192.168.1.1"},
-    external_id: "external_id",
-    paykey: "paykey",
-    payment_date: "2019-12-27"
-  )
-rescue Straddle::Errors::APIConnectionError => e
-  puts("The server could not be reached")
-  puts(e.cause)  # an underlying Exception, likely raised within `net/http`
-rescue Straddle::Errors::RateLimitError => e
-  puts("A 429 status code was received; we should back off a bit.")
-rescue Straddle::Errors::APIStatusError => e
-  puts("Another non-200-range status code was received")
-  puts(e.status)
-end
-```
-
-Error codes are as follows:
-
-| Cause            | Error Type                 |
-| ---------------- | -------------------------- |
-| HTTP 400         | `BadRequestError`          |
-| HTTP 401         | `AuthenticationError`      |
-| HTTP 403         | `PermissionDeniedError`    |
-| HTTP 404         | `NotFoundError`            |
-| HTTP 409         | `ConflictError`            |
-| HTTP 422         | `UnprocessableEntityError` |
-| HTTP 429         | `RateLimitError`           |
-| HTTP >= 500      | `InternalServerError`      |
-| Other HTTP error | `APIStatusError`           |
-| Timeout          | `APITimeoutError`          |
-| Network error    | `APIConnectionError`       |
-
-### Retries
+  response = client.accounts.retrieve("7c9e6679-7425-40de-944b-e07fc1f90ae7")
 
-Certain errors will be automatically retried 2 times by default, with a short exponential backoff.
-
-Connection errors (for example, due to a network connectivity problem), 408 Request Timeout, 409 Conflict, 429 Rate Limit, >=500 Internal errors, and timeouts will all be retried by default.
-
-You can use the `max_retries` option to configure or disable this:
-
-```ruby
-# Configure the default for all requests:
-straddle = Straddle::Client.new(
-  max_retries: 0 # default is 2
-)
-
-# Or, configure per-request:
-straddle.charges.create(
-  amount: 10000,
-  config: {balance_check: "required"},
-  consent_type: "internet",
-  currency: "currency",
-  description: "Monthly subscription fee",
-  device: {ip_address: "192.168.1.1"},
-  external_id: "external_id",
-  paykey: "paykey",
-  payment_date: "2019-12-27",
-  request_options: {max_retries: 5}
-)
-```
-
-### Timeouts
-
-By default, requests will time out after 60 seconds. You can use the timeout option to configure or disable this:
-
-```ruby
-# Configure the default for all requests:
-straddle = Straddle::Client.new(
-  timeout: nil # default is 60
-)
-
-# Or, configure per-request:
-straddle.charges.create(
-  amount: 10000,
-  config: {balance_check: "required"},
-  consent_type: "internet",
-  currency: "currency",
-  description: "Monthly subscription fee",
-  device: {ip_address: "192.168.1.1"},
-  external_id: "external_id",
-  paykey: "paykey",
-  payment_date: "2019-12-27",
-  request_options: {timeout: 5}
-)
-```
-
-On timeout, `Straddle::Errors::APITimeoutError` is raised.
-
-Note that requests that time out are retried by default.
-
-## Advanced concepts
-
-### BaseModel
-
-All parameter and response objects inherit from `Straddle::Internal::Type::BaseModel`, which provides several conveniences, including:
-
-1. All fields, including unknown ones, are accessible with `obj[:prop]` syntax, and can be destructured with `obj => {prop: prop}` or pattern-matching syntax.
-
-2. Structural equivalence for equality; if two API calls return the same values, comparing the responses with == will return true.
-
-3. Both instances and the classes themselves can be pretty-printed.
-
-4. Helpers such as `#to_h`, `#deep_to_h`, `#to_json`, and `#to_yaml`.
-
-### Making custom or undocumented requests
-
-#### Undocumented properties
-
-You can send undocumented parameters to any endpoint, and read undocumented response properties, like so:
-
-Note: the `extra_` parameters of the same name overrides the documented parameters.
-
-```ruby
-charge_v1 =
-  straddle.charges.create(
-    amount: 10000,
-    config: {balance_check: "required"},
-    consent_type: "internet",
-    currency: "currency",
-    description: "Monthly subscription fee",
-    device: {ip_address: "192.168.1.1"},
-    external_id: "external_id",
-    paykey: "paykey",
-    payment_date: "2019-12-27",
-    request_options: {
-      extra_query: {my_query_parameter: value},
-      extra_body: {my_body_parameter: value},
-      extra_headers: {"my-header": value}
-    }
-  )
-
-puts(charge_v1[:my_undocumented_property])
+  puts response.inspect
+rescue Straddle::Errors::APIError => error
+  puts "#{error.status}: #{error.message}"
+  raise
+end
 ```
 
-#### Undocumented request params
+Documented error statuses: `400`, `401`, `403`, `404`, `422`, `500`.
 
-If you want to explicitly send an extra param, you can do so with the `extra_query`, `extra_body`, and `extra_headers` under the `request_options:` parameter when making a request, as seen in the examples above.
+<br />
 
-#### Undocumented endpoints
+## Client Options
 
-To make requests to undocumented endpoints while retaining the benefit of auth, retries, and so on, you can make requests using `client.request`, like so:
+Configure the generated client by setting any of these options when you create it.
 
 ```ruby
-response = client.request(
-  method: :post,
-  path: '/undocumented/endpoint',
-  query: {"dog": "woof"},
-  headers: {"useful-header": "interesting-value"},
-  body: {"hello": "world"}
-)
-```
-
-### Concurrency & connection pooling
-
-The `Straddle::Client` instances are threadsafe, but are only are fork-safe when there are no in-flight HTTP requests.
-
-Each instance of `Straddle::Client` has its own HTTP connection pool with a default size of 99. As such, we recommend instantiating the client once per application in most settings.
-
-When all available connections from the pool are checked out, requests wait for a new connection to become available, with queue time counting towards the request timeout.
-
-Unless otherwise specified, other classes in the SDK do not have locks protecting their underlying data structure.
-
-## Sorbet
-
-This library provides comprehensive [RBI](https://sorbet.org/docs/rbi) definitions, and has no dependency on sorbet-runtime.
-
-You can provide typesafe request parameters like so:
+require "straddle"
 
-```ruby
-straddle.charges.create(
-  amount: 10000,
-  config: Straddle::ChargeCreateParams::Config.new(balance_check: "required"),
-  consent_type: "internet",
-  currency: "currency",
-  description: "Monthly subscription fee",
-  device: Straddle::DeviceInfoV1.new(ip_address: "192.168.1.1"),
-  external_id: "external_id",
-  paykey: "paykey",
-  payment_date: "2019-12-27"
+client = Straddle::Client.new(
+  timeout: 60.0,
+  max_retries: 2,
 )
 ```
 
-Or, equivalently:
+| Option | Type | Default | Description |
+| --- | --- | --- | --- |
+| `bearer` | `String \| nil` | `ENV["BEARER"]` | Send the API key as a bearer token in the `Authorization` header. |
+| `webhook_secret` | `String \| nil` | `ENV["STRADDLE_WEBHOOK_SECRET"]` | Secret used to verify incoming webhook signatures. |
+| `base_url` | `String \| nil` | `ENV["STRADDLE_BASE_URL"]` | Override the default API base URL. |
+| `max_retries` | `Integer` | `2` | Max number of retries to attempt after a failed retryable request. |
+| `timeout` | `Float` | `60.0` | Seconds to wait for a response before timing out. |
+| `initial_retry_delay` | `Float` | `0.5` | Seconds to wait before the first retry; later retries back off exponentially. |
+| `max_retry_delay` | `Float` | `8.0` | Upper bound, in seconds, on the delay between retries. |
 
-```ruby
-# Hashes work, but are not typesafe:
-straddle.charges.create(
-  amount: 10000,
-  config: {balance_check: "required"},
-  consent_type: "internet",
-  currency: "currency",
-  description: "Monthly subscription fee",
-  device: {ip_address: "192.168.1.1"},
-  external_id: "external_id",
-  paykey: "paykey",
-  payment_date: "2019-12-27"
-)
+<br />
 
-# You can also splat a full Params class:
-params = Straddle::ChargeCreateParams.new(
-  amount: 10000,
-  config: Straddle::ChargeCreateParams::Config.new(balance_check: "required"),
-  consent_type: "internet",
-  currency: "currency",
-  description: "Monthly subscription fee",
-  device: Straddle::DeviceInfoV1.new(ip_address: "192.168.1.1"),
-  external_id: "external_id",
-  paykey: "paykey",
-  payment_date: "2019-12-27"
-)
-straddle.charges.create(**params)
-```
-
-### Enums
+## Request Options
 
-Since this library does not depend on `sorbet-runtime`, it cannot provide [`T::Enum`](https://sorbet.org/docs/tenum) instances. Instead, we provide "tagged symbols" instead, which is always a primitive at runtime:
+| Option | Type | Default | Description |
+| --- | --- | --- | --- |
+| `idempotency_key` | `String` | - | Idempotency key for one request, sent when the SDK configures an idempotency header. |
+| `extra_query` | `Hash` | - | Additional query parameters for one request. |
+| `extra_headers` | `Hash` | - | Additional headers for one request. |
+| `extra_body` | `Hash` | - | Additional body fields for one request. |
+| `max_retries` | `Integer` | - | Override retry count for one request. |
+| `timeout` | `Float` | - | Override timeout for one request. |
 
-```ruby
-# :standard
-puts(Straddle::Embed::AccountCreateParams::AccessLevel::STANDARD)
-
-# Revealed type: `T.all(Straddle::Embed::AccountCreateParams::AccessLevel, Symbol)`
-T.reveal_type(Straddle::Embed::AccountCreateParams::AccessLevel::STANDARD)
-```
+<br />
 
-Enum parameters have a "relaxed" type, so you can either pass in enum constants or their literal value:
+## Retries and Timeouts
 
-```ruby
-# Using the enum constants preserves the tagged type information:
-straddle.embed.accounts.create(
-  access_level: Straddle::Embed::AccountCreateParams::AccessLevel::STANDARD,
-  # …
-)
+Generated clients support request timeouts and retry temporary failures such as network errors, 408, 409, 429, and 5xx responses. Retry delays honor `Retry-After` headers when present. Tune the retry and timeout client options shown above, or override them per request.
 
-# Literal values are also permissible:
-straddle.embed.accounts.create(
-  access_level: :standard,
-  # …
-)
-```
+<br />
 
-## Versioning
+## Helpers
 
-This package follows [SemVer](https://semver.org/spec/v2.0.0.html) conventions. As the library is in initial development and has a major version of `0`, APIs may change at any time.
+- Every model is a `BaseModel`: pass a plain hash or a model instance, and read decoded values back as attributes.
+- The gem ships `rbi/` and `sig/` trees, so Sorbet and Steep type-check calls into the SDK.
 
-This package considers improvements to the (non-runtime) `*.rbi` and `*.rbs` type definitions to be non-breaking changes.
+<br />
 
 ## Requirements
 
-Ruby 3.2.0 or higher.
-
-## Contributing
+- Ruby >= 3.2
 
-See [the contributing documentation](https://github.com/straddleio/straddle-ruby/tree/main/CONTRIBUTING.md).
+Powered by Scalar.

data/SECURITY.md

@@ -2,26 +2,18 @@
 
 ## Reporting Security Issues
 
-This SDK is generated by [Stainless Software Inc](http://stainless.com). Stainless takes security seriously, and encourages you to report any security vulnerability promptly so that appropriate action can be taken.
+This is a generated Ruby SDK for Straddle API, produced by the Scalar SDK Generator (https://scalar.com).
 
-To report a security issue, please contact the Stainless team at security@stainless.com.
+If the issue is in the generated SDK itself — its runtime, authentication handling, path construction, or serialization — report it to the Scalar team at support@scalar.com. We will acknowledge the report, triage it for severity and impact, and communicate a timeline for a fix or an explanation if we decline it.
 
 ## Responsible Disclosure
 
-We appreciate the efforts of security researchers and individuals who help us maintain the security of
-SDKs we generate. If you believe you have found a security vulnerability, please adhere to responsible
-disclosure practices by allowing us a reasonable amount of time to investigate and address the issue
-before making any information public.
+Please allow us reasonable time to investigate and address the issue before disclosing it publicly. Do not include credentials, tokens, or private API payloads in a public issue.
 
-## Reporting Non-SDK Related Security Issues
+## Reporting Non-SDK Security Issues
 
-If you encounter security issues that are not directly related to SDKs but pertain to the services
-or products provided by Straddle, please follow the respective company's security reporting guidelines.
-
-### Straddle Terms and Policies
-
-Please contact help@straddle.com for any questions or concerns regarding the security of our services.
+If the issue is in the Straddle API or service rather than in this SDK, report it through the security process Straddle API has published.
 
 ---
 
-Thank you for helping us keep the SDKs and systems they interact with secure.
+Generated code validates emitted paths and escapes spec-derived strings, but OpenAPI documents should still be treated as untrusted input before generation.

data/SKILL.md

@@ -0,0 +1,76 @@
+---
+name: straddle-api-ruby-sdk
+description: "Ruby SDK for Straddle API. Use when writing Ruby code that calls Straddle API with the straddle package: installing it, constructing and authenticating the client, and calling API operations."
+---
+
+# Straddle API Ruby SDK
+
+Generated Ruby client for Straddle API, published as `straddle`. Use the generated client instead of hand-writing HTTP requests.
+
+## Install
+
+Add the gem to your application's `Gemfile`:
+
+```ruby
+gem "straddle", "~> 1.0.0" # x-release-please-version
+```
+
+Or install it directly:
+
+```sh
+gem install straddle
+```
+
+## Client setup and authentication
+
+```ruby
+require "straddle"
+
+client = Straddle::Client.new(
+  bearer: ENV["BEARER"], # defaults to the BEARER env var
+)
+```
+
+Provide credentials using the options below. Environment variables are read automatically when the target runtime supports them:
+
+- `bearer` (env: `BEARER`) — Send the API key as a bearer token in the `Authorization` header.
+
+## Calling operations
+
+```ruby
+require "straddle"
+
+client = Straddle::Client.new(
+  bearer: ENV["BEARER"], # defaults to the BEARER env var
+)
+
+response = client.accounts.retrieve("7c9e6679-7425-40de-944b-e07fc1f90ae7")
+
+puts response.inspect
+```
+
+Method names, parameter shapes, and response types are generated from the API description — do not guess them. Look up the exact call signature in [api.md](./api.md) before writing a call.
+
+## Error handling
+
+Non-success responses throw generated API errors. Error objects expose status, headers, response body, and request metadata where the target runtime supports it.
+
+```ruby
+begin
+  response = client.accounts.retrieve("7c9e6679-7425-40de-944b-e07fc1f90ae7")
+
+  puts response.inspect
+rescue Straddle::Errors::APIError => error
+  puts "#{error.status}: #{error.message}"
+  raise
+end
+```
+
+## Requirements
+
+- Ruby >= 3.2
+
+## Reference files
+
+- [README.md](./README.md) — full feature tour: client options, request options, retries and timeouts.
+- [api.md](./api.md) — complete catalogue of every operation with request and response types.