shopify_api 7.1.0 → 8.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: eabb483e194b801a4280e35ef231090afdb16c4e048b1d04750244981596294d
-  data.tar.gz: caa55aa7f65d51fbb1d7d8fccfcc4ba1ee72331d9709d03c06e1a9e58d27f668
+  metadata.gz: 971668a584dc96aa673c1648c5c8da796e64adfd63a30515da9376b460efbd2a
+  data.tar.gz: d161f78b00baaf4def4c4effc51a802143b483af08281afc043b93e0e8eba940
 SHA512:
-  metadata.gz: 34a727aa05565a3e2098be2d26b6f00472c7c1afb1a3b2cc6a93667309d55881b22aca4d48d7ac3e84a1d313ed614ca1d8303c0e4c5bb9d1cd932b3beba5444f
-  data.tar.gz: c92774a6599fdfb32b11489239519d28d6ab9ba53cb6e4eb41bafa39b9d8fec50e6e3c7254dd73b472ead02b6b6fc4c93ace53233550e2e66c4ead041a04aea5
+  metadata.gz: ca615cd5b6ea53fccc3cd75a0ff4f994ceb6c086034232f36c64a1e2d11abe948faa12cf4b63603e2d9d98f2714038199950b2baa0561dde343b042f551b49e0
+  data.tar.gz: 9043ff8baf6e9f22f536c0ca68d85ba96d542648aea47da73a35909c86949036be7b310de82fa266a689786af7b9ca15c975677f048b70e64fb1399197161b80

data/CHANGELOG.md

@@ -1,3 +1,13 @@
+== Version 8.0.0
+
+* Api Version changes [#600](https://github.com/Shopify/shopify_api/pull/600)
+  * Remove static Api Version definitions.
+  * Introduces Api Version lookup modes: `:define_on_unknown` and `:raise_on_unknown`
+  * See [migration notes](README.md#-breaking-change-notice-for-version-800-)
+* `Session.valid?` checks that api_version `is_a?(ApiVersion)` instead of `present?`
+* `ApiVersion::NullVersion` cannot be instantiated and now has a `match?` method [#615](https://github.com/Shopify/shopify_api/pull/615/files)
+* Introduces new Collection endpoint for looking up products without knowing collection type. Only available if ApiVersion is `:unstable` [#609](https://github.com/Shopify/shopify_api/pull/609)
+
 == Version 7.1.0
 
 * Add 2019-10 to known API versions

data/README.md

@@ -10,6 +10,33 @@ 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 8.0.0 !!
+
+ApiVersion was introduced in Version 7.0.0 and known versions were hard coded into the gem. Manually defining api versions is no longer required for versions not listed in the gem. Version 8.0.0 removes the following:
+* `ShopifyAPI::ApiVersion::Unstable`
+* `ShopifyAPI::ApiVersion::Release`
+* `ShopifyAPI::ApiVersion.define_version`
+
+The following methods on `ApiVersion` have been deprecated:
+- `.coerce_to_version` deprecated. use `.find_version`
+- `.define_known_versions` deprecated. Use `.fetch_known_versions`
+- `.clear_defined_versions` deprecated. Use. `.clear_known_versions`
+- `.latest_stable_version` deprecated. Use `ShopifyAPI::Meta.admin_versions.find(&:latest_supported)` (this fetches info from Shopify servers. No authentication required.)
+- `#name` deprecated. Use `#handle`
+- `#stable?` deprecated. Use `#supported?`
+
+Version 8.0.0 introduces a _version lookup mode_. By default, `ShopifyAPI::ApiVersion.version_lookup_mode` is `:define_on_unknown`. When setting the api_version on `Session` or `Base`, the `api_version` attribute takes a version handle (ie `'2019-07'` or `:unstable`) and sets an instance of `ShopifyAPI::ApiVersion` matching the handle. When the version_lookup_mode is set to `:define_on_unknown`, any handle will naïvely create a new `ApiVersion` if the version is not in the known versions returned by `ShopifyAPI::ApiVersion.versions`.
+
+To ensure only known and active versions can be set, call
+
+```ruby
+ShopifyAPI::ApiVersion.version_lookup_mode = :raise_on_unknown
+ShopifyAPI::ApiVersion.fetch_known_versions
+```
+
+Known and active versions are fetched from https://app.shopify.com/services/apis.json and cached. Trying to use a version outside this cached set will raise an error. To switch back to naïve lookup and create a version if its not found, call `ShopifyAPI::ApiVersion.version_lookup_mode = :define_on_unknown`.
+
+
 ## !! Breaking change notice for version 7.0.0 !!
 
 ### Changes to ShopifyAPI::Session
@@ -38,8 +65,6 @@ ShopifyAPI::Session.temp(domain: domain, token: token, api_version: api_version)
 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/defined_versions.rb), follow these [instructions](#adding-additional-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_version: '2019-04')
@@ -344,21 +369,6 @@ result = client.query(SHOP_NAME_QUERY)
 result.data.shop.name
 ```
 
-## Adding additional 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/lib/shopify_api.rb

@@ -5,8 +5,8 @@ require 'digest/md5'
 require 'base64'
 require 'active_resource/detailed_log_subscriber'
 require 'shopify_api/limits'
-require 'shopify_api/defined_versions'
 require 'shopify_api/api_version'
+require 'shopify_api/meta'
 require 'active_resource/json_errors'
 require 'shopify_api/paginated_collection'
 require 'shopify_api/disable_prefix_check'
@@ -28,5 +28,3 @@ 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

@@ -1,129 +1,204 @@
 # frozen_string_literal: true
 module ShopifyAPI
   class ApiVersion
-    class ApiVersionNotSetError < StandardError; end
     class UnknownVersion < StandardError; end
-    class InvalidVersion < StandardError; end
+    class ApiVersionNotSetError < StandardError; end
+    include Comparable
 
-    extend DefinedVersions
+    HANDLE_FORMAT = /^\d{4}-\d{2}$/.freeze
+    UNSTABLE_HANDLE = 'unstable'
+    UNSTABLE_AS_DATE = Time.utc(3000, 1, 1)
+    API_PREFIX = '/admin/api/'
+    LOOKUP_MODES = [:raise_on_unknown, :define_on_unknown].freeze
 
-    include Comparable
+    class << self
+      attr_reader :versions
 
-    def self.coerce_to_version(version_or_name)
-      return version_or_name if version_or_name.is_a?(ApiVersion)
+      def version_lookup_mode
+        @version_lookup_mode ||= :define_on_unknown
+      end
 
-      @versions ||= {}
-      @versions.fetch(version_or_name.to_s) do
-        raise UnknownVersion, "#{version_or_name} is not in the defined version set: #{@versions.keys.join(', ')}"
+      def version_lookup_mode=(mode)
+        raise ArgumentError, "Mode must be one of #{LOOKUP_MODES}" unless LOOKUP_MODES.include?(mode)
+        sanitize_known_versions if mode == :raise_on_unknown
+        @version_lookup_mode = mode
+      end
+
+      def find_version(version_or_handle)
+        raise ArgumentError, "NullVersion is not a valid version or version handle." if version_or_handle == NullVersion
+        return version_or_handle if version_or_handle.is_a?(ApiVersion)
+        handle = version_or_handle.to_s
+        @versions ||= {}
+        @versions.fetch(handle) do
+          if @version_lookup_mode == :raise_on_unknown
+            raise UnknownVersion, unknown_version_error_message(handle)
+          else
+            add_to_known_versions(ApiVersion.new(handle: handle))
+          end
+        end
       end
-    end
 
-    def self.define_version(version)
-      @versions ||= {}
+      def coerce_to_version(version_or_handle)
+        warn(
+          '[DEPRECATED] ShopifyAPI::ApiVersion.coerce_to_version be removed in a future version. ' \
+            'Use `find_version` instead.'
+        )
+        find_version(version_or_handle)
+      end
 
-      @versions[version.name] = version
-    end
+      def fetch_known_versions
+        @versions = Meta.admin_versions.map do |version|
+          [version.handle, ApiVersion.new(version.attributes.merge(verified: version.persisted?))]
+        end.to_h
+      end
+
+      def define_known_versions
+        warn(
+          '[DEPRECATED] ShopifyAPI::ApiVersion.define_known_versions is deprecated and will be removed in a future version. ' \
+            'Use `fetch_known_versions` instead.'
+        )
+        fetch_known_versions
+      end
 
-    def self.clear_defined_versions
-      @versions = {}
+      def add_to_known_versions(version)
+        @versions[version.handle] = version
+      end
+
+      def clear_known_versions
+        @versions = {}
+      end
+
+      def clear_defined_versions
+        warn(
+          '[DEPRECATED] ShopifyAPI::ApiVersion.clear_defined_versions is deprecated and will be removed in a future version. ' \
+            'Use `clear_known_versions` instead.'
+        )
+        clear_known_versions
+      end
+
+      def latest_stable_version
+        warn(
+          '[DEPRECATED] ShopifyAPI::ApiVersion.latest_stable_version is deprecated and will be removed in a future version.'
+        )
+        versions.values.find(&:latest_supported?)
+      end
+
+      private
+
+      def sanitize_known_versions
+        return if @versions.nil?
+        @versions = @versions.keys.map do |handle|
+          next unless @versions[handle].verified?
+          [handle, @versions[handle]]
+        end.compact.to_h
+      end
+
+      def unknown_version_error_message(handle)
+        msg = "ApiVersion.version_lookup_mode is set to `:raise_on_unknown`. \n"
+        return msg + "No versions defined. You must call `ApiVersion.fetch_known_versions` first." if @versions.empty?
+        msg + "`#{handle}` is not in the defined version set. Available versions: #{@versions.keys}"
+      end
     end
 
-    def self.latest_stable_version
-      @versions.values.select(&:stable?).sort.last
+    attr_reader :handle, :display_name, :supported, :latest_supported, :verified
+
+    def initialize(attributes)
+      attributes = ActiveSupport::HashWithIndifferentAccess.new(attributes)
+      @handle = attributes[:handle].to_s
+      @display_name = attributes.fetch(:display_name, attributes[:handle].to_s)
+      @supported = attributes.fetch(:supported, false)
+      @latest_supported = attributes.fetch(:latest_supported, false)
+      @verified = attributes.fetch(:verified, false)
     end
 
     def to_s
-      @version_name
+      handle
     end
-    alias_method :name, :to_s
 
-    def inspect
-      @version_name
+    def latest_supported?
+      latest_supported
     end
 
-    def ==(other)
-      other.class == self.class && to_s == other.to_s
+    def supported?
+      supported
     end
 
-    def hash
-      @version_name.hash
+    def verified?
+      verified
     end
 
     def <=>(other)
-      numeric_version <=> other.numeric_version
+      handle_as_date <=> other.handle_as_date
     end
 
-    def stable?
-      false
+    def ==(other)
+      other.class == self.class && handle == other.handle
     end
 
-    def construct_api_path(_path)
-      raise NotImplementedError
+    def hash
+      handle.hash
     end
 
-    def construct_graphql_path
-      raise NotImplementedError
+    def construct_api_path(path)
+      "#{API_PREFIX}#{handle}/#{path}"
     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
+    def construct_graphql_path
+      construct_api_path('graphql.json')
     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 name
+      warn(
+        '[DEPRECATED] ShopifyAPI::ApiVersion#name is deprecated and will be removed in a future version. ' \
+          'Use `handle` instead.'
+      )
+      handle
+    end
 
-      def stable?
-        true
-      end
+    def stable?
+      warn(
+        '[DEPRECATED] ShopifyAPI::ApiVersion#stable? is deprecated and will be removed in a future version. ' \
+          'Use `supported?` instead.'
+      )
+      supported?
+    end
 
-      def construct_api_path(path)
-        "#{@url}#{path}"
-      end
+    def unstable?
+      handle == UNSTABLE_HANDLE
+    end
 
-      def construct_graphql_path
-        construct_api_path('graphql.json')
-      end
+    def handle_as_date
+      return UNSTABLE_AS_DATE if unstable?
+      year, month, day = handle.split('-')
+      Time.utc(year, month, day)
     end
 
     class NullVersion
       class << self
-        def stable?
-          raise ApiVersionNotSetError, "You must set ShopifyAPI::Base.api_version before making a request."
+        def new(*_args)
+          raise NoMethodError, "NullVersion is an abstract class and cannot be instantiated."
         end
 
-        def construct_api_path(*_path)
-          raise ApiVersionNotSetError, "You must set ShopifyAPI::Base.api_version before making a request."
+        def matches?(version)
+          version.nil? || version == self
         end
 
-        def construct_graphql_path
+        def raise_not_set_error(*_args)
           raise ApiVersionNotSetError, "You must set ShopifyAPI::Base.api_version before making a request."
         end
+        alias_method :stable?, :raise_not_set_error
+        alias_method :construct_api_path, :raise_not_set_error
+        alias_method :construct_graphql_path, :raise_not_set_error
+        alias_method :latest_supported?, :raise_not_set_error
+        alias_method :supported?, :raise_not_set_error
+        alias_method :verified?, :raise_not_set_error
+        alias_method :unstable?, :raise_not_set_error
+        alias_method :handle, :raise_not_set_error
+        alias_method :display_name, :raise_not_set_error
+        alias_method :supported, :raise_not_set_error
+        alias_method :verified, :raise_not_set_error
+        alias_method :latest_supported, :raise_not_set_error
+        alias_method :name, :raise_not_set_error
       end
     end
   end

data/lib/shopify_api/meta.rb

@@ -0,0 +1,15 @@
+
+# frozen_string_literal: true
+module ShopifyAPI
+  class Meta < ActiveResource::Base
+    self.site = "https://app.shopify.com/services/"
+    self.element_name = 'api'
+    self.primary_key = :handle
+    self.timeout = 5
+
+    def self.admin_versions
+      all.find { |api| api.handle = :admin }.versions
+    end
+  end
+end
+

data/lib/shopify_api/paginated_collection.rb

@@ -29,8 +29,8 @@ module ShopifyAPI
 
       private
 
-      AVAILABLE_IN_VERSION = ShopifyAPI::ApiVersion::Release.new('2019-10')
-      AVAILABLE_IN_VERSION_EARLY = ShopifyAPI::ApiVersion::Release.new('2019-07')
+      AVAILABLE_IN_VERSION = ShopifyAPI::ApiVersion.find_version('2019-10')
+      AVAILABLE_IN_VERSION_EARLY = ShopifyAPI::ApiVersion.find_version('2019-07')
 
       def fetch_page(url)
         ensure_available

data/lib/shopify_api/resources/base.rb

@@ -68,7 +68,7 @@ module ShopifyAPI
       end
 
       def api_version=(version)
-        self._api_version = version.nil? ? ApiVersion::NullVersion : ApiVersion.coerce_to_version(version)
+        self._api_version = ApiVersion::NullVersion.matches?(version) ? ApiVersion::NullVersion : ApiVersion.find_version(version)
       end
 
       def prefix(options = {})

data/lib/shopify_api/resources/collection.rb

@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+
+module ShopifyAPI
+  class Collection < Base
+    include Events
+    include Metafields
+
+    def products(options = {})
+      available_in_version = ShopifyAPI::ApiVersion.find_version(:unstable)
+      raise NotImplementedError unless ShopifyAPI::Base.api_version >= available_in_version
+      Product.find(:all, from: "#{self.class.prefix}collections/#{id}/products.json", params: options)
+    end
+  end
+end

data/lib/shopify_api/session.rb

@@ -127,11 +127,11 @@ module ShopifyAPI
     end
 
     def api_version=(version)
-      @api_version = version.nil? ? nil : ApiVersion.coerce_to_version(version)
+      @api_version = ApiVersion::NullVersion.matches?(version) ? ApiVersion::NullVersion : ApiVersion.find_version(version)
     end
 
     def valid?
-      domain.present? && token.present? && api_version.present?
+      domain.present? && token.present? && api_version.is_a?(ApiVersion)
     end
 
     def expires_in

data/lib/shopify_api/version.rb

@@ -1,3 +1,3 @@
 module ShopifyAPI
-  VERSION = "7.1.0"
+  VERSION = "8.0.0"
 end

data/test/api_version_test.rb

@@ -2,110 +2,83 @@
 require 'test_helper'
 
 class ApiVersionTest < Test::Unit::TestCase
-  def teardown
-    super
-    ShopifyAPI::ApiVersion.clear_defined_versions
-    ShopifyAPI::ApiVersion.define_known_versions
+  test "find_version returns any version object given" do
+    version = ShopifyAPI::ApiVersion.new(handle: :unstable)
+    assert_same(version, ShopifyAPI::ApiVersion.find_version(version))
   end
 
-  test "unstable version creates url that start with /admin/api/unstable/" do
-    assert_equal(
-      "/admin/api/unstable/resource_path/id.json",
-      ShopifyAPI::ApiVersion::Unstable.new.construct_api_path("resource_path/id.json")
-    )
-  end
-
-  test "unstable version creates graphql url that start with /admin/api/unstable/" do
-    assert_equal(
-      "/admin/api/unstable/graphql.json",
-      ShopifyAPI::ApiVersion::Unstable.new.construct_graphql_path
-    )
-  end
-
-  test "coerce_to_version returns any version object given" do
-    version = ShopifyAPI::ApiVersion::Unstable.new
-    assert_same(version, ShopifyAPI::ApiVersion.coerce_to_version(version))
-  end
-
-  test "coerce_to_version converts a known version into a version object" do
+  test "find_version converts a known version into a version object" do
     versions = [
-      ShopifyAPI::ApiVersion::Unstable.new,
-      ShopifyAPI::ApiVersion::Release.new('2019-01'),
+      ShopifyAPI::ApiVersion.new(handle: :unstable),
+      ShopifyAPI::ApiVersion.new(handle: '2019-01'),
     ]
 
     assert_equal(versions, [
-      ShopifyAPI::ApiVersion.coerce_to_version('unstable'),
-      ShopifyAPI::ApiVersion.coerce_to_version('2019-01'),
+      ShopifyAPI::ApiVersion.find_version('unstable'),
+      ShopifyAPI::ApiVersion.find_version('2019-01'),
     ])
   end
 
-  test "coerce_to_version raises when coercing a string that doesn't match a known version" do
-    assert_raises ShopifyAPI::ApiVersion::UnknownVersion do
-      ShopifyAPI::ApiVersion.coerce_to_version('made up version')
-    end
-  end
+  test "find_version removes unverified versions from version set if mode is set to :raise_on_unknown" do
+    ShopifyAPI::ApiVersion.version_lookup_mode = :define_on_unknown
+    assert ShopifyAPI::ApiVersion.versions.values.all?(&:verified?)
+    assert_equal 5, ShopifyAPI::ApiVersion.versions.size
 
-  test "additional defined versions will also be coerced" do
-    versions = [
-      TestApiVersion.new('my_name'),
-      TestApiVersion.new('other_name'),
-    ]
+    ShopifyAPI::ApiVersion.find_version('2019-30')
+    refute ShopifyAPI::ApiVersion.versions.values.all?(&:verified?)
+    assert_equal 6, ShopifyAPI::ApiVersion.versions.size
+    ShopifyAPI::ApiVersion.version_lookup_mode = :raise_on_unknown
 
-    versions.each do |version|
-      ShopifyAPI::ApiVersion.define_version(version)
-    end
-
-    assert_equal(versions, [
-      ShopifyAPI::ApiVersion.coerce_to_version('my_name'),
-      ShopifyAPI::ApiVersion.coerce_to_version('other_name'),
-    ])
+    assert ShopifyAPI::ApiVersion.versions.values.all?(&:verified?)
+    assert_equal 5, ShopifyAPI::ApiVersion.versions.size
   end
 
-  test 'allows a release version with the correct format format to be created' do
-    assert ShopifyAPI::ApiVersion::Release.new('2019-03')
+  test "find_version does not raise when coercing a string if no versions are defined when version_lookup_mode is :define_on_unknown" do
+    ShopifyAPI::ApiVersion.clear_known_versions
+    ShopifyAPI::ApiVersion.version_lookup_mode = :define_on_unknown
+    assert_equal :define_on_unknown, ShopifyAPI::ApiVersion.version_lookup_mode
+    assert_nothing_raised do
+      ShopifyAPI::ApiVersion.find_version('made up version')
+    end
   end
 
-  test 'release versions must follow the format' do
-    assert_raises ShopifyAPI::ApiVersion::InvalidVersion do
-      assert ShopifyAPI::ApiVersion::Release.new('crazy-name')
+  test "find_version does raise when coercing a string if no versions are defined when version_lookup_mode is :raise_on_unknown" do
+    refute ShopifyAPI::ApiVersion.versions['made up version']
+    ShopifyAPI::ApiVersion.version_lookup_mode = :raise_on_unknown
+    assert_raises ShopifyAPI::ApiVersion::UnknownVersion do
+      ShopifyAPI::ApiVersion.find_version('made up version')
     end
   end
 
-  test 'release versions create a url that is /admin/api/<version_name>/' do
-    assert_equal(
-      '/admin/api/2022-03/shop.json',
-      ShopifyAPI::ApiVersion::Release.new('2022-03').construct_api_path('shop.json')
-    )
+  test "find_version raises ArgumentError when given an ShopifyAPI::ApiVersion::NullVersion object" do
+    ShopifyAPI::ApiVersion.clear_known_versions
+    ShopifyAPI::ApiVersion.version_lookup_mode = :define_on_unknown
+    assert_equal :define_on_unknown, ShopifyAPI::ApiVersion.version_lookup_mode
+    assert_raises ArgumentError do
+      ShopifyAPI::ApiVersion.find_version(ShopifyAPI::ApiVersion::NullVersion)
+    end
   end
 
   test 'two versions with the same version number are equal' do
-    version_1 = ShopifyAPI::ApiVersion::Release.new('2018-09')
-    version_2 = ShopifyAPI::ApiVersion::Release.new('2018-09')
+    version_1 = ShopifyAPI::ApiVersion.new(handle: '2018-09')
+    version_2 = ShopifyAPI::ApiVersion.new(handle: '2018-09')
 
     assert_equal version_2, version_1
   end
 
   test 'two versions with the different version numbers are not equal' do
-    version_1 = ShopifyAPI::ApiVersion::Release.new('2019-07')
-    version_2 = ShopifyAPI::ApiVersion::Release.new('2019-11')
+    version_1 = ShopifyAPI::ApiVersion.new(handle: '2019-07')
+    version_2 = ShopifyAPI::ApiVersion.new(handle: '2019-11')
 
     refute_equal version_2, version_1
   end
 
-  test 'release verions are stable' do
-    assert_predicate ShopifyAPI::ApiVersion::Release.new('2019-11'), :stable?
-  end
-
-  test 'no release version are not stable' do
-    refute_predicate ShopifyAPI::ApiVersion::Unstable.new, :stable?
-  end
-
-  test 'release versions are ordered by version number with unstable always being the newest' do
-    version_1 = ShopifyAPI::ApiVersion::Release.new('2017-11')
-    version_2 = ShopifyAPI::ApiVersion::Release.new('2019-11')
-    version_3 = ShopifyAPI::ApiVersion::Release.new('2039-01')
-    version_4 = ShopifyAPI::ApiVersion::Release.new('2039-02')
-    unstable = ShopifyAPI::ApiVersion::Unstable.new
+  test 'versions are ordered by version number with unstable always being the newest' do
+    version_1 = ShopifyAPI::ApiVersion.new(handle: '2017-11')
+    version_2 = ShopifyAPI::ApiVersion.new(handle: '2019-11')
+    version_3 = ShopifyAPI::ApiVersion.new(handle: '2039-01')
+    version_4 = ShopifyAPI::ApiVersion.new(handle: '2039-02')
+    unstable = ShopifyAPI::ApiVersion.new(handle: :unstable)
 
     assert_equal([
       version_1,
@@ -123,17 +96,28 @@ class ApiVersionTest < Test::Unit::TestCase
   end
 
   test 'latest_stable_version will return the version that is newest and stable' do
-    ShopifyAPI::ApiVersion.clear_defined_versions
-    ShopifyAPI::ApiVersion.define_version(ShopifyAPI::ApiVersion::Release.new('2017-11'))
-    ShopifyAPI::ApiVersion.define_version(ShopifyAPI::ApiVersion::Release.new('2019-11'))
-    ShopifyAPI::ApiVersion.define_version(ShopifyAPI::ApiVersion::Release.new('2039-01'))
-    ShopifyAPI::ApiVersion.define_version(ShopifyAPI::ApiVersion::Release.new('2039-02'))
-    ShopifyAPI::ApiVersion.define_version(ShopifyAPI::ApiVersion::Unstable.new)
-
     assert_equal(
-      ShopifyAPI::ApiVersion::Release.new('2039-02'),
-      ShopifyAPI::ApiVersion.latest_stable_version
+      ShopifyAPI::ApiVersion.versions,
+      {
+        "2019-01" => ShopifyAPI::ApiVersion.new(handle: '2019-01', supported: true, latest_supported: false),
+        "2019-04" => ShopifyAPI::ApiVersion.new(handle: '2019-04', supported: true, latest_supported: false),
+        "2019-07" => ShopifyAPI::ApiVersion.new(handle: '2019-07', supported: true, latest_supported: true),
+        "2019-10" => ShopifyAPI::ApiVersion.new(handle: '2019-10', supported: false, latest_supported: false),
+        "unstable" => ShopifyAPI::ApiVersion.new(handle: 'unstable', supported: false, latest_supported: false),
+      }
     )
+    silence_warnings do
+
+      refute_equal(
+        ShopifyAPI::ApiVersion.new(handle: '2019-01'),
+        ShopifyAPI::ApiVersion.latest_stable_version
+      )
+
+      assert_equal(
+        ShopifyAPI::ApiVersion.new(handle: '2019-07'),
+        ShopifyAPI::ApiVersion.latest_stable_version
+      )
+    end
   end
 
   test "NullVersion raises ApiVersionNotSetError" do
@@ -150,6 +134,20 @@ class ApiVersionTest < Test::Unit::TestCase
     end
   end
 
+  test "NullVersion cannot be instantiated and raises NoMethodError if attempted" do
+    assert_raises(NoMethodError) do
+      ShopifyAPI::ApiVersion::NullVersion.new
+    end
+  end
+
+  test "handle_to_date converts a version handle to a date" do
+    version_1 = ShopifyAPI::ApiVersion.new(handle: '2019-01')
+    version_2 = ShopifyAPI::ApiVersion.new(handle: 'unstable')
+
+    assert_equal(version_1.handle_as_date, Time.utc(2019, 01, 01))
+    assert_equal(version_2.handle_as_date, ShopifyAPI::ApiVersion::UNSTABLE_AS_DATE)
+  end
+
   class TestApiVersion < ShopifyAPI::ApiVersion
     def initialize(name)
       @version_name = name

data/test/base_test.rb

@@ -168,6 +168,11 @@ class BaseTest < Test::Unit::TestCase
     assert_equal ShopifyAPI::ApiVersion::NullVersion, ShopifyAPI::Base.api_version
   end
 
+  test "#api_version= ShopifyAPI::ApiVersion::NullVersion should set ApiVersion to ShopifyAPI::ApiVersion::NullVersion" do
+    ShopifyAPI::Base.api_version = ShopifyAPI::ApiVersion::NullVersion
+    assert_equal ShopifyAPI::ApiVersion::NullVersion, ShopifyAPI::Base.api_version
+  end
+
   def clear_header(header)
     [ActiveResource::Base, ShopifyAPI::Base, ShopifyAPI::Product].each do |klass|
       klass.headers.delete(header)

data/test/collection_listing_test.rb

@@ -40,7 +40,7 @@ class CollectionListingTest < Test::Unit::TestCase
   end
 
   def test_get_collection_listing_product_ids_multi_page_with_cursor
-    version = ShopifyAPI::ApiVersion::Release.new('2019-07')
+    version = ShopifyAPI::ApiVersion.find_version('2019-07')
     ShopifyAPI::Base.api_version = version.to_s
 
     collection_listing = ShopifyAPI::CollectionListing.new(collection_id: 1)

data/test/collection_test.rb

@@ -0,0 +1,49 @@
+require 'test_helper'
+
+class CollectionTest < Test::Unit::TestCase
+  test "Collection get products gets all products in a collection on unstable version" do
+    unstable_version = ShopifyAPI::Session.new(domain: 'shop2.myshopify.com', token: 'token2', api_version: :unstable)
+    ShopifyAPI::Base.activate_session(unstable_version)
+
+    fake(
+        'collections',
+        url: 'https://shop2.myshopify.com/admin/api/unstable/collections/1.json',
+        method: :get,
+        status: 200,
+        body: load_fixture('collection'),
+        extension: false
+    )
+
+    collection = ShopifyAPI::Collection.find(1)
+
+    fake(
+        'products',
+        url: 'https://shop2.myshopify.com/admin/api/unstable/collections/1/products.json',
+        method: :get,
+        status: 200,
+        body: load_fixture('collection_products'),
+        extension: false
+    )
+    assert_equal [632910392, 921728736], collection.products.map(&:id)
+  end
+
+  test "Collection get products fails on older api version" do
+    unstable_version = ShopifyAPI::Session.new(domain: 'shop2.myshopify.com', token: 'token2', api_version: '2019-07')
+    ShopifyAPI::Base.activate_session(unstable_version)
+
+    fake(
+        'collections',
+        url: 'https://shop2.myshopify.com/admin/api/2019-07/collections/1.json',
+        method: :get,
+        status: 200,
+        body: load_fixture('collection'),
+        extension: false
+    )
+
+    collection = ShopifyAPI::Collection.find(1)
+
+    assert_raises NotImplementedError do
+      collection.products
+    end
+  end
+end

data/test/detailed_log_subscriber_test.rb

@@ -14,9 +14,14 @@ class LogSubscriberTest < Test::Unit::TestCase
     @request_headers = "Headers: {\"Accept\"=>\"application/json\", " \
       "#{@ua_header}, \"X-Shopify-Access-Token\"=>\"access_token\"}"
 
-    ShopifyAPI::ApiVersion.define_version(ShopifyAPI::ApiVersion::Release.new('2019-01'))
-
     ShopifyAPI::Base.clear_session
+    fake("apis",
+      url: "https://app.shopify.com/services/apis.json",
+      method: :get,
+      status: 200,
+      api_version: :stub,
+      body: load_fixture('apis'))
+    ShopifyAPI::ApiVersion.fetch_known_versions
     session = ShopifyAPI::Session.new(
       domain: "https://this-is-my-test-shop.myshopify.com",
       token: "access_token",
@@ -29,6 +34,12 @@ class LogSubscriberTest < Test::Unit::TestCase
     ActiveResource::DetailedLogSubscriber.attach_to :active_resource_detailed
   end
 
+  def teardown
+    super
+    ShopifyAPI::ApiVersion.clear_known_versions
+    ShopifyAPI::ApiVersion.version_lookup_mode = :raise_on_unknown
+  end
+
   def set_logger(logger)
     ActiveResource::Base.logger = logger
   end

data/test/fixtures/api_versions.json

@@ -0,0 +1,32 @@
+[
+  {
+    "handle": "2019-01",
+    "display_name": "2019-01",
+    "supported": true,
+    "latest_supported": false
+  },
+  {
+    "handle": "2019-04",
+    "display_name": "2019-04",
+    "supported": true,
+    "latest_supported": false
+  },
+  {
+    "handle": "2019-07",
+    "display_name": "2019-07 (Latest)",
+    "supported": true,
+    "latest_supported": true
+  },
+  {
+    "handle": "2019-10",
+    "display_name": "2019-10 (Release candidate)",
+    "supported": false,
+    "latest_supported": false
+  },
+  {
+    "handle": "unstable",
+    "display_name": "unstable",
+    "supported": false,
+    "latest_supported": false
+  }
+]

data/test/fixtures/apis.json

@@ -0,0 +1,36 @@
+{
+  "apis": [{
+      "handle": "admin",
+      "versions": [{
+        "handle": "2019-01",
+        "display_name": "2019-01",
+        "supported": true,
+        "latest_supported": false
+      },{
+          "handle": "2019-04",
+          "latest_supported": false,
+          "display_name": "2019-04",
+          "supported": true
+        },
+        {
+          "handle": "2019-07",
+          "latest_supported": true,
+          "display_name": "2019-07 (Latest)",
+          "supported": true
+        },
+        {
+          "handle": "2019-10",
+          "latest_supported": false,
+          "display_name": "2019-10 (Release candidate)",
+          "supported": false
+        },
+        {
+          "handle": "unstable",
+          "latest_supported": false,
+          "display_name": "unstable",
+          "supported": false
+        }
+      ]
+    }
+  ]
+}

data/test/fixtures/collection.json

@@ -0,0 +1,17 @@
+{
+  "collection": {
+    "id": 1,
+    "handle": "test-collection",
+    "title": "test-collection",
+    "updated_at": "2016-03-17T16:58:37-04:00",
+    "body_html": null,
+    "published_at": "2016-03-17T16:58:37-04:00",
+    "sort_order": "alpha-asc",
+    "template_suffix": null,
+    "published_scope": "global",
+    "image": {
+      "created_at": "2016-03-17T16:58:37-04:00",
+      "src": "https:\/\/cdn.shopify.com\/s\/files\/1\/0006\/9093\/3842\/collections\/fd43f2c8883f6e9b680e3295fd990d2c.gif?v=1458248317"
+    }
+  }
+}

data/test/fixtures/collection_products.json

@@ -0,0 +1,47 @@
+{
+  "products": [
+    {
+      "product_type": "Cult Products",
+      "handle": "ipod-nano",
+      "created_at": "2011-10-20T14:05:13-04:00",
+      "body_html": "<p>It's the small iPod with one very big idea: Video. Now the world's most popular music player, available in 4GB and 8GB models, lets you enjoy TV shows, movies, video podcasts, and more. The larger, brighter display means amazing picture quality. In six eye-catching colors, iPod nano is stunning all around. And with models starting at just $149, little speaks volumes.</p>",
+      "title": "IPod Nano - 8GB",
+      "template_suffix": null,
+      "updated_at": "2011-10-20T14:05:13-04:00",
+      "id": 632910392,
+      "tags": "Emotive, Flash Memory, MP3, Music",
+      "images": [
+        {
+          "position": 1,
+          "created_at": "2011-10-20T14:05:13-04:00",
+          "product_id": 632910392,
+          "updated_at": "2011-10-20T14:05:13-04:00",
+          "src": "http://static.shopify.com/s/files/1/6909/3384/products/ipod-nano.png?0",
+          "id": 850703190
+        }
+      ],
+      "vendor": "Apple",
+      "published_at": "2007-12-31T19:00:00-05:00",
+      "manually_sorted": true,
+      "options": [
+        {
+          "name": "Title"
+        }
+      ]
+    },
+    {
+      "product_type": "Cult Products",
+      "handle": "ipod-touch",
+      "created_at": "2018-09-26T14:05:13-04:00",
+      "body_html": "<p>The iPod Touch has the iPhone's multi-touch interface, with a physical home button off the touch screen. The home screen has a list of buttons for the available applications.</p>",
+      "title": "IPod Touch 8GB",
+      "template_suffix": null,
+      "updated_at": "2018-09-26T14:05:13-04:00",
+      "id": 921728736,
+      "tags": null,
+      "vendor": "Apple",
+      "published_at": "2018-09-26T14:05:13-04:00",
+      "manually_sorted": true
+    }
+  ]
+}

data/test/meta_test.rb

@@ -0,0 +1,43 @@
+# frozen_string_literal: true
+require 'test_helper'
+
+class ApiVersionTest < Test::Unit::TestCase
+  test ".admin_versions returns array of api versions for admin" do
+    versions = [
+      {
+        "handle": "2019-01",
+        "display_name": "2019-01",
+        "supported": true,
+        "latest_supported": false,
+      },
+      {
+        "handle": "2019-04",
+        "latest_supported": false,
+        "display_name": "2019-04",
+        "supported": true,
+      },
+      {
+        "handle": "2019-07",
+        "latest_supported": true,
+        "display_name": "2019-07 (Latest)",
+        "supported": true,
+      },
+      {
+        "handle": "2019-10",
+        "latest_supported": false,
+        "display_name": "2019-10 (Release candidate)",
+        "supported": false,
+      },
+      {
+        "handle": "unstable",
+        "latest_supported": false,
+        "display_name": "unstable",
+        "supported": false,
+      },
+    ].to_json
+
+
+    assert_equal versions, ShopifyAPI::Meta.admin_versions.to_json
+
+  end
+end

data/test/pagination_test.rb

@@ -4,7 +4,7 @@ class PaginationTest < Test::Unit::TestCase
   def setup
     super
 
-    @version = ShopifyAPI::ApiVersion::Release.new('2019-10')
+    @version = ShopifyAPI::ApiVersion.find_version('2019-10')
     ShopifyAPI::Base.api_version = @version.to_s
     @next_page_info = "eyJkaXJlY3Rpb24iOiJuZXh0IiwibGFzdF9pZCI6NDQwMDg5NDIzLCJsYXN0X3ZhbHVlIjoiNDQwMDg5NDIzIn0%3D"
     @previous_page_info = "eyJsYXN0X2lkIjoxMDg4MjgzMDksImxhc3RfdmFsdWUiOiIxMDg4MjgzMDkiLCJkaXJlY3Rpb24iOiJuZXh0In0%3D"
@@ -131,7 +131,7 @@ class PaginationTest < Test::Unit::TestCase
   end
 
   test "raises on an older API version" do
-    version = ShopifyAPI::ApiVersion::Release.new('2019-04')
+    version = ShopifyAPI::ApiVersion.find_version('2019-04')
     ShopifyAPI::Base.api_version = version.to_s
 
     fake 'orders', :method => :get, :status => 200, api_version: version, :body => load_fixture('orders')
@@ -143,7 +143,7 @@ class PaginationTest < Test::Unit::TestCase
   end
 
   test "raises on 2019-07 API version for models that don't support new pagination yet" do
-    version = ShopifyAPI::ApiVersion::Release.new('2019-07')
+    version = ShopifyAPI::ApiVersion.find_version('2019-07')
     ShopifyAPI::Base.api_version = version.to_s
 
     fake 'orders', :method => :get, :status => 200, api_version: version, :body => load_fixture('orders')
@@ -155,7 +155,7 @@ class PaginationTest < Test::Unit::TestCase
   end
 
   test "new pagination works on 2019-07 API version for select models" do
-    version = ShopifyAPI::ApiVersion::Release.new('2019-07')
+    version = ShopifyAPI::ApiVersion.find_version('2019-07')
     ShopifyAPI::Base.api_version = version.to_s
 
     fake 'events', :method => :get, :status => 200, api_version: version, :body => load_fixture('events')
@@ -166,7 +166,7 @@ class PaginationTest < Test::Unit::TestCase
   end
 
   test "does not raise on the unstable version" do
-    version = ShopifyAPI::ApiVersion::Unstable.new
+    version = ShopifyAPI::ApiVersion.find_version('unstable')
     ShopifyAPI::Base.api_version = version.to_s
     @next_link_header = "<https://this-is-my-test-shop.myshopify.com/admin/api/unstable/orders.json?page_info=#{@next_page_info}>; rel=\"next\""
 

data/test/product_listing_test.rb

@@ -39,7 +39,7 @@ class ProductListingTest < Test::Unit::TestCase
   end
 
   def test_get_product_listing_product_ids_multi_page_with_cursor
-    version = ShopifyAPI::ApiVersion::Release.new('2019-10')
+    version = ShopifyAPI::ApiVersion.find_version('2019-10')
     ShopifyAPI::Base.api_version = version.to_s
 
     url = "https://this-is-my-test-shop.myshopify.com/admin/api/2019-10/product_listings/product_ids.json"
@@ -75,7 +75,7 @@ class ProductListingTest < Test::Unit::TestCase
   end
 
   def test_get_product_listing_product_ids_multi_page_with_cursor_fails_on_older_api_version
-    version = ShopifyAPI::ApiVersion::Release.new('2019-07')
+    version = ShopifyAPI::ApiVersion.find_version('2019-07')
     ShopifyAPI::Base.api_version = version.to_s
 
     url = "https://this-is-my-test-shop.myshopify.com/admin/api/2019-07/product_listings/product_ids.json"

data/test/session_test.rb

@@ -21,6 +21,9 @@ class SessionTest < Test::Unit::TestCase
   test "not be valid without an api version" do
     session = ShopifyAPI::Session.new(domain: "testshop.myshopify.com", token: "any-token", api_version: nil)
     assert_not session.valid?
+
+    session = ShopifyAPI::Session.new(domain: "testshop.myshopify.com", token: "any-token", api_version: ShopifyAPI::ApiVersion::NullVersion)
+    assert_not session.valid?
   end
 
   test "be valid with any token, any url and version" do
@@ -87,8 +90,8 @@ class SessionTest < Test::Unit::TestCase
     assert_equal('https://testshop.myshopify.com', @assigned_site.to_s)
     assert_equal('https://fakeshop.myshopify.com', ShopifyAPI::Base.site.to_s)
 
-    assert_equal(ShopifyAPI::ApiVersion::Unstable.new, @assigned_version)
-    assert_equal(ShopifyAPI::ApiVersion::Release.new('2019-01'), ShopifyAPI::Base.api_version)
+    assert_equal(ShopifyAPI::ApiVersion.new(handle: :unstable), @assigned_version)
+    assert_equal(ShopifyAPI::ApiVersion.new(handle: '2019-01'), ShopifyAPI::Base.api_version)
   end
 
   test "#with_session activates the session for the duration of the block" do
@@ -109,8 +112,8 @@ class SessionTest < Test::Unit::TestCase
     assert_equal('https://testshop.myshopify.com', @assigned_site.to_s)
     assert_equal('https://fakeshop.myshopify.com', ShopifyAPI::Base.site.to_s)
 
-    assert_equal(ShopifyAPI::ApiVersion::Unstable.new, @assigned_version)
-    assert_equal(ShopifyAPI::ApiVersion::Release.new('2019-01'), ShopifyAPI::Base.api_version)
+    assert_equal(ShopifyAPI::ApiVersion.new(handle: :unstable), @assigned_version)
+    assert_equal(ShopifyAPI::ApiVersion.new(handle: '2019-01'), ShopifyAPI::Base.api_version)
   end
 
   test "#with_session resets the activated session even if there an exception during the block" do
@@ -128,7 +131,7 @@ class SessionTest < Test::Unit::TestCase
     end
 
     assert_equal('https://fakeshop.myshopify.com', ShopifyAPI::Base.site.to_s)
-    assert_equal(ShopifyAPI::ApiVersion::Release.new('2019-01'), ShopifyAPI::Base.api_version)
+    assert_equal(ShopifyAPI::ApiVersion.new(handle: '2019-01'), ShopifyAPI::Base.api_version)
   end
 
   test "#with_version will adjust the actvated api version for the duration of the block" do
@@ -143,8 +146,8 @@ class SessionTest < Test::Unit::TestCase
     assert_equal('https://fakeshop.myshopify.com', @assigned_site.to_s)
     assert_equal('https://fakeshop.myshopify.com', ShopifyAPI::Base.site.to_s)
 
-    assert_equal(ShopifyAPI::ApiVersion::Unstable.new, @assigned_version)
-    assert_equal(ShopifyAPI::ApiVersion::Release.new('2019-01'), ShopifyAPI::Base.api_version)
+    assert_equal(ShopifyAPI::ApiVersion.new(handle: :unstable), @assigned_version)
+    assert_equal(ShopifyAPI::ApiVersion.new(handle: '2019-01'), ShopifyAPI::Base.api_version)
   end
 
   test "create_permission_url returns correct url with single scope no redirect uri" do
@@ -240,7 +243,7 @@ class SessionTest < Test::Unit::TestCase
   end
 
   test "extra parameters are stored in session" do
-    api_version = ShopifyAPI::ApiVersion::Unstable.new
+    api_version = ShopifyAPI::ApiVersion.new(handle: :unstable)
     fake nil,
       url: "https://testshop.myshopify.com/admin/oauth/access_token",
       method: :post,
@@ -345,6 +348,6 @@ class SessionTest < Test::Unit::TestCase
 
   def any_api_version
     version_name = ['2019-01', :unstable].sample(1).first
-    ShopifyAPI::ApiVersion.coerce_to_version(version_name)
+    ShopifyAPI::ApiVersion.find_version(version_name)
   end
 end

data/test/test_helper.rb

@@ -7,9 +7,9 @@ require 'pry'
 
 $LOAD_PATH.unshift(File.dirname(__FILE__))
 $LOAD_PATH.unshift(File.join(File.dirname(__FILE__), '..', 'lib'))
-require 'shopify_api'
 
 WebMock.disable_net_connect!
+require 'shopify_api'
 
 # setup ShopifyAPI with fake api_key and secret
 module Test
@@ -37,9 +37,16 @@ module Test
           end
         end
 
-        ShopifyAPI::ApiVersion.define_version(ShopifyAPI::ApiVersion::Release.new('2019-01'))
-
         ShopifyAPI::Base.clear_session
+
+        fake("apis",
+              url: "https://app.shopify.com/services/apis.json",
+              method: :get,
+              status: 200,
+              api_version: :stub,
+              body: load_fixture('apis'))
+
+        ShopifyAPI::ApiVersion.fetch_known_versions
         session = ShopifyAPI::Session.new(
           domain: "https://this-is-my-test-shop.myshopify.com",
           token: "token_test_helper",
@@ -55,8 +62,8 @@ module Test
         ShopifyAPI::Base.password = nil
         ShopifyAPI::Base.user = nil
 
-        ShopifyAPI::ApiVersion.clear_defined_versions
-        ShopifyAPI::ApiVersion.define_known_versions
+        ShopifyAPI::ApiVersion.clear_known_versions
+        ShopifyAPI::ApiVersion.version_lookup_mode = :raise_on_unknown
       end
 
       # Custom Assertions
@@ -88,7 +95,7 @@ module Test
         body   = options.has_key?(:body) ? options.delete(:body) : load_fixture(endpoint)
         format = options.delete(:format) || :json
         method = options.delete(:method) || :get
-        api_version = options.delete(:api_version) || ShopifyAPI::ApiVersion.coerce_to_version('2019-01')
+        api_version = options.delete(:api_version) || ShopifyAPI::ApiVersion.find_version('2019-01')
         extension = ".#{options.delete(:extension)||'json'}" unless options[:extension]==false
         status = options.delete(:status) || 200
         url = if options.has_key?(:url)

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: shopify_api
 version: !ruby/object:Gem::Version
-  version: 7.1.0
+  version: 8.0.0
 platform: ruby
 authors:
 - Shopify
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2019-08-29 00:00:00.000000000 Z
+date: 2019-09-05 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activeresource
@@ -210,10 +210,10 @@ files:
 - lib/shopify_api/api_version.rb
 - lib/shopify_api/connection.rb
 - lib/shopify_api/countable.rb
-- lib/shopify_api/defined_versions.rb
 - lib/shopify_api/disable_prefix_check.rb
 - lib/shopify_api/events.rb
 - lib/shopify_api/limits.rb
+- lib/shopify_api/meta.rb
 - lib/shopify_api/metafields.rb
 - lib/shopify_api/paginated_collection.rb
 - lib/shopify_api/pagination_link_headers.rb
@@ -236,6 +236,7 @@ files:
 - lib/shopify_api/resources/cart.rb
 - lib/shopify_api/resources/checkout.rb
 - lib/shopify_api/resources/collect.rb
+- lib/shopify_api/resources/collection.rb
 - lib/shopify_api/resources/collection_listing.rb
 - lib/shopify_api/resources/collection_publication.rb
 - lib/shopify_api/resources/comment.rb
@@ -325,6 +326,7 @@ files:
 - test/collect_test.rb
 - test/collection_listing_test.rb
 - test/collection_publication_test.rb
+- test/collection_test.rb
 - test/countable_test.rb
 - test/currency_test.rb
 - test/custom_collection_test.rb
@@ -337,6 +339,8 @@ files:
 - test/fixtures/abandoned_checkouts.json
 - test/fixtures/access_scopes.json
 - test/fixtures/access_token_delegate.json
+- test/fixtures/api_versions.json
+- test/fixtures/apis.json
 - test/fixtures/application_charge.json
 - test/fixtures/application_charges.json
 - test/fixtures/application_credit.json
@@ -353,10 +357,12 @@ files:
 - test/fixtures/checkout.json
 - test/fixtures/checkouts.json
 - test/fixtures/collect.json
+- test/fixtures/collection.json
 - test/fixtures/collection_listing.json
 - test/fixtures/collection_listing_product_ids.json
 - test/fixtures/collection_listing_product_ids2.json
 - test/fixtures/collection_listings.json
+- test/fixtures/collection_products.json
 - test/fixtures/collection_publication.json
 - test/fixtures/collection_publications.json
 - test/fixtures/currencies.json
@@ -450,6 +456,7 @@ files:
 - test/limits_test.rb
 - test/location_test.rb
 - test/marketing_event_test.rb
+- test/meta_test.rb
 - test/metafield_test.rb
 - test/order_risk_test.rb
 - test/order_test.rb

data/lib/shopify_api/defined_versions.rb

@@ -1,11 +0,0 @@
-# frozen_string_literal: true
-module ShopifyAPI
-  module DefinedVersions
-    def define_known_versions
-      define_version(ShopifyAPI::ApiVersion::Unstable.new)
-      define_version(ShopifyAPI::ApiVersion::Release.new('2019-04'))
-      define_version(ShopifyAPI::ApiVersion::Release.new('2019-07'))
-      define_version(ShopifyAPI::ApiVersion::Release.new('2019-10'))
-    end
-  end
-end