shopify_api 6.0.0 → 7.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 7b0ab297c1e32ac84d673b04ddf366cc5f9d43f2eb6f060d70e5d1fcc7c8736f
-  data.tar.gz: 99a2583bf370e73c85f2b71c4b6e99f1ac2e37db2a628a30dcbed346c29bdf8a
+  metadata.gz: d45434390ab4152c9a33eafcd9757ef46c16372f3ad2dee6b918e0a6260ccc26
+  data.tar.gz: 552c1cb7a7d72c654e0f5c8fafa909a9a5cb9690e02ff689b1d4f29f9f31d530
 SHA512:
-  metadata.gz: 94e653b2a765e962ba1f4c360308bab8a66bb32b8fe487def7ef9880c4b972f934f280fce5805a7f5dcdea60b2a591c0ff4ea87dff04ce6334d490506155aa5a
-  data.tar.gz: 13701b452c87df0a9fb4054857f37d5821b63bb0ee8e467556bc8bb1d5beeae0712ec2457462567a45a715bc8b5a60d68aad8811385d9353e61779bec68bf060
+  metadata.gz: 59f9e5a631f1c9f13d6078636f11480ac711338fecab5caa1a47f5368f11a97514884eb9c42b007e13ad5f1ee8313e0f94c2a3eff7d17a5a3732cc9bea5edc54
+  data.tar.gz: e42b188914ca14ee80f0c3307ca1847ee2cfc0bac22c3cb7c6a4c8a1a0bfd3e41fc46d00deb21348ccef764cb3be97e656b8edc25734cd9a1bee28794842e371

data/.travis.yml

@@ -2,31 +2,22 @@ language: ruby
 sudo: false
 
 rvm:
-  - 2.3.1
-  - 2.4.0-preview1
+  - 2.4.6
+  - 2.5.5
+  - 2.6.2
 
 gemfile:
-  - Gemfile
-  - Gemfile_ar30
-  - Gemfile_ar31
-  - Gemfile_ar32
-  - Gemfile_ar40
+  - Gemfile_ar41
+  - Gemfile_ar50
+  - Gemfile_ar51
   - Gemfile_ar_master
 
 matrix:
   fast_finish: true
   allow_failures:
-    - rvm: 2.4.0-preview1
-      gemfile: Gemfile
-    - rvm: 2.4.0-preview1
-      gemfile: Gemfile_ar30
-    - rvm: 2.4.0-preview1
-      gemfile: Gemfile_ar31
-    - rvm: 2.4.0-preview1
-      gemfile: Gemfile_ar32
-    - rvm: 2.4.0-preview1
-      gemfile: Gemfile_ar40
-    - rvm: 2.4.0-preview1
+    - rvm: 2.4.6
       gemfile: Gemfile_ar_master
-    - rvm: 2.3.1
+    - rvm: 2.5.5
+      gemfile: Gemfile_ar_master
+    - rvm: 2.6.2
       gemfile: Gemfile_ar_master

data/CHANGELOG

@@ -1,3 +1,14 @@
+== Version 7.0.0
+
+* Removed support for `ActiveResouce` < `4.1`.
+* Removed `ShopifyAPI::Oauth`.
+* Added api version support, See [migration
+notes](README.md#-breaking-change-notice-for-version-700-)
+* Changed `ShopifyAPI::Session` method signatures from positional to keyword
+arguments, See [migration notes](README.md#-breaking-change-notice-for-version-700-)
+* Add support for newer call limit header `X-Shopify-Shop-Api-Call-Limit`.
+* Removed all Ping resources.
+
 == Version 6.0.0
 
 * Removed undocumented `protocol` and `port` options from `ShopifyAPI::Session`.

data/Gemfile

@@ -2,5 +2,4 @@ source "https://rubygems.org"
 
 gemspec
 
-gem "activeresource", "~> 4.1"
-gem "rack", "< 2" if RUBY_VERSION < "2.2"
+gem "activeresource", "~> 5.1"

data/Gemfile_ar41

@@ -0,0 +1,5 @@
+source "https://rubygems.org"
+
+gemspec
+
+gem "activeresource", "4.1.0"

data/Gemfile_ar50

@@ -0,0 +1,5 @@
+source "https://rubygems.org"
+
+gemspec
+
+gem "activeresource", "5.0.0"

data/Gemfile_ar51

@@ -0,0 +1,5 @@
+source "https://rubygems.org"
+
+gemspec
+
+gem "activeresource", "5.1.0"

data/Gemfile_ar_master

@@ -3,4 +3,3 @@ source "https://rubygems.org"
 gemspec
 
 gem 'activeresource', git: 'git://github.com/rails/activeresource'
-gem "rack", "< 2" if RUBY_VERSION < "2.2"

data/README.md

@@ -10,12 +10,87 @@ The Shopify API gem allows Ruby developers to programmatically access the admin
 
 The API is implemented as JSON over HTTP using all four verbs (GET/POST/PUT/DELETE). Each resource, like Order, Product, or Collection, has its own URL and is manipulated in isolation. In other words, we’ve tried to make the API follow the REST principles as much as possible.
 
-## ⚠️ Breaking change notice for version 5.0.0 ⚠️
-The [Abandoned Checkout API](https://help.shopify.com/en/api/reference/orders/abandoned_checkouts) is now accessed through the `ShopifyAPI::AbandonedCheckout` resource. If you were previously accessing the Abandoned Checkout API through the `ShopifyAPI::Checkout` resource, you will need to update your code after upgrading from version 4.x.x or earlier.
+## !! Breaking change notice for version 7.0.0 !!
 
-Going forward, the `ShopifyAPI::Checkout` resource is used to access the [Checkout API](https://help.shopify.com/en/api/reference/sales_channels/checkout), which can be used to create new checkouts.
+### Changes to ShopifyAPI::Session
+Session creation requires `api_version` to be set and now uses keyword arguments
 
-For more details, [please see this issue](https://github.com/Shopify/shopify_api/issues/471).
+To upgrade your use of ShopifyAPI you will need to make the following changes.
+
+```ruby
+ShopifyAPI::Session.new(domain, token, extras)
+```
+is now
+```ruby
+ShopifyAPI::Session.new(domain: domain, token: token, api_verison: api_verison, extras: extras)
+```
+Note `extras` is still optional the other arguments are required.
+
+```ruby
+ShopifyAPI::Session.temp(domain, token, extras) do
+  ...
+end
+```
+is now
+```ruby
+ShopifyAPI::Session.temp(domain: domain, token: token, api_verison: api_verison) do
+  ...
+end
+```
+
+The `api_version` attribute can take the string or symbol name of any known version and correctly coerce it to a `ShopifyAPI::ApiVersion`.  You can find the currently defined versions [here](https://github.com/Shopify/shopify_api/blob/master/lib/shopify_api/api_version.rb#L58), follow these [instructions](#adding-aditional-api-versions) to add additional version definitions if needed.
+
+For example if you want to use the `2019-04` version you would create a session like this:
+```ruby
+session = ShopifyAPI::Session.new(domain: domain, token: token, api_verison: '2019-04')
+```
+if you want to use the `unstable` version you would create a session like this:
+```ruby
+session = ShopifyAPI::Session.new(domain: domain, token: token, api_verison: :unstable)
+```
+
+### Changes to how to define resources
+
+If you have defined or customized Resources, classes that extend `ShopifyAPI::Base`:
+The use of `self.prefix =` has been deprecated you should now use `self.resource =` and not include `/admin`.
+For example if you specified a prefix like this before:
+```ruby
+class MyResource < ShopifyAPI::Base
+  self.prefix = '/admin/shop/'
+end
+```
+You will update this to:
+```ruby
+class MyResource < ShopifyAPI::Base
+  self.resource_prefix = 'shop/'
+end
+```
+
+### URL construction
+
+If you have specifed any full paths for API calls in find
+```ruby
+def self.current(options={})
+  find(:one, options.merge(from: "/admin/shop.#{format.extension}"))
+end
+```
+would be changed to
+
+```ruby
+def self.current(options = {})
+  find(:one, options.merge(
+    from: api_version.construct_api_path("shop.#{format.extension}")
+  ))
+end
+```
+
+### URLs that have not changed
+
+- OAuth URLs for `authorize`, getting the `access_token` from a code, `access_scopes`, and using a `refresh_token` have _not_ changed.
+  - get: `/admin/oauth/authorize.json`
+  - post: `/admin/oauth/access_token.json`
+  - get: `/admin/oauth/access_scopes.json`
+- URLs for the merchant’s web admin have _not_ changed. For example: to send the merchant to the product page the url is still `/admin/product/<id>`
 
 ## Usage
 
@@ -57,8 +132,9 @@ ShopifyAPI uses ActiveResource to communicate with the REST web service. ActiveR
 2. For a private App you just need to set the base site url as follows:
 
    ```ruby
-   shop_url = "https://#{API_KEY}:#{PASSWORD}@#{SHOP_NAME}.myshopify.com/admin"
+   shop_url = "https://#{API_KEY}:#{PASSWORD}@#{SHOP_NAME}.myshopify.com"
    ShopifyAPI::Base.site = shop_url
+   ShopifyAPI::Base.api_verison = '<version_name>' # find the latest stable api_version [here](https://help.shopify.com/api/versioning)
    ```
 
    That's it, you're done, skip to step 6 and start using the API!
@@ -88,7 +164,7 @@ ShopifyAPI uses ActiveResource to communicate with the REST web service. ActiveR
    We've added the create_permission_url method to make this easier, first instantiate your session object:
 
    ```ruby
-   shopify_session = ShopifyAPI::Session.new("SHOP_NAME.myshopify.com")
+   shopify_session = ShopifyAPI::Session.new(domain: "SHOP_NAME.myshopify.com", api_version: api_version, token: nil)
    ```
 
    Then call:
@@ -155,7 +231,7 @@ ShopifyAPI uses ActiveResource to communicate with the REST web service. ActiveR
    For future sessions simply pass in the `token` and `extra` hash (optional) when creating the session object:
 
    ```ruby
-   shopify_session = ShopifyAPI::Session.new("SHOP_NAME.myshopify.com", token, extra)
+   shopify_session = ShopifyAPI::Session.new(domain: "SHOP_NAME.myshopify.com", token: token, api_version: api_version, extra: extra)
    ```
 
 5. The session must be activated before use:
@@ -187,10 +263,26 @@ ShopifyAPI uses ActiveResource to communicate with the REST web service. ActiveR
    Alternatively, you can use #temp to initialize a Session and execute a command which also handles temporarily setting ActiveResource::Base.site:
 
    ```ruby
-   products = ShopifyAPI::Session.temp("SHOP_NAME.myshopify.com", token) { ShopifyAPI::Product.find(:all) }
+   products = ShopifyAPI::Session.temp(domain: "SHOP_NAME.myshopify.com", token: token, api_version: api_version) do
+     ShopifyAPI::Product.find(:all)
+   end
+   ```
+
+7. If you would like to run a small number of calls against a different API version you can use this block syntax:
+
+   ```ruby
+   ShopifyAPI::Session.temp(domain: "SHOP_NAME.myshopify.com", token: token, api_version: '2019-04') do
+     ShopifyAPI::Product.find(:all)  # find call against version `2019-04`
+
+     ShopifyAPI::Session.with_version(:unstable) do
+       ShopifyAPI::Product.find(:all)  # find call against version `unstable`
+     end
+
+     ShopifyAPI::Product.find(:all)  # find call against version `2019-04`
+   end
    ```
 
-7. If you want to work with another shop, you'll first need to clear the session:
+8. If you want to work with another shop, you'll first need to clear the session:
 
    ```ruby
    ShopifyAPI::Base.clear_session
@@ -252,6 +344,21 @@ result = client.query(SHOP_NAME_QUERY)
 result.data.shop.name
 ```
 
+## Adding aditional API versions
+We will release a gem update every time we release a new version of the API. Most of the time upgrading the gem will be all you need to do.
+
+If you want access to a newer version without upgrading you can define an api version.
+For example if you wanted to add an `ApiVersion` '2022-03', you would add the following to the initialization of your application:
+```ruby
+ShopifyAPI::ApiVersion.define_version(ShopifyAPI::ApiVersion::Release.new('2022-03')
+```
+Once you have done that you can now set this version in a Sesssion like this:
+
+```ruby
+ShopifyAPI::Session.new(domain: domain, token: token, api_version: '2022-03')
+```
+
+
 ## Threadsafety
 
 ActiveResource is threadsafe as of version 4.1 (which works with Rails 4.x and above).

data/RELEASING

@@ -2,7 +2,7 @@ Releasing ShopifyAPI
 
 1. Check the Semantic Versioning page for info on how to version the new release: http://semver.org
 2. Update the version of ShopifyAPI in lib/shopify_api/version.rb
-3. Add a CHANGELOG entry for the new release with the date
+3. Add a CHANGELOG entry for the new release
 4. Commit the changes with a commit message like "Packaging for release X.Y.Z"
 5. Tag the release with the version (Leave REV blank for HEAD or provide a SHA)
   $ git tag vX.Y.Z REV
@@ -10,7 +10,4 @@ Releasing ShopifyAPI
   $ git push
 7. Push out the tags
   $ git push --tags
-8. Build the new .gem from the updated .gemspec
-  $ gem build shopify_api.gemspec
-9. Publish the Gem to gemcutter
-  $ gem push shopify_api-X.Y.Z.gem
+8. Publish the gem using Shipit

data/lib/shopify_api.rb

@@ -6,11 +6,9 @@ require 'digest/md5'
 require 'base64'
 require 'active_resource/detailed_log_subscriber'
 require 'shopify_api/limits'
-require 'shopify_api/json_format'
+require 'shopify_api/api_version'
 require 'active_resource/json_errors'
-require 'active_resource/disable_prefix_check'
-require 'active_resource/base_ext'
-require 'active_resource/to_query'
+require 'shopify_api/disable_prefix_check'
 
 module ShopifyAPI
   include Limits
@@ -28,3 +26,5 @@ if ShopifyAPI::Base.respond_to?(:connection_class)
 else
   require 'active_resource/connection_ext'
 end
+
+ShopifyAPI::ApiVersion.define_known_versions

data/lib/shopify_api/api_version.rb

@@ -0,0 +1,116 @@
+# frozen_string_literal: true
+module ShopifyAPI
+  class ApiVersion
+    class UnknownVersion < StandardError; end
+    class InvalidVersion < StandardError; end
+
+    include Comparable
+
+    def self.coerce_to_version(version_or_name)
+      return version_or_name if version_or_name.is_a?(ApiVersion)
+
+      @versions ||= {}
+      @versions.fetch(version_or_name.to_s) do
+        raise UnknownVersion, "#{version_or_name} is not in the defined version set: #{@versions.keys.join(', ')}"
+      end
+    end
+
+    def self.define_version(version)
+      @versions ||= {}
+
+      @versions[version.name] = version
+    end
+
+    def self.clear_defined_versions
+      @versions = {}
+    end
+
+    def self.define_known_versions
+      define_version(Unstable.new)
+      define_version(Release.new('2019-04'))
+    end
+
+    def self.latest_stable_version
+      @versions.values.select(&:stable?).sort.last
+    end
+
+    def to_s
+      @version_name
+    end
+    alias_method :name, :to_s
+
+    def inspect
+      @version_name
+    end
+
+    def ==(other)
+      other.class == self.class && to_s == other.to_s
+    end
+
+    def hash
+      @version_name.hash
+    end
+
+    def <=>(other)
+      numeric_version <=> other.numeric_version
+    end
+
+    def stable?
+      false
+    end
+
+    def construct_api_path(_path)
+      raise NotImplementedError
+    end
+
+    def construct_graphql_path
+      raise NotImplementedError
+    end
+
+    protected
+
+    attr_reader :numeric_version
+
+    class Unstable < ApiVersion
+      API_PREFIX = '/admin/api/unstable/'
+
+      def initialize
+        @version_name = "unstable"
+        @url = API_PREFIX
+        @numeric_version = 9_000_00
+      end
+
+      def construct_api_path(path)
+        "#{@url}#{path}"
+      end
+
+      def construct_graphql_path
+        construct_api_path("graphql.json")
+      end
+    end
+
+    class Release < ApiVersion
+      FORMAT = /^\d{4}-\d{2}$/.freeze
+      API_PREFIX = '/admin/api/'
+
+      def initialize(version_number)
+        raise InvalidVersion, version_number unless version_number.match(FORMAT)
+        @version_name = version_number
+        @url = "#{API_PREFIX}#{version_number}/"
+        @numeric_version = version_number.tr('-', '').to_i
+      end
+
+      def stable?
+        true
+      end
+
+      def construct_api_path(path)
+        "#{@url}#{path}"
+      end
+
+      def construct_graphql_path
+        construct_api_path('graphql.json')
+      end
+    end
+  end
+end

data/lib/shopify_api/disable_prefix_check.rb

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+module ShopifyAPI
+  module DisablePrefixCheck
+    extend ActiveSupport::Concern
+
+    module ClassMethods
+      def check_prefix_options(options)
+      end
+
+      # `flexible = true` is hack to allow multiple things through the same AR class
+      def conditional_prefix(resource, flexible = false)
+        resource_id = "#{resource}_id".to_sym
+        resource_type = flexible ? ":#{resource}" : resource.to_s.pluralize
+
+        init_prefix_explicit(resource_type, resource_id)
+
+        define_singleton_method :resource_prefix do |options = {}|
+          resource_type = options[resource] if flexible
+
+          options[resource_id].nil? ? '' : "#{resource_type}/#{options[resource_id]}/"
+        end
+
+        define_singleton_method :instantiate_record do |record, prefix_options = {}|
+          new(record, true).tap do |resource_instance|
+            resource_instance.prefix_options = prefix_options unless prefix_options.blank?
+          end
+        end
+      end
+    end
+  end
+end