shopify_api 9.0.4 → 12.2.1

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,83 +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')
-
-    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])
-          else
-            if raise_on_invalid_schema
-              raise InvalidSchema, "Invalid schema file name `#{schema_file}`. Does not match format of: `<version>.json`."
-            else
-              next
-            end
-          end
-
-          schema = ::GraphQL::Client.load_schema(schema_file.to_s)
-          client = ::GraphQL::Client.new(schema: schema, execute: HTTPClient.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
-
-      private
-
-      def initialize_client_cache
-        @_client_cache ||= {}
-      end
-    end
-  end
-end

data/lib/shopify_api/limits.rb

@@ -1,76 +0,0 @@
-module ShopifyAPI
-  module Limits
-    class LimitUnavailable < StandardError; end
-
-    def self.included(klass)
-      klass.send(:extend, ClassMethods)
-    end
-
-    module ClassMethods
-      # 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: 'X-Shopify-Shop-Api-Call-Limit',
-      }
-
-      ##
-      # How many more API calls can I make?
-      # @return {Integer}
-      #
-      def credit_left
-        credit_limit(:shop) - credit_used(:shop)
-      end
-      alias_method :available_calls, :credit_left
-
-      ##
-      # Have I reached my API call limit?
-      # @return {Boolean}
-      #
-      def credit_maxed?
-        credit_left <= 0
-      end
-      alias_method :maxed?, :credit_maxed?
-
-      ##
-      # How many total API calls can I make?
-      # NOTE: subtracting 1 from credit_limit because I think ShopifyAPI cuts off at 299 or shop limits.
-      # @param {Symbol} scope [:shop]
-      # @return {Integer}
-      #
-      def credit_limit(scope=:shop)
-        api_credit_limit_param(scope).pop.to_i - 1
-      end
-      alias_method :call_limit, :credit_limit
-
-      ##
-      # How many API calls have I made?
-      # @param {Symbol} scope [:shop]
-      # @return {Integer}
-      #
-      def credit_used(scope=:shop)
-        api_credit_limit_param(scope).shift.to_i
-      end
-      alias_method :call_count, :credit_used
-
-      ##
-      # @return {HTTPResonse}
-      #
-      def response
-        Shop.current unless ShopifyAPI::Base.connection.response
-        ShopifyAPI::Base.connection.response
-      end
-
-      private
-
-      ##
-      # @return {Array}
-      #
-      def api_credit_limit_param(scope)
-        header = response[CREDIT_LIMIT_HEADER_PARAM[scope]]
-        raise LimitUnavailable unless header
-        header.split('/')
-      end
-    end
-  end
-end

data/lib/shopify_api/message_enricher.rb

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

@@ -1,15 +0,0 @@
-
-# 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,20 +0,0 @@
-module ShopifyAPI
-  module Metafields
-    def metafields(**options)
-      options.merge! resource: self.class.collection_name, resource_id: id
-
-      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
-      }
-      metafield.save
-      metafield
-    end
-  end
-end

data/lib/shopify_api/paginated_collection.rb

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

data/lib/shopify_api/pagination_link_headers.rb

@@ -1,33 +0,0 @@
-module ShopifyAPI
-  class InvalidPaginationLinksError < StandardError; end
-
-  class PaginationLinkHeaders
-    LinkHeader = Struct.new(:url, :rel)
-    attr_reader :previous_link, :next_link
-
-    def initialize(link_header)
-      links = parse_link_header(link_header)
-      @previous_link = links.find { |link| link.rel == :previous }
-      @next_link = links.find { |link| link.rel == :next }
-
-      self
-    end
-
-    private
-
-    def parse_link_header(link_header)
-      return [] unless link_header.present?
-      links = link_header.split(',')
-      links.map do |link|
-        parts = link.split('; ')
-        raise ShopifyAPI::InvalidPaginationLinksError.new("Invalid link header: url and rel expected") unless parts.length == 2
-
-        url = parts[0][/<(.*)>/, 1]
-        rel = parts[1][/rel="(.*)"/, 1]&.to_sym
-
-        url = URI.parse(url)
-        LinkHeader.new(url, rel)
-      end
-    end
-  end
-end

data/lib/shopify_api/resources/abandoned_checkout.rb

@@ -1,7 +0,0 @@
-# frozen_string_literal: true
-
-module ShopifyAPI
-  class AbandonedCheckout < Base
-    self.element_name = "checkout"
-  end
-end

data/lib/shopify_api/resources/access_scope.rb

@@ -1,10 +0,0 @@
-# frozen_string_literal: true
-module ShopifyAPI
-  class AccessScope < Base
-    class << self
-      def prefix(_options={})
-        '/admin/oauth/'
-      end
-    end
-  end
-end

data/lib/shopify_api/resources/access_token.rb

@@ -1,8 +0,0 @@
-module ShopifyAPI
-  class AccessToken < Base
-    def self.delegate(access_scope, expires_in = nil)
-      resource = post(:delegate, delegate_access_scope: access_scope, expires_in: expires_in)
-      instantiate_record(format.decode(resource.body), {})
-    end
-  end
-end

data/lib/shopify_api/resources/address.rb

@@ -1,4 +0,0 @@
-module ShopifyAPI
-  class Address < Base
-  end
-end

data/lib/shopify_api/resources/announcement.rb

@@ -1,4 +0,0 @@
-module ShopifyAPI
-  class Announcement < Base
-  end
-end

data/lib/shopify_api/resources/api_permission.rb

@@ -1,9 +0,0 @@
-# frozen_string_literal: true
-
-module ShopifyAPI
-  class ApiPermission < Base
-    def self.destroy
-      delete(:current)
-    end
-  end
-end

data/lib/shopify_api/resources/application_charge.rb

@@ -1,15 +0,0 @@
-module ShopifyAPI
-  class ApplicationCharge < Base
-    undef_method :test
-
-    class << self
-      [:pending, :expired, :accepted, :declined].each do |status|
-        define_method(status) { (all || []).select { |c| c.status == status.to_s } }
-      end
-    end
-
-    def activate
-      load_attributes_from_response(post(:activate))
-    end
-  end
-end

data/lib/shopify_api/resources/application_credit.rb

@@ -1,4 +0,0 @@
-module ShopifyAPI
-  class ApplicationCredit < Base
-  end
-end

data/lib/shopify_api/resources/array_base.rb

@@ -1,13 +0,0 @@
-# frozen_string_literal: true
-
-module ShopifyAPI
-  class ArrayBase < Base
-    class << self
-      private
-
-      def instantiate_record(record, *)
-        record
-      end
-    end
-  end
-end

data/lib/shopify_api/resources/article.rb

@@ -1,21 +0,0 @@
-module ShopifyAPI
-  class Article < Base
-    include Events
-    include Metafields
-    include DisablePrefixCheck
-
-    conditional_prefix :blog
-
-    def comments
-      Comment.find(:all, :params => { :article_id => id })
-    end
-
-    def self.authors(options = {})
-      get(:authors, options)
-    end
-
-    def self.tags(options={})
-      get(:tags, options)
-    end
-  end
-end

data/lib/shopify_api/resources/asset.rb

@@ -1,100 +0,0 @@
-module ShopifyAPI
-  # Assets represent the files that comprise your theme.
-  # There are different buckets which hold different kinds
-  # of assets, each corresponding to one of the folders
-  # within a theme's zip file: "layout", "templates",
-  # "snippets", "assets", and "config". The full key of an
-  # asset always starts with the bucket name, and the path
-  # separator is a forward slash, like layout/theme.liquid
-  # or assets/bg-body.gif.
-  #
-  # Initialize with a key:
-  #   asset = ShopifyAPI::Asset.new(:key => 'assets/special.css', :theme_id => 12345)
-  #
-  # Find by key:
-  #   asset = ShopifyAPI::Asset.find('assets/image.png', :params => {:theme_id => 12345})
-  #
-  # Get the text or binary value:
-  #   asset.value # decodes from attachment attribute if necessary
-  #
-  # You can provide new data for assets in a few different ways:
-  #
-  #   * assign text data for the value directly:
-  #       asset.value = "div.special {color:red;}"
-  #
-  #   * provide binary data for the value:
-  #       asset.attach(File.read('image.png'))
-  #
-  #   * set a URL from which Shopify will fetch the value:
-  #       asset.src = "http://mysite.com/image.png"
-  #
-  #   * set a source key of another of your assets from which
-  #     the value will be copied:
-  #       asset.source_key = "assets/another_image.png"
-  class Asset < Base
-    include DisablePrefixCheck
-
-    self.primary_key = 'key'
-
-    conditional_prefix :theme
-
-    def self.element_path(id, prefix_options = {}, query_options = nil) #:nodoc:
-      prefix_options, query_options = split_options(prefix_options) if query_options.nil?
-      "#{prefix(prefix_options)}#{collection_name}.#{format.extension}#{query_string(query_options)}"
-    end
-
-    # find an asset by key:
-    #   ShopifyAPI::Asset.find('layout/theme.liquid', :params => { theme_id: 99 })
-    def self.find(*args)
-      if args[0].is_a?(Symbol)
-        super
-      else
-        params = { asset: { key: args[0] } }
-        params = params.merge(args[1][:params]) if args[1] && args[1][:params]
-        path_prefix = params[:theme_id] ? "themes/#{params[:theme_id]}/" : ""
-        resource = find(
-          :one,
-          from: api_version.construct_api_path("#{path_prefix}assets.#{format.extension}"),
-          params: params
-        )
-        resource.prefix_options[:theme_id] = params[:theme_id] if resource && params[:theme_id]
-        resource
-      end
-    end
-
-    # For text assets, Shopify returns the data in the 'value' attribute.
-    # For binary assets, the data is base-64-encoded and returned in the
-    # 'attachment' attribute. This accessor returns the data in both cases.
-    def value
-      attributes['value'] ||
-      (attributes['attachment'] ? Base64.decode64(attributes['attachment']) : nil)
-    end
-
-    def attach(data)
-      self.attachment = Base64.encode64(data)
-    end
-
-    def destroy
-      connection.delete(element_path(prefix_options.merge(:asset => {:key => key})), self.class.headers)
-    end
-
-    def new?
-      false
-    end
-
-    def method_missing(method_symbol, *arguments) #:nodoc:
-      if %w{value= attachment= src= source_key=}.include?(method_symbol)
-        wipe_value_attributes
-      end
-      super
-    end
-
-    private
-
-    def wipe_value_attributes
-      %w{value attachment src source_key}.each do |attr|
-        attributes.delete(attr)
-      end
-    end
-  end
-end