shopify_api 13.1.0 → 13.4.0

data/docs/usage/rest.md

@@ -1,10 +1,153 @@
 # Make a REST API call
 
-Once OAuth is complete, we can use the `ShopifyAPI::Clients::Rest::Admin` client to make an API call to the Shopify Admin API. To do this, you can create an instance of `ShopifyAPI::Clients::Rest::Admin` using the current session to make requests to the Admin API.
+Once OAuth is complete, we can use `ShopifyAPI`'s REST library to make authenticated API calls to the Shopify Admin API.
+#### Required Session
+Every API request requires a valid
+[ShopifyAPI::Auth::Session](https://github.com/Shopify/shopify-api-ruby/blob/main/lib/shopify_api/auth/session.rb).
+
+To instantiate a session, we recommend you either use the `shopify_app` if working in Rails, or refer to our OAuth docs on constructing a session:
+ - ["Custom Apps"](https://github.com/Shopify/shopify-api-ruby/blob/main/docs/usage/custom_apps.md) - documentation on how to create Session from a custom app API token.
+ - ["Performing OAuth"](https://github.com/Shopify/shopify-api-ruby/blob/main/docs/usage/oauth.md) - documentation on how to create new sessions
+ - [[ShopifyApp] - "Session"](https://github.com/Shopify/shopify_app/blob/main/docs/shopify_app/sessions.md) - documentation on session handling if you're using the [`ShopifyApp`](https://github.com/Shopify/shopify_app) gem.
+
+#### There are 2 methods you can use to make REST API calls to Shopify:
+- [Using REST Resources](#using-rest-resources)
+  - Resource classes with similar syntax as `ActiveResource`, and follows our REST convention. Example:
+  ``` ruby
+  # Update product title
+  product = ShopifyAPI::Product.find(id: <product_id>)
+  product.title = "My awesome product"
+  product.save!
+  ```
+
+- [Using REST Admin Client](#using-rest-admin-client)
+  - More manual input method to make the API call. Example:
+  ```ruby
+  # Create a new client.
+  rest_client = ShopifyAPI::Clients::Rest::Admin.new
+
+  # Update product title
+  body = {
+    product: {
+      title: "My cool product"
+    }
+  }
+
+  # Use `client.put` to send your request to the specified Shopify Admin REST API endpoint.
+  rest_client.put(path: "products/<id>.json", body: body)
+  ```
+
+## Using REST Resources
+We provide a templated class library to access REST resources similar to `ActiveResource`. Format of the methods closely resemble our [REST API schema](https://shopify.dev/docs/api/admin-rest).
+
+The version of REST resource that's loaded and used is set from [`ShopifyAPI::Context.setup`](https://github.com/Shopify/shopify-api-ruby/blob/main/README.md#setup-shopify-context)
+
+### Instantiation
+Create an instance of the REST resource you'd like to use and optionally provide the following parameters.
+#### Constructor parameters
+| Parameter | Type | Notes |
+| ----------|------|-------|
+| `session` | `ShopifyAPI::Auth::Session` | Default value is `nil`. <br><br>When `nil` is passed in, active session information is inferred from `ShopifyAPI::Context.active_session`. <br>To set active session, use `ShopifyAPI::Context.activate_session`. <br><br>This is handled automatically behind the scenes if you use ShopifyApp's [session controllers](https://github.com/Shopify/shopify_app/blob/main/docs/shopify_app/sessions.md). |
+| `from_hash` | `Hash` |  Default value is `nil`. Sets the resource properties to the values provided from the hash. |
+
+Examples:
+
+```ruby
+# To construct an Orders object using default session
+# This creates a new order object with properties provided from the hash
+order = ShopifyAPI::Orders.new(from_hash: {property: value})
+order.save!
+```
+
+### Methods
+Typical methods provided for each resources are:
+- `find`
+- `delete`
+- `all`
+- `count`
+
+Full list of methods can be found on each of the resource class.
+- Path:
+  - https://github.com/Shopify/shopify-api-ruby/blob/main/lib/shopify_api/rest/resources/#{version}/#{resource}.rb
+- Example for `Order` resource on `2023-04` version:
+  - https://github.com/Shopify/shopify-api-ruby/blob/main/lib/shopify_api/rest/resources/2023_04/order.rb
+
+### Usage Examples
+⚠️ Reference documentation on [shopify.dev](https://shopify.dev/docs/api/admin-rest) contains more examples on how to use each REST Resources.
+
+```Ruby
+# Find and update a customer email
+customer = ShopifyAPI::Customer.find(id: customer_id)
+customer.email = "steve-lastnameson@example.com"
+customer.save!
+
+# Create a new product from hash
+product_properties = {
+  title: "My awesome product"
+}
+product = ShopifyAPI::Product.new(from_hash: product_properties)
+product.save!
+
+# Create a product manually
+product = ShopifyAPI::Product.new
+product.title = "Another one"
+product.save!
+
+# Get all orders
+orders = ShopifyAPI::Orders.all
+
+# Retrieve a specific fulfillment order
+fulfillment_order_id = 123456789
+fulfillment_order = ShopifyAPI::FulfillmentOrder.find(id: fulfillment_order_id)
+
+# Remove an existing product image
+product_id = 1234567
+image_id = 1233211234567
+ShopifyAPI::Image.delete(product_id: product_id, id: image_id)
+```
+
+More examples can be found in each resource's documentation on [shopify.dev](https://shopify.dev/docs/api/admin-rest), e.g.:
+- [Order](https://shopify.dev/docs/api/admin-rest/current/resources/order)
+- [Product](https://shopify.dev/docs/api/admin-rest/current/resources/product)
+
+## Using REST Admin Client
 
-## Methods
+### Instantiation
+Create an instance of [`ShopifyAPI::Clients::Rest::Admin`](https://github.com/Shopify/shopify-api-ruby/blob/main/lib/shopify_api/clients/rest/admin.rb) using the current session to make requests to the Admin API.
+#### Constructor parameters
+| Parameter | Type | Notes |
+| ----------|------|-------|
+| `session` | `ShopifyAPI::Auth::Session` | Default value is `nil`. <br><br>When `nil` is passed in, active session information is inferred from `ShopifyAPI::Context.active_session`. <br>To set active session, use `ShopifyAPI::Context.activate_session`. <br><br>This is handled automatically behind the scenes if you use ShopifyApp's [session controllers](https://github.com/Shopify/shopify_app/blob/main/docs/shopify_app/sessions.md). |
+| `api_version` | `String` | Default value is `nil`. When `nil` is passed in, api version is inferred from [`ShopifyAPI::Context.setup`](https://github.com/Shopify/shopify-api-ruby/blob/main/README.md#setup-shopify-context).|
 
-The Rest Admin client offers the 4 core request methods: `get`, `delete`, `post`, and `put`. These methods each take the parameters outlined in the table below. If the request is successful these methods will all return a `ShopifyAPI::Clients::HttpResponse` object, which has properties `code`, `headers`, and `body` otherwise an error will be raised describing what went wrong.
+Examples:
+```ruby
+# Create a default client with `ShopifyAPI::Context.api_version`
+# and the active session from `ShopifyAPI::Context.active_session`
+client = ShopifyAPI::Clients::Rest::Admin.new
+
+# Create a client with a specific session "my_session"
+client = ShopifyAPI::Clients::Rest::Admin.new(session: my_session)
+
+# Create a client with active session from `ShopifyAPI::Context.active_session`
+# and a specific api_version - "unstable"
+client = ShopifyAPI::Clients::Rest::Admin.new(api_version: "unstable")
+
+# Create a client with a specific session "my_session" and api_version "unstable"
+client = ShopifyAPI::Clients::Rest::Admin.new(session: my_session, api_version: "unstable")
+```
+
+### Methods
+
+The `ShopifyAPI::Clients::Rest::Admin` client offers the 4 core request methods:
+- `get`
+- `delete`
+- `post`
+- `put`
+
+#### Input Parameters
+
+Each method can take the parameters outlined in the table below.
 
 | Parameter      | Type                                                     | Required in Methods | Default Value | Notes                                                                                                                                                                                                                                                                                  |
 | -------------- | -------------------------------------------------------- | :-----------------: | :-----------: | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
@@ -14,16 +157,40 @@ The Rest Admin client offers the 4 core request methods: `get`, `delete`, `post`
 | `extraHeaders` | `Hash(any(Symbol, String), any(String, Integer, Float))` |        none         |     none      | Any additional headers you want to send with your request                                                                                                                                                                                                                              |
 | `tries`        | `Integer`                                                |        None         |      `1`      | The maximum number of times to try the request _(must be >= 0)_                                                                                                                                                                                                                        |
 
-**Note:** _These paramaters can still be used in all methods regardless of if they are required._
+**Note:** _These parameters can still be used in all methods regardless of if they are required._
 
-## Usage Examples:
+#### Output
+##### Success
+If the request is successful these methods will all return a [`ShopifyAPI::Clients::HttpResponse`](https://github.com/Shopify/shopify-api-ruby/blob/main/lib/shopify_api/clients/http_response.rb) object, which has the following methods:
+| Methods | Type | Notes |
+|---------|------|-------|
+| `code`  |`Integer`| HTTP Response code, e.g. `200`|
+| `header` |`Hash{String, [String]}` | HTTP Response headers |
+| `body`  | `Hash{String, Untyped}`  | HTTP Response body |
+| `prev_page_info` | `String` | See [Pagination](#pagination)|
+| `next_page_info` | `String` | See [Pagination](#pagination)|
 
-### Perform a `GET` request:
+##### Failure
+If the request has failed, an error will be raised describing what went wrong.
+You can rescue [`ShopifyAPI::Errors::HttpResponseError`](https://github.com/Shopify/shopify-api-ruby/blob/main/lib/shopify_api/errors/http_response_error.rb)
+and output error messages with `errors.full_messages`
+
+See example:
 
 ```ruby
-# Load the current session to get the `accessToken`.
-session = ShopifyAPI::Utils::SessionUtils.load_current_session(headers, cookies, is_online)
+    client = ShopifyAPI::Clients::Rest::Admin.new(session: session)
+    response = client.get(path: "NOT-REAL")
+    some_function(response.body)
+rescue ShopifyAPI::Errors::HttpResponseError => e
+  puts fulfillment.errors.full_messages
+  # {"errors"=>"Not Found"}
+  # If you report this error, please include this id: bce76672-40c6-4047-b598-46208ab076f0.
+```
+### Usage Examples
 
+#### Perform a `GET` request
+
+```ruby
 # Create a new client.
 client = ShopifyAPI::Clients::Rest::Admin.new(session: session)
 
@@ -33,13 +200,11 @@ response = client.get(path: "products")
 # Do something with the returned data
 some_function(response.body)
 ```
+_For more information on the `products` endpoint, [check out our API reference guide](https://shopify.dev/docs/api/admin-rest/latest/resources/product)._
 
-### Perform a `POST` request:
+#### Perform a `POST` request
 
 ```ruby
-# Load the current session to get the `accessToken`.
-session = ShopifyAPI::Utils::SessionUtils.load_current_session(headers, cookies, is_online)
-
 # Create a new client.
 client = ShopifyAPI::Clients::Rest::Admin.new(session: session)
 
@@ -54,64 +219,59 @@ body = {
 }
 
 # Use `client.post` to send your request to the specified Shopify Admin REST API endpoint.
+# This POST request will create a new product.
 client.post({
   path: "products",
   body: body,
 });
 ```
 
-_for more information on the `products` endpoint, [check out our API reference guide](https://shopify.dev/docs/api/admin-rest/unstable/resources/product)._
+_For more information on the `products` endpoint, [check out our API reference guide](https://shopify.dev/docs/api/admin-rest/latest/resources/product)._
 
-### Override the `api_version`:
+#### Perform a `PUT` request
+  ```ruby
+  # Create a new client.
+  client = ShopifyAPI::Clients::Rest::Admin.new
 
-```ruby
-# To experiment with prerelease features, pass the api_version "unstable".
-client = ShopifyAPI::Clients::Rest::Admin.new(session: session, api_version: "unstable")
+  # Update product title
+  body = {
+    product: {
+      title: "My cool product"
+    }
+  }
+
+  # Use `client.put` to send your request to the specified Shopify Admin REST API endpoint.
+  # This will update product title for product with ID <id>
+  client.put(path: "products/<id>.json", body: body)
 ```
 
-## Pagination
+_For more information on the `products` endpoint, [check out our API reference guide](https://shopify.dev/docs/api/admin-rest/latest/resources/product)._
 
-This library also supports cursor-based pagination for REST Admin API requests. [Learn more about REST request pagination](https://shopify.dev/docs/api/usage/pagination-rest).
+#### Accessing Rate Limit information
 
-After making a request, the `next_page_info` and `prev_page_info` can be found on the response object and passed as the page_info query param in other requests.
-
-An example of this is shown below:
+The REST resources have `api_call_limit` and `retry_after` can be found on the Resource class. These values correspond to the `X-Shopify-Shop-Api-Call-Limit` and `Retry-After` [headers](https://shopify.dev/docs/api/usage/rate-limits#rest-admin-api-rate-limits) respectively.
 
 ```ruby
-session = ShopifyAPI::Utils::SessionUtils.load_current_session(headers, cookies, is_online)
-client = ShopifyAPI::Clients::Rest::Admin.new(session: session)
-
-response = client.get(path: "products", query: { limit: 10 })
-
-loop do
-  some_function(response.body)
-  break unless response.next_page_info
-  response =  client.get(path: "products", query: { limit: 10, page_info: response.next_page_info })
-end
-```
+product = ShopifyAPI::Product.find(session: session, id: 12345)
 
-Similarly, when using REST resources the `next_page_info` and `prev_page_info` can be found on the Resource class and passed as the page_info query param in other requests.
+# X-Shopify-Shop-Api-Call-Limit: 32/40
+request_count = ShopifyAPI::Product.api_call_limit[:request_count] # 32
+bucket_size = ShopifyAPI::Product.api_call_limit[:bucket_size] # 40
 
-An example of this is shown below:
+retry_after = ShopifyAPI::Product.retry_request_after
 
-```ruby
-session = ShopifyAPI::Utils::SessionUtils.load_current_session(headers, cookies, is_online)
+```
 
-products = ShopifyAPI::Product.all(session: session, limit: 10)
+### Pagination
 
-loop do
-  some_function(products)
-  break unless ShopifyAPI::Product.next_page?
-  products = ShopifyAPI::Product.all(session: session, limit: 10, page_info: ShopifyAPI::Product.next_page_info)
-end
-```
+This library also supports cursor-based pagination for REST Admin API requests. [Learn more about REST request pagination](https://shopify.dev/docs/api/usage/pagination-rest).
 
-The next/previous page_info strings can also be retrieved from the response object and added to a request query to retrieve the next/previous pages.
+#### REST Admin Client
+After making a request, the `next_page_info` and `prev_page_info` can be found on the response object and passed as the `page_info` query param in other requests.
 
 An example of this is shown below:
 
 ```ruby
-session = ShopifyAPI::Utils::SessionUtils.load_current_session(headers, cookies, is_online)
 client = ShopifyAPI::Clients::Rest::Admin.new(session: session)
 
 response = client.get(path: "products", query: { limit: 10 })
@@ -123,22 +283,19 @@ if next_page_info
 end
 ```
 
-### Error Messages
+#### REST Resource
+Similarly, when using REST resources the `next_page_info` and `prev_page_info` can be found on the Resource class and passed as the `page_info` query param in other requests.
 
-You can rescue `ShopifyAPI::Errors::HttpResponseError` and output error messages with `errors.full_messages`
-
-See example:
+An example of this is shown below:
 
 ```ruby
- fulfillment = ShopifyAPI::Fulfillment.new(session: @session)
-  fulfillment.order_id = 2776493818000
-  ...
-  fulfillment.tracking_company = "Jack Black's Pack, Stack and Track"
-  fulfillment.save()
-rescue ShopifyAPI::Errors::HttpResponseError => e
-  puts fulfillment.errors.full_messages
-  # {"base"=>["Line items are already fulfilled"]}
-  # If you report this error, please include this id: e712dde0-1270-4258-8cdb-d198792c917e.
+products = ShopifyAPI::Product.all(session: session, limit: 10)
+
+loop do
+  some_function(products)
+  break unless ShopifyAPI::Product.next_page?
+  products = ShopifyAPI::Product.all(session: session, limit: 10, page_info: ShopifyAPI::Product.next_page_info)
+end
 ```
 
 [Back to guide index](../README.md)

data/docs/usage/webhooks.md

@@ -2,13 +2,16 @@
 
 The `shopify_api` gem provides webhook functionality to make it easy to both subscribe to and process webhooks. To implement in your app follow the steps outlined below.
 
+## Use with Rails
+If using in the Rails framework, we highly recommend you use the [shopify_app](https://github.com/Shopify/shopify_app) gem to interact with this gem. That gem handles [webhooks with a declarative configuration](https://github.com/Shopify/shopify_app/blob/main/docs/shopify_app/webhooks.md).
+
 ## Create a Webhook Handler
 
 If you want to register for an http webhook you need to implement a webhook handler which the `shopify_api` gem can use to determine how to process your webhook. You can make multiple implementations (one per topic) or you can make one implementation capable of handling all the topics you want to subscribe to. To do this simply make a module or class that includes or extends `ShopifyAPI::Webhooks::WebhookHandler` and implement the handle method which accepts the following named parameters: topic: `String`, shop: `String`, and body: `Hash[String, untyped]`. An example implementation is shown below:
 
 ```ruby
 module WebhookHandler 
-  include ShopifyAPI::Webhooks::Handler
+  extend ShopifyAPI::Webhooks::Handler
 
   class << self
     def handle(topic:, shop:, body:)
@@ -25,7 +28,10 @@ end
 The next step is to add all the webhooks you would like to subscribe to for any shop to the webhook registry. To do this you can call `ShopifyAPI::Webhooks::Registry.add_registration` for each webhook you would like to handle. `add_registration` accepts a topic string, a delivery_method symbol (currently supporting `:http`, `:event_bridge`, and `:pub_sub`), a webhook path (the relative path for an http webhook) and a handler. This only needs to be done once when the app is started and we recommend doing this at the same time that you setup `ShopifyAPI::Context`. An example is shown below to register an http webhook:
 
 ```ruby
-registration = ShopifyAPI::Webhooks::Registry.add_registration(topic: "orders/create", delivery_method: :http, handler: WebhookHandler) 
+registration = ShopifyAPI::Webhooks::Registry.add_registration(topic: "orders/create", 
+                                                               delivery_method: :http,
+                                                               handler: WebhookHandler,
+                                                               path: 'callback/orders/create') 
 ```
 If you are only interested in particular fields, you can optionally filter the data sent by Shopify by specifying the `fields` parameter. Note that you will still receive a webhook request from Shopify every time the resource is updated, but only the specified fields will be sent:
 
@@ -34,8 +40,20 @@ registration = ShopifyAPI::Webhooks::Registry.add_registration(
   topic: "orders/create", 
   delivery_method: :http, 
   handler: WebhookHandler, 
+  path: 'callback/orders/create',
   fields: ["number","note"] # this can also be a single comma separated string
-) 
+)
+```
+
+If you are storing metafields on an object you are receiving webhooks for, you can specify them on registration to make sure that they are also sent through the `metafieldNamespaces` parameter. Note if you are also using the `fields` parameter you will need to add `metafields` into that as well.
+
+```ruby
+registration = ShopifyAPI::Webhooks::Registry.add_registration(
+  topic: "orders/create",
+  delivery_method: :http,
+  handler: WebhookHandler,
+  metafieldNamespaces: ["custom"]
+)
 ```
 
 **Note**: The webhooks you register with Shopify are saved in the Shopify platform, but the local `ShopifyAPI::Webhooks::Registry` needs to be reloaded whenever your server restarts.
@@ -75,7 +93,7 @@ ShopifyAPI::Webhooks::Registry.register(topic: "<specific-topic>", session: shop
 
 This will return a single `ShopifyAPI::Webhooks::RegisterResult`.
 
-## Unregister a Webhook 
+## Unregister a Webhook
 
 To unregister a topic from a shop you can simply call:
 ```ruby

data/lib/shopify_api/admin_versions.rb

@@ -5,6 +5,8 @@ module ShopifyAPI
   module AdminVersions
     SUPPORTED_ADMIN_VERSIONS = T.let([
       "unstable",
+      "2024-01",
+      "2023-10",
       "2023-07",
       "2023-04",
       "2023-01",
@@ -14,7 +16,7 @@ module ShopifyAPI
       "2022-01",
     ], T::Array[String])
 
-    LATEST_SUPPORTED_ADMIN_VERSION = T.let("2023-07", String)
+    LATEST_SUPPORTED_ADMIN_VERSION = T.let("2024-01", String)
   end
 
   SUPPORTED_ADMIN_VERSIONS = ShopifyAPI::AdminVersions::SUPPORTED_ADMIN_VERSIONS

data/lib/shopify_api/auth/jwt_payload.rb

@@ -75,8 +75,8 @@ module ShopifyAPI
       def decode_token(token, api_secret_key)
         JWT.decode(token, api_secret_key, true,
           { exp_leeway: JWT_EXPIRATION_LEEWAY, algorithm: "HS256" })[0]
-      rescue
-        raise ShopifyAPI::Errors::InvalidJwtTokenError, "Failed to parse session token '#{token}'"
+      rescue JWT::DecodeError => err
+        raise ShopifyAPI::Errors::InvalidJwtTokenError, "Error decoding session token: #{err.message}"
       end
     end
   end

data/lib/shopify_api/auth/oauth.rb

@@ -70,15 +70,25 @@ module ShopifyAPI
           raise Errors::InvalidOauthError,
             "Invalid state in OAuth callback." unless state == auth_query.state
 
-          # TODO: replace this call with the HTTP client once it is built
+          null_session = Auth::Session.new(shop: auth_query.shop)
           body = { client_id: Context.api_key, client_secret: Context.api_secret_key, code: auth_query.code }
-          response = HTTParty.post("https://#{auth_query.shop}/admin/oauth/access_token", body: body)
-          unless response.ok?
+
+          client = Clients::HttpClient.new(session: null_session, base_path: "/admin/oauth")
+          response = begin
+            client.request(
+              Clients::HttpRequest.new(
+                http_method: :post,
+                path: "access_token",
+                body: body,
+                body_type: "application/json",
+              ),
+            )
+          rescue ShopifyAPI::Errors::HttpResponseError => e
             raise Errors::RequestAccessTokenError,
-              "Cannot complete OAuth process. Received a #{response.code} error while requesting access token."
+              "Cannot complete OAuth process. Received a #{e.code} error while requesting access token."
           end
-          session_params = response.to_h
 
+          session_params = T.cast(response.body, T::Hash[String, T.untyped]).to_h
           session = create_new_session(session_params, auth_query.shop)
 
           cookie = if Context.embedded?

data/lib/shopify_api/auth/session.rb

@@ -35,6 +35,11 @@ module ShopifyAPI
         @is_online
       end
 
+      sig { returns(T::Boolean) }
+      def expired?
+        @expires ? @expires < Time.now : false
+      end
+
       sig do
         params(
           shop: String,

data/lib/shopify_api/clients/graphql/client.rb

@@ -42,6 +42,7 @@ module ShopifyAPI
               body_type: "application/json",
               tries: tries,
             ),
+            response_as_struct: Context.response_as_struct || false,
           )
         end
       end

data/lib/shopify_api/clients/http_client.rb

@@ -13,7 +13,9 @@ module ShopifyAPI
         session ||= Context.active_session
         raise Errors::NoActiveSessionError, "No passed or active session" unless session
 
-        @base_uri = T.let("https://#{session.shop}", String)
+        api_host = Context.api_host
+
+        @base_uri = T.let("https://#{api_host || session.shop}", String)
         @base_uri_and_path = T.let("#{@base_uri}#{base_path}", String)
 
         user_agent_prefix = Context.user_agent_prefix.nil? ? "" : "#{Context.user_agent_prefix} | "
@@ -23,13 +25,15 @@ module ShopifyAPI
           "Accept": "application/json",
         }, T::Hash[T.any(Symbol, String), T.untyped])
 
+        @headers["Host"] = session.shop unless api_host.nil?
+
         unless session.access_token.nil? || T.must(session.access_token).empty?
           @headers["X-Shopify-Access-Token"] = T.cast(session.access_token, String)
         end
       end
 
-      sig { params(request: HttpRequest).returns(HttpResponse) }
-      def request(request)
+      sig { params(request: HttpRequest, response_as_struct: T::Boolean).returns(HttpResponse) }
+      def request(request, response_as_struct: false)
         request.verify
 
         headers = @headers
@@ -56,6 +60,11 @@ module ShopifyAPI
             body = res.body
           end
 
+          if response_as_struct && body.is_a?(Hash)
+            json_body = body.to_json
+            body = JSON.parse(json_body, object_class: OpenStruct)
+          end
+
           response = HttpResponse.new(code: res.code.to_i, headers: res.headers.to_h, body: body)
 
           if response.headers["x-shopify-api-deprecated-reason"]

data/lib/shopify_api/clients/http_response.rb

@@ -12,17 +12,23 @@ module ShopifyAPI
       sig { returns(T::Hash[String, T::Array[String]]) }
       attr_reader :headers
 
-      sig { returns(T.any(T::Hash[String, T.untyped], String)) }
+      sig { returns(T.any(T::Hash[String, T.untyped], String, OpenStruct)) }
       attr_reader :body
 
       sig { returns(T.nilable(String)) }
       attr_reader :prev_page_info, :next_page_info
 
+      sig { returns(T.nilable(T::Hash[String, Integer])) }
+      attr_reader :api_call_limit
+
+      sig { returns(T.nilable(Float)) }
+      attr_reader :retry_request_after
+
       sig do
         params(
           code: Integer,
           headers: T::Hash[String, T::Array[String]],
-          body: T.any(T::Hash[String, T.untyped], String),
+          body: T.any(T::Hash[String, T.untyped], String, OpenStruct),
         ).void
       end
       def initialize(code:, headers:, body:)
@@ -33,6 +39,11 @@ module ShopifyAPI
         @prev_page_info = T.let(nil, T.nilable(String))
         @next_page_info = T.let(nil, T.nilable(String))
         @prev_page_info, @next_page_info = parse_link_header
+
+        @api_call_limit = T.let(nil, T.nilable(T::Hash[String, Integer]))
+        @retry_request_after = T.let(nil, T.nilable(Float))
+        @api_call_limit = parse_api_call_limit_header
+        @retry_request_after = parse_retry_header
       end
 
       sig { returns(T::Boolean) }
@@ -61,6 +72,22 @@ module ShopifyAPI
 
         [page_info["previous"], page_info["next"]]
       end
+
+      sig { returns(T.nilable(Float)) }
+      def parse_retry_header
+        return nil if @headers["retry-after"].nil?
+
+        T.must(@headers["retry-after"])[0].to_f
+      end
+
+      sig { returns(T.nilable(T::Hash[String, Integer])) }
+      def parse_api_call_limit_header
+        rate_limit_info = headers["x-shopify-shop-api-call-limit"]&.first
+        return if rate_limit_info.nil?
+
+        request_count, bucket_size = rate_limit_info.split("/").map(&:to_i)
+        { request_count: request_count, bucket_size: bucket_size }
+      end
     end
   end
 end