dodopayments 1.20.0 → 1.47.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 9c7b22e5857506ae73a79e9a4f5c8cbd92f03696fcf72f9934b7f70d73b9be99
-  data.tar.gz: 3aba6366092a43c500db25321615514724aa4e0015ca108ec27eb478346acd06
+  metadata.gz: 2252a6403fed71969ac392ab9bb4ba2848d974c23f4d1b74794adef1f07b59ad
+  data.tar.gz: 5e8dd97afcdc4842b4be9e6e5180530a76704a3fb2a6a8ef69cf1562c1abdda1
 SHA512:
-  metadata.gz: 0bb40b6240681cf2f68f968c3da1b960e782aa9daebe21cc1738730290ebb6aea7100f4aa8ac9b642dd685059dc5c155955984bc2bc1d7fb5c6604cf5e425171
-  data.tar.gz: be7ead7c6dcef10ddcacb9c6c6b46b423ccab46231a8f4ac9794054a0214b5220c69e0829837504be20a20f4214d846a5b0ba2f5c0fbb9ba7ead43e661669e0c
+  metadata.gz: 2118a05e104d278c37ef7482b7be3f9882d80135faae3850a660839a688f760cbe472c93067a44b7a298eef4919230f3f4ad4fbc61b36bd0a6c02236c45048c8
+  data.tar.gz: d94324ab3b148412073eb5a314115030d12b463b554da4ba47d5c967702692e00262d050223cae492df5e8ff190823a5a26a9ddfb31c779962baa8f1489c0e01

data/CHANGELOG.md

@@ -1,5 +1,50 @@
 # Changelog
 
+## 1.47.0 (2025-08-13)
+
+Full Changelog: [v1.22.0...v1.47.0](https://github.com/dodopayments/dodopayments-ruby/compare/v1.22.0...v1.47.0)
+
+### Features
+
+* **api:** manual updates ([983773e](https://github.com/dodopayments/dodopayments-ruby/commit/983773e4c578f0ed96f540e3f045834c10554143))
+
+
+### Chores
+
+* sync repo ([db17fcd](https://github.com/dodopayments/dodopayments-ruby/commit/db17fcde07de41be8514f3a310def3322718a388))
+
+## 1.22.0 (2025-05-09)
+
+Full Changelog: [v1.20.0...v1.22.0](https://github.com/dodopayments/dodopayments-ruby/compare/v1.20.0...v1.22.0)
+
+### Features
+
+* **api:** fixed api key schema to bearer ([06d3549](https://github.com/dodopayments/dodopayments-ruby/commit/06d354910a3eb15c036d35f68cfb5393c5a20c62))
+* **api:** manual updates ([eae9353](https://github.com/dodopayments/dodopayments-ruby/commit/eae935376b239dc03bc8ad8ed201e9ca9c2eeaa4))
+* **api:** updated openapi spec ([c369261](https://github.com/dodopayments/dodopayments-ruby/commit/c369261442be58e8b31890f0362fba1536bb9593))
+
+
+### Bug Fixes
+
+* **internal:** fix formatting script for macos ([8abfc9c](https://github.com/dodopayments/dodopayments-ruby/commit/8abfc9c2b3921e5fb3e5903612111e02a87e92d1))
+
+
+### Chores
+
+* accept all nd-json mimetype variants ([b0dd5d6](https://github.com/dodopayments/dodopayments-ruby/commit/b0dd5d644ce5ebbcd0259dca5f9113befa548b54))
+* always check if current page is empty in `next_page?` ([45b817d](https://github.com/dodopayments/dodopayments-ruby/commit/45b817d504e3c4cbc17b328c53ab9a310d038b22))
+* **internal:** codegen related update ([e3ce1b3](https://github.com/dodopayments/dodopayments-ruby/commit/e3ce1b36a1ea8dba0fbd2915a6deadc01820d280))
+* **internal:** codegen related update ([2cd0f3e](https://github.com/dodopayments/dodopayments-ruby/commit/2cd0f3e089a67097c26e9abef90b55cecfaa014c))
+* re-export top level models under library namespace ([bbc82df](https://github.com/dodopayments/dodopayments-ruby/commit/bbc82df831d64038e9169ff0912401d2e333082b))
+* remove Gemfile.lock during bootstrap ([a484914](https://github.com/dodopayments/dodopayments-ruby/commit/a48491445f25a274883dd8068913efcd9e68c32d))
+* revert ignoring Gemfile.lock ([8ba5e6a](https://github.com/dodopayments/dodopayments-ruby/commit/8ba5e6a4f876f0823b33eb92443ebd5d97c2139f))
+* validate request option coercion correctness ([1ac286c](https://github.com/dodopayments/dodopayments-ruby/commit/1ac286ccf79b674d312bf50fa29bb8a1f7e37176))
+
+
+### Documentation
+
+* illustrate environmental defaults for auth variables ([520d6cf](https://github.com/dodopayments/dodopayments-ruby/commit/520d6cf3692d5aeaf3faee980160521d81bd3867))
+
 ## 1.20.0 (2025-05-01)
 
 Full Changelog: [v1.19.0...v1.20.0](https://github.com/dodopayments/dodopayments-ruby/compare/v1.19.0...v1.20.0)

data/README.md

@@ -1,6 +1,6 @@
 # Dodo Payments Ruby API library
 
-The Dodo Payments Ruby library provides convenient access to the Dodo Payments REST API from any Ruby 3.2.0+ application.
+The Dodo Payments Ruby library provides convenient access to the Dodo Payments 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/dodopayments/dodopayments-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.
 
 It is generated with [Stainless](https://www.stainless.com/).
 
@@ -17,7 +17,7 @@ To use this gem, install via Bundler by adding the following to your application
 <!-- x-release-please-start-version -->
 
 ```ruby
-gem "dodopayments", "~> 1.20.0"
+gem "dodopayments", "~> 1.47.0"
 ```
 
 <!-- x-release-please-end -->
@@ -29,25 +29,19 @@ require "bundler/setup"
 require "dodopayments"
 
 dodo_payments = Dodopayments::Client.new(
-  api_key: "My API Key", # defaults to ENV["DODO_PAYMENTS_API_KEY"]
+  bearer_token: ENV["DODO_PAYMENTS_API_KEY"], # This is the default and can be omitted
   environment: "test_mode" # defaults to "live_mode"
 )
 
-payment = dodo_payments.payments.create
+payment = dodo_payments.payments.create(
+  billing: {city: "city", country: "AF", state: "state", street: "street", zipcode: "zipcode"},
+  customer: {customer_id: "customer_id"},
+  product_cart: [{product_id: "product_id", quantity: 0}]
+)
 
 puts(payment.payment_id)
 ```
 
-## Sorbet
-
-This library is written with [Sorbet type definitions](https://sorbet.org/docs/rbi). However, there is no runtime dependency on the `sorbet-runtime`.
-
-When using sorbet, it is recommended to use model classes as below. This provides stronger type checking and tooling integration.
-
-```ruby
-dodo_payments.payments.create
-```
-
 ### Pagination
 
 List methods in the Dodo Payments API are paginated.
@@ -59,23 +53,42 @@ page = dodo_payments.payments.list
 
 # Fetch single item from page.
 payment = page.items[0]
-puts(payment.payment_id)
+puts(payment.brand_id)
 
 # Automatically fetches more pages as needed.
 page.auto_paging_each do |payment|
-  puts(payment.payment_id)
+  puts(payment.brand_id)
 end
 ```
 
-### Errors
+Alternatively, you can use the `#next_page?` and `#next_page` methods for more granular control working with pages.
+
+```ruby
+if page.next_page?
+  new_page = page.next_page
+  puts(new_page.items[0].brand_id)
+end
+```
+
+### 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 `Dodopayments::Errors::APIError` will be thrown:
 
 ```ruby
 begin
-  payment = dodo_payments.payments.create
-rescue Dodopayments::Errors::APIError => e
-  puts(e.status) # 400
+  payment = dodo_payments.payments.create(
+    billing: {city: "city", country: "AF", state: "state", street: "street", zipcode: "zipcode"},
+    customer: {customer_id: "customer_id"},
+    product_cart: [{product_id: "product_id", quantity: 0}]
+  )
+rescue Dodopayments::Errors::APIConnectionError => e
+  puts("The server could not be reached")
+  puts(e.cause)  # an underlying Exception, likely raised within `net/http`
+rescue Dodopayments::Errors::RateLimitError => e
+  puts("A 429 status code was received; we should back off a bit.")
+rescue Dodopayments::Errors::APIStatusError => e
+  puts("Another non-200-range status code was received")
+  puts(e.status)
 end
 ```
 
@@ -110,16 +123,17 @@ dodo_payments = Dodopayments::Client.new(
 )
 
 # Or, configure per-request:
-dodo_payments.payments.create(request_options: {max_retries: 5})
+dodo_payments.payments.create(
+  billing: {city: "city", country: "AF", state: "state", street: "street", zipcode: "zipcode"},
+  customer: {customer_id: "customer_id"},
+  product_cart: [{product_id: "product_id", quantity: 0}],
+  request_options: {max_retries: 5}
+)
 ```
 
 ### Timeouts
 
-By default, requests will time out after 60 seconds.
-
-Timeouts are applied separately to the initial connection and the overall request time, so in some cases a request could wait 2\*timeout seconds before it fails.
-
-You can use the `timeout` option to configure or disable this:
+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:
@@ -128,42 +142,63 @@ dodo_payments = Dodopayments::Client.new(
 )
 
 # Or, configure per-request:
-dodo_payments.payments.create(request_options: {timeout: 5})
+dodo_payments.payments.create(
+  billing: {city: "city", country: "AF", state: "state", street: "street", zipcode: "zipcode"},
+  customer: {customer_id: "customer_id"},
+  product_cart: [{product_id: "product_id", quantity: 0}],
+  request_options: {timeout: 5}
+)
 ```
 
-## Model DSL
+On timeout, `Dodopayments::Errors::APITimeoutError` is raised.
 
-This library uses a simple DSL to represent request parameters and response shapes in `lib/dodopayments/models`.
+Note that requests that time out are retried by default.
 
-With the right [editor plugins](https://shopify.github.io/ruby-lsp), you can ctrl-click on elements of the DSL to navigate around and explore the library.
+## Advanced concepts
 
-In all places where a `BaseModel` type is specified, vanilla Ruby `Hash` can also be used. For example, the following are interchangeable as arguments:
+### BaseModel
 
-```ruby
-# This has tooling readability, for auto-completion, static analysis, and goto definition with supported language services
-params = Dodopayments::Models::PaymentCreateParams.new
+All parameter and response objects inherit from `Dodopayments::Internal::Type::BaseModel`, which provides several conveniences, including:
 
-# This also works
-params = {
+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.
 
-## Editor support
+3. Both instances and the classes themselves can be pretty-printed.
 
-A combination of [Shopify LSP](https://shopify.github.io/ruby-lsp) and [Solargraph](https://solargraph.org/) is recommended for non-[Sorbet](https://sorbet.org) users. The former is especially good at go to definition, while the latter has much better auto-completion support.
+4. Helpers such as `#to_h`, `#deep_to_h`, `#to_json`, and `#to_yaml`.
 
-## Advanced concepts
+### Making custom or undocumented requests
+
+#### Undocumented properties
 
-### Making custom/undocumented requests
+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
+payment =
+  dodo_payments.payments.create(
+    billing: {city: "city", country: "AF", state: "state", street: "street", zipcode: "zipcode"},
+    customer: {customer_id: "customer_id"},
+    product_cart: [{product_id: "product_id", quantity: 0}],
+    request_options: {
+      extra_query: {my_query_parameter: value},
+      extra_body: {my_body_parameter: value},
+      extra_headers: {"my-header": value}
+    }
+  )
+
+puts(payment[:my_undocumented_property])
+```
 
 #### Undocumented request params
 
-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 requests as seen in examples above.
+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.
 
 #### Undocumented endpoints
 
-To make requests to undocumented endpoints, you can make requests using `client.request`. Options on the client will be respected (such as retries) when making this request.
+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:
 
 ```ruby
 response = client.request(
@@ -171,42 +206,91 @@ response = client.request(
   path: '/undocumented/endpoint',
   query: {"dog": "woof"},
   headers: {"useful-header": "interesting-value"},
-  body: {"he": "llo"},
+  body: {"hello": "world"}
 )
 ```
 
 ### Concurrency & connection pooling
 
-The `Dodopayments::Client` instances are thread-safe, and should be re-used across multiple threads. By default, each `Client` have their own HTTP connection pool, with a maximum number of connections equal to thread count.
+The `Dodopayments::Client` instances are threadsafe, but are only are fork-safe when there are no in-flight HTTP requests.
+
+Each instance of `Dodopayments::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 the maximum number of connections has been checked out from the connection pool, the `Client` will wait for an in use connection to become available. The queue time for this mechanism is accounted for by the per-request timeout.
+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.
 
-Currently, `Dodopayments::Client` instances are only fork-safe if there are no in-flight HTTP requests.
+## Sorbet
 
-### Sorbet
+This library provides comprehensive [RBI](https://sorbet.org/docs/rbi) definitions, and has no dependency on sorbet-runtime.
 
-#### Enums
+You can provide typesafe request parameters like so:
 
-Sorbet's typed enums require sub-classing of the [`T::Enum` class](https://sorbet.org/docs/tenum) from the `sorbet-runtime` gem.
+```ruby
+dodo_payments.payments.create(
+  billing: Dodopayments::BillingAddress.new(
+    city: "city",
+    country: "AF",
+    state: "state",
+    street: "street",
+    zipcode: "zipcode"
+  ),
+  customer: Dodopayments::AttachExistingCustomer.new(customer_id: "customer_id"),
+  product_cart: [Dodopayments::OneTimeProductCartItem.new(product_id: "product_id", quantity: 0)]
+)
+```
 
-Since this library does not depend on `sorbet-runtime`, it uses a [`T.all` intersection type](https://sorbet.org/docs/intersection-types) with a ruby primitive type to construct a "tagged alias" instead.
+Or, equivalently:
 
 ```ruby
-module Dodopayments::Models::IntentStatus
-  # This alias aids language service driven navigation.
-  TaggedSymbol = T.type_alias { T.all(Symbol, Dodopayments::Models::IntentStatus) }
-end
+# Hashes work, but are not typesafe:
+dodo_payments.payments.create(
+  billing: {city: "city", country: "AF", state: "state", street: "street", zipcode: "zipcode"},
+  customer: {customer_id: "customer_id"},
+  product_cart: [{product_id: "product_id", quantity: 0}]
+)
+
+# You can also splat a full Params class:
+params = Dodopayments::PaymentCreateParams.new(
+  billing: Dodopayments::BillingAddress.new(
+    city: "city",
+    country: "AF",
+    state: "state",
+    street: "street",
+    zipcode: "zipcode"
+  ),
+  customer: Dodopayments::AttachExistingCustomer.new(customer_id: "customer_id"),
+  product_cart: [Dodopayments::OneTimeProductCartItem.new(product_id: "product_id", quantity: 0)]
+)
+dodo_payments.payments.create(**params)
 ```
 
-#### Argument passing trick
+### Enums
 
-It is possible to pass a compatible model / parameter class to a method that expects keyword arguments by using the `**` splat operator.
+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:
 
 ```ruby
-params = Dodopayments::Models::PaymentCreateParams.new
-dodo_payments.payments.create(**params)
+# :AED
+puts(Dodopayments::Currency::AED)
+
+# Revealed type: `T.all(Dodopayments::Currency, Symbol)`
+T.reveal_type(Dodopayments::Currency::AED)
+```
+
+Enum parameters have a "relaxed" type, so you can either pass in enum constants or their literal value:
+
+```ruby
+# Using the enum constants preserves the tagged type information:
+dodo_payments.payments.create(
+  billing_currency: Dodopayments::Currency::AED,
+  # …
+)
+
+# Literal values are also permissible:
+dodo_payments.payments.create(
+  billing_currency: :AED,
+  # …
+)
 ```
 
 ## Versioning

data/SECURITY.md

@@ -16,11 +16,11 @@ before making any information public.
 ## Reporting Non-SDK Related Security Issues
 
 If you encounter security issues that are not directly related to SDKs but pertain to the services
-or products provided by Dodo Payments please follow the respective company's security reporting guidelines.
+or products provided by Dodo Payments, please follow the respective company's security reporting guidelines.
 
 ### Dodo Payments Terms and Policies
 
-Please contact founders@dodopayments.com for any questions or concerns regarding security of our services.
+Please contact founders@dodopayments.com for any questions or concerns regarding the security of our services.
 
 ---
 

data/lib/dodopayments/client.rb

@@ -20,8 +20,9 @@ module Dodopayments
     ENVIRONMENTS = {live_mode: "https://live.dodopayments.com", test_mode: "https://test.dodopayments.com"}
     # rubocop:enable Style/MutableConstant
 
+    # Bearer Token for API authentication
     # @return [String]
-    attr_reader :api_key
+    attr_reader :bearer_token
 
     # @return [Dodopayments::Resources::Payments]
     attr_reader :payments
@@ -68,18 +69,27 @@ module Dodopayments
     # @return [Dodopayments::Resources::Addons]
     attr_reader :addons
 
+    # @return [Dodopayments::Resources::Brands]
+    attr_reader :brands
+
+    # @return [Dodopayments::Resources::Webhooks]
+    attr_reader :webhooks
+
+    # @return [Dodopayments::Resources::YourWebhookURL]
+    attr_reader :your_webhook_url
+
     # @api private
     #
     # @return [Hash{String=>String}]
     private def auth_headers
-      return {} if @api_key.nil?
+      return {} if @bearer_token.nil?
 
-      {"authorization" => "Bearer #{@api_key}"}
+      {"authorization" => "Bearer #{@bearer_token}"}
     end
 
     # Creates and returns a new client for interacting with the API.
     #
-    # @param api_key [String, nil] Defaults to `ENV["DODO_PAYMENTS_API_KEY"]`
+    # @param bearer_token [String, nil] Bearer Token for API authentication Defaults to `ENV["DODO_PAYMENTS_API_KEY"]`
     #
     # @param environment [:live_mode, :test_mode, nil] Specifies the environment to use for the API.
     #
@@ -99,24 +109,24 @@ module Dodopayments
     #
     # @param max_retry_delay [Float]
     def initialize(
-      api_key: ENV["DODO_PAYMENTS_API_KEY"],
+      bearer_token: ENV["DODO_PAYMENTS_API_KEY"],
       environment: nil,
       base_url: ENV["DODO_PAYMENTS_BASE_URL"],
-      max_retries: Dodopayments::Client::DEFAULT_MAX_RETRIES,
-      timeout: Dodopayments::Client::DEFAULT_TIMEOUT_IN_SECONDS,
-      initial_retry_delay: Dodopayments::Client::DEFAULT_INITIAL_RETRY_DELAY,
-      max_retry_delay: Dodopayments::Client::DEFAULT_MAX_RETRY_DELAY
+      max_retries: self.class::DEFAULT_MAX_RETRIES,
+      timeout: self.class::DEFAULT_TIMEOUT_IN_SECONDS,
+      initial_retry_delay: self.class::DEFAULT_INITIAL_RETRY_DELAY,
+      max_retry_delay: self.class::DEFAULT_MAX_RETRY_DELAY
     )
       base_url ||= Dodopayments::Client::ENVIRONMENTS.fetch(environment&.to_sym || :production) do
         message = "environment must be one of #{Dodopayments::Client::ENVIRONMENTS.keys}, got #{environment}"
         raise ArgumentError.new(message)
       end
 
-      if api_key.nil?
-        raise ArgumentError.new("api_key is required, and can be set via environ: \"DODO_PAYMENTS_API_KEY\"")
+      if bearer_token.nil?
+        raise ArgumentError.new("bearer_token is required, and can be set via environ: \"DODO_PAYMENTS_API_KEY\"")
       end
 
-      @api_key = api_key.to_s
+      @bearer_token = bearer_token.to_s
 
       super(
         base_url: base_url,
@@ -141,6 +151,9 @@ module Dodopayments
       @misc = Dodopayments::Resources::Misc.new(client: self)
       @discounts = Dodopayments::Resources::Discounts.new(client: self)
       @addons = Dodopayments::Resources::Addons.new(client: self)
+      @brands = Dodopayments::Resources::Brands.new(client: self)
+      @webhooks = Dodopayments::Resources::Webhooks.new(client: self)
+      @your_webhook_url = Dodopayments::Resources::YourWebhookURL.new(client: self)
     end
   end
 end

data/lib/dodopayments/errors.rb

@@ -9,6 +9,28 @@ module Dodopayments
     end
 
     class ConversionError < Dodopayments::Errors::Error
+      # @return [StandardError, nil]
+      def cause = @cause.nil? ? super : @cause
+
+      # @api private
+      #
+      # @param on [Class<StandardError>]
+      # @param method [Symbol]
+      # @param target [Object]
+      # @param value [Object]
+      # @param cause [StandardError, nil]
+      def initialize(on:, method:, target:, value:, cause: nil)
+        cls = on.name.split("::").last
+
+        message = [
+          "Failed to parse #{cls}.#{method} from #{value.class} to #{target.inspect}.",
+          "To get the unparsed API response, use #{cls}[#{method.inspect}].",
+          cause && "Cause: #{cause.message}"
+        ].filter(&:itself).join(" ")
+
+        @cause = cause
+        super(message)
+      end
     end
 
     class APIError < Dodopayments::Errors::Error
@@ -99,7 +121,7 @@ module Dodopayments
       # @param response [nil]
       # @param message [String, nil]
       #
-      # @return [Dodopayments::Errors::APIStatusError]
+      # @return [self]
       def self.for(url:, status:, body:, request:, response:, message: nil)
         kwargs = {
           url: url,

data/lib/dodopayments/file_part.rb

@@ -45,9 +45,9 @@ module Dodopayments
       @filename =
         case content
         in Pathname
-          filename.nil? ? content.basename.to_path : File.basename(filename)
+          filename.nil? ? content.basename.to_path : ::File.basename(filename)
         else
-          filename.nil? ? nil : File.basename(filename)
+          filename.nil? ? nil : ::File.basename(filename)
         end
       @content_type = content_type
     end

data/lib/dodopayments/internal/cursor_page_pagination.rb

@@ -0,0 +1,90 @@
+# frozen_string_literal: true
+
+module Dodopayments
+  module Internal
+    # @generic Elem
+    #
+    # @example
+    #   if cursor_page_pagination.has_next?
+    #     cursor_page_pagination = cursor_page_pagination.next_page
+    #   end
+    #
+    # @example
+    #   cursor_page_pagination.auto_paging_each do |webhook|
+    #     puts(webhook)
+    #   end
+    class CursorPagePagination
+      include Dodopayments::Internal::Type::BasePage
+
+      # @return [Array<generic<Elem>>, nil]
+      attr_accessor :data
+
+      # @return [String]
+      attr_accessor :iterator
+
+      # @return [Boolean]
+      attr_accessor :done
+
+      # @return [Boolean]
+      def next_page?
+        done
+      end
+
+      # @raise [Dodopayments::HTTP::Error]
+      # @return [self]
+      def next_page
+        unless next_page?
+          message = "No more pages available. Please check #next_page? before calling ##{__method__}"
+          raise RuntimeError.new(message)
+        end
+
+        req = Dodopayments::Internal::Util.deep_merge(@req, {query: {iterator: iterator}})
+        @client.request(req)
+      end
+
+      # @param blk [Proc]
+      #
+      # @yieldparam [generic<Elem>]
+      def auto_paging_each(&blk)
+        unless block_given?
+          raise ArgumentError.new("A block must be given to ##{__method__}")
+        end
+
+        page = self
+        loop do
+          page.data&.each(&blk)
+
+          break unless page.next_page?
+          page = page.next_page
+        end
+      end
+
+      # @api private
+      #
+      # @param client [Dodopayments::Internal::Transport::BaseClient]
+      # @param req [Hash{Symbol=>Object}]
+      # @param headers [Hash{String=>String}, Net::HTTPHeader]
+      # @param page_data [Hash{Symbol=>Object}]
+      def initialize(client:, req:, headers:, page_data:)
+        super
+
+        case page_data
+        in {data: Array => data}
+          @data = data.map { Dodopayments::Internal::Type::Converter.coerce(@model, _1) }
+        else
+        end
+        @iterator = page_data[:iterator]
+        @done = page_data[:done]
+      end
+
+      # @api private
+      #
+      # @return [String]
+      def inspect
+        model = Dodopayments::Internal::Type::Converter.inspect(@model, depth: 1)
+
+        "#<#{self.class}[#{model}]:0x#{object_id.to_s(16)} iterator=#{iterator.inspect} done=#{done.inspect}>"
+      end
+    end
+  end
+end

data/lib/dodopayments/internal/default_page_number_pagination.rb

@@ -72,8 +72,8 @@ module Dodopayments
         super
 
         case page_data
-        in {items: Array | nil => items}
-          @items = items&.map { Dodopayments::Internal::Type::Converter.coerce(@model, _1) }
+        in {items: Array => items}
+          @items = items.map { Dodopayments::Internal::Type::Converter.coerce(@model, _1) }
         else
         end
       end