Move api_version to client

This matches the approach taken the js client and will serve more
use cases than on the query.

lib/shopify_api/clients/graphql/admin.rb

@@ -5,9 +5,9 @@ module ShopifyAPI
   module Clients
     module Graphql
       class Admin < Client
-        sig { params(session: T.nilable(Auth::Session)).void }
-        def initialize(session:)
-          super(session: session, base_path: "/admin/api")
+        sig { params(session: T.nilable(Auth::Session), api_version: T.nilable(String)).void }
+        def initialize(session:, api_version: nil)
+          super(session: session, base_path: "/admin/api", api_version: api_version)
         end
       end
     end

lib/shopify_api/clients/graphql/client.rb

@@ -7,9 +7,10 @@ module Graphql
       class Client
         extend T::Sig
 
-        sig { params(session: T.nilable(Auth::Session), base_path: String).void }
-        def initialize(session:, base_path:)
+        sig { params(session: T.nilable(Auth::Session), base_path: String, api_version: T.nilable(String)).void }
+        def initialize(session:, base_path:, api_version: nil)
           @http_client = T.let(HttpClient.new(session: session, base_path: base_path), HttpClient)
+          @api_version = T.let(api_version || Context.api_version, String)
         end
 
         sig do
@@ -18,16 +19,14 @@ def initialize(session:, base_path:)
             variables: T.nilable(T::Hash[T.any(Symbol, String), T.untyped]),
             headers: T.nilable(T::Hash[T.any(Symbol, String), T.untyped]),
             tries: Integer,
-            api_version: T.nilable(String),
           ).returns(HttpResponse)
         end
-        def query(query:, variables: nil, headers: nil, tries: 1, api_version: nil)
+        def query(query:, variables: nil, headers: nil, tries: 1)
           body = { query: query, variables: variables }
-          api_version ||= Context.api_version
           @http_client.request(
             HttpRequest.new(
               http_method: :post,
-              path: "#{api_version}/graphql.json",
+              path: "#{@api_version}/graphql.json",
               body: body,
               query: nil,
               extra_headers: headers,

lib/shopify_api/clients/graphql/storefront.rb

@@ -5,15 +5,15 @@ module ShopifyAPI
   module Clients
     module Graphql
       class Storefront < Client
-        sig { params(shop: String, storefront_access_token: String).void }
-        def initialize(shop, storefront_access_token)
+        sig { params(shop: String, storefront_access_token: String, api_version: T.nilable(String)).void }
+        def initialize(shop, storefront_access_token, api_version: nil)
           session = Auth::Session.new(
             id: shop,
             shop: shop,
             access_token: "",
             is_online: false,
           )
-          super(session: session, base_path: "/api")
+          super(session: session, base_path: "/api", api_version: api_version)
           @storefront_access_token = storefront_access_token
         end
 
@@ -23,12 +23,11 @@ def initialize(shop, storefront_access_token)
             variables: T.nilable(T::Hash[T.any(Symbol, String), T.untyped]),
             headers: T.nilable(T::Hash[T.any(Symbol, String), T.untyped]),
             tries: Integer,
-            api_version: T.nilable(String),
           ).returns(HttpResponse)
         end
-        def query(query:, variables: nil, headers: {}, tries: 1, api_version: nil)
+        def query(query:, variables: nil, headers: {}, tries: 1)
           T.must(headers).merge!({ "X-Shopify-Storefront-Access-Token": @storefront_access_token })
-          super(query: query, variables: variables, headers: headers, tries: tries, api_version: api_version)
+          super(query: query, variables: variables, headers: headers, tries: tries)
         end
       end
     end

lib/shopify_api/clients/rest/admin.rb

@@ -7,9 +7,10 @@ module Rest
       class Admin < HttpClient
         extend T::Sig
 
-        sig { params(session: T.nilable(Auth::Session)).void }
-        def initialize(session: nil)
-          super(session: session, base_path: "/admin/api/#{Context.api_version}")
+        sig { params(session: T.nilable(Auth::Session), api_version: T.nilable(String)).void }
+        def initialize(session: nil, api_version: nil)
+          @api_version = T.let(api_version || Context.api_version, String)
+          super(session: session, base_path: "/admin/api/#{@api_version}")
         end
 
         sig do

test/clients/graphql/admin_test.rb

@@ -13,12 +13,20 @@ def setup
           super
           @session = ShopifyAPI::Auth::Session.new(shop: "test-shop.myshopify.com",
             access_token: SecureRandom.alphanumeric(10))
-          @client = ShopifyAPI::Clients::Graphql::Admin.new(session: @session)
+          @client = build_client
           @path = "admin/api"
           @expected_headers = TestHelpers::Constants::DEFAULT_CLIENT_HEADERS.merge({
             "X-Shopify-Access-Token": @session.access_token,
           })
         end
+
+        def build_client
+          if !defined?("@api_version")
+            ShopifyAPI::Clients::Graphql::Admin.new(session: @session)
+          else
+            ShopifyAPI::Clients::Graphql::Admin.new(session: @session, api_version: @api_version)
+          end
+        end
       end
     end
   end

test/clients/graphql/storefront_test.rb

@@ -13,12 +13,20 @@ def setup
           super
           @shop = "test-shop.myshopify.com"
           @storefront_access_token = SecureRandom.alphanumeric(10)
-          @client = ShopifyAPI::Clients::Graphql::Storefront.new(@shop, @storefront_access_token)
+          @client = build_client
           @path = "api"
           @expected_headers = TestHelpers::Constants::DEFAULT_CLIENT_HEADERS.merge({
             "X-Shopify-Storefront-Access-Token": @storefront_access_token,
           })
         end
+
+        def build_client
+          if !defined?("@api_version")
+            ShopifyAPI::Clients::Graphql::Storefront.new(@shop, @storefront_access_token)
+          else
+            ShopifyAPI::Clients::Graphql::Storefront.new(@shop, @storefront_access_token, api_version: @api_version)
+          end
+        end
       end
     end
   end

test/clients/rest/admin_test.rb

@@ -45,12 +45,21 @@ def test_path_starting_at_admin_overrides_default
     assert_equal(response_headers.to_h { |k, v| [k, [v]] }, response.headers)
   end
 
+  def test_api_version_can_be_overrriden
+    @api_version = "2022-07"
+    run_test(:post)
+  end
+
   private
 
   def run_test(http_method, path = "/some-path", expected_path = "some-path.json")
     session = ShopifyAPI::Auth::Session.new(shop: "test-shop.myshopify.com",
       access_token: SecureRandom.alphanumeric(10))
-    client = ShopifyAPI::Clients::Rest::Admin.new(session: session)
+    client = if defined?(@api_version)
+      ShopifyAPI::Clients::Rest::Admin.new(session: session,  api_version: @api_version)
+    else
+      ShopifyAPI::Clients::Rest::Admin.new(session: session)
+    end
 
     request = {
       path: path,
@@ -66,9 +75,11 @@ def run_test(http_method, path = "/some-path", expected_path = "some-path.json")
     success_body = { "success" => true }
     response_headers = { "content-type" => "application/json" }
 
+    api_version = defined?(@api_version) ? @api_version : ShopifyAPI::Context.api_version
+
     stub_request(
       http_method,
-      "https://#{session.shop}/admin/api/#{ShopifyAPI::Context.api_version}/#{expected_path}",
+      "https://#{session.shop}/admin/api/#{api_version}/#{expected_path}",
     )
       .with(body: request[:body].to_json, query: request[:query], headers: expected_headers)
       .to_return(body: success_body.to_json, headers: response_headers)

test/test_helpers/graphql_client.rb

@@ -55,6 +55,7 @@ def test_can_make_query_with_variables
     end
 
     def test_can_override_api_version
+      @api_version = "2022-01"
       query = <<~QUERY
         query myTestQuery($first: Int) {
           products (first: $first) {
@@ -72,16 +73,15 @@ def test_can_override_api_version
         first: 10,
       }
       setup
-      api_version = "2022-01"
       body = { query: query, variables: variables }
       success_body = { "success" => true }
       response_headers = { "content-type" => "application/json" }
 
-      stub_request(:post, "https://test-shop.myshopify.com/#{@path}/#{api_version}/graphql.json")
+      stub_request(:post, "https://test-shop.myshopify.com/#{@path}/#{@api_version}/graphql.json")
         .with(body: body, headers: @expected_headers)
         .to_return(body: success_body.to_json, headers: response_headers)
 
-      @client.query(query: query, variables: variables, api_version: api_version)
+      @client.query(query: query, variables: variables)
     end
   end
 end