shopify_api 13.1.0 → 13.3.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
+### 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
 
-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.
+# 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
+
+### 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).|
+
+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,49 +219,61 @@ 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)._
+
+### Pagination
 
 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).
 
-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.
+#### 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 })
+next_page_info = response.next_page_info
 
-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 })
+if next_page_info
+  next_page_response =client.get(path: "products", query: { limit: 10, page_info: next_page_info })
+  some_function(next_page_response)
 end
 ```
 
-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.
+#### 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.
 
 An example of this is shown below:
 
 ```ruby
-session = ShopifyAPI::Utils::SessionUtils.load_current_session(headers, cookies, is_online)
-
 products = ShopifyAPI::Product.all(session: session, limit: 10)
 
 loop do
@@ -106,39 +283,4 @@ loop do
 end
 ```
 
-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.
-
-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 })
-next_page_info = response.next_page_info
-
-if next_page_info
-  next_page_response =client.get(path: "products", query: { limit: 10, page_info: next_page_info })
-  some_function(next_page_response)
-end
-```
-
-### Error Messages
-
-You can rescue `ShopifyAPI::Errors::HttpResponseError` and output error messages with `errors.full_messages`
-
-See example:
-
-```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.
-```
-
 [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,7 @@ module ShopifyAPI
   module AdminVersions
     SUPPORTED_ADMIN_VERSIONS = T.let([
       "unstable",
+      "2023-10",
       "2023-07",
       "2023-04",
       "2023-01",
@@ -14,7 +15,7 @@ module ShopifyAPI
       "2022-01",
     ], T::Array[String])
 
-    LATEST_SUPPORTED_ADMIN_VERSION = T.let("2023-07", String)
+    LATEST_SUPPORTED_ADMIN_VERSION = T.let("2023-10", 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/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,6 +25,8 @@ 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

data/lib/shopify_api/context.rb

@@ -8,11 +8,14 @@ module ShopifyAPI
     @api_key = T.let("", String)
     @api_secret_key = T.let("", String)
     @api_version = T.let(LATEST_SUPPORTED_ADMIN_VERSION, String)
+    @api_host = T.let(nil, T.nilable(String))
     @scope = T.let(Auth::AuthScopes.new, Auth::AuthScopes)
     @is_private = T.let(false, T::Boolean)
     @private_shop = T.let(nil, T.nilable(String))
     @is_embedded = T.let(true, T::Boolean)
-    @logger = T.let(::Logger.new($stdout), ::Logger)
+    # Logger can either be a Logger or an ActiveSupport::BroadcastLogger, which is new in Rails 7.1.0. To avoid adding a
+    # dependency Active Support >= 7.1.0, we go with T.untyped
+    @logger = T.let(::Logger.new($stdout), T.untyped)
     @log_level = T.let(:info, Symbol)
     @notified_missing_resources_folder = T.let({}, T::Hash[String, T::Boolean])
     @active_session = T.let(Concurrent::ThreadLocalVar.new { nil }, T.nilable(Concurrent::ThreadLocalVar))
@@ -33,12 +36,13 @@ module ShopifyAPI
           is_private: T::Boolean,
           is_embedded: T::Boolean,
           log_level: T.any(String, Symbol),
-          logger: ::Logger,
+          logger: T.untyped,
           host_name: T.nilable(String),
           host: T.nilable(String),
           private_shop: T.nilable(String),
           user_agent_prefix: T.nilable(String),
           old_api_secret_key: T.nilable(String),
+          api_host: T.nilable(String),
         ).void
       end
       def setup(
@@ -54,7 +58,8 @@ module ShopifyAPI
         host: ENV["HOST"] || "https://#{host_name}",
         private_shop: nil,
         user_agent_prefix: nil,
-        old_api_secret_key: nil
+        old_api_secret_key: nil,
+        api_host: nil
       )
         unless ShopifyAPI::AdminVersions::SUPPORTED_ADMIN_VERSIONS.include?(api_version)
           raise Errors::UnsupportedVersionError,
@@ -64,6 +69,7 @@ module ShopifyAPI
         @api_key = api_key
         @api_secret_key = api_secret_key
         @api_version = api_version
+        @api_host = api_host
         @host = T.let(host, T.nilable(String))
         @is_private = is_private
         @scope = Auth::AuthScopes.new(scope)
@@ -116,7 +122,7 @@ module ShopifyAPI
       sig { returns(Auth::AuthScopes) }
       attr_reader :scope
 
-      sig { returns(::Logger) }
+      sig { returns(T.untyped) }
       attr_reader :logger
 
       sig { returns(Symbol) }
@@ -128,7 +134,7 @@ module ShopifyAPI
       end
 
       sig { returns(T.nilable(String)) }
-      attr_reader :private_shop, :user_agent_prefix, :old_api_secret_key, :host
+      attr_reader :private_shop, :user_agent_prefix, :old_api_secret_key, :host, :api_host
 
       sig { returns(T::Boolean) }
       def embedded?

data/lib/shopify_api/rest/base.rb

@@ -97,9 +97,9 @@ module ShopifyAPI
           class_name.underscore
         end
 
-        sig { returns(String) }
-        def json_response_body_name
-          class_name
+        sig { returns(T::Array[String]) }
+        def json_response_body_names
+          [class_name]
         end
 
         sig { returns(T.nilable(String)) }
@@ -210,14 +210,16 @@ module ShopifyAPI
 
           body = T.cast(response.body, T::Hash[String, T.untyped])
 
-          response_name = json_response_body_name
+          response_names = json_response_body_names
 
-          if body.key?(response_name.pluralize) || (body.key?(response_name) && body[response_name].is_a?(Array))
-            (body[response_name.pluralize] || body[response_name]).each do |entry|
-              objects << create_instance(data: entry, session: session)
+          response_names.each do |response_name|
+            if body.key?(response_name.pluralize) || (body.key?(response_name) && body[response_name].is_a?(Array))
+              (body[response_name.pluralize] || body[response_name]).each do |entry|
+                objects << create_instance(data: entry, session: session)
+              end
+            elsif body.key?(response_name)
+              objects << create_instance(data: body[response_name], session: session)
             end
-          elsif body.key?(response_name)
-            objects << create_instance(data: body[response_name], session: session)
           end
 
           objects
@@ -347,10 +349,8 @@ module ShopifyAPI
         )
 
         if update_object
-          self.class.create_instance(
-            data: response.body[self.class.class_name.downcase],
-            session: @session, instance: self
-          )
+          response_name = self.class.json_response_body_names & response.body.keys
+          self.class.create_instance(data: response.body[response_name.first], session: @session, instance: self)
         end
       rescue ShopifyAPI::Errors::HttpResponseError => e
         @errors.errors << e
@@ -365,10 +365,18 @@ module ShopifyAPI
           self.class.read_only_attributes&.include?("@#{attribute}".to_sym)
         end
 
-        HashDiff::Comparison.new(
+        diff = HashDiff::Comparison.new(
           deep_stringify_keys(original_state_for_update),
           deep_stringify_keys(to_hash(true)),
         ).left_diff
+
+        diff.each do |attribute, value|
+          if value.is_a?(Hash) && value[0] == HashDiff::NO_VALUE
+            diff[attribute] = send(attribute)
+          end
+        end
+
+        diff
       end
 
       sig { returns(Symbol) }

data/lib/shopify_api/rest/resources/2022_10/assigned_fulfillment_order.rb

@@ -51,10 +51,12 @@ module ShopifyAPI
 
     class << self
       sig do
-        returns(String)
+        returns(T::Array[String])
       end
-      def json_response_body_name()
-        "fulfillment_order"
+      def json_response_body_names()
+        [
+          "fulfillment_order"
+        ]
       end
 
       sig do

data/lib/shopify_api/rest/resources/2022_10/customer_address.rb

@@ -87,6 +87,16 @@ module ShopifyAPI
         "address"
       end
 
+      sig do
+        returns(T::Array[String])
+      end
+      def json_response_body_names()
+        [
+          "customer_address",
+          "address"
+        ]
+      end
+
       sig do
         params(
           id: T.any(Integer, String),

data/lib/shopify_api/rest/resources/2022_10/fulfillment_request.rb

@@ -31,6 +31,16 @@ module ShopifyAPI
     attr_reader :fulfillment_order_id
 
     class << self
+      sig do
+        returns(T::Array[String])
+      end
+      def json_response_body_names()
+        [
+          "submitted_fulfillment_order",
+          "fulfillment_order"
+        ]
+      end
+
     end
 
     sig do