shopify_api 9.5.1 → 13.1.0

data/lib/active_resource/detailed_log_subscriber.rb

@@ -1,55 +0,0 @@
-# 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}")
-    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

data/lib/active_resource/json_errors.rb

@@ -1,37 +0,0 @@
-# frozen_string_literal: true
-require 'active_resource/base'
-
-module ActiveResource
-  class Errors < ActiveModel::Errors
-    def from_json(json, save_cache = false)
-      data =
-        begin
-          ActiveSupport::JSON.decode(json)['errors'] || {}
-        rescue
-          {}
-        end
-      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_access.rb

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

@@ -1,206 +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,36 +0,0 @@
-# frozen_string_literal: true
-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,15 +0,0 @@
-# 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
-      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,8 +0,0 @@
-# frozen_string_literal: true
-module ShopifyAPI
-  module Events
-    def events
-      Event.find(:all, params: { resource: self.class.collection_name, resource_id: id })
-    end
-  end
-end

data/lib/shopify_api/graphql/http_client.rb

@@ -1,22 +0,0 @@
-# frozen_string_literal: true
-require 'graphql/client/http'
-
-module ShopifyAPI
-  module GraphQL
-    class HTTPClient < ::GraphQL::Client::HTTP
-      def initialize(api_version)
-        @api_version = api_version
-      end
-
-      def headers(_context)
-        ShopifyAPI::Base.headers
-      end
-
-      def uri
-        ShopifyAPI::Base.site.dup.tap do |uri|
-          uri.path = @api_version.construct_graphql_path
-        end
-      end
-    end
-  end
-end

data/lib/shopify_api/graphql/railtie.rb

@@ -1,17 +0,0 @@
-# frozen_string_literal: true
-require 'rails/railtie'
-
-module ShopifyAPI
-  module GraphQL
-    class Railtie < Rails::Railtie
-      initializer 'shopify_api.initialize_graphql_clients' do |app|
-        ShopifyAPI::GraphQL.schema_location = app.root.join('db', ShopifyAPI::GraphQL.schema_location)
-        ShopifyAPI::GraphQL.initialize_clients
-      end
-
-      rake_tasks do
-        load 'shopify_api/graphql/task.rake'
-      end
-    end
-  end
-end

data/lib/shopify_api/graphql/task.rake

@@ -1,100 +0,0 @@
-# frozen_string_literal: true
-require 'fileutils'
-
-namespace :shopify_api do
-  namespace :graphql do
-    desc 'Dumps a local JSON schema file of the Shopify Admin API'
-    task :dump do
-      usage = <<~USAGE
-
-        Usage: rake shopify_api:graphql:dump [<args>]
-
-        Dumps a local JSON schema file of the Shopify Admin API. The schema is specific to an
-        API version and authentication is required (either OAuth or private app).
-
-        Dump the schema file for the 2020-01 API version using private app authentication:
-          $ rake shopify_api:graphql:dump SHOP_URL="https://API_KEY:PASSWORD@SHOP_NAME.myshopify.com" API_VERSION=2020-01
-
-        Dump the schema file for the unstable API version using an OAuth access token:
-          $ rake shopify_api:graphql:dump SHOP_DOMAIN=SHOP_NAME.myshopify.com ACCESS_TOKEN=abc API_VERSION=unstable
-
-        See https://github.com/Shopify/shopify_api#getting-started for more
-        details on getting started with authenticated API calls.
-
-        Arguments:
-          ACCESS_TOKEN  OAuth access token (shop specific)
-          API_VERSION   API version handle [example: 2020-01]
-          SHOP_DOMAIN   Shop domain (without path) [example: SHOP_NAME.myshopify.com]
-          SHOP_URL      Shop URL for private apps [example: https://API_KEY:PASSWORD@SHOP_NAME.myshopify.com]
-      USAGE
-
-      access_token = ENV['ACCESS_TOKEN'] || ENV['access_token']
-      api_version = ENV['API_VERSION'] || ENV['api_version']
-      shop_url = ENV['SHOP_URL'] || ENV['shop_url']
-      shop_domain = ENV['SHOP_DOMAIN'] || ENV['shop_domain']
-
-      unless access_token || api_version || shop_url || shop_domain
-        puts usage
-        exit(1)
-      end
-
-      unless shop_url || shop_domain
-        puts 'Error: either SHOP_DOMAIN or SHOP_URL is required for authentication'
-        puts usage
-        exit(1)
-      end
-
-      if shop_url && shop_domain
-        puts 'Error: SHOP_DOMAIN and SHOP_URL cannot be used together. Use one or the other for authentication.'
-        puts usage
-        exit(1)
-      end
-
-      if shop_domain && !access_token
-        puts 'Error: ACCESS_TOKEN required when SHOP_DOMAIN is used'
-        puts usage
-        exit(1)
-      end
-
-      unless api_version
-        puts 'Error: API_VERSION required. Example: 2020-01'
-        puts usage
-        exit(1)
-      end
-
-      Rake::Task['environment'].invoke if Rake::Task.task_defined?('environment')
-
-      ShopifyAPI::ApiVersion.fetch_known_versions
-      ShopifyAPI::ApiVersion.version_lookup_mode = :raise_on_unknown
-
-      shopify_session = ShopifyAPI::Session.new(domain: shop_domain, token: access_token, api_version: api_version)
-      ShopifyAPI::Base.activate_session(shopify_session)
-
-      if shop_url
-        ShopifyAPI::Base.site = shop_url
-      end
-
-      puts "Fetching schema for #{ShopifyAPI::Base.api_version.handle} API version..."
-
-      client = ShopifyAPI::GraphQL::HTTPClient.new(ShopifyAPI::Base.api_version)
-      document = GraphQL.parse('{ __schema { queryType { name } } }')
-      response = client.execute(document: document).to_h
-
-      unless response['data'].present?
-        puts "Error: failed to query the API."
-        puts "Response: #{response}"
-        puts 'Ensure your SHOP_DOMAIN or SHOP_URL are valid and you have valid authentication credentials.'
-        puts usage
-        exit(1)
-      end
-
-      schema_location = ShopifyAPI::GraphQL.schema_location
-      FileUtils.mkdir_p(schema_location) unless Dir.exist?(schema_location)
-
-      schema_file = schema_location.join("#{api_version}.json")
-      GraphQL::Client.dump_schema(client, schema_file.to_s)
-
-      puts "Wrote file #{schema_file}"
-    end
-  end
-end

data/lib/shopify_api/graphql.rb

@@ -1,103 +0,0 @@
-# frozen_string_literal: true
-require 'graphql/client'
-require 'shopify_api/graphql/http_client'
-
-module ShopifyAPI
-  module GraphQL
-    DEFAULT_SCHEMA_LOCATION_PATH = Pathname('shopify_graphql_schemas')
-    DEFAULT_EXECUTION_ADAPTER = HTTPClient
-    DEFAULT_GRAPHQL_CLIENT = ::GraphQL::Client
-
-    InvalidSchema = Class.new(StandardError)
-    InvalidClient = Class.new(StandardError)
-
-    class << self
-      delegate :parse, :query, to: :client
-
-      def client(api_version = ShopifyAPI::Base.api_version.handle)
-        initialize_client_cache
-        cached_client = @_client_cache[api_version]
-
-        if cached_client
-          cached_client
-        else
-          schema_file = schema_location.join("#{api_version}.json")
-
-          if !schema_file.exist?
-            raise InvalidClient, <<~MSG
-              Client for API version #{api_version} does not exist because no schema file exists at `#{schema_file}`.
-
-              To dump the schema file, use the `rake shopify_api:graphql:dump` task.
-            MSG
-          else
-            puts(
-              '[WARNING] Client was not pre-initialized. Ensure `ShopifyAPI::GraphQL.initialize_clients` ' \
-                'is called during app initialization.'
-            )
-            initialize_clients
-            @_client_cache[api_version]
-          end
-        end
-      end
-
-      def clear_clients
-        @_client_cache = {}
-      end
-
-      def initialize_clients(raise_on_invalid_schema: true)
-        initialize_client_cache
-
-        Dir.glob(schema_location.join("*.json")).each do |schema_file|
-          schema_file = Pathname(schema_file)
-          matches = schema_file.basename.to_s.match(/^#{ShopifyAPI::ApiVersion::HANDLE_FORMAT}\.json$/)
-
-          if matches
-            api_version = ShopifyAPI::ApiVersion.new(handle: matches[1])
-          elsif raise_on_invalid_schema
-            raise InvalidSchema,
-              "Invalid schema file name `#{schema_file}`. Does not match format of: `<version>.json`."
-          else
-            next
-          end
-
-          schema = graphql_client.load_schema(schema_file.to_s)
-          client = graphql_client.new(schema: schema, execute: execution_adapter.new(api_version)).tap do |c|
-            c.allow_dynamic_queries = true
-          end
-
-          @_client_cache[api_version.handle] = client
-        end
-      end
-
-      def schema_location
-        @schema_location || DEFAULT_SCHEMA_LOCATION_PATH
-      end
-
-      def schema_location=(path)
-        @schema_location = Pathname(path)
-      end
-
-      def execution_adapter
-        @execution_adapter || DEFAULT_EXECUTION_ADAPTER
-      end
-
-      def execution_adapter=(executor)
-        @execution_adapter = executor
-      end
-
-      def graphql_client
-        @graphql_client || DEFAULT_GRAPHQL_CLIENT
-      end
-
-      def graphql_client=(client)
-        @graphql_client = client
-      end
-
-      private
-
-      def initialize_client_cache
-        @_client_cache ||= {}
-      end
-    end
-  end
-end