shopify_api 13.3.1 → 13.4.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: b06b6f5bbea4f3ec2bfc6362e689d9323dff226bce6e89df9ad3678b07f5ccd1
-  data.tar.gz: 4aa27ed36ac0734941ad377a814ea13c9015ab44f7644bcfae61b69dabd749b3
+  metadata.gz: d837a507476d9d344892dc7667fed5cf1fcc20ac37c5bc5488e4a2583b3dab5c
+  data.tar.gz: b385d9e275df49f00fd8aac9bba99c6df69a9f111afd92285e12e2b411d734e5
 SHA512:
-  metadata.gz: aa6dde76b4b48dfefa13708a232354dfa8877befee6d9c83f6dc7e55dc9c7f9c3da0109e3a91b3aeb9b5bca954bc19d46b01e8f77c0c630e7eb140edf15b1c9e
-  data.tar.gz: 10527f74a2c026c49875e6c0a7caafd6c53e1137b8ee655a00b2524067e83439abebc47ac1f640cd6d74cd195c08dd8884243cebefdb270f1bced10e92ee100d
+  metadata.gz: 0f1de95b3fd22f3f7494914d74647cb51607e5302c3bbf23c7d29e159f1a90f21509d2c7ade5606287dd698ce67e7ec018bf0fa0a099f4034eefdac363d0f20f
+  data.tar.gz: 58e4c9c8c67bed4996f056e0219d45c38d589feb2e04e3902302afb71e3f282b2138f85b813d394a953c7c323cfd2f42c71464931fdd7f83327c145921b18d96

data/.rubocop.yml

@@ -57,6 +57,8 @@ Layout/EmptyLineAfterGuardClause:
   Enabled: true
 Style/GlobalStdStream:
   Enabled: true
+Style/OpenStructUse:
+  Enabled: false
 Layout/LineLength:
   Exclude:
     - "test/clients/*"

data/CHANGELOG.md

@@ -4,6 +4,11 @@ Note: For changes to the API, see https://shopify.dev/changelog?filter=api
 
 ## Unreleased
 
+## 13.4.0
+- [#1210](https://github.com/Shopify/shopify-api-ruby/pull/1246) Add context option `response_as_struct` to allow GraphQL API responses to be accessed via dot notation.
+- [#1257](https://github.com/Shopify/shopify-api-ruby/pull/1257) Add `api_call_limit` and `retry_request_after` to REST resources to expose rate limit information.
+- [#1257](https://github.com/Shopify/shopify-api-ruby/pull/1257) Added support for the 2024-01 API version. This also includes a fix for the `for_hash` option when creating resources.
+
 ## 13.3.1
 
 - [#1244](https://github.com/Shopify/shopify-api-ruby/pull/1244) Add `expired?` to `ShopifyAPI::Auth::Session` to check if the session is expired (mainly for user sessions)

data/Gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: .
   specs:
-    shopify_api (13.3.1)
+    shopify_api (13.4.0)
       activesupport
       concurrent-ruby
       hash_diff
@@ -30,7 +30,7 @@ GEM
       public_suffix (>= 2.0.2, < 5.0)
     ast (2.4.2)
     base64 (0.2.0)
-    bigdecimal (3.1.4)
+    bigdecimal (3.1.5)
     byebug (11.1.3)
     coderay (1.1.3)
     concurrent-ruby (1.2.2)
@@ -57,7 +57,8 @@ GEM
     multi_xml (0.6.0)
     mutex_m (0.2.0)
     netrc (0.11.0)
-    oj (3.16.1)
+    oj (3.16.3)
+      bigdecimal (>= 3.0)
     openssl (3.2.0)
     parallel (1.22.1)
     parser (3.2.2.4)
@@ -98,7 +99,7 @@ GEM
       rubocop (>= 0.90.0)
     ruby-progressbar (1.11.0)
     ruby2_keywords (0.0.5)
-    securerandom (0.3.0)
+    securerandom (0.3.1)
     sorbet (0.5.10438)
       sorbet-static (= 0.5.10438)
     sorbet-runtime (0.5.10438)

data/docs/usage/graphql.md

@@ -117,7 +117,7 @@ response = client.query(query: query, variables: variables)
 
 ### 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: 
+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`|
@@ -137,6 +137,35 @@ This library also supports cursor-based pagination for GraphQL Admin API request
 
 After making a request, the `next_page_info` and `prev_page_info` can be found on the response object and be used in the query param in other requests.
 
+## Response as Struct
+By default the response body is returned as a `Hash{String, Untyped}`. If you would like to return the response body as a `Struct`, you can pass `response_as_struct: true` to the `ShopifyAPI::Context.setup` method.
+Then you can access the object with both dot and hash notation.
+
+```ruby
+    ShopifyAPI::Context.setup(
+      api_key: ShopifyApp.configuration.api_key,
+      api_secret_key: ShopifyApp.configuration.secret,
+      ...
+      response_as_struct: true
+    )
+
+    # Make a graphql query
+      response = client.query(
+        query: CREATE_PRODUCTS_MUTATION,
+        variables: {
+          input: {
+            title: random_title,
+            variants: [{ price: random_price }],
+          },
+        },
+      )
+      # Access result with dot notation
+      created_product2 = response.body.data.productCreate.product
+      # Access result with hash notation
+      created_product = response.body["data"]["productCreate"]["product"]
+
+```
+
 ## Proxy a GraphQL Query
 
 If you would like to give your front end the ability to make authenticated graphql queries to the Shopify Admin API, the `shopify_api` gem makes proxy-ing a graphql request easy! The gem provides a utility function which will accept the raw request body (a GraphQL query), the headers, and the cookies (optional). It will add authentication to the request, proxy it to the Shopify Admin API, and return a `ShopifyAPI::Clients::HttpResponse`. An example utilization of this in Rails is shown below:

data/docs/usage/rest.md

@@ -122,7 +122,7 @@ Create an instance of [`ShopifyAPI::Clients::Rest::Admin`](https://github.com/Sh
 
 Examples:
 ```ruby
-# Create a default client with `ShopifyAPI::Context.api_version` 
+# Create a default client with `ShopifyAPI::Context.api_version`
 # and the active session from `ShopifyAPI::Context.active_session`
 client = ShopifyAPI::Clients::Rest::Admin.new
 
@@ -147,7 +147,7 @@ The `ShopifyAPI::Clients::Rest::Admin` client offers the 4 core request methods:
 
 #### Input Parameters
 
-Each method can take the parameters outlined in the table below. 
+Each method can take the parameters outlined in the table below.
 
 | Parameter      | Type                                                     | Required in Methods | Default Value | Notes                                                                                                                                                                                                                                                                                  |
 | -------------- | -------------------------------------------------------- | :-----------------: | :-----------: | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
@@ -161,7 +161,7 @@ Each method can take the parameters outlined in the table below.
 
 #### 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: 
+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`|
@@ -247,6 +247,21 @@ _For more information on the `products` endpoint, [check out our API reference g
 
 _For more information on the `products` endpoint, [check out our API reference guide](https://shopify.dev/docs/api/admin-rest/latest/resources/product)._
 
+#### Accessing Rate Limit information
+
+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
+product = ShopifyAPI::Product.find(session: session, id: 12345)
+
+# 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
+
+retry_after = ShopifyAPI::Product.retry_request_after
+
+```
+
 ### 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).

data/lib/shopify_api/admin_versions.rb

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

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

@@ -32,8 +32,8 @@ module ShopifyAPI
         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
@@ -60,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

data/lib/shopify_api/context.rb

@@ -21,6 +21,7 @@ module ShopifyAPI
     @active_session = T.let(Concurrent::ThreadLocalVar.new { nil }, T.nilable(Concurrent::ThreadLocalVar))
     @user_agent_prefix = T.let(nil, T.nilable(String))
     @old_api_secret_key = T.let(nil, T.nilable(String))
+    @response_as_struct = T.let(false, T.nilable(T::Boolean))
 
     @rest_resource_loader = T.let(nil, T.nilable(Zeitwerk::Loader))
 
@@ -43,6 +44,7 @@ module ShopifyAPI
           user_agent_prefix: T.nilable(String),
           old_api_secret_key: T.nilable(String),
           api_host: T.nilable(String),
+          response_as_struct: T.nilable(T::Boolean),
         ).void
       end
       def setup(
@@ -59,7 +61,8 @@ module ShopifyAPI
         private_shop: nil,
         user_agent_prefix: nil,
         old_api_secret_key: nil,
-        api_host: nil
+        api_host: nil,
+        response_as_struct: false
       )
         unless ShopifyAPI::AdminVersions::SUPPORTED_ADMIN_VERSIONS.include?(api_version)
           raise Errors::UnsupportedVersionError,
@@ -78,6 +81,7 @@ module ShopifyAPI
         @private_shop = private_shop
         @user_agent_prefix = user_agent_prefix
         @old_api_secret_key = old_api_secret_key
+        @response_as_struct = response_as_struct
         @log_level = if valid_log_level?(log_level)
           log_level.to_sym
         else
@@ -128,6 +132,9 @@ module ShopifyAPI
       sig { returns(Symbol) }
       attr_reader :log_level
 
+      sig { returns T.nilable(T::Boolean) }
+      attr_reader :response_as_struct
+
       sig { returns(T::Boolean) }
       def private?
         @is_private

data/lib/shopify_api/rest/base.rb

@@ -79,6 +79,9 @@ module ShopifyAPI
           instance_variable_get(:"@prev_page_info").value = response.prev_page_info
           instance_variable_get(:"@next_page_info").value = response.next_page_info
 
+          instance_variable_get(:"@retry_request_after").value = response.retry_request_after
+          instance_variable_get(:"@api_call_limit").value = response.api_call_limit
+
           create_instances_from_response(response: response, session: T.must(session))
         end
 
@@ -122,6 +125,16 @@ module ShopifyAPI
           !instance_variable_get(:"@next_page_info").value.nil?
         end
 
+        sig { returns T.nilable(Float) }
+        def retry_request_after
+          instance_variable_get(:"@retry_request_after").value
+        end
+
+        sig { returns T.nilable(T::Hash[String, Integer]) }
+        def api_call_limit
+          instance_variable_get(:"@api_call_limit").value
+        end
+
         sig { params(attribute: Symbol).returns(T::Boolean) }
         def has_many?(attribute)
           @has_many.include?(attribute)

data/lib/shopify_api/rest/resources/2022_04/abandoned_checkout.rb

@@ -12,9 +12,11 @@ module ShopifyAPI
     @prev_page_info = T.let(Concurrent::ThreadLocalVar.new { nil }, Concurrent::ThreadLocalVar)
     @next_page_info = T.let(Concurrent::ThreadLocalVar.new { nil }, Concurrent::ThreadLocalVar)
 
-    sig { params(session: T.nilable(ShopifyAPI::Auth::Session)).void }
-    def initialize(session: ShopifyAPI::Context.active_session)
-      super(session: session)
+    @api_call_limit = T.let(Concurrent::ThreadLocalVar.new { nil }, Concurrent::ThreadLocalVar)
+    @retry_request_after = T.let(Concurrent::ThreadLocalVar.new { nil }, Concurrent::ThreadLocalVar)
+
+    sig { params(session: T.nilable(ShopifyAPI::Auth::Session), from_hash: T.nilable(T::Hash[T.untyped, T.untyped])).void }
+    def initialize(session: ShopifyAPI::Context.active_session, from_hash: nil)
 
       @abandoned_checkout_url = T.let(nil, T.nilable(String))
       @billing_address = T.let(nil, T.nilable(T::Hash[T.untyped, T.untyped]))
@@ -55,6 +57,8 @@ module ShopifyAPI
       @total_weight = T.let(nil, T.nilable(Integer))
       @updated_at = T.let(nil, T.nilable(String))
       @user_id = T.let(nil, T.nilable(Integer))
+
+      super(session: session, from_hash: from_hash)
     end
 
     @has_one = T.let({

data/lib/shopify_api/rest/resources/2022_04/access_scope.rb

@@ -12,12 +12,16 @@ module ShopifyAPI
     @prev_page_info = T.let(Concurrent::ThreadLocalVar.new { nil }, Concurrent::ThreadLocalVar)
     @next_page_info = T.let(Concurrent::ThreadLocalVar.new { nil }, Concurrent::ThreadLocalVar)
 
-    sig { params(session: T.nilable(ShopifyAPI::Auth::Session)).void }
-    def initialize(session: ShopifyAPI::Context.active_session)
-      super(session: session)
+    @api_call_limit = T.let(Concurrent::ThreadLocalVar.new { nil }, Concurrent::ThreadLocalVar)
+    @retry_request_after = T.let(Concurrent::ThreadLocalVar.new { nil }, Concurrent::ThreadLocalVar)
+
+    sig { params(session: T.nilable(ShopifyAPI::Auth::Session), from_hash: T.nilable(T::Hash[T.untyped, T.untyped])).void }
+    def initialize(session: ShopifyAPI::Context.active_session, from_hash: nil)
 
       @handle = T.let(nil, T.nilable(String))
       @access_scopes = T.let(nil, T.nilable(T::Array[T.untyped]))
+
+      super(session: session, from_hash: from_hash)
     end
 
     @has_one = T.let({}, T::Hash[Symbol, Class])

data/lib/shopify_api/rest/resources/2022_04/android_pay_key.rb

@@ -12,12 +12,16 @@ module ShopifyAPI
     @prev_page_info = T.let(Concurrent::ThreadLocalVar.new { nil }, Concurrent::ThreadLocalVar)
     @next_page_info = T.let(Concurrent::ThreadLocalVar.new { nil }, Concurrent::ThreadLocalVar)
 
-    sig { params(session: T.nilable(ShopifyAPI::Auth::Session)).void }
-    def initialize(session: ShopifyAPI::Context.active_session)
-      super(session: session)
+    @api_call_limit = T.let(Concurrent::ThreadLocalVar.new { nil }, Concurrent::ThreadLocalVar)
+    @retry_request_after = T.let(Concurrent::ThreadLocalVar.new { nil }, Concurrent::ThreadLocalVar)
+
+    sig { params(session: T.nilable(ShopifyAPI::Auth::Session), from_hash: T.nilable(T::Hash[T.untyped, T.untyped])).void }
+    def initialize(session: ShopifyAPI::Context.active_session, from_hash: nil)
 
       @id = T.let(nil, T.nilable(Integer))
       @public_key = T.let(nil, T.nilable(String))
+
+      super(session: session, from_hash: from_hash)
     end
 
     @has_one = T.let({}, T::Hash[Symbol, Class])

data/lib/shopify_api/rest/resources/2022_04/apple_pay_certificate.rb

@@ -12,13 +12,17 @@ module ShopifyAPI
     @prev_page_info = T.let(Concurrent::ThreadLocalVar.new { nil }, Concurrent::ThreadLocalVar)
     @next_page_info = T.let(Concurrent::ThreadLocalVar.new { nil }, Concurrent::ThreadLocalVar)
 
-    sig { params(session: T.nilable(ShopifyAPI::Auth::Session)).void }
-    def initialize(session: ShopifyAPI::Context.active_session)
-      super(session: session)
+    @api_call_limit = T.let(Concurrent::ThreadLocalVar.new { nil }, Concurrent::ThreadLocalVar)
+    @retry_request_after = T.let(Concurrent::ThreadLocalVar.new { nil }, Concurrent::ThreadLocalVar)
+
+    sig { params(session: T.nilable(ShopifyAPI::Auth::Session), from_hash: T.nilable(T::Hash[T.untyped, T.untyped])).void }
+    def initialize(session: ShopifyAPI::Context.active_session, from_hash: nil)
 
       @id = T.let(nil, T.nilable(Integer))
       @merchant_id = T.let(nil, T.nilable(String))
       @status = T.let(nil, T.nilable(String))
+
+      super(session: session, from_hash: from_hash)
     end
 
     @has_one = T.let({}, T::Hash[Symbol, Class])

data/lib/shopify_api/rest/resources/2022_04/application_charge.rb

@@ -12,9 +12,11 @@ module ShopifyAPI
     @prev_page_info = T.let(Concurrent::ThreadLocalVar.new { nil }, Concurrent::ThreadLocalVar)
     @next_page_info = T.let(Concurrent::ThreadLocalVar.new { nil }, Concurrent::ThreadLocalVar)
 
-    sig { params(session: T.nilable(ShopifyAPI::Auth::Session)).void }
-    def initialize(session: ShopifyAPI::Context.active_session)
-      super(session: session)
+    @api_call_limit = T.let(Concurrent::ThreadLocalVar.new { nil }, Concurrent::ThreadLocalVar)
+    @retry_request_after = T.let(Concurrent::ThreadLocalVar.new { nil }, Concurrent::ThreadLocalVar)
+
+    sig { params(session: T.nilable(ShopifyAPI::Auth::Session), from_hash: T.nilable(T::Hash[T.untyped, T.untyped])).void }
+    def initialize(session: ShopifyAPI::Context.active_session, from_hash: nil)
 
       @confirmation_url = T.let(nil, T.nilable(String))
       @created_at = T.let(nil, T.nilable(String))
@@ -26,6 +28,8 @@ module ShopifyAPI
       @status = T.let(nil, T.nilable(String))
       @test = T.let(nil, T.nilable(T::Boolean))
       @updated_at = T.let(nil, T.nilable(String))
+
+      super(session: session, from_hash: from_hash)
     end
 
     @has_one = T.let({

data/lib/shopify_api/rest/resources/2022_04/application_credit.rb

@@ -12,15 +12,19 @@ module ShopifyAPI
     @prev_page_info = T.let(Concurrent::ThreadLocalVar.new { nil }, Concurrent::ThreadLocalVar)
     @next_page_info = T.let(Concurrent::ThreadLocalVar.new { nil }, Concurrent::ThreadLocalVar)
 
-    sig { params(session: T.nilable(ShopifyAPI::Auth::Session)).void }
-    def initialize(session: ShopifyAPI::Context.active_session)
-      super(session: session)
+    @api_call_limit = T.let(Concurrent::ThreadLocalVar.new { nil }, Concurrent::ThreadLocalVar)
+    @retry_request_after = T.let(Concurrent::ThreadLocalVar.new { nil }, Concurrent::ThreadLocalVar)
+
+    sig { params(session: T.nilable(ShopifyAPI::Auth::Session), from_hash: T.nilable(T::Hash[T.untyped, T.untyped])).void }
+    def initialize(session: ShopifyAPI::Context.active_session, from_hash: nil)
 
       @amount = T.let(nil, T.nilable(String))
       @currency = T.let(nil, T.nilable(Currency))
       @description = T.let(nil, T.nilable(String))
       @id = T.let(nil, T.nilable(Integer))
       @test = T.let(nil, T.nilable(T::Boolean))
+
+      super(session: session, from_hash: from_hash)
     end
 
     @has_one = T.let({

data/lib/shopify_api/rest/resources/2022_04/article.rb

@@ -12,9 +12,11 @@ module ShopifyAPI
     @prev_page_info = T.let(Concurrent::ThreadLocalVar.new { nil }, Concurrent::ThreadLocalVar)
     @next_page_info = T.let(Concurrent::ThreadLocalVar.new { nil }, Concurrent::ThreadLocalVar)
 
-    sig { params(session: T.nilable(ShopifyAPI::Auth::Session)).void }
-    def initialize(session: ShopifyAPI::Context.active_session)
-      super(session: session)
+    @api_call_limit = T.let(Concurrent::ThreadLocalVar.new { nil }, Concurrent::ThreadLocalVar)
+    @retry_request_after = T.let(Concurrent::ThreadLocalVar.new { nil }, Concurrent::ThreadLocalVar)
+
+    sig { params(session: T.nilable(ShopifyAPI::Auth::Session), from_hash: T.nilable(T::Hash[T.untyped, T.untyped])).void }
+    def initialize(session: ShopifyAPI::Context.active_session, from_hash: nil)
 
       @author = T.let(nil, T.nilable(String))
       @blog_id = T.let(nil, T.nilable(Integer))
@@ -32,6 +34,8 @@ module ShopifyAPI
       @title = T.let(nil, T.nilable(String))
       @updated_at = T.let(nil, T.nilable(String))
       @user_id = T.let(nil, T.nilable(Integer))
+
+      super(session: session, from_hash: from_hash)
     end
 
     @has_one = T.let({}, T::Hash[Symbol, Class])

data/lib/shopify_api/rest/resources/2022_04/asset.rb

@@ -12,9 +12,11 @@ module ShopifyAPI
     @prev_page_info = T.let(Concurrent::ThreadLocalVar.new { nil }, Concurrent::ThreadLocalVar)
     @next_page_info = T.let(Concurrent::ThreadLocalVar.new { nil }, Concurrent::ThreadLocalVar)
 
-    sig { params(session: T.nilable(ShopifyAPI::Auth::Session)).void }
-    def initialize(session: ShopifyAPI::Context.active_session)
-      super(session: session)
+    @api_call_limit = T.let(Concurrent::ThreadLocalVar.new { nil }, Concurrent::ThreadLocalVar)
+    @retry_request_after = T.let(Concurrent::ThreadLocalVar.new { nil }, Concurrent::ThreadLocalVar)
+
+    sig { params(session: T.nilable(ShopifyAPI::Auth::Session), from_hash: T.nilable(T::Hash[T.untyped, T.untyped])).void }
+    def initialize(session: ShopifyAPI::Context.active_session, from_hash: nil)
 
       @attachment = T.let(nil, T.nilable(String))
       @checksum = T.let(nil, T.nilable(String))
@@ -26,6 +28,8 @@ module ShopifyAPI
       @theme_id = T.let(nil, T.nilable(Integer))
       @updated_at = T.let(nil, T.nilable(String))
       @value = T.let(nil, T.nilable(String))
+
+      super(session: session, from_hash: from_hash)
     end
 
     @has_one = T.let({}, T::Hash[Symbol, Class])

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

@@ -12,9 +12,11 @@ module ShopifyAPI
     @prev_page_info = T.let(Concurrent::ThreadLocalVar.new { nil }, Concurrent::ThreadLocalVar)
     @next_page_info = T.let(Concurrent::ThreadLocalVar.new { nil }, Concurrent::ThreadLocalVar)
 
-    sig { params(session: T.nilable(ShopifyAPI::Auth::Session)).void }
-    def initialize(session: ShopifyAPI::Context.active_session)
-      super(session: session)
+    @api_call_limit = T.let(Concurrent::ThreadLocalVar.new { nil }, Concurrent::ThreadLocalVar)
+    @retry_request_after = T.let(Concurrent::ThreadLocalVar.new { nil }, Concurrent::ThreadLocalVar)
+
+    sig { params(session: T.nilable(ShopifyAPI::Auth::Session), from_hash: T.nilable(T::Hash[T.untyped, T.untyped])).void }
+    def initialize(session: ShopifyAPI::Context.active_session, from_hash: nil)
 
       @assigned_location_id = T.let(nil, T.nilable(Integer))
       @destination = T.let(nil, T.nilable(T::Hash[T.untyped, T.untyped]))
@@ -24,6 +26,8 @@ module ShopifyAPI
       @request_status = T.let(nil, T.nilable(String))
       @shop_id = T.let(nil, T.nilable(Integer))
       @status = T.let(nil, T.nilable(String))
+
+      super(session: session, from_hash: from_hash)
     end
 
     @has_one = T.let({}, T::Hash[Symbol, Class])
@@ -51,10 +55,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_04/balance.rb

@@ -12,10 +12,13 @@ module ShopifyAPI
     @prev_page_info = T.let(Concurrent::ThreadLocalVar.new { nil }, Concurrent::ThreadLocalVar)
     @next_page_info = T.let(Concurrent::ThreadLocalVar.new { nil }, Concurrent::ThreadLocalVar)
 
-    sig { params(session: T.nilable(ShopifyAPI::Auth::Session)).void }
-    def initialize(session: ShopifyAPI::Context.active_session)
-      super(session: session)
+    @api_call_limit = T.let(Concurrent::ThreadLocalVar.new { nil }, Concurrent::ThreadLocalVar)
+    @retry_request_after = T.let(Concurrent::ThreadLocalVar.new { nil }, Concurrent::ThreadLocalVar)
 
+    sig { params(session: T.nilable(ShopifyAPI::Auth::Session), from_hash: T.nilable(T::Hash[T.untyped, T.untyped])).void }
+    def initialize(session: ShopifyAPI::Context.active_session, from_hash: nil)
+
+      super(session: session, from_hash: from_hash)
     end
 
     @has_one = T.let({}, T::Hash[Symbol, Class])

data/lib/shopify_api/rest/resources/2022_04/blog.rb

@@ -12,9 +12,11 @@ module ShopifyAPI
     @prev_page_info = T.let(Concurrent::ThreadLocalVar.new { nil }, Concurrent::ThreadLocalVar)
     @next_page_info = T.let(Concurrent::ThreadLocalVar.new { nil }, Concurrent::ThreadLocalVar)
 
-    sig { params(session: T.nilable(ShopifyAPI::Auth::Session)).void }
-    def initialize(session: ShopifyAPI::Context.active_session)
-      super(session: session)
+    @api_call_limit = T.let(Concurrent::ThreadLocalVar.new { nil }, Concurrent::ThreadLocalVar)
+    @retry_request_after = T.let(Concurrent::ThreadLocalVar.new { nil }, Concurrent::ThreadLocalVar)
+
+    sig { params(session: T.nilable(ShopifyAPI::Auth::Session), from_hash: T.nilable(T::Hash[T.untyped, T.untyped])).void }
+    def initialize(session: ShopifyAPI::Context.active_session, from_hash: nil)
 
       @admin_graphql_api_id = T.let(nil, T.nilable(String))
       @commentable = T.let(nil, T.nilable(String))
@@ -28,6 +30,8 @@ module ShopifyAPI
       @template_suffix = T.let(nil, T.nilable(String))
       @title = T.let(nil, T.nilable(String))
       @updated_at = T.let(nil, T.nilable(String))
+
+      super(session: session, from_hash: from_hash)
     end
 
     @has_one = T.let({}, T::Hash[Symbol, Class])

data/lib/shopify_api/rest/resources/2022_04/cancellation_request.rb

@@ -12,11 +12,15 @@ module ShopifyAPI
     @prev_page_info = T.let(Concurrent::ThreadLocalVar.new { nil }, Concurrent::ThreadLocalVar)
     @next_page_info = T.let(Concurrent::ThreadLocalVar.new { nil }, Concurrent::ThreadLocalVar)
 
-    sig { params(session: T.nilable(ShopifyAPI::Auth::Session)).void }
-    def initialize(session: ShopifyAPI::Context.active_session)
-      super(session: session)
+    @api_call_limit = T.let(Concurrent::ThreadLocalVar.new { nil }, Concurrent::ThreadLocalVar)
+    @retry_request_after = T.let(Concurrent::ThreadLocalVar.new { nil }, Concurrent::ThreadLocalVar)
+
+    sig { params(session: T.nilable(ShopifyAPI::Auth::Session), from_hash: T.nilable(T::Hash[T.untyped, T.untyped])).void }
+    def initialize(session: ShopifyAPI::Context.active_session, from_hash: nil)
 
       @fulfillment_order_id = T.let(nil, T.nilable(Integer))
+
+      super(session: session, from_hash: from_hash)
     end
 
     @has_one = T.let({}, T::Hash[Symbol, Class])