shopify_api 1.0.4 → 12.3.0

data/lib/shopify_api.rb

@@ -1,472 +1,23 @@
-require 'active_resource'
-require 'digest/md5'
-
-module ShopifyAPI
-  METAFIELD_ENABLED_CLASSES = %w( Order Product CustomCollection SmartCollection Page Blog Article Variant)
-
-  module Countable
-    def count(options = {})
-      Integer(get(:count, options))
-    end
-  end
-  
-  module Metafields
-    def metafields
-      Metafield.find(:all, :params => {:resource => self.class.collection_name, :resource_id => id})
-    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
-  
-  # 
-  #  The Shopify API authenticates each call via HTTP Authentication, using
-  #    * the application's API key as the username, and
-  #    * a hex digest of the application's shared secret and an 
-  #      authentication token as the password.
-  #  
-  #  Generation & acquisition of the beforementioned looks like this:
-  # 
-  #    0. Developer (that's you) registers Application (and provides a
-  #       callback url) and receives an API key and a shared secret
-  # 
-  #    1. User visits Application and are told they need to authenticate the
-  #       application first for read/write permission to their data (needs to
-  #       happen only once). User is asked for their shop url.
-  # 
-  #    2. Application redirects to Shopify : GET <user's shop url>/admin/api/auth?api_key=<API key>
-  #       (See Session#create_permission_url)
-  # 
-  #    3. User logs-in to Shopify, approves application permission request
-  # 
-  #    4. Shopify redirects to the Application's callback url (provided during
-  #       registration), including the shop's name, and an authentication token in the parameters:
-  #         GET client.com/customers?shop=snake-oil.myshopify.com&t=a94a110d86d2452eb3e2af4cfb8a3828
-  # 
-  #    5. Authentication password computed using the shared secret and the
-  #       authentication token (see Session#computed_password)
-  # 
-  #    6. Profit!
-  #       (API calls can now authenticate through HTTP using the API key, and
-  #       computed password)
-  # 
-  #  LoginController and ShopifyLoginProtection use the Session class to set Shopify::Base.site
-  #  so that all API calls are authorized transparently and end up just looking like this:
-  # 
-  #    # get 3 products
-  #    @products = ShopifyAPI::Product.find(:all, :params => {:limit => 3})
-  #    
-  #    # get latest 3 orders
-  #    @orders = ShopifyAPI::Order.find(:all, :params => {:limit => 3, :order => "created_at DESC" })
-  # 
-  #  As an example of what your LoginController should look like, take a look
-  #  at the following:
-  # 
-  #    class LoginController < ApplicationController
-  #      def index
-  #        # Ask user for their #{shop}.myshopify.com address
-  #      end
-  #    
-  #      def authenticate
-  #        redirect_to ShopifyAPI::Session.new(params[:shop]).create_permission_url
-  #      end
-  #    
-  #      # Shopify redirects the logged-in user back to this action along with
-  #      # the authorization token t.
-  #      # 
-  #      # This token is later combined with the developer's shared secret to form
-  #      # the password used to call API methods.
-  #      def finalize
-  #        shopify_session = ShopifyAPI::Session.new(params[:shop], params[:t])
-  #        if shopify_session.valid?
-  #          session[:shopify] = shopify_session
-  #          flash[:notice] = "Logged in to shopify store."
-  #    
-  #          return_address = session[:return_to] || '/home'
-  #          session[:return_to] = nil
-  #          redirect_to return_address
-  #        else
-  #          flash[:error] = "Could not log in to Shopify store."
-  #          redirect_to :action => 'index'
-  #        end
-  #      end
-  #    
-  #      def logout
-  #        session[:shopify] = nil
-  #        flash[:notice] = "Successfully logged out."
-  #    
-  #        redirect_to :action => 'index'
-  #      end
-  #    end
-  # 
-  class Session
-    cattr_accessor :api_key
-    cattr_accessor :secret
-    cattr_accessor :protocol 
-    self.protocol = 'https'
-
-    attr_accessor :url, :token, :name
-    
-    def self.setup(params)
-      params.each { |k,value| send("#{k}=", value) }
-    end
-
-    def initialize(url, token = nil, params = nil)
-      self.url, self.token = url, token
-
-      if params && params[:signature]
-        unless self.class.validate_signature(params) && params[:timestamp].to_i > 24.hours.ago.utc.to_i
-          raise "Invalid Signature: Possible malicious login" 
-        end
-      end
-
-      self.class.prepare_url(self.url) if valid?
-    end
-    
-    def shop
-      Shop.current
-    end
-    
-    def create_permission_url
-      "http://#{url}/admin/api/auth?api_key=#{api_key}"
-    end
-
-    # Used by ActiveResource::Base to make all non-authentication API calls
-    # 
-    # (ShopifyAPI::Base.site set in ShopifyLoginProtection#shopify_session)
-    def site
-      "#{protocol}://#{api_key}:#{computed_password}@#{url}/admin"
-    end
-
-    def valid?
-      url.present? && token.present?
-    end
-
-    private
-
-    # The secret is computed by taking the shared_secret which we got when 
-    # registring this third party application and concating the request_to it, 
-    # and then calculating a MD5 hexdigest. 
-    def computed_password
-      Digest::MD5.hexdigest(secret + token.to_s)
-    end
-    
-    def self.prepare_url(url)
-      url.gsub!(/https?:\/\//, '')                            # remove http:// or https://
-      url.concat(".myshopify.com") unless url.include?('.')   # extend url to myshopify.com if no host is given
-    end
-    
-    def self.validate_signature(params)
-      return false unless signature = params[:signature]
-
-      sorted_params = params.except(:signature, :action, :controller).collect{|k,v|"#{k}=#{v}"}.sort.join
-      Digest::MD5.hexdigest(secret + sorted_params) == signature
-    end
-  end
-  
-  class Base < ActiveResource::Base
-    extend Countable
-  end
-
-  # Shop object. Use Shop.current to receive 
-  # the shop.
-  class Shop < Base
-    def self.current
-      find(:one, :from => "/admin/shop.xml")
-    end
-    
-    def metafields
-      Metafield.find(:all)
-    end
-    
-    def add_metafield(metafield)
-      raise ArgumentError, "You can only add metafields to resource that has been saved" if new?      
-      metafield.save
-      metafield
-    end
-  end               
-
-  # Custom collection
-  #
-  class CustomCollection < Base
-    def products
-      Product.find(:all, :params => {:collection_id => self.id})
-    end
-    
-    def add_product(product)
-      Collect.create(:collection_id => self.id, :product_id => product.id)
-    end
-    
-    def remove_product(product)
-      collect = Collect.find(:first, :params => {:collection_id => self.id, :product_id => product.id})
-      collect.destroy if collect
-    end
-  end                                                                 
-  
-  class SmartCollection < Base
-    def products
-      Product.find(:all, :params => {:collection_id => self.id})
-    end
-  end  
-  
-  # For adding/removing products from custom collections
-  class Collect < Base
-  end
-
-  class ShippingAddress < Base
-  end
-
-  class BillingAddress < Base
-  end         
-
-  class LineItem < Base 
-  end       
-
-  class ShippingLine < Base
-  end  
-
-  class NoteAttribute < Base
-  end
-
-  class Order < Base
-    def close; load_attributes_from_response(post(:close)); end
-
-    def open; load_attributes_from_response(post(:open)); end
-
-    def transactions
-      Transaction.find(:all, :params => { :order_id => id })
-    end
-    
-    def capture(amount = "")
-      Transaction.create(:amount => amount, :kind => "capture", :order_id => id)
-    end
-  end
-  
-  class Product < Base
-
-    # Share all items of this store with the 
-    # shopify marketplace
-    def self.share; post :share;  end    
-    def self.unshare; delete :share; end
-
-    # compute the price range
-    def price_range
-      prices = variants.collect(&:price)
-      format =  "%0.2f"
-      if prices.min != prices.max
-        "#{format % prices.min} - #{format % prices.max}"
-      else
-        format % prices.min
-      end
-    end
-    
-    def collections
-      CustomCollection.find(:all, :params => {:product_id => self.id})
-    end
-    
-    def smart_collections
-      SmartCollection.find(:all, :params => {:product_id => self.id})
-    end
-    
-    def add_to_collection(collection)
-      collection.add_product(self)
-    end
-    
-    def remove_from_collection(collection)
-      collection.remove_product(self)
-    end
-  end
-  
-  class Variant < Base
-    self.prefix = "/admin/products/:product_id/"
-  end
-  
-  class Image < Base
-    self.prefix = "/admin/products/:product_id/"
-    
-    # generate a method for each possible image variant
-    [:pico, :icon, :thumb, :small, :medium, :large, :original].each do |m|
-      reg_exp_match = "/\\1_#{m}.\\2"
-      define_method(m) { src.gsub(/\/(.*)\.(\w{2,4})/, reg_exp_match) }
-    end
-    
-    def attach_image(data, filename = nil)
-      attributes['attachment'] = Base64.encode64(data)
-      attributes['filename'] = filename unless filename.nil?
-    end
-  end
-
-  class Transaction < Base
-    self.prefix = "/admin/orders/:order_id/"
-  end
-  
-  class Fulfillment < Base
-    self.prefix = "/admin/orders/:order_id/"
-  end
-
-  class Country < Base
-  end
-
-  class Page < Base
-  end
-  
-  class Blog < Base
-    def articles
-      Article.find(:all, :params => { :blog_id => id })
-    end
-  end
-  
-  class Article < Base
-    self.prefix = "/admin/blogs/:blog_id/"
-  end
-  
-  class Metafield < Base
-    self.prefix = "/admin/:resource/:resource_id/"
-    
-    # Hack to allow both Shop and other Metafields in through the same AR class
-    def self.prefix(options={})
-      options[:resource].nil? ? "/admin/" : "/admin/#{options[:resource]}/#{options[:resource_id]}/"
-    end
-            
-    def value
-      return if attributes["value"].nil?
-      attributes["value_type"] == "integer" ? attributes["value"].to_i : attributes["value"]
-    end
-
-  end
-
-  class Comment < Base 
-    def remove; load_attributes_from_response(post(:remove)); end
-    def ham; load_attributes_from_response(post(:ham)); end
-    def spam; load_attributes_from_response(post(:spam)); end
-    def approve; load_attributes_from_response(post(:approve)); end        
-  end
-  
-  class Province < Base
-    self.prefix = "/admin/countries/:country_id/"
-  end
-  
-  class Redirect < Base
-  end
-  
-  class Webhook < Base
-  end
-  
-  # 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, and
-  # assets. 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')
-  # 
-  # Find by key:
-  #   asset = ShopifyAPI::Asset.find('assets/image.png')
-  # 
-  # 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
-    self.primary_key = 'key'
-    
-    # find an asset by key:
-    #   ShopifyAPI::Asset.find('layout/theme.liquid')
-    def self.find(*args)
-      if args[0].is_a?(Symbol)
-        super
-      else
-        find(:one, :from => "/admin/assets.xml", :params => {:asset => {:key => args[0]}})
-      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 #:nodoc:
-      connection.delete(element_path(:asset => {:key => key}), self.class.headers)
-    end
-    
-    def new? #:nodoc:
-      false
-    end
-    
-    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
-    
-    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
-  
-  class RecurringApplicationCharge < Base
-    def self.current
-      find(:all).find{|charge| charge.status == 'active'}
-    end
-    
-    def cancel
-      load_attributes_from_response(self.destroy)
-    end
-    
-    def activate
-      load_attributes_from_response(post(:activate))
-    end
-  end
-
-  class ApplicationCharge < Base
-    def activate
-      load_attributes_from_response(post(:activate))
-    end
-  end
-  
-  # Include Metafields module in all enabled classes
-  METAFIELD_ENABLED_CLASSES.each do |klass|
-    "ShopifyAPI::#{klass}".constantize.send(:include, Metafields)
-  end
-end
+# typed: strict
+# frozen_string_literal: true
+
+$LOAD_PATH.unshift(File.dirname(__FILE__))
+
+require "oj"
+require "sorbet-runtime"
+require "securerandom"
+require "cgi"
+require "uri"
+require "openssl"
+require "httparty"
+require "zeitwerk"
+require "jwt"
+require "concurrent"
+
+require_relative "shopify_api/inflector"
+require_relative "shopify_api/admin_versions"
+
+loader = Zeitwerk::Loader.for_gem
+loader.inflector = ShopifyAPI::Inflector.new(__FILE__)
+loader.ignore("#{__dir__}/shopify_api/rest/resources")
+loader.setup

data/service.yml

@@ -0,0 +1 @@
+audience: partner

data/shipit.rubygems.yml

@@ -0,0 +1 @@
+# using the default shipit config

data/shopify_api.gemspec

@@ -1,113 +1,54 @@
-# Generated by jeweler
-# DO NOT EDIT THIS FILE DIRECTLY
-# Instead, edit Jeweler::Tasks in Rakefile, and run the gemspec command
-# -*- encoding: utf-8 -*-
+# frozen_string_literal: true
 
-Gem::Specification.new do |s|
-  s.name = %q{shopify_api}
-  s.version = "1.0.4"
-
-  s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
-  s.authors = ["Tobias L\303\274tke", "Cody Fauser", "Dennis Theisen"]
-  s.date = %q{2010-01-28}
-  s.description = %q{= Shopify API
-
-The Shopify API gem allows Ruby developers to programmatically access the admin section of Shopify stores.
-
-The API is implemented as XML over HTTP using all four verbs (GET/POST/PUT/DELETE). Each resource, like Order, Product, or Collection, has its own URL and is manipulated in isolation. In other words, we’ve tried to make the API follow the REST principles as much as possible.
-
-
-== Usage
-
-=== Requirements
-
-All API usage happens through Shopify applications, created by either shop owners for their own shops, or by Shopify Partners for use by other shop owners:
-
-* Shop owners can create applications for themselves through their own admin (under the Preferences > Applications tab).
-* Shopify Partners create applications through their admin: http://app.shopify.com/services/partners 
-
-For more information and detailed documentation about the API visit http://api.shopify.com
-
-=== Getting Started
-
-ShopifyAPI uses ActiveResource to communicate with the REST web service. ActiveResource has to be configured with a fully authorized URL of a particular store first. To obtain that URL you can follow these steps:
-
-1. First create a new application in either the partners admin or your store admin and write down your API_KEY and SHARED_SECRET.
-
-2. You will need to supply two parameters to the Session class before you instantiate it:
-
-    ShopifyAPI::Session.setup({:api_key => API_KEY, :secret => SHARED_SECRET})
-
-3. Create a new Session for a specific shop. That session is not fully valid yet, but it can be used to create a URL that you will redirect your users to:
+$LOAD_PATH.push(File.expand_path("../lib", __FILE__))
+require "shopify_api/version"
 
-    session = ShopifyAPI::Session.new("yourshopname.myshopify.com")
-    session.valid?  # returns false
-
-4. To access the API shop owners need a "token" from that specific shop. In order to get this token they need to authorize with that shop first. The URL to redirect your user to can be generated via:
-
-    url = session.create_permission_url
-
-5. After visiting this URL, the shop redirects the owner to a custom URL of your application where the "token" gets sent to (it's param name is just "t"). Use that token to instantiate a "valid" session, that is ready to make calls to that particular shop.
-
-    token = params[:t]
-    session = ShopifyAPI::Session.new("yourshopname.myshopify.com", token)
-    session.valid?  # returns true
-
-6. Now you can finally get the fully authorized URL for that shop. Use that URL to configure ActiveResource and you're set:
-
-     ActiveResource::Base.site = session.site
-
-7. Get data from that shop (returns ActiveResource instances):
+Gem::Specification.new do |s|
+  s.name = "shopify_api"
+  s.version = ShopifyAPI::VERSION
+  s.author = "Shopify"
 
-     shop = ShopifyAPI::Shop.current
-     latest_orders = ShopifyAPI::Order.find(:all)
+  s.summary = "The gem for accessing the Shopify API"
+  s.description = <<~HERE
+    This gem allows Ruby developers to programmatically access the admin
+    section of Shopify stores.
+  HERE
+  s.email = "developers@shopify.com"
+  s.homepage = "https://shopify.dev/apps"
 
-== Copyright
+  s.metadata["allowed_push_host"] = "https://rubygems.org"
 
-Copyright (c) 2009 "JadedPixel inc.". See LICENSE for details.
-}
-  s.email = %q{developers@jadedpixel.com}
   s.extra_rdoc_files = [
     "LICENSE",
-     "README.rdoc"
-  ]
-  s.files = [
-    ".document",
-     ".gitignore",
-     "CHANGELOG",
-     "LICENSE",
-     "README.rdoc",
-     "Rakefile",
-     "VERSION",
-     "lib/shopify_api.rb",
-     "shopify_api.gemspec",
-     "test/order_test.rb",
-     "test/shopify_api_test.rb",
-     "test/test_helper.rb"
-  ]
-  s.homepage = %q{http://github.com/Shopify/shopify_api}
-  s.rdoc_options = ["--charset=UTF-8"]
-  s.require_paths = ["lib"]
-  s.rubyforge_project = %q{shopify-api}
-  s.rubygems_version = %q{1.3.5}
-  s.summary = %q{ShopifyAPI is a lightweight gem for accessing the Shopify admin REST web services}
-  s.test_files = [
-    "test/order_test.rb",
-     "test/shopify_api_test.rb",
-     "test/test_helper.rb"
+    "README.md",
   ]
+  s.files = Dir.chdir(File.expand_path("..", __FILE__)) do
+    %x(git ls-files -z).split("\x0").reject { |f| f.match(%r{^(test)/}) }
+  end
 
-  if s.respond_to? :specification_version then
-    current_version = Gem::Specification::CURRENT_SPECIFICATION_VERSION
-    s.specification_version = 3
+  s.rdoc_options = ["--charset=UTF-8"]
 
-    if Gem::Version.new(Gem::RubyGemsVersion) >= Gem::Version.new('1.2.0') then
-      s.add_runtime_dependency(%q<activeresource>, [">= 2.2.2"])
-    else
-      s.add_dependency(%q<activeresource>, [">= 2.2.2"])
-    end
-  else
-    s.add_dependency(%q<activeresource>, [">= 2.2.2"])
-  end
+  s.license = "MIT"
+
+  s.required_ruby_version = ">= 2.6"
+
+  s.add_runtime_dependency("activesupport")
+  s.add_runtime_dependency("concurrent-ruby")
+  s.add_runtime_dependency("hash_diff")
+  s.add_runtime_dependency("httparty")
+  s.add_runtime_dependency("jwt")
+  s.add_runtime_dependency("oj")
+  s.add_runtime_dependency("openssl")
+  s.add_runtime_dependency("securerandom")
+  s.add_runtime_dependency("sorbet-runtime")
+  s.add_runtime_dependency("zeitwerk", "~> 2.5", "< 2.6.5") # https://github.com/Shopify/shopify-api-ruby/issues/1058
+
+  s.add_development_dependency("pry-byebug")
+  s.add_development_dependency("rake")
+  s.add_development_dependency("rubocop")
+  s.add_development_dependency("rubocop-shopify")
+  s.add_development_dependency("rubocop-sorbet")
+  s.add_development_dependency("ruby-lsp")
+  s.add_development_dependency("sorbet")
+  s.add_development_dependency("tapioca")
 end
-

data/sorbet/config

@@ -0,0 +1,3 @@
+--dir
+.
+--ignore=test/rest