shopify-client 0.0.1

data/lib/shopify-client/cookieless/middleware.rb

@@ -0,0 +1,39 @@
+# frozen_string_literal: true
+
+require 'json'
+
+module ShopifyClient
+  module Cookieless
+    # Rack middleware implementing cookieless authentication with App Bridge
+    # session tokens.
+    #
+    # Returns a 401 response if a request is unauthorised.
+    class Middleware
+      # @param app [#call]
+      # @param is_authenticated [#call]
+      #   predicate for deciding when the request should be checked
+      def initialize(app, is_authenticated: ->(env) { true })
+        @app = app
+
+        @is_authenticated = is_authenticated
+      end
+
+      # @param env [Hash]
+      #
+      # @param [Array<Integer, Hash{String => String}, Array<String>]
+      def call(env)
+        CheckHeader.new.(env) if @is_authenticated.(env)
+
+        @app.call(env)
+      rescue UnauthorisedError
+        Rack::Response.new do |response|
+          response.status = 401
+          response.set_header('Content-Type', 'application/json')
+          response.write({
+            error: 'Invalid session token',
+          }.to_json)
+        end.to_a
+      end
+    end
+  end
+end

data/lib/shopify-client/create_all_webhooks.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+module ShopifyClient
+  class CreateAllWebhooks
+    # Create all registered webhooks for a shop.
+    #
+    # @param client [Client]
+    #
+    # @return [Array<Hash>] response data
+    def call(client)
+      create_webhook = CreateWebhook.new
+
+      ShopifyClient.webhooks.map do |topic|
+        Thread.new do
+          create_webhook.(client, {
+            topic: topic,
+            fields: topic[:fields],
+          })
+        end
+      end.map(&:value)
+    end
+  end
+end

data/lib/shopify-client/create_webhook.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+module ShopifyClient
+  class CreateWebhook
+    # @param client [Client]
+    # @param webhook [Hash]
+    # @option webhook [String] :topic
+    # @option webhook [Array<String>] :fields
+    #
+    # @return [Hash] response data
+    def call(client, webhook)
+      client.post_json(credentials, 'webhooks', webhook: webhook.merge(
+        address: ShopifyClient.config.webhook_uri,
+      ))
+    rescue Response::Error => e
+      raise e unless e.response.errors.message?([
+        /has already been taken/,
+      ])
+    end
+  end
+end

data/lib/shopify-client/delete_all_webhooks.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+module ShopifyClient
+  class DeleteAllWebhooks
+    # Delete any existing webhooks.
+    #
+    # @param client [Client]
+    #
+    # @return [Array<Hash>] response data
+    def call(client)
+      webhooks = client.get(credentials, 'webhooks')['webhooks']
+
+      delete_webhook = DeleteWebhook.new
+
+      webhooks.map do |webhook|
+        Thread.new do
+          delete_webhook.(client, webhook['id'])
+        end
+      end.map(&:value)
+    end
+  end
+end

data/lib/shopify-client/delete_webhook.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+module ShopifyClient
+  class DeleteWebhook
+    # @param client [Client]
+    # @param id [Integer]
+    #
+    # @return [Hash] response data
+    def call(client, id)
+      client.delete(credentials, "webhooks/#{id}")
+    end
+  end
+end

data/lib/shopify-client/error.rb

@@ -0,0 +1,9 @@
+# frozen_string_literal: true
+
+module ShopifyClient
+  # Subclass this class for all gem exceptions, so that callers may rescue
+  # any subclass with:
+  #
+  #     rescue ShopifyClient::Error => e
+  Error = Class.new(StandardError)
+end

data/lib/shopify-client/parse_link_header.rb

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+require 'addressable'
+
+module ShopifyClient
+  class ParseLinkHeader
+    # Parse a Link header into query params for each pagination link (e.g.
+    # :next, :previous).
+    #
+    # @param link_header [String]
+    #
+    # @return [Hash]
+    def call(link_header)
+      link_header.split(',').map do |link|
+        url, rel = link.split(';') # rel should be the first param
+        url = url[/<(.*)>/, 1]
+        rel = rel[/rel="?(\w+)"?/, 1]
+
+        [
+          rel.to_sym,
+          params(url),
+        ]
+      end.to_h
+    end
+
+    # @param url [String]
+    #
+    # @return [Hash]
+    private def params(url)
+      Addressable::URI.parse(url).query_values
+    end
+  end
+end

data/lib/shopify-client/request.rb

@@ -0,0 +1,40 @@
+# frozen_string_literal: true
+
+module ShopifyClient
+  # @!attribute [rw] myshopify_domain
+  #   @return [String]
+  # @!attribute [rw] access_token
+  #   @return [String, nil]
+  # @!attribute [rw] method
+  #   @return [Symbol]
+  # @!attribute [rw] path
+  #   @return [String]
+  # @!attribute [rw] params
+  #   @return [Hash]
+  # @!attribute [rw] headers
+  #   @return [Hash]
+  # @!attribute [rw] data
+  #   @return [Hash, nil]
+  # @!attribute [rw] client
+  #   @return [Client, nil]
+  Request = Struct.new(
+    :myshopify_domain,
+    :access_token,
+    :method,
+    :path,
+    :params,
+    :headers,
+    :data,
+    :client,
+  ) do
+    # @return [Boolean]
+    def graphql?
+      path == '/graphql.json'
+    end
+
+    # @return [String]
+    def inspect
+      "#<ShopifyClient::Request (#{myshopify_domain}#{path})>"
+    end
+  end
+end

data/lib/shopify-client/resource/base.rb

@@ -0,0 +1,46 @@
+# frozen_string_literal: true
+
+module ShopifyClient
+  module Resource
+    module Base
+      module ClassMethods
+        # Set the remote API resource name for the subclass. If a singular
+        # is not provided, the plural will be used, without any trailing 's'.
+        #
+        # @param resource_plural [String, #to_s]
+        # @param resource_singular [String, #to_s, nil]
+        #
+        # @example
+        #   resource :orders
+        #
+        # @example
+        #   resource :orders, :order
+        def resource(name_plural, name_singular = nil)
+          define_method(:resource_name) { name_plural.to_s }
+          define_method(:resource_name_singular) do
+            name_singular ? name_singular.to_s :  name_plural.to_s.sub(/s$/, '')
+          end
+        end
+      end
+
+      # @param base [Class]
+      def self.included(base)
+        base.extend(ClassMethods)
+      end
+
+      # @abstract Use {ClassMethods#resource} to implement (required)
+      #
+      # @return [String]
+      def resource_name
+        raise NotImplementedError
+      end
+
+      # @abstract Use {ClassMethods#resource} to implement (required)
+      #
+      # @return [String]
+      def resource_name_singular
+        raise NotImplementedError
+      end
+    end
+  end
+end

data/lib/shopify-client/resource/create.rb

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+module ShopifyClient
+  module Resource
+    module Create
+      # @param base [Class]
+      def self.included(base)
+        base.include(Base)
+      end
+
+      # @param client [Client]
+      # @param data [Hash]
+      #
+      # @return [Integer] the new result.id
+      def create(client, data)
+        result = client.post(resource_name, resource_name_singular => data).data[resource_name_singular]
+
+        result['id'].tap do |id|
+          ShopifyClient.config.logger({
+            source: 'shopify-client',
+            type: 'create',
+            info: {
+              resource: resource_name,
+              id: id,
+            },
+          }.to_json)
+        end
+      end
+    end
+  end
+end

data/lib/shopify-client/resource/delete.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+module ShopifyClient
+  module Resource
+    module Delete
+      # @param base [Class]
+      def self.included(base)
+        base.include(Base)
+      end
+
+      # @param client [Client]
+      # @param id [Integer]
+      def delete(client, id)
+        client.delete("#{resource_name}/#{id}")
+
+        ShopifyClient.config.logger({
+          source: 'shopify-client',
+          type: 'delete',
+          info: {
+            resource: resource_name,
+            id: id,
+          },
+        }.to_json)
+
+        nil
+      end
+    end
+  end
+end

data/lib/shopify-client/resource/read.rb

@@ -0,0 +1,80 @@
+# frozen_string_literal: true
+
+module ShopifyClient
+  module Resource
+    module Read
+      module ClassMethods
+        # Set the default query params. Note that 'fields' may be passed as an
+        # array of strings.
+        #
+        # @param params [Hash]
+        #
+        # @example
+        #   default_params fields: 'id,tags'
+        def default_params(params)
+          define_method(:default_params) { params }
+        end
+      end
+
+      # @param base [Class]
+      def self.included(base)
+        base.extend(ClassMethods)
+
+        base.include(Base)
+      end
+
+      # @abstract Use {ClassMethods#default_params} to implement (optional)
+      #
+      # @return [Hash]
+      def default_params
+        {}
+      end
+
+      # Find a single result.
+      #
+      # @param client [Client]
+      # @param id [Integer]
+      # @param params [Hash]
+      #
+      # @return [Hash]
+      def find_by_id(client, id, params = {})
+        params = default_params.merge(params)
+
+        client.get("#{resource_name}/#{id}", params).data[resource_name_singular]
+      end
+
+      # Find all results.
+      #
+      # @param client [Client]
+      # @param params [Hash]
+      #
+      # @return [Enumerator<Hash>]
+      #
+      # @raise [ArgumentError] if 'fields' does not include 'id'
+      def all(client, params = {})
+        raise ArgumentError, 'missing id field' unless has_id?(params)
+
+        Enumerator.new do |yielder|
+          response = client.get(resource_name, params)
+
+          loop do
+            response.data[resource_name].each { |result| yielder << result }
+
+            response = response.next_page || break
+          end
+        end
+      end
+
+      # @param params [Hash]
+      #
+      # @return [Boolean]
+      private def has_id?(params)
+        fields = params[:fields] || params['fields']
+
+        return true if fields.nil?
+
+        fields =~ /\bid\b/
+      end
+    end
+  end
+end

data/lib/shopify-client/resource/update.rb

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+module ShopifyClient
+  module Resource
+    module Update
+      # @param base [Class]
+      def self.included(base)
+        base.include(Base)
+      end
+
+      # @param client [Client]
+      # @param id [Integer]
+      # @param data [Hash]
+      def update(client, id, data)
+        client.put("#{resource_name}/#{id}", resource_name_singular => data)
+
+        ShopifyClient.config.logger({
+          source: 'shopify-client',
+          type: 'update',
+          info: {
+            resource: resource_name,
+            id: id,
+          },
+        }.to_json)
+
+        nil
+      end
+    end
+  end
+end

data/lib/shopify-client/response.rb

@@ -0,0 +1,201 @@
+# frozen_string_literal: true
+
+require 'addressable'
+
+module ShopifyClient
+  # @!attribute [rw] request
+  #   @return [Request]
+  # @!attribute [rw] status_code
+  #   @return [Integer]
+  # @!attribute [rw] headers
+  #   @return [Hash]
+  # @!attribute [rw] data
+  #   @return [Hash]
+  Response = Struct.new(:request, :status_code, :headers, :data)
+
+  # NOTE: Reopened for proper scoping of error classes.
+  class Response
+    class << self
+      # @param faraday_response [Faraday::Response]
+      # @param client [Client]
+      #
+      # @return [Response]
+      def from_faraday_response(faraday_response, client = nil)
+        uri = Addressable::URI.parse(faraday_response.env[:url])
+
+        new(
+          Request.new(
+            # Merchant myshopify.domain.
+            uri.host,
+            # Merchant access token.
+            faraday_response.env[:request_headers]['X-Shopify-Access-Token'],
+            # Request HTTP method.
+            faraday_response.env[:method],
+            # Request path.
+            uri.path,
+            # Request params.
+            uri.query_values,
+            # Request headers.
+            faraday_response.env[:request_headers],
+            # Request data.
+            faraday_response.env[:request_body],
+            # Client used for the request.
+            client,
+          ),
+          faraday_response.status,
+          faraday_response.headers,
+          faraday_response.body || {},
+        ).tap(&:assert!)
+      end
+    end
+
+    # @raise [ClientError] for status 4xx
+    # @raise [ServerError] for status 5xx
+    #
+    # @see https://shopify.dev/concepts/about-apis/response-codes
+    def assert!
+      case status_code
+      when 401
+        if errors.message?([/access token/i])
+          raise InvalidAccessTokenError.new(request, self), 'Invalid access token'
+        else
+          raise ClientError.new(request, self)
+        end
+      when 402
+        raise ShopError.new(request, self), 'Shop is frozen, awaiting payment'
+      when 403
+        # NOTE: Not sure what this one means (undocumented).
+        if errors.message?([/unavailable shop/i])
+          raise ShopError.new(request, self), 'Shop is unavailable'
+        else
+          raise ClientError.new(request, self)
+        end
+      when 423
+        raise ShopError.new(request, self), 'Shop is locked'
+      when 400..499
+        raise ClientError.new(request, self)
+      when 500..599
+        raise ServerError.new(request, self)
+      end
+
+      # GraphQL always has status 200.
+      if request.graphql? && (errors? || user_errors?)
+        raise GraphQLClientError.new(request, self)
+      end
+    end
+
+    # @return [Hash]
+    private def link
+      @link ||= ParseLinkHeader.new.(headers['Link'] || '')
+    end
+
+    # Request the next page for a GET request, if any.
+    #
+    # @param [Client]
+    #
+    # @return [Response, nil]
+    def next_page(client = request.client)
+      raise ArgumentError, 'missing client' if client.nil?
+
+      return nil unless link[:next]
+
+      client.get(request.path, link[:next])
+    end
+
+    # Request the next page for a GET request, if any.
+    #
+    # @param [Client]
+    #
+    # @return [Response, nil]
+    def previous_page(client = request.client)
+      raise ArgumentError, 'missing client' if client.nil?
+
+      return nil unless link[:previous]
+
+      client.get(request.path, link[:previous])
+    end
+
+    # Response errors (usually included with a 422 response).
+    #
+    # @return [ResponseErrors]
+    def errors
+      @errors ||= ResponseErrors.from_response_data(data)
+    end
+
+    # @return [Boolean]
+    def errors?
+      errors.any?
+    end
+
+    # GraphQL user errors (errors in mutation input).
+    #
+    # @return [ResponseUserErrors, nil]
+    def user_errors
+      return nil unless request.graphql?
+
+      @user_errors ||= ResponseUserErrors.from_response_data(data)
+    end
+
+    # @return [Boolean]
+    def user_errors?
+      return false unless request.graphql?
+
+      user_errors.any?
+    end
+
+    # @return [String]
+    def inspect
+      "#<ShopifyClient::Response (#{status_code}, #{request.inspect})>"
+    end
+  end
+
+  class Response
+    # @!attribute [r] request
+    #   @return [Request]
+    # @!attribute [r] response
+    #   @return [Response]
+    class Error < Error
+      # @param request [Request]
+      # @param response [Response]
+      def initialize(request, response)
+        @request = request
+        @response = response
+      end
+
+      attr_reader :request
+      attr_reader :response
+
+      # @return [String]
+      def message
+        if response.errors?
+          "bad response (#{response.status_code}): #{response.errors.messages.first}"
+        else
+          "bad response (#{response.status_code})"
+        end
+      end
+    end
+
+    # Client errors in the 4xx range.
+    ClientError = Class.new(Error)
+    # Server errors in the 5xx range.
+    ServerError = Class.new(Error)
+    # The access token was not accepted.
+    InvalidAccessTokenError = Class.new(ClientError)
+    # The shop is frozen/locked/unavailable.
+    ShopError = Class.new(ClientError)
+
+    # The GraphQL API always responds with a status code of 200.
+    GraphQLClientError = Class.new(ClientError) do
+      def message
+        case
+        when response.errors?
+          "bad response: #{response.errors.messages.first}"
+        when response.user_errors?
+          "bad response: #{response.user_errors.messages.first}"
+        else
+          "bad response"
+        end
+      end
+    end
+  end
+end