straddle_pay 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 23aebc721853de383064f4e317d3f9a6e73705d06f2f4d0e8376873dbf05bace
+  data.tar.gz: 1996288b18fc0434b255e7638e8e75b83db350687eeca1dc93cd46f091525ac9
+SHA512:
+  metadata.gz: 36203c68e86e4df953735bdcb7b811a7d9db9c7867a8fa10c1ace55663ce894146621983a7d56f5490e8b1dc9cd62be65a27bb314bd4aed467e63215d78e0967
+  data.tar.gz: ff082a8507a7146e55ddee23a5286834212d7b97924821ce55f7a6c4c516c9653897b480173d5e363c333d6050504cd13399450972405ff2665d31bfb3ef9b72

data/CHANGELOG.md

@@ -0,0 +1,10 @@
+## [0.1.0] - 2026-02-19
+
+### Added
+- Initial release
+- Full Straddle API v1 coverage (59 endpoints)
+- Faraday-based HTTP client with configurable timeouts
+- Global config with per-instance overrides
+- Error hierarchy with validation detail accessors
+- Auto-unwrapped response envelope
+- Rails Engine support

data/LICENSE.txt

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2026 dpaluy
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.

data/README.md

@@ -0,0 +1,229 @@
+# StraddlePay
+
+Ruby client for the [Straddle](https://straddle.dev) payment infrastructure API.
+
+[![Gem Version](https://badge.fury.io/rb/straddle_pay.svg)](https://badge.fury.io/rb/straddle_pay)
+[![ci](https://github.com/dpaluy/straddle_pay/actions/workflows/ci.yml/badge.svg)](https://github.com/dpaluy/straddle_pay/actions/workflows/ci.yml)
+
+Lightweight, idiomatic Ruby wrapper using Faraday. No auto-generated code, no type system overhead — just clean Hash responses.
+
+## Installation
+
+```
+bundle add straddle_pay
+```
+
+## Usage
+
+Configure once:
+
+```ruby
+StraddlePay.configure do |config|
+  config.api_key  = ENV.fetch("STRADDLE_API_KEY")
+  config.base_url = StraddlePay::Config::PRODUCTION_URL  # default: sandbox
+end
+```
+
+Per-instance overrides:
+
+```ruby
+client = StraddlePay::Client.new(
+  api_key: "sk_different_key",
+  base_url: "https://production.straddle.io"
+)
+```
+
+### Environments
+
+| Environment | URL |
+|-------------|-----|
+| Sandbox (default) | `https://sandbox.straddle.io` |
+| Production | `https://production.straddle.io` |
+
+### Rails
+
+Create `config/initializers/straddle_pay.rb`:
+
+```ruby
+StraddlePay.configure do |config|
+  config.api_key  = Rails.application.credentials.straddle_api_key
+  config.base_url = StraddlePay::Config::PRODUCTION_URL
+  config.logger   = Rails.logger
+end
+```
+
+### Charges
+
+```ruby
+client = StraddlePay::Client.new
+
+charge = client.charges.create(
+  paykey: "pk_abc123",
+  amount: 10_000,
+  currency: "usd",
+  description: "Monthly subscription",
+  payment_date: "2026-03-01",
+  consent_type: "internet",
+  device: { ip_address: "192.168.1.1" },
+  external_id: "order_456"
+)
+charge["id"] # => "ch_..."
+
+client.charges.get("ch_abc123")
+client.charges.update("ch_abc123", amount: 15_000)
+client.charges.cancel("ch_abc123")
+client.charges.hold("ch_abc123")
+client.charges.release("ch_abc123")
+client.charges.unmask("ch_abc123")
+```
+
+### Payouts
+
+```ruby
+payout = client.payouts.create(
+  paykey: "pk_abc123",
+  amount: 5_000,
+  currency: "usd",
+  description: "Vendor payment",
+  payment_date: "2026-03-01",
+  device: { ip_address: "192.168.1.1" },
+  external_id: "payout_789"
+)
+
+# Cancel/hold/release require a reason
+client.payouts.cancel("po_abc123", reason: "Duplicate payment")
+client.payouts.hold("po_abc123", reason: "Under review")
+client.payouts.release("po_abc123", reason: "Review complete")
+```
+
+### Customers
+
+```ruby
+customer = client.customers.create(
+  name: "John Doe",
+  type: "individual",
+  email: "john@example.com",
+  phone: "+15551234567",
+  device: { ip_address: "192.168.1.1" }
+)
+
+customers = client.customers.list(page_number: 1, page_size: 25)
+
+# Identity review
+review = client.customers.reviews.get("cust_abc123")
+client.customers.reviews.decision("cust_abc123", status: "approved")
+client.customers.reviews.refresh("cust_abc123")
+```
+
+### Bridge (Bank Account Linking)
+
+```ruby
+session = client.bridge.initialize_session(customer_id: "cust_abc123")
+
+# Direct bank account link
+client.bridge.links.bank_account(
+  customer_id: "cust_abc123",
+  account_number: "1234567890",
+  routing_number: "021000021",
+  account_type: "checking"
+)
+
+# Or via Plaid/Quiltt
+client.bridge.links.plaid(customer_id: "cust_abc123", plaid_token: "plaid_token")
+client.bridge.links.quiltt(customer_id: "cust_abc123", quiltt_token: "quiltt_token")
+```
+
+### Paykeys
+
+```ruby
+client.paykeys.get("pk_abc123")
+client.paykeys.list
+client.paykeys.reveal("pk_abc123")
+client.paykeys.cancel("pk_abc123")
+```
+
+### Embedded Accounts
+
+```ruby
+org = client.embed.organizations.create(name: "Partner Corp")
+
+account = client.embed.accounts.create(
+  organization_id: org["id"],
+  account_type: "standard",
+  business_profile: { name: "Partner Corp" },
+  access_level: "standard"
+)
+client.embed.accounts.onboard(account["id"], terms_of_service: { accepted: true })
+
+client.embed.representatives.create(
+  account_id: account["id"],
+  first_name: "Jane", last_name: "Smith",
+  email: "jane@partner.com", dob: "1985-06-15",
+  mobile_number: "+15559876543", relationship: "owner", ssn_last4: "4321"
+)
+
+client.embed.linked_bank_accounts.create(
+  account_id: account["id"],
+  bank_account: { account_number: "9876543210", routing_number: "021000021" },
+  description: "Operating account"
+)
+```
+
+### Scoped Requests
+
+Pass `straddle_account_id` to scope requests to an embedded account:
+
+```ruby
+client.charges.create(
+  paykey: "pk_abc",
+  amount: 10_000,
+  currency: "usd",
+  description: "Scoped charge",
+  payment_date: "2026-03-01",
+  consent_type: "internet",
+  device: { ip_address: "1.2.3.4" },
+  external_id: "ext_1",
+  straddle_account_id: "acct_partner123"
+)
+```
+
+Headers `request_id`, `correlation_id`, and `idempotency_key` are also supported on all methods.
+
+## Error Handling
+
+```ruby
+begin
+  client.charges.create(...)
+rescue StraddlePay::AuthenticationError => e
+  # 401 or 403
+rescue StraddlePay::ClientError => e
+  # 400, 404, 409, 422
+  e.error_type    # => "validation_error"
+  e.error_items   # => [{"reference" => "email", "detail" => "is invalid"}]
+rescue StraddlePay::RateLimitError
+  # 429 - retry with backoff
+rescue StraddlePay::ServerError
+  # 500+
+rescue StraddlePay::NetworkError
+  # Timeout or connection failure
+end
+```
+
+### API Reference
+
+Full endpoint details: [straddle.dev/api-reference](https://straddle.dev/api-reference)
+
+## Development
+
+```
+bundle exec rake test
+bundle exec rubocop
+```
+
+## Contributing
+
+Bug reports and pull requests are welcome on GitHub at https://github.com/dpaluy/straddle_pay.
+
+## License
+
+The gem is available as open source under the terms of the [MIT License](https://opensource.org/licenses/MIT).

data/lib/straddle_pay/client.rb

@@ -0,0 +1,136 @@
+# frozen_string_literal: true
+
+require "faraday"
+require "json"
+
+module StraddlePay
+  class Client
+    attr_reader :api_key, :base_url
+
+    def initialize(api_key: nil, base_url: nil, logger: nil, open_timeout: nil, read_timeout: nil)
+      configuration = StraddlePay.config
+      @api_key      = api_key      || configuration.api_key
+      @base_url     = base_url     || configuration.base_url
+      @logger       = logger       || configuration.logger
+      @open_timeout = open_timeout || configuration.open_timeout
+      @read_timeout = read_timeout || configuration.read_timeout
+
+      raise ArgumentError, "Missing API key for StraddlePay" if @api_key.to_s.empty?
+    end
+
+    def customers      = @customers ||= Resources::Customers.new(self)
+    def bridge         = @bridge ||= Resources::Bridge.new(self)
+    def paykeys        = @paykeys ||= Resources::Paykeys.new(self)
+    def charges        = @charges ||= Resources::Charges.new(self)
+    def payouts        = @payouts ||= Resources::Payouts.new(self)
+    def payments       = @payments ||= Resources::Payments.new(self)
+    def funding_events = @funding_events ||= Resources::FundingEvents.new(self)
+    def reports        = @reports ||= Resources::Reports.new(self)
+    def embed          = @embed ||= Resources::Embed.new(self)
+
+    def get(path, params: nil, headers: {})
+      request(:get, path, params: params, headers: headers)
+    end
+
+    def post(path, body = nil, headers: {})
+      request(:post, path, body: body, headers: headers)
+    end
+
+    def put(path, body = nil, headers: {})
+      request(:put, path, body: body, headers: headers)
+    end
+
+    def patch(path, body = nil, headers: {})
+      request(:patch, path, body: body, headers: headers)
+    end
+
+    def delete(path, body = nil, headers: {})
+      request(:delete, path, body: body, headers: headers)
+    end
+
+    private
+
+    def request(method, path, body: nil, params: nil, headers: {})
+      response = connection.public_send(method, path) do |req|
+        apply_headers(req, headers)
+        apply_body(req, body) if body
+        req.params.update(params) if params
+      end
+      log_response(method, path, response)
+      handle_response(response)
+    rescue Faraday::TimeoutError, Faraday::ConnectionFailed => e
+      raise NetworkError, "Network error: #{e.message}"
+    end
+
+    def connection
+      @connection ||= Faraday.new(url: @base_url) do |f|
+        f.options.timeout      = @read_timeout
+        f.options.open_timeout = @open_timeout
+        f.adapter Faraday.default_adapter
+      end
+    end
+
+    def apply_headers(req, extra = {})
+      req.headers["Authorization"] = "Bearer #{@api_key}"
+      req.headers["Content-Type"]  = "application/json"
+      req.headers["Accept"]        = "application/json"
+      extra.each { |k, v| req.headers[k.to_s] = v.to_s if v }
+    end
+
+    def apply_body(req, body)
+      req.headers["Content-Type"] = "application/json"
+      req.body = JSON.generate(body)
+    end
+
+    def handle_response(response)
+      body = parse_body(response.body)
+      return unwrap_data(body) if success?(response.status)
+
+      raise_error(response.status, body)
+    end
+
+    def unwrap_data(body)
+      return body unless body.is_a?(Hash) && body.key?("data")
+
+      body["data"]
+    end
+
+    def success?(status)
+      (200..299).cover?(status)
+    end
+
+    def parse_body(body)
+      return {} if body.nil? || (body.is_a?(String) && body.empty?)
+      return body unless body.is_a?(String)
+
+      JSON.parse(body)
+    rescue JSON::ParserError
+      body
+    end
+
+    def raise_error(status, body)
+      message = error_message(status, body)
+      case status
+      when 401, 403 then raise AuthenticationError.new(message, status: status, body: body)
+      when 400, 404, 409, 422 then raise ClientError.new(message, status: status, body: body)
+      when 429 then raise RateLimitError.new(message, status: status, body: body)
+      when 500..599 then raise ServerError.new(message, status: status, body: body)
+      else raise Error.new(message, status: status, body: body)
+      end
+    end
+
+    def error_message(status, body)
+      detail = if body.is_a?(Hash)
+                 err = body["error"] || {}
+                 err.is_a?(Hash) ? (err["detail"] || err["title"] || err.to_json) : err.to_s
+               else
+                 body.to_s
+               end
+      "HTTP #{status}: #{detail}"
+    end
+
+    def log_response(method, path, response)
+      @logger&.debug { "StraddlePay #{method.upcase} #{path} -> #{response.status}" }
+    end
+  end
+end

data/lib/straddle_pay/config.rb

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+
+require "logger"
+
+module StraddlePay
+  class Config
+    SANDBOX_URL = "https://sandbox.straddle.io"
+    PRODUCTION_URL = "https://production.straddle.io"
+
+    attr_accessor :api_key, :base_url, :open_timeout, :read_timeout
+    attr_writer :logger
+
+    def initialize
+      @api_key = ENV.fetch("STRADDLE_API_KEY", nil)
+      @base_url = ENV.fetch("STRADDLE_BASE_URL", SANDBOX_URL)
+      @open_timeout = integer_or_default("STRADDLE_OPEN_TIMEOUT", 5)
+      @read_timeout = integer_or_default("STRADDLE_READ_TIMEOUT", 30)
+    end
+
+    def logger
+      @logger ||= (defined?(Rails) && Rails.respond_to?(:logger) && Rails.logger) || Logger.new($stderr)
+    end
+
+    private
+
+    def integer_or_default(key, default)
+      Integer(ENV.fetch(key, default))
+    rescue StandardError
+      default
+    end
+  end
+end

data/lib/straddle_pay/engine.rb

@@ -0,0 +1,9 @@
+# frozen_string_literal: true
+
+module StraddlePay
+  if defined?(Rails)
+    class Engine < ::Rails::Engine
+      isolate_namespace StraddlePay
+    end
+  end
+end

data/lib/straddle_pay/errors.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+module StraddlePay
+  class Error < StandardError
+    attr_reader :status, :body, :error_type, :error_items
+
+    def initialize(message = nil, status: nil, body: nil)
+      error_hash = body.is_a?(Hash) ? (body["error"] || {}) : {}
+      @error_type = error_hash["type"] if error_hash.is_a?(Hash)
+      @error_items = (error_hash.is_a?(Hash) ? error_hash["items"] : nil) || []
+      super(message)
+      @status = status
+      @body = body
+    end
+  end
+
+  class AuthenticationError < Error; end
+  class ClientError < Error; end
+  class RateLimitError < Error; end
+  class ServerError < Error; end
+  class NetworkError < Error; end
+end

data/lib/straddle_pay/resources/base.rb

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+module StraddlePay
+  module Resources
+    class Base
+      HEADER_KEYS = {
+        straddle_account_id: "Straddle-Account-Id",
+        request_id: "Request-Id",
+        correlation_id: "Correlation-Id",
+        idempotency_key: "Idempotency-Key"
+      }.freeze
+
+      def initialize(client)
+        @client = client
+      end
+
+      private
+
+      def extract_headers(params)
+        headers = {}
+        HEADER_KEYS.each do |key, header|
+          headers[header] = params.delete(key).to_s if params.key?(key)
+        end
+        headers
+      end
+    end
+  end
+end

data/lib/straddle_pay/resources/bridge.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+module StraddlePay
+  module Resources
+    class Bridge < Base
+      def links = @links ||= BridgeLinks.new(@client)
+
+      def initialize_session(customer_id:, **options)
+        payload = { customer_id: customer_id, **options }.compact
+        headers = extract_headers(payload)
+        @client.post("v1/bridge/initialize", payload, headers: headers)
+      end
+    end
+  end
+end

data/lib/straddle_pay/resources/bridge_links.rb

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+
+module StraddlePay
+  module Resources
+    class BridgeLinks < Base
+      def bank_account(customer_id:, account_number:, routing_number:, account_type:, **options)
+        payload = {
+          customer_id: customer_id, account_number: account_number,
+          routing_number: routing_number, account_type: account_type, **options
+        }.compact
+        headers = extract_headers(payload)
+        @client.post("v1/bridge/bank_account", payload, headers: headers)
+      end
+
+      def plaid(customer_id:, plaid_token:, **options)
+        payload = { customer_id: customer_id, plaid_token: plaid_token, **options }.compact
+        headers = extract_headers(payload)
+        @client.post("v1/bridge/plaid", payload, headers: headers)
+      end
+
+      def quiltt(customer_id:, quiltt_token:, **options)
+        payload = { customer_id: customer_id, quiltt_token: quiltt_token, **options }.compact
+        headers = extract_headers(payload)
+        @client.post("v1/bridge/quiltt", payload, headers: headers)
+      end
+
+      def tan(customer_id:, routing_number:, account_type:, tan:, **options)
+        payload = {
+          customer_id: customer_id, routing_number: routing_number,
+          account_type: account_type, tan: tan, **options
+        }.compact
+        headers = extract_headers(payload)
+        @client.post("v1/bridge/tan", payload, headers: headers)
+      end
+    end
+  end
+end

data/lib/straddle_pay/resources/charges.rb

@@ -0,0 +1,48 @@
+# frozen_string_literal: true
+
+module StraddlePay
+  module Resources
+    class Charges < Base
+      def create(paykey:, amount:, currency:, description:, payment_date:, consent_type:, device:, external_id:,
+                 **options)
+        payload = {
+          paykey: paykey, amount: amount, currency: currency, description: description,
+          payment_date: payment_date, consent_type: consent_type, device: device,
+          external_id: external_id, **options
+        }.compact
+        headers = extract_headers(payload)
+        @client.post("v1/charges", payload, headers: headers)
+      end
+
+      def get(id, **options)
+        headers = extract_headers(options)
+        @client.get("v1/charges/#{id}", headers: headers)
+      end
+
+      def update(id, **options)
+        headers = extract_headers(options)
+        @client.put("v1/charges/#{id}", options, headers: headers)
+      end
+
+      def cancel(id, **options)
+        headers = extract_headers(options)
+        @client.put("v1/charges/#{id}/cancel", options, headers: headers)
+      end
+
+      def hold(id, **options)
+        headers = extract_headers(options)
+        @client.put("v1/charges/#{id}/hold", options, headers: headers)
+      end
+
+      def release(id, **options)
+        headers = extract_headers(options)
+        @client.put("v1/charges/#{id}/release", options, headers: headers)
+      end
+
+      def unmask(id, **options)
+        headers = extract_headers(options)
+        @client.get("v1/charges/#{id}/unmask", headers: headers)
+      end
+    end
+  end
+end

data/lib/straddle_pay/resources/customer_reviews.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+module StraddlePay
+  module Resources
+    class CustomerReviews < Base
+      def get(customer_id, **options)
+        headers = extract_headers(options)
+        @client.get("v1/customers/#{customer_id}/review", headers: headers)
+      end
+
+      def decision(customer_id, status:, **options)
+        payload = { status: status, **options }.compact
+        headers = extract_headers(payload)
+        @client.patch("v1/customers/#{customer_id}/review", payload, headers: headers)
+      end
+
+      def refresh(customer_id, **options)
+        headers = extract_headers(options)
+        @client.put("v1/customers/#{customer_id}/refresh_review", options, headers: headers)
+      end
+    end
+  end
+end

data/lib/straddle_pay/resources/customers.rb

@@ -0,0 +1,40 @@
+# frozen_string_literal: true
+
+module StraddlePay
+  module Resources
+    class Customers < Base
+      def reviews = @reviews ||= CustomerReviews.new(@client)
+
+      def create(name:, type:, email:, phone:, device:, **options)
+        payload = { name: name, type: type, email: email, phone: phone, device: device, **options }.compact
+        headers = extract_headers(payload)
+        @client.post("v1/customers", payload, headers: headers)
+      end
+
+      def get(id, **options)
+        headers = extract_headers(options)
+        @client.get("v1/customers/#{id}", headers: headers)
+      end
+
+      def list(**options)
+        headers = extract_headers(options)
+        @client.get("v1/customers", params: options, headers: headers)
+      end
+
+      def update(id, **options)
+        headers = extract_headers(options)
+        @client.put("v1/customers/#{id}", options, headers: headers)
+      end
+
+      def delete(id, **options)
+        headers = extract_headers(options)
+        @client.delete("v1/customers/#{id}", headers: headers)
+      end
+
+      def unmasked(id, **options)
+        headers = extract_headers(options)
+        @client.get("v1/customers/#{id}/unmasked", headers: headers)
+      end
+    end
+  end
+end

data/lib/straddle_pay/resources/embed.rb

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+
+module StraddlePay
+  module Resources
+    class Embed < Base
+      def accounts              = @accounts ||= EmbedAccounts.new(@client)
+      def organizations         = @organizations ||= EmbedOrganizations.new(@client)
+      def representatives       = @representatives ||= EmbedRepresentatives.new(@client)
+      def linked_bank_accounts  = @linked_bank_accounts ||= EmbedLinkedBankAccounts.new(@client)
+    end
+  end
+end

data/lib/straddle_pay/resources/embed_accounts.rb

@@ -0,0 +1,43 @@
+# frozen_string_literal: true
+
+module StraddlePay
+  module Resources
+    class EmbedAccounts < Base
+      def create(organization_id:, account_type:, business_profile:, access_level:, **options)
+        payload = {
+          organization_id: organization_id, account_type: account_type,
+          business_profile: business_profile, access_level: access_level, **options
+        }.compact
+        headers = extract_headers(payload)
+        @client.post("v1/accounts", payload, headers: headers)
+      end
+
+      def get(id, **options)
+        headers = extract_headers(options)
+        @client.get("v1/accounts/#{id}", headers: headers)
+      end
+
+      def list(**options)
+        headers = extract_headers(options)
+        @client.get("v1/accounts", params: options, headers: headers)
+      end
+
+      def update(id, **options)
+        headers = extract_headers(options)
+        @client.put("v1/accounts/#{id}", options, headers: headers)
+      end
+
+      def onboard(id, terms_of_service:, **options)
+        payload = { terms_of_service: terms_of_service, **options }.compact
+        headers = extract_headers(payload)
+        @client.post("v1/accounts/#{id}/onboard", payload, headers: headers)
+      end
+
+      def simulate(id, final_status:, **options)
+        payload = { final_status: final_status, **options }.compact
+        headers = extract_headers(payload)
+        @client.post("v1/accounts/#{id}/simulate", payload, headers: headers)
+      end
+    end
+  end
+end

data/lib/straddle_pay/resources/embed_linked_bank_accounts.rb

@@ -0,0 +1,41 @@
+# frozen_string_literal: true
+
+module StraddlePay
+  module Resources
+    class EmbedLinkedBankAccounts < Base
+      def create(account_id:, bank_account:, description:, **options)
+        payload = {
+          account_id: account_id, bank_account: bank_account,
+          description: description, **options
+        }.compact
+        headers = extract_headers(payload)
+        @client.post("v1/linked_bank_accounts", payload, headers: headers)
+      end
+
+      def get(id, **options)
+        headers = extract_headers(options)
+        @client.get("v1/linked_bank_accounts/#{id}", headers: headers)
+      end
+
+      def list(**options)
+        headers = extract_headers(options)
+        @client.get("v1/linked_bank_accounts", params: options, headers: headers)
+      end
+
+      def update(id, **options)
+        headers = extract_headers(options)
+        @client.put("v1/linked_bank_accounts/#{id}", options, headers: headers)
+      end
+
+      def cancel(id, **options)
+        headers = extract_headers(options)
+        @client.patch("v1/linked_bank_accounts/#{id}/cancel", options.empty? ? nil : options, headers: headers)
+      end
+
+      def unmask(id, **options)
+        headers = extract_headers(options)
+        @client.get("v1/linked_bank_accounts/#{id}/unmask", headers: headers)
+      end
+    end
+  end
+end

data/lib/straddle_pay/resources/embed_organizations.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+module StraddlePay
+  module Resources
+    class EmbedOrganizations < Base
+      def create(name:, **options)
+        payload = { name: name, **options }.compact
+        headers = extract_headers(payload)
+        @client.post("v1/organizations", payload, headers: headers)
+      end
+
+      def get(id, **options)
+        headers = extract_headers(options)
+        @client.get("v1/organizations/#{id}", headers: headers)
+      end
+
+      def list(**options)
+        headers = extract_headers(options)
+        @client.get("v1/organizations", params: options, headers: headers)
+      end
+    end
+  end
+end

data/lib/straddle_pay/resources/embed_representatives.rb

@@ -0,0 +1,38 @@
+# frozen_string_literal: true
+
+module StraddlePay
+  module Resources
+    class EmbedRepresentatives < Base
+      def create(account_id:, first_name:, last_name:, email:, dob:, mobile_number:, relationship:, ssn_last4:,
+                 **options)
+        payload = {
+          account_id: account_id, first_name: first_name, last_name: last_name,
+          email: email, dob: dob, mobile_number: mobile_number,
+          relationship: relationship, ssn_last4: ssn_last4, **options
+        }.compact
+        headers = extract_headers(payload)
+        @client.post("v1/representatives", payload, headers: headers)
+      end
+
+      def get(id, **options)
+        headers = extract_headers(options)
+        @client.get("v1/representatives/#{id}", headers: headers)
+      end
+
+      def list(**options)
+        headers = extract_headers(options)
+        @client.get("v1/representatives", params: options, headers: headers)
+      end
+
+      def update(id, **options)
+        headers = extract_headers(options)
+        @client.put("v1/representatives/#{id}", options, headers: headers)
+      end
+
+      def unmask(id, **options)
+        headers = extract_headers(options)
+        @client.get("v1/representatives/#{id}/unmask", headers: headers)
+      end
+    end
+  end
+end

data/lib/straddle_pay/resources/funding_events.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+module StraddlePay
+  module Resources
+    class FundingEvents < Base
+      def list(**options)
+        headers = extract_headers(options)
+        @client.get("v1/funding-events", params: options, headers: headers)
+      end
+
+      def get(id, **options)
+        headers = extract_headers(options)
+        @client.get("v1/funding-events/#{id}", headers: headers)
+      end
+    end
+  end
+end

data/lib/straddle_pay/resources/paykeys.rb

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+
+module StraddlePay
+  module Resources
+    class Paykeys < Base
+      def get(id, **options)
+        headers = extract_headers(options)
+        @client.get("v1/paykeys/#{id}", headers: headers)
+      end
+
+      def list(**options)
+        headers = extract_headers(options)
+        @client.get("v1/paykeys", params: options, headers: headers)
+      end
+
+      def unmasked(id, **options)
+        headers = extract_headers(options)
+        @client.get("v1/paykeys/#{id}/unmasked", headers: headers)
+      end
+
+      def reveal(id, **options)
+        headers = extract_headers(options)
+        @client.get("v1/paykeys/#{id}/reveal", headers: headers)
+      end
+
+      def cancel(id, **options)
+        headers = extract_headers(options)
+        @client.put("v1/paykeys/#{id}/cancel", options, headers: headers)
+      end
+
+      def review(id, **options)
+        headers = extract_headers(options)
+        @client.patch("v1/paykeys/#{id}/review", options, headers: headers)
+      end
+    end
+  end
+end

data/lib/straddle_pay/resources/payments.rb

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+
+module StraddlePay
+  module Resources
+    class Payments < Base
+      def list(**options)
+        headers = extract_headers(options)
+        @client.get("v1/payments", params: options, headers: headers)
+      end
+    end
+  end
+end

data/lib/straddle_pay/resources/payouts.rb

@@ -0,0 +1,49 @@
+# frozen_string_literal: true
+
+module StraddlePay
+  module Resources
+    class Payouts < Base
+      def create(paykey:, amount:, currency:, description:, payment_date:, device:, external_id:, **options)
+        payload = {
+          paykey: paykey, amount: amount, currency: currency, description: description,
+          payment_date: payment_date, device: device, external_id: external_id, **options
+        }.compact
+        headers = extract_headers(payload)
+        @client.post("v1/payouts", payload, headers: headers)
+      end
+
+      def get(id, **options)
+        headers = extract_headers(options)
+        @client.get("v1/payouts/#{id}", headers: headers)
+      end
+
+      def update(id, **options)
+        headers = extract_headers(options)
+        @client.put("v1/payouts/#{id}", options, headers: headers)
+      end
+
+      def cancel(id, reason:, **options)
+        payload = { reason: reason, **options }.compact
+        headers = extract_headers(payload)
+        @client.put("v1/payouts/#{id}/cancel", payload, headers: headers)
+      end
+
+      def hold(id, reason:, **options)
+        payload = { reason: reason, **options }.compact
+        headers = extract_headers(payload)
+        @client.put("v1/payouts/#{id}/hold", payload, headers: headers)
+      end
+
+      def release(id, reason:, **options)
+        payload = { reason: reason, **options }.compact
+        headers = extract_headers(payload)
+        @client.put("v1/payouts/#{id}/release", payload, headers: headers)
+      end
+
+      def unmask(id, **options)
+        headers = extract_headers(options)
+        @client.get("v1/payouts/#{id}/unmask", headers: headers)
+      end
+    end
+  end
+end

data/lib/straddle_pay/resources/reports.rb

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+
+module StraddlePay
+  module Resources
+    class Reports < Base
+      def total_customers_by_status(**options)
+        headers = extract_headers(options)
+        @client.post("v1/reports/total_customers_by_status", options.empty? ? nil : options, headers: headers)
+      end
+    end
+  end
+end

data/lib/straddle_pay/version.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+module StraddlePay
+  VERSION = "0.1.0"
+end

data/lib/straddle_pay.rb

@@ -0,0 +1,49 @@
+# frozen_string_literal: true
+
+require_relative "straddle_pay/version"
+
+module StraddlePay
+  autoload :Config, "straddle_pay/config"
+  autoload :Client, "straddle_pay/client"
+  autoload :Error, "straddle_pay/errors"
+  autoload :AuthenticationError, "straddle_pay/errors"
+  autoload :ClientError, "straddle_pay/errors"
+  autoload :RateLimitError, "straddle_pay/errors"
+  autoload :ServerError, "straddle_pay/errors"
+  autoload :NetworkError, "straddle_pay/errors"
+
+  module Resources
+    autoload :Base, "straddle_pay/resources/base"
+    autoload :Charges, "straddle_pay/resources/charges"
+    autoload :Payouts, "straddle_pay/resources/payouts"
+    autoload :Customers, "straddle_pay/resources/customers"
+    autoload :CustomerReviews, "straddle_pay/resources/customer_reviews"
+    autoload :Bridge, "straddle_pay/resources/bridge"
+    autoload :BridgeLinks, "straddle_pay/resources/bridge_links"
+    autoload :Paykeys, "straddle_pay/resources/paykeys"
+    autoload :Payments, "straddle_pay/resources/payments"
+    autoload :FundingEvents, "straddle_pay/resources/funding_events"
+    autoload :Reports, "straddle_pay/resources/reports"
+    autoload :Embed, "straddle_pay/resources/embed"
+    autoload :EmbedAccounts, "straddle_pay/resources/embed_accounts"
+    autoload :EmbedOrganizations, "straddle_pay/resources/embed_organizations"
+    autoload :EmbedRepresentatives, "straddle_pay/resources/embed_representatives"
+    autoload :EmbedLinkedBankAccounts, "straddle_pay/resources/embed_linked_bank_accounts"
+  end
+
+  class << self
+    def config
+      @config ||= Config.new
+    end
+
+    def configure
+      yield(config)
+    end
+
+    def reset_configuration!
+      @config = nil
+    end
+  end
+end
+
+require_relative "straddle_pay/engine"

metadata

@@ -0,0 +1,90 @@
+--- !ruby/object:Gem::Specification
+name: straddle_pay
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- dpaluy
+bindir: bin
+cert_chain: []
+date: 1980-01-02 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: faraday
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.9'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.9'
+description: StraddlePay provides a lightweight Faraday-based wrapper for Straddle's
+  payment API including charges, payouts, customers, bridge, paykeys, and embedded
+  account management.
+email:
+- dpaluy@users.noreply.github.com
+executables: []
+extensions: []
+extra_rdoc_files:
+- CHANGELOG.md
+- LICENSE.txt
+- README.md
+files:
+- CHANGELOG.md
+- LICENSE.txt
+- README.md
+- lib/straddle_pay.rb
+- lib/straddle_pay/client.rb
+- lib/straddle_pay/config.rb
+- lib/straddle_pay/engine.rb
+- lib/straddle_pay/errors.rb
+- lib/straddle_pay/resources/base.rb
+- lib/straddle_pay/resources/bridge.rb
+- lib/straddle_pay/resources/bridge_links.rb
+- lib/straddle_pay/resources/charges.rb
+- lib/straddle_pay/resources/customer_reviews.rb
+- lib/straddle_pay/resources/customers.rb
+- lib/straddle_pay/resources/embed.rb
+- lib/straddle_pay/resources/embed_accounts.rb
+- lib/straddle_pay/resources/embed_linked_bank_accounts.rb
+- lib/straddle_pay/resources/embed_organizations.rb
+- lib/straddle_pay/resources/embed_representatives.rb
+- lib/straddle_pay/resources/funding_events.rb
+- lib/straddle_pay/resources/paykeys.rb
+- lib/straddle_pay/resources/payments.rb
+- lib/straddle_pay/resources/payouts.rb
+- lib/straddle_pay/resources/reports.rb
+- lib/straddle_pay/version.rb
+homepage: https://github.com/dpaluy/straddle_pay
+licenses:
+- MIT
+metadata:
+  rubygems_mfa_required: 'true'
+  homepage_uri: https://github.com/dpaluy/straddle_pay
+  documentation_uri: https://rubydoc.info/gems/straddle_pay
+  source_code_uri: https://github.com/dpaluy/straddle_pay
+  changelog_uri: https://github.com/dpaluy/straddle_pay/blob/master/CHANGELOG.md
+  bug_tracker_uri: https://github.com/dpaluy/straddle_pay/issues
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 3.2.0
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 4.0.3
+specification_version: 4
+summary: Ruby client for the Straddle payment infrastructure API.
+test_files: []