shopify_api 4.9.0 → 9.4.1

data/lib/active_resource/connection_ext.rb

@@ -1,3 +1,4 @@
+# frozen_string_literal: true
 require 'shopify_api/connection'
 
 module ActiveResource

data/lib/active_resource/detailed_log_subscriber.rb

@@ -1,19 +1,55 @@
+# frozen_string_literal: true
 module ActiveResource
   class DetailedLogSubscriber < ActiveSupport::LogSubscriber
+    VERSION_EOL_WARNING_HEADER = 'x-shopify-api-version-warning'
+    VERSION_DEPRECATION_HEADER = 'x-shopify-api-deprecated-reason'
+    SHOPIFY_ACCESS_TOKEN = 'X-Shopify-Access-Token'
+    FILTERED = '[FILTERED]'
+
     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!
+      headers[SHOPIFY_ACCESS_TOKEN] = FILTERED
       request_body = data.first
 
-      info "Request:\n#{request_body}" if request_body
-      info "Headers: #{headers.inspect}"
-      info "Response:\n#{event.payload[:response].body}"
+      info("Request:\n#{request_body}") if request_body
+      info("Headers: #{headers.inspect}")
+      info("Response:\n#{event.payload[:response].body}")
     end
 
-    def logger
-      ActiveResource::Base.logger
+    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,9 +1,15 @@
+# frozen_string_literal: true
 require 'active_resource/base'
 
 module ActiveResource
   class Errors < ActiveModel::Errors
     def from_json(json, save_cache = false)
-      data = ActiveSupport::JSON.decode(json)['errors'] || {} rescue {}
+      data =
+        begin
+          ActiveSupport::JSON.decode(json)['errors'] || {}
+        rescue
+          {}
+        end
       case data
       when String
         from_string(data, save_cache)
@@ -15,7 +21,7 @@ module ActiveResource
     def from_hash(messages, save_cache = false)
       clear unless save_cache
 
-      messages.each do |key,errors|
+      messages.each do |key, errors|
         errors.each do |error|
           add(key, error)
         end

data/lib/shopify_api.rb

@@ -1,16 +1,16 @@
-$:.unshift File.dirname(__FILE__)
-
+# frozen_string_literal: true
+$:.unshift(File.dirname(__FILE__))
 require 'active_resource'
 require 'active_support/core_ext/class/attribute_accessors'
 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 'shopify_api/meta'
 require 'active_resource/json_errors'
-require 'active_resource/disable_prefix_check'
-require 'active_resource/base_ext'
-require 'active_resource/to_query'
+require 'shopify_api/paginated_collection'
+require 'shopify_api/disable_prefix_check'
 
 module ShopifyAPI
   include Limits
@@ -21,10 +21,20 @@ require 'shopify_api/metafields'
 require 'shopify_api/countable'
 require 'shopify_api/resources'
 require 'shopify_api/session'
+require 'shopify_api/api_access'
+require 'shopify_api/message_enricher'
 require 'shopify_api/connection'
+require 'shopify_api/pagination_link_headers'
+require 'shopify_api/graphql'
+require 'shopify_api/graphql/railtie' if defined?(Rails)
 
 if ShopifyAPI::Base.respond_to?(:connection_class)
   ShopifyAPI::Base.connection_class = ShopifyAPI::Connection
 else
   require 'active_resource/connection_ext'
 end
+
+if ENV["SHOPIFY_LOG_PATH"]
+  ActiveResource::Base.logger = Logger.new(ENV["SHOPIFY_LOG_PATH"])
+  ActiveResource::DetailedLogSubscriber.attach_to(:active_resource_detailed)
+end

data/lib/shopify_api/api_access.rb

@@ -0,0 +1,57 @@
+# frozen_string_literal: true
+
+module ShopifyAPI
+  class ApiAccess
+    SCOPE_DELIMITER = ','
+
+    def initialize(scope_names)
+      if scope_names.is_a?(String)
+        scope_names = scope_names.to_s.split(SCOPE_DELIMITER)
+      end
+
+      store_scopes(scope_names)
+    end
+
+    def covers?(scopes)
+      scopes.compressed_scopes <= expanded_scopes
+    end
+
+    def to_s
+      to_a.join(SCOPE_DELIMITER)
+    end
+
+    def to_a
+      compressed_scopes.to_a
+    end
+
+    def ==(other)
+      other.class == self.class &&
+        compressed_scopes == other.compressed_scopes
+    end
+
+    alias :eql? :==
+
+    def hash
+      compressed_scopes.hash
+    end
+
+    protected
+
+    attr_reader :compressed_scopes, :expanded_scopes
+
+    private
+
+    def store_scopes(scope_names)
+      scopes = scope_names.map(&:strip).reject(&:empty?).to_set
+      implied_scopes = scopes.map { |scope| implied_scope(scope) }.compact
+
+      @compressed_scopes = scopes - implied_scopes
+      @expanded_scopes = scopes + implied_scopes
+    end
+
+    def implied_scope(scope)
+      is_write_scope = scope =~ /\A(unauthenticated_)?write_(.*)\z/
+      "#{$1}read_#{$2}" if is_write_scope
+    end
+  end
+end

data/lib/shopify_api/api_version.rb

@@ -0,0 +1,206 @@
+# 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,10 +1,11 @@
+# frozen_string_literal: true
 module ShopifyAPI
   class Connection < ActiveResource::Connection
     attr_reader :response
 
     module ResponseCapture
       def handle_response(response)
-        @response = super
+        @response = super(ShopifyAPI::MessageEnricher.new(response))
       end
     end
 
@@ -13,15 +14,17 @@ module ShopifyAPI
     module RequestNotification
       def request(method, path, *arguments)
         super.tap do |response|
-          notify_about_request(response, arguments)
+          notify_about_request(method, path, response, arguments)
         end
       rescue => e
-        notify_about_request(e.response, arguments) if e.respond_to?(:response)
+        notify_about_request(method, path, e.response, arguments) if e.respond_to?(:response)
         raise
       end
 
-      def notify_about_request(response, arguments)
+      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

data/lib/shopify_api/countable.rb

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