shopify_api 11.1.0 → 12.4.0

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

@@ -11,7 +11,7 @@ module ShopifyAPI
             id: shop,
             shop: shop,
             access_token: "",
-            is_online: false
+            is_online: false,
           )
           super(session: session, base_path: "/api")
           @storefront_access_token = storefront_access_token
@@ -22,7 +22,7 @@ module ShopifyAPI
             query: String,
             variables: T.nilable(T::Hash[T.any(Symbol, String), T.untyped]),
             headers: T.nilable(T::Hash[T.any(Symbol, String), T.untyped]),
-            tries: Integer
+            tries: Integer,
           ).returns(HttpResponse)
         end
         def query(query:, variables: nil, headers: {}, tries: 1)

data/lib/shopify_api/clients/http_client.rb

@@ -45,7 +45,7 @@ module ShopifyAPI
             request_url(request),
             headers: headers,
             query: request.query,
-            body: request.body.class == Hash ? T.unsafe(request.body).to_json : request.body
+            body: request.body.class == Hash ? T.unsafe(request.body).to_json : request.body,
           ), HTTParty::Response)
 
           body = res.body.empty? ? {} : JSON.parse(res.body)
@@ -69,13 +69,13 @@ module ShopifyAPI
           error_message = error_messages.join("\n")
 
           unless [429, 500].include?(response.code)
-            raise ShopifyAPI::Errors::HttpResponseError.new(code: response.code.to_i), error_message
+            raise ShopifyAPI::Errors::HttpResponseError.new(response: response), error_message
           end
 
           if tries == request.tries
-            raise ShopifyAPI::Errors::HttpResponseError.new(code: response.code), error_message if request.tries == 1
+            raise ShopifyAPI::Errors::HttpResponseError.new(response: response), error_message if request.tries == 1
 
-            raise ShopifyAPI::Errors::MaxHttpRetriesExceededError.new(code: response.code),
+            raise ShopifyAPI::Errors::MaxHttpRetriesExceededError.new(response: response),
               "Exceeded maximum retry count of #{request.tries}. Last message: #{error_message}"
           end
 

data/lib/shopify_api/clients/rest/admin.rb

@@ -18,13 +18,13 @@ module ShopifyAPI
             body: T.nilable(T::Hash[T.any(Symbol, String), T.untyped]),
             query: T.nilable(T::Hash[T.any(Symbol, String), T.untyped]),
             headers: T.nilable(T::Hash[T.any(Symbol, String), T.untyped]),
-            tries: T.nilable(Integer)
+            tries: T.nilable(Integer),
           ).returns(HttpResponse)
         end
         def get(path:, body: nil, query: nil, headers: nil, tries: 1)
           request(
             make_request(http_method: :get, path: path, body: body, query: query, headers: headers,
-              tries: T.must(tries))
+              tries: T.must(tries)),
           )
         end
 
@@ -34,13 +34,13 @@ module ShopifyAPI
             body: T.nilable(T::Hash[T.any(Symbol, String), T.untyped]),
             query: T.nilable(T::Hash[T.any(Symbol, String), T.untyped]),
             headers: T.nilable(T::Hash[T.any(Symbol, String), T.untyped]),
-            tries: T.nilable(Integer)
+            tries: T.nilable(Integer),
           ).returns(HttpResponse)
         end
         def delete(path:, body: nil, query: nil, headers: nil, tries: 1)
           request(
             make_request(http_method: :delete, path: path, body: body, query: query, headers: headers,
-              tries: T.must(tries))
+              tries: T.must(tries)),
           )
         end
 
@@ -50,13 +50,13 @@ module ShopifyAPI
             body: T::Hash[T.any(Symbol, String), T.untyped],
             query: T.nilable(T::Hash[T.any(Symbol, String), T.untyped]),
             headers: T.nilable(T::Hash[T.any(Symbol, String), T.untyped]),
-            tries: T.nilable(Integer)
+            tries: T.nilable(Integer),
           ).returns(HttpResponse)
         end
         def put(path:, body:, query: nil, headers: nil, tries: 1)
           request(
             make_request(http_method: :put, path: path, body: body, query: query, headers: headers,
-              tries: T.must(tries))
+              tries: T.must(tries)),
           )
         end
 
@@ -66,13 +66,13 @@ module ShopifyAPI
             body: T::Hash[T.any(Symbol, String), T.untyped],
             query: T.nilable(T::Hash[T.any(Symbol, String), T.untyped]),
             headers: T.nilable(T::Hash[T.any(Symbol, String), T.untyped]),
-            tries: T.nilable(Integer)
+            tries: T.nilable(Integer),
           ).returns(HttpResponse)
         end
         def post(path:, body:, query: nil, headers: nil, tries: 1)
           request(
             make_request(http_method: :post, path: path, body: body, query: query, headers: headers,
-              tries: T.must(tries))
+              tries: T.must(tries)),
           )
         end
 
@@ -98,7 +98,7 @@ module ShopifyAPI
             body: T.nilable(T::Hash[T.any(Symbol, String), T.untyped]),
             query: T.nilable(T::Hash[T.any(Symbol, String), T.untyped]),
             headers: T.nilable(T::Hash[T.any(Symbol, String), T.untyped]),
-            tries: Integer
+            tries: Integer,
           ).returns(HttpRequest)
         end
         def make_request(http_method:, path:, body:, query:, headers:, tries:)
@@ -109,7 +109,7 @@ module ShopifyAPI
             query: query,
             extra_headers: headers,
             body_type: body.nil? ? nil : "application/json",
-            tries: tries
+            tries: tries,
           )
         end
       end

data/lib/shopify_api/context.rb

@@ -8,15 +8,15 @@ module ShopifyAPI
     @api_key = T.let("", String)
     @api_secret_key = T.let("", String)
     @api_version = T.let(LATEST_SUPPORTED_ADMIN_VERSION, String)
-    @host_name = T.let("", String)
     @scope = T.let(Auth::AuthScopes.new, Auth::AuthScopes)
-    @session_storage = T.let(ShopifyAPI::Auth::FileSessionStorage.new, ShopifyAPI::Auth::SessionStorage)
     @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 = T.let(::Logger.new($stdout), ::Logger)
+    @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 }, Concurrent::ThreadLocalVar)
+    @session_storage = T.let(nil, T.nilable(ShopifyAPI::Auth::SessionStorage))
     @user_agent_prefix = T.let(nil, T.nilable(String))
     @old_api_secret_key = T.let(nil, T.nilable(String))
 
@@ -30,12 +30,14 @@ module ShopifyAPI
           api_key: String,
           api_secret_key: String,
           api_version: String,
-          host_name: String,
           scope: T.any(T::Array[String], String),
           is_private: T::Boolean,
           is_embedded: T::Boolean,
-          session_storage: ShopifyAPI::Auth::SessionStorage,
-          logger: Logger,
+          log_level: T.any(String, Symbol),
+          logger: ::Logger,
+          session_storage: T.nilable(ShopifyAPI::Auth::SessionStorage),
+          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),
@@ -45,25 +47,27 @@ module ShopifyAPI
         api_key:,
         api_secret_key:,
         api_version:,
-        host_name:,
         scope:,
         is_private:,
         is_embedded:,
-        session_storage:,
-        logger: Logger.new($stdout),
+        log_level: :info,
+        logger: ::Logger.new($stdout),
+        session_storage: nil,
+        host_name: nil,
+        host: ENV["HOST"] || "https://#{host_name}",
         private_shop: nil,
         user_agent_prefix: nil,
         old_api_secret_key: nil
       )
         unless ShopifyAPI::AdminVersions::SUPPORTED_ADMIN_VERSIONS.include?(api_version)
           raise Errors::UnsupportedVersionError,
-            "Invalid vession #{api_version}, supported versions: #{ShopifyAPI::AdminVersions::SUPPORTED_ADMIN_VERSIONS}"
+            "Invalid version #{api_version}, supported versions: #{ShopifyAPI::AdminVersions::SUPPORTED_ADMIN_VERSIONS}"
         end
 
         @api_key = api_key
         @api_secret_key = api_secret_key
         @api_version = api_version
-        @host_name = host_name
+        @host = T.let(host, T.nilable(String))
         @is_private = is_private
         @scope = Auth::AuthScopes.new(scope)
         @is_embedded = is_embedded
@@ -72,6 +76,18 @@ module ShopifyAPI
         @private_shop = private_shop
         @user_agent_prefix = user_agent_prefix
         @old_api_secret_key = old_api_secret_key
+        @log_level = if valid_log_level?(log_level)
+          log_level.to_sym
+        else
+          :info
+        end
+
+        if @session_storage
+          ::ShopifyAPI::Logger.deprecated("The use of SessionStorage in the API library has been deprecated. " \
+            "The ShopifyAPI will no longer have responsibility for session persistence. " \
+            "Upgrading to `shopify_app` 21.3 will allow you to remove session_storage" \
+            " from the API library Context configuration.", "13.0.0")
+        end
 
         load_rest_resources(api_version: api_version)
       end
@@ -105,24 +121,27 @@ module ShopifyAPI
       end
 
       sig { returns(String) }
-      attr_reader :api_key, :api_secret_key, :api_version, :host_name
+      attr_reader :api_key, :api_secret_key, :api_version
 
       sig { returns(Auth::AuthScopes) }
       attr_reader :scope
 
-      sig { returns(ShopifyAPI::Auth::SessionStorage) }
+      sig { returns(T.nilable(ShopifyAPI::Auth::SessionStorage)) }
       attr_reader :session_storage
 
-      sig { returns(Logger) }
+      sig { returns(::Logger) }
       attr_reader :logger
 
+      sig { returns(Symbol) }
+      attr_reader :log_level
+
       sig { returns(T::Boolean) }
       def private?
         @is_private
       end
 
       sig { returns(T.nilable(String)) }
-      attr_reader :private_shop, :user_agent_prefix, :old_api_secret_key
+      attr_reader :private_shop, :user_agent_prefix, :old_api_secret_key, :host
 
       sig { returns(T::Boolean) }
       def embedded?
@@ -131,7 +150,7 @@ module ShopifyAPI
 
       sig { returns(T::Boolean) }
       def setup?
-        !(api_key.empty? || api_secret_key.empty? || host_name.empty?)
+        [api_key, api_secret_key, T.must(host)].none?(&:empty?)
       end
 
       sig { returns(T.nilable(Auth::Session)) }
@@ -150,6 +169,28 @@ module ShopifyAPI
       def deactivate_session
         @active_session.value = nil
       end
+
+      sig { returns(String) }
+      def host_scheme
+        T.must(URI.parse(T.must(host)).scheme)
+      end
+
+      sig { returns(String) }
+      def host_name
+        T.must(URI(T.must(host)).host)
+      end
+
+      private
+
+      sig { params(log_level: T.any(Symbol, String)).returns(T::Boolean) }
+      def valid_log_level?(log_level)
+        return true if ::ShopifyAPI::Logger.levels.include?(log_level.to_sym)
+
+        ShopifyAPI::Logger.warn("#{log_level} is not a valid log_level. "\
+          "Valid options are #{::ShopifyAPI::Logger.levels.join(", ")}")
+
+        false
+      end
     end
   end
 end

data/lib/shopify_api/errors/feature_deprecated_error.rb

@@ -0,0 +1,9 @@
+# typed: strict
+# frozen_string_literal: true
+
+module ShopifyAPI
+  module Errors
+    class FeatureDeprecatedError < StandardError
+    end
+  end
+end

data/lib/shopify_api/errors/http_response_error.rb

@@ -9,10 +9,14 @@ module ShopifyAPI
       sig { returns(Integer) }
       attr_reader :code
 
-      sig { params(code: Integer).void }
-      def initialize(code:)
+      sig { returns(ShopifyAPI::Clients::HttpResponse) }
+      attr_reader :response
+
+      sig { params(response: ShopifyAPI::Clients::HttpResponse).void }
+      def initialize(response:)
         super
-        @code = code
+        @code = T.let(response.code, Integer)
+        @response = response
       end
     end
   end

data/lib/shopify_api/errors/log_level_not_found_error.rb

@@ -0,0 +1,9 @@
+# typed: strict
+# frozen_string_literal: true
+
+module ShopifyAPI
+  module Errors
+    class LogLevelNotFoundError < StandardError
+    end
+  end
+end

data/lib/shopify_api/logger.rb

@@ -0,0 +1,82 @@
+# typed: strict
+# frozen_string_literal: true
+
+module ShopifyAPI
+  class Logger
+    LOG_LEVELS = T.let({ debug: 0, info: 1, warn: 2, error: 3, off: 6 }, T::Hash[Symbol, Integer])
+    DEFAULT_LOG_LEVEL = :info
+
+    class << self
+      extend T::Sig
+
+      sig { params(message: String).void }
+      def debug(message)
+        send_to_logger(:debug, message)
+      end
+
+      sig { params(message: String).void }
+      def info(message)
+        send_to_logger(:info, message)
+      end
+
+      sig { params(message: String).void }
+      def warn(message)
+        send_to_logger(:warn, message)
+      end
+
+      sig { params(message: String).void }
+      def error(message)
+        send_to_logger(:error, message)
+      end
+
+      sig { params(message: String, version: String).void }
+      def deprecated(message, version)
+        return unless enabled_for_log_level?(:warn)
+
+        raise Errors::FeatureDeprecatedError unless valid_version(version)
+
+        send_to_logger(:warn, message)
+      end
+
+      sig { returns(T::Array[Symbol]) }
+      def levels
+        LOG_LEVELS.keys
+      end
+
+      private
+
+      sig { params(log_level: Symbol).returns(String) }
+      def context(log_level)
+        current_shop = ShopifyAPI::Context.active_session&.shop
+
+        if current_shop.nil?
+          "[ ShopifyAPI | #{log_level.to_s.upcase} ]"
+        else
+          "[ ShopifyAPI | #{log_level.to_s.upcase} | #{current_shop} ]"
+        end
+      end
+
+      sig { params(log_level: Symbol, message: String).void }
+      def send_to_logger(log_level, message)
+        return unless enabled_for_log_level?(log_level)
+
+        full_message = "#{context(log_level)} #{message}"
+
+        ShopifyAPI::Context.logger.public_send(log_level, full_message)
+      end
+
+      sig { params(log_level: Symbol).returns(T::Boolean) }
+      def enabled_for_log_level?(log_level)
+        T.must(LOG_LEVELS[log_level]) >= T.must(LOG_LEVELS[ShopifyAPI::Context.log_level] ||
+          LOG_LEVELS[DEFAULT_LOG_LEVEL])
+      end
+
+      sig { params(version: String).returns(T::Boolean) }
+      def valid_version(version)
+        current_version = Gem::Version.create(ShopifyAPI::VERSION)
+        deprecate_version = Gem::Version.create(version)
+        current_version < deprecate_version
+      end
+    end
+  end
+end

data/lib/shopify_api/rest/base.rb

@@ -97,6 +97,11 @@ module ShopifyAPI
           class_name.underscore
         end
 
+        sig { returns(String) }
+        def json_response_body_name
+          class_name
+        end
+
         sig { returns(T.nilable(String)) }
         def prev_page_info
           instance_variable_get(:"@prev_page_info").value
@@ -137,7 +142,7 @@ module ShopifyAPI
             http_method: Symbol,
             operation: Symbol,
             entity: T.nilable(Base),
-            ids: T::Hash[Symbol, T.any(Integer, String)]
+            ids: T::Hash[Symbol, T.any(Integer, String)],
           ).returns(T.nilable(String))
         end
         def get_path(http_method:, operation:, entity: nil, ids: {})
@@ -205,12 +210,14 @@ module ShopifyAPI
 
           body = T.cast(response.body, T::Hash[String, T.untyped])
 
-          if body.key?(class_name.pluralize) || (body.key?(class_name) && body[class_name].is_a?(Array))
-            (body[class_name.pluralize] || body[class_name]).each do |entry|
+          response_name = json_response_body_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?(class_name)
-            objects << create_instance(data: body[class_name], session: session)
+          elsif body.key?(response_name)
+            objects << create_instance(data: body[response_name], session: session)
           end
 
           objects
@@ -297,7 +304,7 @@ module ShopifyAPI
             element_hash = get_element_hash(
               get_property(attribute),
               T.unsafe(self.class.has_one[attribute]),
-              saving
+              saving,
             )
             hash[attribute.to_s] = element_hash if element_hash || @forced_nils[attribute.to_s]
           elsif !get_property(attribute).nil? || @forced_nils[attribute.to_s]
@@ -312,7 +319,7 @@ module ShopifyAPI
       def delete(params: {})
         @client.delete(
           path: T.must(self.class.get_path(http_method: :delete, operation: :delete, entity: self)),
-          query: params.compact
+          query: params.compact,
         )
       rescue ShopifyAPI::Errors::HttpResponseError => e
         @errors.errors << e

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

@@ -65,6 +65,7 @@ module ShopifyAPI
       discount_codes: DiscountCode
     }, T::Hash[Symbol, Class])
     @paths = T.let([
+      {http_method: :get, operation: :checkouts, ids: [], path: "checkouts.json"},
       {http_method: :get, operation: :checkouts, ids: [], path: "checkouts.json"}
     ], T::Array[T::Hash[String, T.any(T::Array[Symbol], String, Symbol)]])
 
@@ -150,25 +151,25 @@ module ShopifyAPI
     class << self
       sig do
         params(
-          limit: T.untyped,
           since_id: T.untyped,
           created_at_min: T.untyped,
           created_at_max: T.untyped,
           updated_at_min: T.untyped,
           updated_at_max: T.untyped,
           status: T.untyped,
+          limit: T.untyped,
           session: Auth::Session,
           kwargs: T.untyped
         ).returns(T.untyped)
       end
       def checkouts(
-        limit: nil,
         since_id: nil,
         created_at_min: nil,
         created_at_max: nil,
         updated_at_min: nil,
         updated_at_max: nil,
         status: nil,
+        limit: nil,
         session: ShopifyAPI::Context.active_session,
         **kwargs
       )
@@ -177,7 +178,7 @@ module ShopifyAPI
           operation: :checkouts,
           session: session,
           ids: {},
-          params: {limit: limit, since_id: since_id, created_at_min: created_at_min, created_at_max: created_at_max, updated_at_min: updated_at_min, updated_at_max: updated_at_max, status: status}.merge(kwargs).compact,
+          params: {since_id: since_id, created_at_min: created_at_min, created_at_max: created_at_max, updated_at_min: updated_at_min, updated_at_max: updated_at_max, status: status, limit: limit}.merge(kwargs).compact,
           body: {},
           entity: nil,
         )

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

@@ -50,6 +50,13 @@ module ShopifyAPI
     attr_reader :status
 
     class << self
+      sig do
+        returns(String)
+      end
+      def json_response_body_name()
+        "fulfillment_order"
+      end
+
       sig do
         params(
           assignment_status: T.untyped,

data/lib/shopify_api/rest/resources/2022_01/customer.rb

@@ -33,6 +33,8 @@ module ShopifyAPI
       @multipass_identifier = T.let(nil, T.nilable(String))
       @note = T.let(nil, T.nilable(String))
       @orders_count = T.let(nil, T.nilable(Integer))
+      @password = T.let(nil, T.nilable(String))
+      @password_confirmation = T.let(nil, T.nilable(String))
       @phone = T.let(nil, T.nilable(String))
       @sms_marketing_consent = T.let(nil, T.nilable(T::Hash[T.untyped, T.untyped]))
       @state = T.let(nil, T.nilable(String))
@@ -49,6 +51,7 @@ module ShopifyAPI
     }, T::Hash[Symbol, Class])
     @has_many = T.let({}, T::Hash[Symbol, Class])
     @paths = T.let([
+      {http_method: :delete, operation: :delete, ids: [:id], path: "customers/<id>.json"},
       {http_method: :get, operation: :count, ids: [], path: "customers/count.json"},
       {http_method: :get, operation: :get, ids: [], path: "customers.json"},
       {http_method: :get, operation: :get, ids: [:id], path: "customers/<id>.json"},
@@ -95,6 +98,10 @@ module ShopifyAPI
     sig { returns(T.nilable(Integer)) }
     attr_reader :orders_count
     sig { returns(T.nilable(String)) }
+    attr_reader :password
+    sig { returns(T.nilable(String)) }
+    attr_reader :password_confirmation
+    sig { returns(T.nilable(String)) }
     attr_reader :phone
     sig { returns(T.nilable(T::Hash[T.untyped, T.untyped])) }
     attr_reader :sms_marketing_consent
@@ -134,6 +141,25 @@ module ShopifyAPI
         T.cast(result[0], T.nilable(Customer))
       end
 
+      sig do
+        params(
+          id: T.any(Integer, String),
+          session: Auth::Session
+        ).returns(T.untyped)
+      end
+      def delete(
+        id:,
+        session: ShopifyAPI::Context.active_session
+      )
+        request(
+          http_method: :delete,
+          operation: :delete,
+          session: session,
+          ids: {id: id},
+          params: {},
+        )
+      end
+
       sig do
         params(
           ids: T.untyped,
@@ -171,11 +197,19 @@ module ShopifyAPI
 
       sig do
         params(
+          created_at_min: T.untyped,
+          created_at_max: T.untyped,
+          updated_at_min: T.untyped,
+          updated_at_max: T.untyped,
           session: Auth::Session,
           kwargs: T.untyped
         ).returns(T.untyped)
       end
       def count(
+        created_at_min: nil,
+        created_at_max: nil,
+        updated_at_min: nil,
+        updated_at_max: nil,
         session: ShopifyAPI::Context.active_session,
         **kwargs
       )
@@ -184,7 +218,7 @@ module ShopifyAPI
           operation: :count,
           session: session,
           ids: {},
-          params: {}.merge(kwargs).compact,
+          params: {created_at_min: created_at_min, created_at_max: created_at_max, updated_at_min: updated_at_min, updated_at_max: updated_at_max}.merge(kwargs).compact,
           body: {},
           entity: nil,
         )

data/lib/shopify_api/rest/resources/2022_01/draft_order.rb

@@ -248,12 +248,14 @@ module ShopifyAPI
 
     sig do
       params(
+        payment_gateway_id: T.untyped,
         payment_pending: T.untyped,
         body: T.untyped,
         kwargs: T.untyped
       ).returns(T.untyped)
     end
     def complete(
+      payment_gateway_id: nil,
       payment_pending: nil,
       body: nil,
       **kwargs
@@ -263,7 +265,7 @@ module ShopifyAPI
         operation: :complete,
         session: @session,
         ids: {id: @id},
-        params: {payment_pending: payment_pending}.merge(kwargs).compact,
+        params: {payment_gateway_id: payment_gateway_id, payment_pending: payment_pending}.merge(kwargs).compact,
         body: body,
         entity: self,
       )

data/lib/shopify_api/rest/resources/2022_01/fulfillment.rb

@@ -245,11 +245,15 @@ module ShopifyAPI
 
     sig do
       params(
+        notify_customer: T.untyped,
+        tracking_info: T.untyped,
         body: T.untyped,
         kwargs: T.untyped
       ).returns(T.untyped)
     end
     def update_tracking(
+      notify_customer: nil,
+      tracking_info: nil,
       body: nil,
       **kwargs
     )
@@ -258,7 +262,7 @@ module ShopifyAPI
         operation: :update_tracking,
         session: @session,
         ids: {id: @id},
-        params: {}.merge(kwargs).compact,
+        params: {notify_customer: notify_customer, tracking_info: tracking_info}.merge(kwargs).compact,
         body: body,
         entity: self,
       )

data/lib/shopify_api/rest/resources/2022_01/fulfillment_order.rb

@@ -193,13 +193,13 @@ module ShopifyAPI
 
     sig do
       params(
-        new_location_id: T.untyped,
+        fulfillment_order: T.untyped,
         body: T.untyped,
         kwargs: T.untyped
       ).returns(T.untyped)
     end
     def move(
-      new_location_id: nil,
+      fulfillment_order: nil,
       body: nil,
       **kwargs
     )
@@ -208,7 +208,7 @@ module ShopifyAPI
         operation: :move,
         session: @session,
         ids: {id: @id},
-        params: {new_location_id: new_location_id}.merge(kwargs).compact,
+        params: {fulfillment_order: fulfillment_order}.merge(kwargs).compact,
         body: body,
         entity: self,
       )