shopify_api 4.9.0 → 9.4.1

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

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

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/limits.rb

@@ -1,3 +1,4 @@
+# frozen_string_literal: true
 module ShopifyAPI
   module Limits
     class LimitUnavailable < StandardError; end
@@ -7,14 +8,14 @@ module ShopifyAPI
     end
 
     module ClassMethods
-
-      # Takes form num_requests_executed/max_requests
-      # Eg: 101/3000
+      # Takes form <call count>/<bucket size>
+      # See https://help.shopify.com/en/api/getting-started/api-call-limit
+      # Eg: 2/40
       CREDIT_LIMIT_HEADER_PARAM = {
-        :shop => 'http_x_shopify_shop_api_call_limit'
+        shop: 'X-Shopify-Shop-Api-Call-Limit',
       }
 
-        ##
+      ##
       # How many more API calls can I make?
       # @return {Integer}
       #
@@ -38,9 +39,8 @@ module ShopifyAPI
       # @param {Symbol} scope [:shop]
       # @return {Integer}
       #
-      def credit_limit(scope=:shop)
-        @api_credit_limit ||= {}
-        @api_credit_limit[scope] ||= api_credit_limit_param(scope).pop.to_i - 1
+      def credit_limit(scope = :shop)
+        api_credit_limit_param(scope).pop.to_i - 1
       end
       alias_method :call_limit, :credit_limit
 
@@ -49,7 +49,7 @@ module ShopifyAPI
       # @param {Symbol} scope [:shop]
       # @return {Integer}
       #
-      def credit_used(scope=:shop)
+      def credit_used(scope = :shop)
         api_credit_limit_param(scope).shift.to_i
       end
       alias_method :call_count, :credit_used

data/lib/shopify_api/message_enricher.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+module ShopifyAPI
+  class MessageEnricher < SimpleDelegator
+    def message
+      return super unless (400...500).include?(code.to_i)
+
+      @_cached_message ||= begin
+        detailed_error =
+          begin
+            parsed_body = JSON.parse(body)
+
+            if parsed_body['error']
+              parsed_body['error'].to_s
+            elsif parsed_body['errors']
+              Array(parsed_body['errors']).join('; ')
+            end
+          rescue JSON::ParserError
+            nil
+          end
+
+        detailed_error.present? ? "#{super} (#{detailed_error})" : super
+      end
+    end
+  end
+end

data/lib/shopify_api/meta.rb

@@ -0,0 +1,14 @@
+
+# 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/metafields.rb

@@ -1,17 +1,18 @@
+# frozen_string_literal: true
 module ShopifyAPI
   module Metafields
     def metafields(**options)
-      options.merge! resource: self.class.collection_name, resource_id: id
+      options.merge!(resource: self.class.collection_name, resource_id: id)
 
-      Metafield.find :all, params: options
+      Metafield.find(:all, params: options)
     end
 
     def add_metafield(metafield)
       raise ArgumentError, "You can only add metafields to resource that has been saved" if new?
 
       metafield.prefix_options = {
-        :resource => self.class.collection_name,
-        :resource_id => id
+        resource: self.class.collection_name,
+        resource_id: id,
       }
       metafield.save
       metafield

data/lib/shopify_api/paginated_collection.rb

@@ -0,0 +1,69 @@
+# frozen_string_literal: true
+
+module ShopifyAPI
+  class PaginatedCollection < ActiveResource::Collection
+    module CollectionPagination
+      def initialize(args)
+        @next_url = pagination_link_headers.next_link&.url&.to_s
+        @previous_url = pagination_link_headers.previous_link&.url&.to_s
+        super(args)
+      end
+
+      def next_page?
+        ensure_available
+        @next_url.present?
+      end
+
+      def previous_page?
+        ensure_available
+        @previous_url.present?
+      end
+
+      def fetch_next_page
+        fetch_page(@next_url)
+      end
+
+      def fetch_previous_page
+        fetch_page(@previous_url)
+      end
+
+      def next_page_info
+        extract_page_info(@next_url)
+      end
+
+      def previous_page_info
+        extract_page_info(@previous_url)
+      end
+
+      private
+
+      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
+        return [] unless url.present?
+
+        resource_class.all(from: url)
+      end
+
+      def pagination_link_headers
+        @pagination_link_headers ||= ShopifyAPI::PaginationLinkHeaders.new(
+          ShopifyAPI::Base.connection.response["Link"]
+        )
+      end
+
+      def ensure_available
+        return if ShopifyAPI::Base.api_version >= AVAILABLE_IN_VERSION
+        return if ShopifyAPI::Base.api_version >= AVAILABLE_IN_VERSION_EARLY && resource_class.early_july_pagination?
+        raise NotImplementedError
+      end
+
+      def extract_page_info(url)
+        CGI.escape(Rack::Utils.parse_query(URI(url).query)['page_info']) if url.present?
+      end
+    end
+
+    include CollectionPagination
+  end
+end