ruby_shopify_api 1.0.0

data/lib/active_resource/detailed_log_subscriber.rb

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

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

@@ -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

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

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

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

data/lib/shopify_api/events.rb

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

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

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

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

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