shopify_api 13.3.1 → 14.0.0

data/lib/shopify_api/auth/token_exchange.rb

@@ -0,0 +1,80 @@
+# typed: strict
+# frozen_string_literal: true
+
+module ShopifyAPI
+  module Auth
+    module TokenExchange
+      extend T::Sig
+
+      TOKEN_EXCHANGE_GRANT_TYPE = "urn:ietf:params:oauth:grant-type:token-exchange"
+      ID_TOKEN_TYPE = "urn:ietf:params:oauth:token-type:id_token"
+
+      class RequestedTokenType < T::Enum
+        enums do
+          ONLINE_ACCESS_TOKEN = new("urn:shopify:params:oauth:token-type:online-access-token")
+          OFFLINE_ACCESS_TOKEN = new("urn:shopify:params:oauth:token-type:offline-access-token")
+        end
+      end
+
+      class << self
+        extend T::Sig
+
+        sig do
+          params(
+            shop: String,
+            session_token: String,
+            requested_token_type: RequestedTokenType,
+          ).returns(ShopifyAPI::Auth::Session)
+        end
+        def exchange_token(shop:, session_token:, requested_token_type:)
+          unless ShopifyAPI::Context.setup?
+            raise ShopifyAPI::Errors::ContextNotSetupError,
+              "ShopifyAPI::Context not setup, please call ShopifyAPI::Context.setup"
+          end
+          raise ShopifyAPI::Errors::UnsupportedOauthError,
+            "Cannot perform OAuth Token Exchange for private apps." if ShopifyAPI::Context.private?
+          raise ShopifyAPI::Errors::UnsupportedOauthError,
+            "Cannot perform OAuth Token Exchange for non embedded apps." unless ShopifyAPI::Context.embedded?
+
+          # Validate the session token content
+          ShopifyAPI::Auth::JwtPayload.new(session_token)
+
+          shop_session = ShopifyAPI::Auth::Session.new(shop: shop)
+          body = {
+            client_id: ShopifyAPI::Context.api_key,
+            client_secret: ShopifyAPI::Context.api_secret_key,
+            grant_type: TOKEN_EXCHANGE_GRANT_TYPE,
+            subject_token: session_token,
+            subject_token_type: ID_TOKEN_TYPE,
+            requested_token_type: requested_token_type.serialize,
+          }
+
+          client = Clients::HttpClient.new(session: shop_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 => error
+            if error.code == 400 && error.response.body["error"] == "invalid_subject_token"
+              raise ShopifyAPI::Errors::InvalidJwtTokenError, "Session token was rejected by token exchange"
+            end
+
+            raise error
+          end
+
+          session_params = T.cast(response.body, T::Hash[String, T.untyped]).to_h
+
+          Session.from(
+            shop: shop,
+            access_token_response: Oauth::AccessTokenResponse.from_hash(session_params),
+          )
+        end
+      end
+    end
+  end
+end

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/logger.rb

@@ -75,7 +75,7 @@ module ShopifyAPI
       def valid_version(version)
         current_version = Gem::Version.create(ShopifyAPI::VERSION)
         deprecate_version = Gem::Version.create(version)
-        current_version < deprecate_version
+        T.must(current_version) < deprecate_version
       end
     end
   end

data/lib/shopify_api/rest/base.rb

@@ -2,7 +2,6 @@
 # frozen_string_literal: true
 
 require "active_support/inflector"
-require "hash_diff"
 
 module ShopifyAPI
   module Rest
@@ -11,8 +10,9 @@ module ShopifyAPI
       extend T::Helpers
       abstract!
 
-      @has_one = T.let({}, T::Hash[Symbol, Class])
-      @has_many = T.let({}, T::Hash[Symbol, Class])
+      @headers = T.let(nil, T.nilable(T::Hash[T.any(Symbol, String), String]))
+      @has_one = T.let({}, T::Hash[Symbol, T::Class[T.anything]])
+      @has_many = T.let({}, T::Hash[Symbol, T::Class[T.anything]])
       @paths = T.let([], T::Array[T::Hash[Symbol, T.any(T::Array[Symbol], String, Symbol)]])
       @custom_prefix = T.let(nil, T.nilable(String))
       @read_only_attributes = T.let([], T.nilable(T::Array[Symbol]))
@@ -55,12 +55,24 @@ module ShopifyAPI
         sig { returns(T.nilable(String)) }
         attr_reader :custom_prefix
 
-        sig { returns(T::Hash[Symbol, Class]) }
+        sig { returns(T::Hash[Symbol, T::Class[T.anything]]) }
         attr_reader :has_many
 
-        sig { returns(T::Hash[Symbol, Class]) }
+        sig { returns(T::Hash[Symbol, T::Class[T.anything]]) }
         attr_reader :has_one
 
+        sig { returns(T.nilable(T::Hash[T.any(Symbol, String), String])) }
+        attr_accessor :headers
+
+        sig { params(subclass: T::Class[T.anything]).returns(T.untyped) }
+        def inherited(subclass)
+          super
+
+          subclass.define_singleton_method(:headers) do
+            ShopifyAPI::Rest::Base.headers
+          end
+        end
+
         sig do
           params(
             session: T.nilable(Auth::Session),
@@ -74,11 +86,14 @@ module ShopifyAPI
           client = ShopifyAPI::Clients::Rest::Admin.new(session: session)
 
           path = T.must(get_path(http_method: :get, operation: :get, ids: ids))
-          response = client.get(path: path, query: params.compact)
+          response = client.get(path: path, query: params.compact, headers: headers)
 
           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 +137,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)
@@ -174,6 +199,21 @@ module ShopifyAPI
           custom_prefix ? "#{T.must(custom_prefix).sub(%r{\A/}, "")}/#{match}" : match
         end
 
+        sig do
+          params(
+            http_method: Symbol,
+            operation: Symbol,
+          ).returns(T.nilable(T::Array[Symbol]))
+        end
+        def get_path_ids(http_method:, operation:)
+          found_path = @paths.find do |path|
+            http_method == path[:http_method] && operation == path[:operation]
+          end
+          return nil if found_path.nil?
+
+          T.cast(found_path[:ids], T::Array[Symbol])
+        end
+
         sig do
           params(
             http_method: Symbol,
@@ -192,13 +232,13 @@ module ShopifyAPI
 
           case http_method
           when :get
-            client.get(path: T.must(path), query: params.compact)
+            client.get(path: T.must(path), query: params.compact, headers: headers)
           when :post
-            client.post(path: T.must(path), query: params.compact, body: body || {})
+            client.post(path: T.must(path), query: params.compact, body: body || {}, headers: headers)
           when :put
-            client.put(path: T.must(path), query: params.compact, body: body || {})
+            client.put(path: T.must(path), query: params.compact, body: body || {}, headers: headers)
           when :delete
-            client.delete(path: T.must(path), query: params.compact)
+            client.delete(path: T.must(path), query: params.compact, headers: headers)
           else
             raise Errors::InvalidHttpRequestError, "Invalid HTTP method: #{http_method}"
           end
@@ -328,6 +368,7 @@ module ShopifyAPI
         @client.delete(
           path: T.must(self.class.get_path(http_method: :delete, operation: :delete, entity: self)),
           query: params.compact,
+          headers: self.class.headers,
         )
       rescue ShopifyAPI::Errors::HttpResponseError => e
         @errors.errors << e
@@ -342,10 +383,16 @@ module ShopifyAPI
       sig { params(update_object: T::Boolean).void }
       def save(update_object: false)
         method = deduce_write_verb
+
+        body = {
+          self.class.json_body_name => attributes_to_update.merge(build_required_attributes(http_method: method)),
+        }
+
         response = @client.public_send(
           method,
-          body: { self.class.json_body_name => attributes_to_update },
+          body: body,
           path: deduce_write_path(method),
+          headers: self.class.headers,
         )
 
         if update_object
@@ -361,22 +408,34 @@ module ShopifyAPI
 
       sig { returns(T::Hash[String, String]) }
       def attributes_to_update
-        original_state_for_update = original_state.reject do |attribute, _|
+        updatable_attributes = original_state.reject do |attribute, _|
           self.class.read_only_attributes&.include?("@#{attribute}".to_sym)
         end
 
-        diff = HashDiff::Comparison.new(
-          deep_stringify_keys(original_state_for_update),
-          deep_stringify_keys(to_hash(true)),
-        ).left_diff
+        stringified_updatable_attributes = deep_stringify_keys(updatable_attributes)
+        stringified_new_attributes = deep_stringify_keys(to_hash(true))
+        ShopifyAPI::Utils::AttributesComparator.compare(
+          stringified_updatable_attributes,
+          stringified_new_attributes,
+        )
+      end
 
-        diff.each do |attribute, value|
-          if value.is_a?(Hash) && value[0] == HashDiff::NO_VALUE
-            diff[attribute] = send(attribute)
-          end
+      sig { params(http_method: Symbol).returns(T::Hash[String, T.untyped]) }
+      def build_required_attributes(http_method:)
+        required_attributes = {}
+
+        primary_key_value = send(self.class.primary_key)
+        unless primary_key_value.nil?
+          required_attributes[self.class.primary_key] = primary_key_value
         end
 
-        diff
+        path_ids = deduce_path_ids(http_method)
+        path_ids&.each do |path_id|
+          path_id_value = send(path_id)
+          required_attributes[path_id.to_s] = path_id_value unless path_id_value.nil?
+        end
+
+        required_attributes
       end
 
       sig { returns(Symbol) }
@@ -396,6 +455,18 @@ module ShopifyAPI
         path
       end
 
+      sig { params(method: Symbol).returns(T.nilable(T::Array[Symbol])) }
+      def deduce_path_ids(method)
+        path_ids = self.class.get_path_ids(http_method: method, operation: method)
+
+        if path_ids.nil?
+          method = method == :post ? :put : :post
+          path_ids = self.class.get_path_ids(http_method: method, operation: method)
+        end
+
+        path_ids
+      end
+
       sig { params(hash: T::Hash[T.any(String, Symbol), T.untyped]).returns(T::Hash[String, String]) }
       def deep_stringify_keys(hash)
         hash.each_with_object({}) do |(key, value), result|
@@ -427,7 +498,7 @@ module ShopifyAPI
       sig do
         params(
           element: T.nilable(T.any(T::Hash[String, T.untyped], ShopifyAPI::Rest::Base)),
-          attribute_class: Class,
+          attribute_class: T::Class[T.anything],
           saving: T::Boolean,
         ).returns(T.nilable(T::Hash[String, T.untyped]))
       end

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