shopify_api 9.1.0 → 12.4.0

data/.travis.yml

@@ -1,22 +0,0 @@
-language: ruby
-
-rvm:
-  - 2.4.6
-  - 2.5.5
-  - 2.6.2
-
-gemfile:
-  - Gemfile_ar41
-  - Gemfile_ar50
-  - Gemfile_ar51
-  - Gemfile_ar_master
-
-matrix:
-  fast_finish: true
-  allow_failures:
-    - rvm: 2.4.6
-      gemfile: Gemfile_ar_master
-    - rvm: 2.5.5
-      gemfile: Gemfile_ar_master
-    - rvm: 2.6.2
-      gemfile: Gemfile_ar_master

data/CONTRIBUTORS

@@ -1,3 +0,0 @@
-API limits code
-
-* Contributed by Chris Scott, https://github.com/christocracy/shopify-api-limits

data/Gemfile_ar41

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

data/Gemfile_ar50

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

data/Gemfile_ar51

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

data/Gemfile_ar_master

@@ -1,5 +0,0 @@
-source "https://rubygems.org"
-
-gemspec
-
-gem 'activeresource', git: 'git://github.com/rails/activeresource'

data/RELEASING

@@ -1,13 +0,0 @@
-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
-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
-6. Push out the changes
-  $ git push
-7. Push out the tags
-  $ git push --tags
-8. Publish the gem using Shipit

data/bin/shopify

@@ -1,3 +0,0 @@
-#!/usr/bin/env ruby
-puts "shopify command is no longer bundled with shopify_api."
-puts "if you need these tools, install the shopify_cli gem"

data/docker-compose.yml

@@ -1,13 +0,0 @@
-version: '3.5'
-services:
-  api:
-    container_name: shopify_api
-    image: ruby:2.6
-    working_dir: /shopify_api
-    volumes:
-      - .:/shopify_api
-      - bundle:/usr/local/bundle
-    command: bash -c "bundle install && tail -f /dev/null"
-
-volumes:
-  bundle:

data/docs/graphql.md

@@ -1,196 +0,0 @@
-# GraphQL client
-
-The `shopify_api` gem includes a full featured GraphQL client to interact with
-Shopify's [GraphQL Admin API](https://help.shopify.com/en/api/graphql-admin-api).
-GitHub's [graphql-client](https://github.com/github/graphql-client) is used as
-the underlying client and this library integrates it with our existing
-session, authentication, and API versioning features.
-
-## Example
-
-```ruby
-client = ShopifyAPI::GraphQL.client
-
-SHOP_NAME_QUERY = client.parse <<-'GRAPHQL'
-  {
-    shop {
-      name
-    }
-  }
-GRAPHQL
-
-result = client.query(SHOP_NAME_QUERY)
-result.data.shop.name
-```
-
-* [Getting started](#getting-started)
-* [Rails integration](#rails-integration)
-* [API versioning](#api-versioning)
-* [Initialization process](#initialization-process)
-* [Migration guide](#migration-guide)
-
-## Getting started
-
-1. [Dump the schema](#dump-the-schema)
-2. [Configure session/authencation](#sessions-and-authentication)
-3. [Make queries](#make-queries)
-
-### Dump the schema
-One of the main benefits of GraphQL is its [schema and type system](https://graphql.org/learn/schema/)
-which enables tools like graphql-client to ensure your queries are valid in development.
-
-So the first step in making GraphQL queries is having a local JSON file of Shopify's Admin schema.
-This gem provides a `shopify_api:graphql:dump` Rake task to make it as easy as possible:
-
-#### Private apps
-```bash
-$ rake shopify_api:graphql:dump SHOP_URL="https://API_KEY:PASSWORD@SHOP_NAME.myshopify.com" API_VERSION=2020-01
-```
-#### Public apps
-```bash
-$ rake shopify_api:graphql:dump SHOP_DOMAIN="SHOP_NAME.myshopify.com" ACCESS_TOKEN="SHOP_TOKEN" API_VERSION=2020-01
-```
-
-If successful `db/shopify_graphql_schemas/2020-01.json` will be created.
-
-You can either use private app authentication or an OAuth access token. Run `rake shopify_api:graphql:dump`
-to see full usage details.
-
-If you're using shopify_api in a Rails app, the default location for schema files is `db/shopify_graphql_schemas`.
-For non-Rails applications, the default is `shopify_graphql_schemas` in your project root.
-
-The schema path location can be changed via `ShopifyAPI::GraphQL.schema_location`:
-
-```ruby
-ShopifyAPI::GraphQL.schema_location = 'assets/schemas'
-```
-
-#### Updating schemas
-Each time you want to use a new API version, or update an existing one
-(such as the `unstable` version), simply run the Rake task again to overwrite the file.
-
-### Sessions and authentication
-The GraphQL client is designed to be integrated with the rest of shopify_api so
-all its features such as sessions, authentication, and API versioning work the
-exact same.
-
-If you've already been using the shopify_api gem in your application to make
-REST API calls then no other configuration is necessary.
-
-Steps 1-5 of our main [Getting started](https://github.com/Shopify/shopify_api#getting-started)
-section still apply for the GraphQL client as well.
-
-### Make queries
-Now that you've dumped a schema file and configured an authenticated session, you can make GraphQL API requests.
-graphql-client encourages all queries to be defined statically as constants:
-
-```ruby
-SHOP_NAME_QUERY = ShopifyAPI::GraphQL.client.parse <<-'GRAPHQL'
-  {
-    shop {
-      name
-    }
-  }
-GRAPHQL
-
-result = ShopifyAPI::GraphQL.client.query(SHOP_NAME_QUERY)
-result.data.shop.name
-```
-
-But we've also enabled its `allow_dynamic_queries` option if you prefer:
-
-```ruby
-query = ShopifyAPI::GraphQL.client.parse <<-'GRAPHQL'
-  {
-    shop {
-      name
-    }
-  }
-GRAPHQL
-
-result = ShopifyAPI::GraphQL.client.query(query)
-result.data.shop.name
-```
-
-See the [graphql-client documentation](https://github.com/github/graphql-client#defining-queries)
-for more details on defining and executing queries.
-
-## Rails integration
-`ShopifyAPI::GraphQL` integrates with Rails to automatically do the following:
-
-* load the `shopify_api:graphql:dump` Rake task
-* set the `schema_location` to be in the `db` directory in your Rails root
-* initialize clients in the Rails app initializer phase
-
-## API versioning
-`ShopifyAPI::GraphQL` is version aware and lets you easily make queries to multiple
-API versions through version specific clients if need be.
-
-If you have multiple clients and need to be explicit you can specify the version parameter:
-
-```ruby
-ShopifyAPI::GraphQL.client # defaults to the client using ShopifyAPI::Base.api_version
-ShopifyAPI::GraphQL.client('unstable')
-```
-
-## Initialization process
-`ShopifyAPI::GraphQL` is a thin integration layer which initializes `GraphQL::Client`s
-from local schema files.
-
-`ShopifyAPI::GraphQL.initialize_clients` scans `ShopifyAPI::GraphQL.schema_location`
-and creates a client for each version specific schema file found.
-
-This happens automatically in a Rails application due to our [integration](#rails-integration).
-For non-Rails applications, ensure you call `ShopifyAPI::GraphQL.initialize_clients`
-during your boot process.
-
-The goal is to have all clients created at boot so there's no schema loading,
-parsing, or client instantiation done during runtime when your app serves a request.
-
-## Migration guide
-Prior to shopify_api v9.0 the GraphQL client implementation was limited and almost
-unusable due to the client making dynamic introspection queries to Shopify's API.
-This was not only very slow but also led to unbounded memory growth.
-
-There are two steps to migrate to the new client:
-1. [Dump a local schema file](#dump-the-schema)
-2. [Migrate `client` usage](#migrate-usage)
-
-### Migrate usage
-
-Previously a client was initialized with `ShopifyAPI::GraphQL.new`:
-```ruby
-client = ShopifyAPI::GraphQL.new
-
-SHOP_NAME_QUERY = client.parse <<-'GRAPHQL'
-  {
-    shop {
-      name
-    }
-  }
-GRAPHQL
-
-result = client.query(SHOP_NAME_QUERY)
-result.data.shop.name
-```
-
-Now there's no need to initialize a client so all references to
-`ShopifyAPI::GraphQL.new` should be removed and instead the client is called
-via `ShopifyAPI::GraphQL.client`:
-
-```ruby
-client = ShopifyAPI::GraphQL.client
-
-SHOP_NAME_QUERY = client.parse <<-'GRAPHQL'
-  {
-    shop {
-      name
-    }
-  }
-GRAPHQL
-
-result = client.query(SHOP_NAME_QUERY)
-result.data.shop.name
-```
-
-See [making queries](#making-queries) for more usage details.

data/lib/active_resource/connection_ext.rb

@@ -1,10 +0,0 @@
-require 'shopify_api/connection'
-
-module ActiveResource
-  class Connection
-    attr_reader :response
-
-    prepend ShopifyAPI::Connection::ResponseCapture
-    prepend ShopifyAPI::Connection::RequestNotification
-  end
-end

data/lib/active_resource/detailed_log_subscriber.rb

@@ -1,52 +0,0 @@
-module ActiveResource
-  class DetailedLogSubscriber < ActiveSupport::LogSubscriber
-    VERSION_EOL_WARNING_HEADER = 'x-shopify-api-version-warning'
-    VERSION_DEPRECATION_HEADER = 'x-shopify-api-deprecated-reason'
-    def request(event)
-      log_request_response_details(event)
-      warn_on_deprecated_header_or_version_eol_header(event)
-    end
-
-    def logger
-      ActiveResource::Base.logger
-    end
-
-    private
-
-    def log_request_response_details(event)
-      data = event.payload[:data]
-      headers = data.extract_options!
-      request_body = data.first
-
-      info "Request:\n#{request_body}" if request_body
-      info "Headers: #{headers.inspect}"
-      info "Response:\n#{event.payload[:response].body}"
-    end
-
-    def warn_on_deprecated_header_or_version_eol_header(event)
-      payload = event.payload
-
-      payload[:response].each do |header_name, header_value|
-        case header_name.downcase
-        when VERSION_DEPRECATION_HEADER
-          warning_message = <<-MSG
-          [DEPRECATED] ShopifyAPI made a call to #{payload[:method].upcase} #{payload[:path]}, and this call made
-          use of a deprecated endpoint, behaviour, or parameter. See #{header_value} for more details.
-          MSG
-
-          warn warning_message
-
-        when VERSION_EOL_WARNING_HEADER
-          warning_message = <<-MSG
-          [API Version Warning] ShopifyAPI made a call to #{payload[:method].upcase} #{payload[:path]}, and this call used
-          an API version that is unsupported or will become unsupported within 30 days. See #{header_value} for more details.
-          MSG
-
-          warn warning_message
-        end
-      end
-    end
-  end
-end
-
-ActiveResource::DetailedLogSubscriber.attach_to :active_resource_detailed

data/lib/active_resource/json_errors.rb

@@ -1,31 +0,0 @@
-require 'active_resource/base'
-
-module ActiveResource
-  class Errors < ActiveModel::Errors
-    def from_json(json, save_cache = false)
-      data = ActiveSupport::JSON.decode(json)['errors'] || {} rescue {}
-      case data
-      when String
-        from_string(data, save_cache)
-      else
-        from_hash(data, save_cache)
-      end
-    end
-
-    def from_hash(messages, save_cache = false)
-      clear unless save_cache
-
-      messages.each do |key,errors|
-        errors.each do |error|
-          add(key, error)
-        end
-      end
-    end
-
-    def from_string(error, save_cache = false)
-      clear unless save_cache
-
-      add(:base, error)
-    end
-  end
-end

data/lib/shopify_api/api_version.rb

@@ -1,205 +0,0 @@
-# frozen_string_literal: true
-module ShopifyAPI
-  class ApiVersion
-    class UnknownVersion < StandardError; end
-    class ApiVersionNotSetError < StandardError; end
-    include Comparable
-
-    UNSTABLE_HANDLE = 'unstable'
-    HANDLE_FORMAT = /((\d{4}-\d{2})|#{UNSTABLE_HANDLE})/.freeze
-    UNSTABLE_AS_DATE = Time.utc(3000, 1, 1)
-    API_PREFIX = '/admin/api/'
-    LOOKUP_MODES = [:raise_on_unknown, :define_on_unknown].freeze
-
-    class << self
-      attr_reader :versions
-
-      def version_lookup_mode
-        @version_lookup_mode ||= :define_on_unknown
-      end
-
-      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
-
-      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
-
-      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 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
-
-    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
-      handle
-    end
-
-    def latest_supported?
-      latest_supported
-    end
-
-    def supported?
-      supported
-    end
-
-    def verified?
-      verified
-    end
-
-    def <=>(other)
-      handle_as_date <=> other.handle_as_date
-    end
-
-    def ==(other)
-      other.class == self.class && handle == other.handle
-    end
-
-    def hash
-      handle.hash
-    end
-
-    def construct_api_path(path)
-      "#{API_PREFIX}#{handle}/#{path}"
-    end
-
-    def construct_graphql_path
-      construct_api_path('graphql.json')
-    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?
-      warn(
-        '[DEPRECATED] ShopifyAPI::ApiVersion#stable? is deprecated and will be removed in a future version. ' \
-          'Use `supported?` instead.'
-      )
-      supported?
-    end
-
-    def unstable?
-      handle == UNSTABLE_HANDLE
-    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 new(*_args)
-          raise NoMethodError, "NullVersion is an abstract class and cannot be instantiated."
-        end
-
-        def matches?(version)
-          version.nil? || version == self
-        end
-
-        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
-end

data/lib/shopify_api/connection.rb

@@ -1,35 +0,0 @@
-module ShopifyAPI
-  class Connection < ActiveResource::Connection
-    attr_reader :response
-
-    module ResponseCapture
-      def handle_response(response)
-        @response = super(ShopifyAPI::MessageEnricher.new(response))
-      end
-    end
-
-    include ResponseCapture
-
-    module RequestNotification
-      def request(method, path, *arguments)
-        super.tap do |response|
-          notify_about_request(method, path, response, arguments)
-        end
-      rescue => e
-        notify_about_request(method, path, e.response, arguments) if e.respond_to?(:response)
-        raise
-      end
-
-      def notify_about_request(method, path, response, arguments)
-        ActiveSupport::Notifications.instrument("request.active_resource_detailed") do |payload|
-          payload[:method]   = method
-          payload[:path]     = path
-          payload[:response] = response
-          payload[:data]     = arguments
-        end
-      end
-    end
-
-    include RequestNotification
-  end
-end

data/lib/shopify_api/countable.rb

@@ -1,14 +0,0 @@
-module ShopifyAPI
-  module Countable
-    def count(options = {})
-      data = get(:count, options)
-
-      count = case data
-        when Hash then data["count"]
-        else data
-      end
-
-      Integer(count)
-    end
-  end
-end

data/lib/shopify_api/disable_prefix_check.rb

@@ -1,31 +0,0 @@
-# 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

data/lib/shopify_api/events.rb

@@ -1,7 +0,0 @@
-module ShopifyAPI
-  module Events
-    def events
-      Event.find(:all, :params => {:resource => self.class.collection_name, :resource_id => id})
-    end
-  end
-end