lucid_shopify 0.5.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: e4631f8c0d8631d94e42e0213c32c9e349c2f86648fd0816acb98595f8891b98
+  data.tar.gz: ce3b5019de9bd7b89bb20a01c6bc61ad23f5ea04290f752fdd8ac6121ff637fa
+SHA512:
+  metadata.gz: 793fed51a3be7594e48d4a6f2190d8651a30846e50bf13691e547618aa82358bb91b4824d47ca7987df02a15896fef864350db61e3e3c4ad616d920eb4400db0
+  data.tar.gz: bab3fdf7ae40219c614db5c76436392468d92ec766ccdf06773c31572a0b20995ccff7c5b8701cea5a366f22883e188294d1cadb9405ebaaf13f194fa3cd1dc2

data/README.md

@@ -0,0 +1,102 @@
+lucid_shopify
+=============
+
+Installation
+------------
+
+Add the following lines to your ‘Gemfile’:
+
+    git_source :lucid { |r| "https://github.com/lucidnz/gem-lucid_#{r}.git" }
+
+    gem 'lucid_shopify', lucid: 'shopify'
+
+
+Usage
+-----
+
+### Configure the default API client credentials
+
+    LucidShopify.credentials = LucidShopify::Credentials.new(
+      '...', # api_key
+      '...', # shared_secret
+      '...', # scope
+      '...', # billing_callback_uri
+      '...', # webhook_uri
+    )
+
+Alternatively, a credentials object may be passed as a keyword
+argument to any of the classes that make use of it.
+
+Additionally, each API request requires authorization:
+
+    request_credentials = LucidShopify::RequestCredentials.new(
+      '...', # myshopify_domain
+      '...', # access_token
+    )
+
+If the access token is omitted, the request will be unauthorized.
+This is only useful during the OAuth2 process.
+
+
+### Configure webhooks
+
+Configure each webhook the app will create (if any):
+
+    LucidShopify.webhooks << {topic: 'orders/create', fields: %w(id tags)}
+    LucidShopify.webhooks << {topic: '...', fields: %w(...)}
+
+
+### Register webhook handlers
+
+For each webhook, register one or more handlers:
+
+    delegate_webhooks = LucidShopify::DelegateWebhooks.default
+
+    delegate_webhooks.register('orders/create', OrdersCreateWebhook.new)
+
+See the inline method documentation for more detail.
+
+To call/delegate a webhook to its handler for processing, you will likely want
+to create a worker around something like this:
+
+    webhook = LucidShopify::Webhook.new(myshopify_domain, topic, data)
+
+    delegate_webhooks.(webhook)
+
+
+### Create and delete webhooks
+
+Create/delete all configured webhooks (see above):
+
+    webhooks = LucidShopify::Webhooks.new
+
+    webhooks.create_all(request_credentials)
+    webhooks.delete_all(request_credentials)
+
+Create/delete webhooks manually:
+
+    webhook = {topic: 'orders/create', fields: %w(id tags)}
+
+    webhooks.create(request_credentials, webhook)
+    webhooks.delete(request_credentials, webhook_id)
+
+
+### Verification
+
+Verify callback requests with the request params:
+
+    LucidShopify::Verify::Callback.new.(params_hash).success?
+
+Verify webhook requests with the request data and the HMAC header:
+
+    LucidShopify::Verify::Webhook.new.(data, hmac).success?
+
+
+### Authorization
+
+_TODO_
+
+
+### Make an API request
+
+_TODO_

data/lib/lucid_shopify.rb

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+# Primarily for Bundler.
+
+require 'lucid_shopify/activate_charge'
+require 'lucid_shopify/charge'
+require 'lucid_shopify/client'
+require 'lucid_shopify/create_charge'
+require 'lucid_shopify/credentials'
+require 'lucid_shopify/delegate_webhooks'
+require 'lucid_shopify/delete_request'
+require 'lucid_shopify/fetch_access_token'
+require 'lucid_shopify/get_request'
+require 'lucid_shopify/post_request'
+require 'lucid_shopify/put_request'
+require 'lucid_shopify/request_credentials'
+require 'lucid_shopify/request'
+require 'lucid_shopify/response'
+require 'lucid_shopify/result'
+require 'lucid_shopify/send_request'
+require 'lucid_shopify/send_throttled_request'
+require 'lucid_shopify/verify_callback'
+require 'lucid_shopify/verify_webhook'
+require 'lucid_shopify/version'
+require 'lucid_shopify/webhook'
+require 'lucid_shopify/webhooks'

data/lib/lucid_shopify/activate_charge.rb

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+require 'dry-initializer'
+
+require 'lucid_shopify/client'
+
+module LucidShopify
+  class ActivateCharge
+    extend Dry::Initializer
+
+    # @return [Client]
+    option :client, default: proc { Client.new }
+
+    #
+    # Activate a recurring application charge.
+    #
+    # @param request_credentials [RequestCredentials]
+    # @param charge [Hash, #to_h] an accepted charge received from Shopify via callback
+    #
+    # @return [Hash] the active charge
+    #
+    def call(request_credentials, charge)
+      data = client.post_json(request_credentials, "recurring_application_charges/#{charge_id}/activate", charge.to_h)
+
+      data['recurring_application_charge']
+    end
+  end
+end

data/lib/lucid_shopify/charge.rb

@@ -0,0 +1,53 @@
+# frozen_string_literal: true
+
+require 'dry-initializer'
+
+require 'lucid_shopify/credentials'
+
+module LucidShopify
+  #
+  # Provides a convenient way to build the charge hash for {CreateCharge}.
+  #
+  class Charge
+    extend Dry::Initializer
+
+    # @return [String]
+    param :plan_name
+    # @return [Integer]
+    param :price
+    # @return [Integer] requires price_terms
+    option :price_cap, optional: true
+    # @return [String] requires price_cap
+    option :price_terms, optional: true
+    # @return [Boolean] is this a test charge?
+    option :test, default: proc { false }
+    # @return [Integer]
+    option :trial_days, default: proc { 7 }
+    # @return [Credentials]
+    option :credentials, default: proc { LucidShopify.credentials }
+
+    #
+    # Map to the Shopify API structure.
+    #
+    # @return [Hash]
+    #
+    def to_h
+      {}.tap do |hash|
+        hash[:name] = plan_name
+        hash[:price] = price
+        hash[:capped_amount] = price_cap if usage_based_billing?
+        hash[:terms] = price_terms if usage_based_billing?
+        hash[:return_url] = credentials.billing_callback_uri
+        hash[:test] = test if test
+        hash[:trial_days] = trial_days if trial_days
+      end
+    end
+
+    #
+    # @return [Boolean]
+    #
+    private def usage_based_billing?
+      price_cap && price_terms
+    end
+  end
+end

data/lib/lucid_shopify/client.rb

@@ -0,0 +1,49 @@
+# frozen_string_literal: true
+
+require 'lucid_shopify/send_request'
+
+%w(delete get post put).each do |method|
+  require "lucid_shopify/#{method}_request"
+end
+
+module LucidShopify
+  class Client
+    #
+    # @param send_request [SendRequest]
+    #
+    def initialize(send_request: SendRequest.new)
+      @send_request = send_request
+    end
+
+    # @return [SendRequest]
+    attr_reader :send_request
+
+    #
+    # @see {DeleteRequest#initialize}
+    #
+    def delete(*args)
+      send_request.(DeleteRequest.new(*args))
+    end
+
+    #
+    # @see {GetRequest#initialize}
+    #
+    def get(*args)
+      send_request.(GetRequest.new(*args))
+    end
+
+    #
+    # @see {PostRequest#initialize}
+    #
+    def post_json(*args)
+      send_request.(PostRequest.new(*args))
+    end
+
+    #
+    # @see {PutRequest#initialize}
+    #
+    def put_json(*args)
+      send_request.(PutRequest.new(*args))
+    end
+  end
+end

data/lib/lucid_shopify/create_charge.rb

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+require 'dry-initializer'
+
+require 'lucid_shopify/client'
+
+module LucidShopify
+  class CreateCharge
+    extend Dry::Initializer
+
+    # @return [Client]
+    option :client, default: proc { Client.new }
+
+    #
+    # Create a new recurring application charge.
+    #
+    # @param request_credentials [RequestCredentials]
+    # @param charge [Hash, #to_h]
+    #
+    # @return [Hash] the pending charge
+    #
+    def call(request_credentials, charge)
+      data = client.post_json(request_credentials, 'recurring_application_charge', charge.to_h)
+
+      data['recurring_application_charge']
+    end
+  end
+end

data/lib/lucid_shopify/credentials.rb

@@ -0,0 +1,42 @@
+# frozen_string_literal: true
+
+require 'dry-initializer'
+
+module LucidShopify
+  MissingCredentialsError = Class.new(StandardError)
+
+  class Credentials
+    extend Dry::Initializer
+
+    # @return [String]
+    param :api_key
+    # @return [String]
+    param :shared_secret
+    # @return [String]
+    param :scope
+    # @return [String]
+    param :billing_callback_uri
+    # @return [String]
+    param :webhook_uri
+  end
+end
+
+class << LucidShopify
+  #
+  # Assign default API credentials.
+  #
+  # @param credentials [LucidShopify::Credentials]
+  #
+  attr_writer :credentials
+
+  #
+  # @return [LucidShopify::Credentials]
+  #
+  # @raise [LucidShopify::MissingCredentialsError] if credentials are unset
+  #
+  def credentials
+    raise MissingCredentialsError unless @credentials
+
+    @credentials
+  end
+end

data/lib/lucid_shopify/delegate_webhooks.rb

@@ -0,0 +1,43 @@
+# frozen_string_literal: true
+
+module LucidShopify
+  class DelegateWebhooks
+    class << self
+      #
+      # @return [DelegateWebhooks]
+      #
+      def default
+        @default ||= new
+      end
+    end
+
+    def initialize
+      @handlers = {}
+    end
+
+    # @return [Hash<String, Array<#call>>]
+    attr_reader :handlers
+
+    #
+    # Call each of the handlers registered for the given topic in turn. See
+    # {#register} below for more on webhook handlers.
+    #
+    # @param webhook [LucidShopify::Webhook]
+    #
+    def call(webhook)
+      handlers[webhook.topic]&.each { |handler| handler.(webhook) }
+    end
+
+    #
+    # Register a handler for a webhook topic. The callable handler will be
+    # called with the argument passed to {#call}.
+    #
+    # @param topic [String] e.g. 'orders/create'
+    # @param handler [#call]
+    #
+    def register(topic, handler)
+      handlers[topic] ||= []
+      handlers[topic] << handler
+    end
+  end
+end

data/lib/lucid_shopify/delete_request.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+require 'lucid_shopify/request'
+
+module LucidShopify
+  class DeleteRequest < Request
+    #
+    # @param credentials [RequestCredentials]
+    # @param path [String] the endpoint relative to the base URL
+    #
+    def initialize(credentials, path)
+      super(credentials, :delete, path)
+    end
+  end
+end

data/lib/lucid_shopify/fetch_access_token.rb

@@ -0,0 +1,50 @@
+# frozen_string_literal: true
+
+require 'dry-initializer'
+
+require 'lucid_shopify/client'
+
+module LucidShopify
+  class FetchAccessToken
+    Error = Class.new(StandardError)
+
+    extend Dry::Initializer
+
+    # @return [Client]
+    option :client, default: proc { Client.new }
+    # @return [Credentials]
+    option :credentials, default: proc { LucidShopify.credentials }
+
+    #
+    # Exchange an authorization code for a new Shopify access token.
+    #
+    # @param request_credentials [RequestCredentials]
+    # @param authorization_code [String]
+    #
+    # @return [String] the access token
+    #
+    # @raise [Error] if the response is invalid
+    #
+    def call(request_credentials, authorization_code)
+      data = client.post_json(request_credentials, 'oauth/access_token', post_data(authorization_code))
+
+      raise Error if data['access_token'].nil?
+      raise Error if data['scope'] != credentials.scope
+
+      data['access_token']
+    end
+
+    #
+    # @param authorization_code [String]
+    #
+    # @return [Hash]
+    #
+    private def post_data(authorization_code)
+      {
+        client_id: credentials.api_key,
+        client_secret: credentials.shared_secret,
+        code: authorization_code,
+      }
+    end
+  end
+end

data/lib/lucid_shopify/get_request.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+require 'lucid_shopify/request'
+
+module LucidShopify
+  class GetRequest < Request
+    #
+    # @param credentials [RequestCredentials]
+    # @param path [String] the endpoint relative to the base URL
+    # @param params [Hash] the query params
+    #
+    def initialize(credentials, path, params = {})
+      super(credentials, :get, path, params: params)
+    end
+  end
+end

data/lib/lucid_shopify/post_request.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+require 'lucid_shopify/request'
+
+module LucidShopify
+  class PostRequest < Request
+    #
+    # @param credentials [RequestCredentials]
+    # @param path [String] the endpoint relative to the base URL
+    # @param json [Hash] the JSON request body
+    #
+    def initialize(credentials, path, json)
+      super(credentials, :post, path, json: json)
+    end
+  end
+end

data/lib/lucid_shopify/put_request.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+require 'lucid_shopify/request'
+
+module LucidShopify
+  class PutRequest < Request
+    #
+    # @param credentials [RequestCredentials]
+    # @param path [String] the endpoint relative to the base URL
+    # @param json [Hash] the JSON request body
+    #
+    def initialize(credentials, path, json)
+      super(credentials, :put, path, json: json)
+    end
+  end
+end

data/lib/lucid_shopify/request.rb

@@ -0,0 +1,50 @@
+# frozen_string_literal: true
+
+require 'dry-initializer'
+
+module LucidShopify
+  #
+  # @abstract
+  #
+  class Request
+    extend Dry::Initializer
+
+    # @return [RequestCredentials]
+    param :credentials
+    # @return [Symbol]
+    param :http_method
+    # @return [String] the endpoint relative to the base URL
+    param :path, reader: :private
+    # @return [Hash]
+    param :options, default: proc { {} }
+
+    # @return [Hash]
+    param :http_headers, default: proc { build_headers }
+    # @return [String]
+    param :url, default: proc { build_url }
+
+    #
+    # @return [String]
+    #
+    private def build_url
+      admin_url = "https://#{credentials.myshopify_domain}/admin"
+
+      path = path.sub(/^\//, '')
+      path = path.sub(/\.json$/, '')
+
+      admin_url + '/' + path + '.json'
+    end
+
+    #
+    # @return [Hash]
+    #
+    private def build_headers
+      access_token = credentials.access_token
+
+      {}.tap do |headers|
+        headers['Accept'] = 'application/json'
+        headers['X-Shopify-Access-token'] = access_token if access_token
+      end
+    end
+  end
+end

data/lib/lucid_shopify/request_credentials.rb

@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+
+require 'dry-initializer'
+
+module LucidShopify
+  class RequestCredentials
+    extend Dry::Initializer
+
+    # @return [String]
+    param :myshopify_domain
+    # @return [String, nil] if {nil}, request will be unauthorized
+    param :access_token, optional: true
+  end
+end

data/lib/lucid_shopify/response.rb

@@ -0,0 +1,113 @@
+# frozen_string_literal: true
+
+require 'dry-initializer'
+require 'json'
+
+module LucidShopify
+  class Response
+    #
+    # @abstract
+    #
+    class Error < StandardError
+      extend Dry::Initializer
+
+      # @return [Request]
+      param :request
+      # @return [Response]
+      param :response
+
+      #
+      # @return [String]
+      #
+      def message
+        "bad response (#{response.status_code})"
+      end
+    end
+
+    ClientError = Class.new(Error)
+    ServerError = Class.new(Error)
+
+    extend Dry::Initializer
+
+    # @return [Request] the original request
+    param :request
+    # @return [Integer]
+    param :status_code
+    # @return [Hash]
+    param :headers
+    # @return [String]
+    param :data
+    # @return [Hash] the parsed response body
+    param :data_hash, default: proc { parse_data }
+
+    #
+    # @return [Hash]
+    #
+    private def parse_data
+      return {} unless json?
+
+      JSON.parse(data)
+    end
+    # private def parse_data(data)
+    #   JSON.parse(data)
+    # rescue JSON::ParserError
+    #   {}
+    # end
+
+    #
+    # @return [Boolean]
+    #
+    private def json?
+      headers['Content-Type'] =~ /application\/json/
+    end
+
+    #
+    # @return [String]
+    #
+    # @see {#assert!}
+    #
+    def data!
+      assert!.data
+    end
+
+    #
+    # @return [Hash] the parsed response body
+    #
+    # @see {#assert!}
+    #
+    def data_hash!
+      assert!.data_hash
+    end
+
+    #
+    # @raise [ClientError] for status 4xx
+    # @raise [ServerError] for status 5xx
+    #
+    # @return [self]
+    #
+    def assert!
+      case status_code
+      when 400..499
+        raise ClientError.new(request, self)
+      when 500..599
+        raise ServerError.new(request, self)
+      end
+
+      self
+    end
+
+    #
+    # @return [Boolean]
+    #
+    def success?
+      status_code.between?(200, 299)
+    end
+
+    #
+    # @return [Boolean]
+    #
+    def failure?
+      !success?
+    end
+  end
+end

data/lib/lucid_shopify/result.rb

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+module LucidShopify
+  class Result
+    #
+    # @param value [Object]
+    # @param error [Object]
+    #
+    def initialize(value, error = nil)
+      @value = value
+      @error = error
+    end
+
+    # @return [Object]
+    attr_reader :value
+    # @return [Object]
+    attr_reader :error
+
+    #
+    # @return [Boolean]
+    #
+    def success?
+      error.nil?
+    end
+
+    #
+    # @return [Boolean]
+    #
+    def failure?
+      !success?
+    end
+  end
+end

data/lib/lucid_shopify/send_request.rb

@@ -0,0 +1,64 @@
+# frozen_string_literal: true
+
+require 'dry-initializer'
+require 'http'
+
+require 'lucid_shopify/response'
+
+module LucidShopify
+  class SendRequest
+    class NetworkError < StandardError
+      extend Dry::Initializer
+
+      # @return [HTTP::Error]
+      param :original_exception
+    end
+
+    #
+    # @param request [Request]
+    # @param attempts [Integer] additional request attempts on client error
+    #
+    # @return [Hash] the parsed response body
+    #
+    # @raise [NetworkError] if the request failed all attempts
+    # @raise [Response::ClientError] for status 4xx
+    # @raise [Response::ServerError] for status 5xx
+    #
+    def call(request, attempts = default_attempts)
+      req = request
+      res = send(req.http_method, req.url, req.options)
+      res = Response.new(req, res.code, res.headers.to_h, res.to_s)
+
+      res.data_hash!
+    rescue *http_network_errors => e
+      raise NetworkError.new(e), e.message if attempts.zero?
+
+      call(request, attempts - 1)
+    end
+
+    #
+    # @return [HTTP::Response]
+    #
+    private def send(http_method, url, options)
+      HTTP.headers(request.headers).__send__(http_method, url, options)
+    end
+
+    #
+    # @return [Integer]
+    #
+    private def default_attempts
+      3
+    end
+
+    #
+    # @return [Array<Class>]
+    #
+    private def http_network_errors
+      [
+        HTTP::ConnectionError,
+        HTTP::ResponseError,
+        HTTP::TimeoutError,
+      ]
+    end
+  end
+end

data/lib/lucid_shopify/send_throttled_request.rb

@@ -0,0 +1,50 @@
+# frozen_string_literal: true
+
+require 'lucid_shopify/send_request'
+
+module LucidShopify
+  class SendThrottledRequest < SendRequest
+    MINIMUM_INTERVAL = 500 # ms
+
+    #
+    # @see {SendRequest#call}
+    #
+    private def call(*)
+      interval
+
+      super
+    end
+
+    #
+    # Sleep for the difference if time since the last request is less than the
+    # MINIMUM_INTERVAL.
+    #
+    # @note Throttling is only maintained across a single thread.
+    #
+    private def interval
+      if Thread.current[interval_key]
+        (timestamp - Thread.current[interval_key]).tap do |n|
+          sleep(Rational(n, 1000)) if n < MINIMUM_INTERVAL
+        end
+      end
+
+      Thread.current[interval_key] = timestamp
+    end
+
+    #
+    # @return [String]
+    #
+    private def interval_key
+      '%s[%s].timestamp' % [self.class, request.credentials.myshopify_domain]
+    end
+
+    #
+    # Time in milliseconds since the UNIX epoch.
+    #
+    # @return [Integer]
+    #
+    private def timestamp
+      (Time.now.to_f * 1000).to_i
+    end
+  end
+end

data/lib/lucid_shopify/verify_callback.rb

@@ -0,0 +1,70 @@
+# frozen_string_literal: true
+
+require 'openssl'
+
+require 'lucid_shopify/credentials'
+require 'lucid_shopify/result'
+
+module LucidShopify
+  class VerifyCallback
+    #
+    # @param credentials [LucidShopify::Credentials]
+    #
+    def initialize(credentials: LucidShopify.credentials)
+      @credentials = credentials
+    end
+
+    # @return [LucidShopify::Credentials]
+    attr_reader :credentials
+
+    #
+    # Verify that the callback request originated from Shopify.
+    #
+    # @param params_hash [Hash] the request params
+    #
+    # @return [Result]
+    #
+    def call(params_hash)
+      digest = OpenSSL::Digest::SHA256.new
+      digest = OpenSSL::HMAC.hexdigest(digest, credentials.shared_secret, encoded_params(params_hash))
+      result = digest == params_hash[:hmac]
+
+      Result.new(result, result ? nil : 'invalid request')
+    end
+
+    #
+    # @param params_hash [Hash]
+    #
+    # @return [String]
+    #
+    private def encoded_params(params_hash)
+      params_hash.reject do |k, _|
+        k == :hmac
+      end.map do |k, v|
+        encode_key(k) + '=' + encode_value(v)
+      end.join('&')
+    end
+
+    #
+    # @param k [String, Symbol]
+    #
+    # @return [String]
+    #
+    private def encode_key(k)
+      k.to_s.gsub(/./) do |chr|
+        {'%' => '%25', '&' => '%26', '=' => '%3D'}[chr] || chr
+      end
+    end
+
+    #
+    # @param v [String]
+    #
+    # @return [String]
+    #
+    private def encode_value(v)
+      v.gsub(/./) do |chr|
+        {'%' => '%25', '&' => '%26'}[chr] || chr
+      end
+    end
+  end
+end

data/lib/lucid_shopify/verify_webhook.rb

@@ -0,0 +1,40 @@
+# frozen_string_literal: true
+
+require 'base64'
+require 'openssl'
+
+require 'lucid_shopify/credentials'
+require 'lucid_shopify/result'
+
+module LucidShopify
+  class VerifyWebhook
+    Error = Class.new(StandardError)
+
+    #
+    # @param credentials [LucidShopify::Credentials]
+    #
+    def initialize(credentials: LucidShopify.credentials)
+      @credentials = credentials
+    end
+
+    # @return [LucidShopify::Credentials]
+    attr_reader :credentials
+
+    #
+    # Verify that the webhook request originated from Shopify.
+    #
+    # @param data [String] the signed request data
+    # @param hmac [String] the signature
+    #
+    # @return [Result]
+    #
+    def call(data, hmac)
+      digest = OpenSSL::Digest::SHA256.new
+      digest = OpenSSL::HMAC.digest(digest, credentials.shared_secret, data)
+      digest = Base64.encode64(digest).strip
+      result = digest == hmac
+
+      Result.new(result, result ? nil : 'invalid request')
+    end
+  end
+end

data/lib/lucid_shopify/version.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+module LucidShopify
+  VERSION = '0.5.1'
+end

data/lib/lucid_shopify/webhook.rb

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+require 'dry-initializer'
+require 'json'
+
+module LucidShopify
+  class Webhook
+    extend Dry::Initializer
+
+    # @return [String]
+    param :myshopify_domain
+    # @return [String]
+    param :topic
+    # @return [String]
+    param :data
+    # @return [Hash] the parsed request body
+    param :data_hash, default: proc { parse_data }
+
+    #
+    # @return [Hash]
+    #
+    private def parse_data
+      JSON.parse(data)
+    rescue JSON::ParserError
+      {}
+    end
+  end
+end

data/lib/lucid_shopify/webhooks.rb

@@ -0,0 +1,82 @@
+# frozen_string_literal: true
+
+require 'dry-initializer'
+
+require 'lucid_shopify/client'
+require 'lucid_shopify/credentials'
+
+module LucidShopify
+  class Webhooks
+    extend Dry::Initializer
+
+    # @return [Client]
+    option :client, default: proc { Client.new }
+    # @return [Credentials]
+    option :credentials, default: proc { LucidShopify.credentials }
+
+    #
+    # Delete any existing webhooks, then (re)create all webhooks for the shop.
+    #
+    # @param request_credentials [RequestCredentials]
+    #
+    def create_all(request_credentials)
+      delete_all
+
+      LucidShopify.webhooks.map do |webhook|
+        Thread.new { create(request_credentials, webhook) }
+      end.map(&:value)
+    end
+
+    #
+    # Create a webhook.
+    #
+    # @param request_credentials [RequestCredentials]
+    # @param webhook [Hash]
+    #
+    def create(request_credentials, webhook)
+      data = {}
+      data[:address] = credentials.webhook_uri
+      data[:fields] = webhook[:fields] if webhook[:fields]
+      data[:topic] = webhook[:topic]
+
+      client.post_json(request_credentials, 'webhooks', webhook: data)
+    end
+
+    #
+    # Delete any existing webhooks.
+    #
+    # @param request_credentials [RequestCredentials]
+    #
+    def delete_all(request_credentials)
+      webhooks = client.get('webhooks')['webhooks']
+
+      webhooks.map do |webhook|
+        Thread.new { delete(request_credentials, webhook['id']) }
+      end.map(&:value)
+    end
+
+    #
+    # Delete a webhook.
+    #
+    # @param request_credentials [RequestCredentials]
+    # @param id [Integer]
+    #
+    def delete(request_credentials, id)
+      client.delete(request_credentials, "webhooks/#{id}")
+    end
+  end
+end
+
+class << LucidShopify
+  #
+  # Webhooks created for each shop.
+  #
+  # @return [Array<Hash>]
+  #
+  # @example
+  #   LucidShopify.webhooks << {topic: 'orders/create', fields: %w(id)}
+  #
+  def webhooks
+    @webhooks ||= []
+  end
+end

metadata

@@ -0,0 +1,123 @@
+--- !ruby/object:Gem::Specification
+name: lucid_shopify
+version: !ruby/object:Gem::Version
+  version: 0.5.1
+platform: ruby
+authors:
+- Kelsey Judson
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2018-03-02 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.6'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.6'
+- !ruby/object:Gem::Dependency
+  name: rubocop
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.52.0
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.52.0
+- !ruby/object:Gem::Dependency
+  name: dry-initializer
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.4'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.4'
+- !ruby/object:Gem::Dependency
+  name: http
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.0'
+description: 
+email: kelsey@lucid.nz
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- README.md
+- lib/lucid_shopify.rb
+- lib/lucid_shopify/activate_charge.rb
+- lib/lucid_shopify/charge.rb
+- lib/lucid_shopify/client.rb
+- lib/lucid_shopify/create_charge.rb
+- lib/lucid_shopify/credentials.rb
+- lib/lucid_shopify/delegate_webhooks.rb
+- lib/lucid_shopify/delete_request.rb
+- lib/lucid_shopify/fetch_access_token.rb
+- lib/lucid_shopify/get_request.rb
+- lib/lucid_shopify/post_request.rb
+- lib/lucid_shopify/put_request.rb
+- lib/lucid_shopify/request.rb
+- lib/lucid_shopify/request_credentials.rb
+- lib/lucid_shopify/response.rb
+- lib/lucid_shopify/result.rb
+- lib/lucid_shopify/send_request.rb
+- lib/lucid_shopify/send_throttled_request.rb
+- lib/lucid_shopify/verify_callback.rb
+- lib/lucid_shopify/verify_webhook.rb
+- lib/lucid_shopify/version.rb
+- lib/lucid_shopify/webhook.rb
+- lib/lucid_shopify/webhooks.rb
+homepage: https://github.com/lucidnz/gem-lucid_shopify
+licenses:
+- ISC
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.7.3
+signing_key: 
+specification_version: 4
+summary: Shopify client library
+test_files: []