shopify_graphql 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: c5d57d24db5937afd5ca663c1302d3329df42217689189a6fdd352e7a2dc9a8c
+  data.tar.gz: 9800960c97b1f454fd4c7f820dee12290ded69a897492e5f573ef86e7d33b564
+SHA512:
+  metadata.gz: bfbc348ebd97d9945a9738b23eb1968d1fa76101e320255681229c6800cefbc9341c1d3ae62aed64a3fa3442fd602072d40a6ac77e76e2f5c051f7e37cef1aec
+  data.tar.gz: d487e89b766310f3f0496ec7de788efa0c215a69199153eb9b42c732774e0166f298e7e4763c7bd25ad63972b58810cf2d091a4d92cef44b1820d6fdf9d2b8cc

data/LICENSE.txt

@@ -0,0 +1,20 @@
+Copyright 2021 Kirill Platonov
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.md

@@ -0,0 +1,262 @@
+# Shopify Graphql
+
+Less painful way to work with [Shopify Graphql API](https://shopify.dev/api/admin/graphql/reference) in Ruby.
+
+> **This library is under active development. Breaking changes are likely until stable release.**
+
+## Features
+
+- Simple API for Graphql calls
+- Graphql webhooks integration
+- Built-in error handling
+- No schema and no memory issues
+- (Planned) Testing helpers
+- (Planned) Buil-in retry on error
+- (Planned) Pre-built calls for common Graphql operations
+
+## Usage
+
+### Making Graphql calls directly
+
+```ruby
+CREATE_WEBHOOK_MUTATION = <<~GRAPHQL
+  mutation($topic: WebhookSubscriptionTopic!, $webhookSubscription: WebhookSubscriptionInput!) {
+    webhookSubscriptionCreate(topic: $topic, webhookSubscription: $webhookSubscription) {
+      webhookSubscription {
+        id
+      }
+      userErrors {
+        field
+        message
+      }
+    }
+  }
+GRAPHQL
+
+response = ShopifyGraphql.execute(CREATE_WEBHOOK_MUTATION,
+  topic: "TOPIC",
+  webhookSubscription: { callbackUrl: "ADDRESS", format: "JSON" },
+)
+response = response.data.webhookSubscriptionCreate
+ShopifyGraphql.handle_user_errors(response)
+```
+
+### Creating wrappers for queries, mutations, and fields
+
+To isolate Graphql boilerplate you can create wrappers. To keep them organized use the following conventions:
+- Put them all into `app/graphql` folder
+- Use `Fields` suffix to name fields (eg `AppSubscriptionFields`)
+- Use `Get` prefix to name queries (eg `GetProducts` or `GetAppSubscription`)
+- Use imperative to name mutations (eg `CreateUsageSubscription` or `BulkUpdateVariants`)
+
+#### Example fields
+
+Definition:
+```ruby
+class AppSubscriptionFields
+  FRAGMENT = <<~GRAPHQL
+    fragment AppSubscriptionFields on AppSubscription {
+      id
+      name
+      status
+      trialDays
+      currentPeriodEnd
+      test
+      lineItems {
+        id
+        plan {
+          pricingDetails {
+            __typename
+            ... on AppRecurringPricing {
+              price {
+                amount
+              }
+              interval
+            }
+            ... on AppUsagePricing {
+              balanceUsed {
+                amount
+              }
+              cappedAmount {
+                amount
+              }
+              interval
+              terms
+            }
+          }
+        }
+      }
+    }
+  GRAPHQL
+
+  def self.parse(data)
+    recurring_line_item = data.lineItems.find { |i| i.plan.pricingDetails.__typename == "AppRecurringPricing" }
+    recurring_pricing = recurring_line_item&.plan&.pricingDetails
+    usage_line_item = data.lineItems.find { |i| i.plan.pricingDetails.__typename == "AppUsagePricing" }
+    usage_pricing = usage_line_item&.plan&.pricingDetails
+
+    OpenStruct.new(
+      id: data.id,
+      name: data.name,
+      status: data.status,
+      trial_days: data.trialDays,
+      current_period_end: data.currentPeriodEnd && Time.parse(data.currentPeriodEnd),
+      test: data.test,
+      recurring_line_item_id: recurring_line_item&.id,
+      recurring_price: recurring_pricing&.price&.amount&.to_d,
+      recurring_interval: recurring_pricing&.interval,
+      usage_line_item_id: usage_line_item&.id,
+      usage_balance: usage_pricing&.balanceUsed&.amount&.to_d,
+      usage_capped_amount: usage_pricing&.cappedAmount&.amount&.to_d,
+      usage_interval: usage_pricing&.interval,
+      usage_terms: usage_pricing&.terms,
+    )
+  end
+end
+```
+
+For usage examples see query and mutation below.
+
+#### Example query
+
+Definition:
+```ruby
+class GetAppSubscription
+  include ShopifyGraphql::Query
+
+  QUERY = <<~GRAPHQL
+    #{AppSubscriptionFields::FRAGMENT}
+    query($id: ID!) {
+      node(id: $id) {
+        ... AppSubscriptionFields
+      }
+    }
+  GRAPHQL
+
+  def call(id:)
+    response = execute(QUERY, id: id)
+    response.data = AppSubscriptionFields.parse(response.data.node)
+    response
+  end
+end
+```
+
+Usage:
+```ruby
+shopify_subscription = GetAppSubscription.call(id: @id).data
+shopify_subscription.status
+shopify_subscription.current_period_end
+```
+
+#### Example mutation
+
+Definition:
+```ruby
+class CreateRecurringSubscription
+  include ShopifyGraphql::Mutation
+
+  MUTATION = <<~GRAPHQL
+    #{AppSubscriptionFields::FRAGMENT}
+    mutation appSubscriptionCreate(
+      $name: String!,
+      $lineItems: [AppSubscriptionLineItemInput!]!,
+      $returnUrl: URL!,
+      $trialDays: Int,
+      $test: Boolean
+    ) {
+      appSubscriptionCreate(
+        name: $name,
+        lineItems: $lineItems,
+        returnUrl: $returnUrl,
+        trialDays: $trialDays,
+        test: $test
+      ) {
+        appSubscription {
+          ... AppSubscriptionFields
+        }
+        confirmationUrl
+        userErrors {
+          field
+          message
+        }
+      }
+    }
+  GRAPHQL
+
+  def call(name:, price:, return_url:, trial_days: nil, test: nil, interval: :monthly)
+    payload = { name: name, returnUrl: return_url }
+    plan_interval = (interval == :monthly) ? 'EVERY_30_DAYS' : 'ANNUAL'
+    payload[:lineItems] = [{
+      plan: {
+        appRecurringPricingDetails: {
+          price: { amount: price, currencyCode: 'USD' },
+          interval: plan_interval
+        }
+      }
+    }]
+    payload[:trialDays] = trial_days if trial_days
+    payload[:test] = test if test
+
+    response = execute(MUTATION, **payload)
+    response.data = response.data.appSubscriptionCreate
+    handle_user_errors(response.data)
+    response.data = parse_data(response.data)
+    response
+  end
+
+  private
+
+  def parse_data(data)
+    OpenStruct.new(
+      subscription: AppSubscriptionFields.parse(data.appSubscription),
+      confirmation_url: data.confirmationUrl,
+    )
+  end
+end
+```
+
+Usage:
+```ruby
+response = CreateRecurringSubscription.call(
+  name: "Plan Name",
+  price: 10,
+  return_url: "RETURN URL",
+  trial_days: 3,
+  test: true,
+).data
+confirmation_url = response.confirmation_url
+shopify_subscription = response.subscription
+```
+
+## Installation
+
+In Gemfile, add:
+```
+gem 'shopify_graphql', github: 'kirillplatonov/shopify_graphql', branch: 'main'
+```
+
+This gem relies on `shopify_app` for authentication so no extra setup is required. But you still need to wrap your Graphql calls with `shop.with_shopify_session`:
+```ruby
+shop.with_shopify_session do
+  # your calls to graphql
+end
+```
+
+The gem has built-in support for graphql webhooks (similar to `shopify_app`). To enable it add the following config to `config/initializers/shopify_app.rb`:
+```ruby
+ShopifyGraphql.configure do |config|
+  # Webhooks
+  webhooks_prefix = "https://#{Rails.configuration.app_host}/graphql_webhooks"
+  config.webhook_jobs_namespace = 'shopify/webhooks'
+  config.webhook_enabled_environments = ['production']
+  config.webhooks = [
+    { topic: 'SHOP_UPDATE', address: "#{webhooks_prefix}/shop_update" },
+    { topic: 'APP_SUBSCRIPTIONS_UPDATE', address: "#{webhooks_prefix}/app_subscriptions_update" },
+    { topic: 'APP_UNINSTALLED', address: "#{webhooks_prefix}/app_uninstalled" },
+  ]
+end
+```
+
+## License
+
+The gem is available as open source under the terms of the [MIT License](https://opensource.org/licenses/MIT).

data/app/controllers/shopify_graphql/graphql_webhooks_controller.rb

@@ -0,0 +1,35 @@
+module ShopifyGraphql
+  class MissingWebhookJobError < StandardError; end
+
+  class GraphqlWebhooksController < ActionController::Base
+    include ShopifyGraphql::WebhookVerification
+
+    def receive
+      params.permit!
+      webhook_job_klass.perform_later(shop_domain: shop_domain, webhook: webhook_params.to_h)
+      head(:ok)
+    end
+
+    private
+
+    def webhook_params
+      params.except(:controller, :action, :type)
+    end
+
+    def webhook_job_klass
+      webhook_job_klass_name.safe_constantize || raise(ShopifyGraphql::MissingWebhookJobError)
+    end
+
+    def webhook_job_klass_name(type = webhook_type)
+      [webhook_namespace, "#{type}_job"].compact.join('/').classify
+    end
+
+    def webhook_type
+      params[:type]
+    end
+
+    def webhook_namespace
+      ShopifyGraphql.configuration.webhook_jobs_namespace
+    end
+  end
+end

data/config/routes.rb

@@ -0,0 +1,5 @@
+ShopifyGraphql::Engine.routes.draw do
+  namespace :graphql_webhooks do
+    post ':type' => :receive
+  end
+end

data/lib/shopify_graphql/client.rb

@@ -0,0 +1,105 @@
+module ShopifyGraphql
+  class Client
+    def initialize(api_version = ShopifyAPI::Base.api_version)
+      @api_version = api_version
+    end
+
+    def execute(query, **variables)
+      operation_name = variables.delete(:operation_name)
+      response = connection.post do |req|
+        req.body = {
+          query: query,
+          operationName: operation_name,
+          variables: variables,
+        }.to_json
+      end
+      response = handle_response(response)
+      ShopifyGraphql::Response.new(response)
+    end
+
+    def api_url
+      [ShopifyAPI::Base.site, @api_version.construct_graphql_path].join
+    end
+
+    def request_headers
+      ShopifyAPI::Base.headers
+    end
+
+    def connection
+      @connection ||= Faraday.new(url: api_url, headers: request_headers) do |conn|
+        conn.request :json
+        conn.response :json, parser_options: { object_class: OpenStruct }
+      end
+    end
+
+    def handle_response(response)
+      case response.status
+      when 200..400
+        handle_graphql_errors(response.body)
+      when 400
+        raise BadRequest.new(response.body, code: response.status)
+      when 401
+        raise UnauthorizedAccess.new(response.body, code: response.status)
+      when 402
+        raise PaymentRequired.new(response.body, code: response.status)
+      when 403
+        raise ForbiddenAccess.new(response.body, code: response.status)
+      when 404
+        raise ResourceNotFound.new(response.body, code: response.status)
+      when 405
+        raise MethodNotAllowed.new(response.body, code: response.status)
+      when 409
+        raise ResourceConflict.new(response.body, code: response.status)
+      when 410
+        raise ResourceGone.new(response.body, code: response.status)
+      when 412
+        raise PreconditionFailed.new(response.body, code: response.status)
+      when 422
+        raise ResourceInvalid.new(response.body, code: response.status)
+      when 429
+        raise TooManyRequests.new(response.body, code: response.status)
+      when 401...500
+        raise ClientError.new(response.body, code: response.status)
+      when 500...600
+        raise ServerError.new(response.body, code: response.status)
+      else
+        raise ConnectionError.new(response.body, "Unknown response code: #{response.status}")
+      end
+    end
+
+    def handle_graphql_errors(response)
+      return response if response.errors.blank?
+
+      error = response.errors.first
+      error_message = error.message
+      error_code = error.extensions&.code
+      error_doc = error.extensions&.documentation
+
+      case error_code
+      when "THROTTLED"
+        raise TooManyRequests.new(response, error_message, code: error_code, doc: error_doc)
+      else
+        raise ConnectionError.new(response, error_message, code: error_code, doc: error_doc)
+      end
+    end
+
+    def handle_user_errors(response)
+      return response if response.userErrors.blank?
+
+      error = response.userErrors.first
+      error_message = error.message
+      error_fields = error.field
+      error_code = error.code
+
+      raise UserError.new(response, error_message, fields: error_fields, code: error_code)
+    end
+  end
+
+  class << self
+    delegate :execute, :handle_user_errors, to: :client
+
+    def client(api_version = ShopifyAPI::Base.api_version)
+      Client.new(api_version)
+    end
+  end
+end

data/lib/shopify_graphql/configuration.rb

@@ -0,0 +1,29 @@
+module ShopifyGraphql
+  class Configuration
+    attr_accessor :webhooks
+    attr_accessor :webhook_jobs_namespace
+    attr_accessor :webhook_enabled_environments
+    attr_accessor :webhooks_manager_queue_name
+
+    def initialize
+      @webhooks_manager_queue_name = Rails.application.config.active_job.queue_name
+      @webhook_enabled_environments = ['production']
+    end
+
+    def has_webhooks?
+      webhooks.present?
+    end
+  end
+
+  def self.configuration
+    @configuration ||= Configuration.new
+  end
+
+  def self.configuration=(config)
+    @configuration = config
+  end
+
+  def self.configure
+    yield configuration
+  end
+end

data/lib/shopify_graphql/controller_concerns/payload_verification.rb

@@ -0,0 +1,23 @@
+module ShopifyGraphql
+  module PayloadVerification
+    extend ActiveSupport::Concern
+
+    private
+
+    def shopify_hmac
+      request.headers['HTTP_X_SHOPIFY_HMAC_SHA256']
+    end
+
+    def hmac_valid?(data)
+      secrets = [ShopifyApp.configuration.secret, ShopifyApp.configuration.old_secret].reject(&:blank?)
+
+      secrets.any? do |secret|
+        digest = OpenSSL::Digest.new('sha256')
+        ActiveSupport::SecurityUtils.secure_compare(
+          shopify_hmac,
+          Base64.strict_encode64(OpenSSL::HMAC.digest(digest, secret, data))
+        )
+      end
+    end
+  end
+end

data/lib/shopify_graphql/controller_concerns/webhook_verification.rb

@@ -0,0 +1,22 @@
+module ShopifyGraphql
+  module WebhookVerification
+    extend ActiveSupport::Concern
+    include ShopifyGraphql::PayloadVerification
+
+    included do
+      skip_before_action :verify_authenticity_token, raise: false
+      before_action :verify_request
+    end
+
+    private
+
+    def verify_request
+      data = request.raw_post
+      return head(:unauthorized) unless hmac_valid?(data)
+    end
+
+    def shop_domain
+      request.headers['HTTP_X_SHOPIFY_SHOP_DOMAIN']
+    end
+  end
+end

data/lib/shopify_graphql/engine.rb

@@ -0,0 +1,32 @@
+module ShopifyGraphql
+  module RedactJobParams
+    private
+
+    def args_info(job)
+      log_disabled_classes = %[
+        ShopifyGraphql::CreateWebhooksJob
+        ShopifyGraphql::DestroyWebhooksJob
+        ShopifyGraphql::UpdateWebhooksJob
+      ]
+      return "" if log_disabled_classes.include?(job.class.name)
+      super
+    end
+  end
+
+  class Engine < ::Rails::Engine
+    engine_name 'shopify_graphql'
+    isolate_namespace ShopifyGraphql
+
+    initializer "shopify_app.redact_job_params" do
+      ActiveSupport.on_load(:active_job) do
+        if ActiveJob::Base.respond_to?(:log_arguments?)
+          CreateWebhooksJob.log_arguments = false
+          DestroyWebhooksJob.log_arguments = false
+          UpdateWebhooksJob.log_arguments = false
+        elsif ActiveJob::Logging::LogSubscriber.private_method_defined?(:args_info)
+          ActiveJob::Logging::LogSubscriber.prepend(RedactJobParams)
+        end
+      end
+    end
+  end
+end

data/lib/shopify_graphql/exceptions.rb

@@ -0,0 +1,74 @@
+module ShopifyGraphql
+  class ConnectionError < StandardError
+    attr_reader :response, :code, :doc, :fields
+
+    def initialize(response, message = nil, code: nil, doc: nil, fields: nil)
+      @response = response
+      @message = message
+      @code = code
+      @doc = doc
+      @fields = fields
+    end
+
+    def to_s
+      message = "Failed.".dup
+      message << " Response code = #{@code}." if @code
+      message << " Response message = #{@message}." if @message
+      message << " Documentation = #{@doc}." if @doc
+      message << " Fields = #{@fields}." if @fields
+      message
+    end
+  end
+
+  # 4xx Client Error
+  class ClientError < ConnectionError
+  end
+
+  # 400 Bad Request
+  class BadRequest < ClientError # :nodoc:
+  end
+
+  # 401 Unauthorized
+  class UnauthorizedAccess < ClientError # :nodoc:
+  end
+
+  # 402 Payment Required
+  class PaymentRequired < ClientError # :nodoc:
+  end
+
+  # 403 Forbidden
+  class ForbiddenAccess < ClientError # :nodoc:
+  end
+
+  # 404 Not Found
+  class ResourceNotFound < ClientError # :nodoc:
+  end
+
+  # 405 Method Not Allowed
+  class MethodNotAllowed < ClientError # :nodoc:
+  end
+
+  # 409 Conflict
+  class ResourceConflict < ClientError # :nodoc:
+  end
+
+  # 410 Gone
+  class ResourceGone < ClientError # :nodoc:
+  end
+
+  # 412 Precondition Failed
+  class PreconditionFailed < ClientError # :nodoc:
+  end
+
+  # 429 Too Many Requests
+  class TooManyRequests < ClientError # :nodoc:
+  end
+
+  # Graphql userErrors
+  class UserError < ClientError # :nodoc:
+  end
+
+  # 5xx Server Error
+  class ServerError < ConnectionError
+  end
+end

data/lib/shopify_graphql/jobs/create_webhooks_job.rb

@@ -0,0 +1,19 @@
+module ShopifyGraphql
+  class CreateWebhooksJob < ActiveJob::Base
+    queue_as do
+      ShopifyGraphql.configuration.webhooks_manager_queue_name
+    end
+
+    def perform(shop_domain:, shop_token:)
+      api_version = ShopifyApp.configuration.api_version
+      webhooks = ShopifyGraphql.configuration.webhooks
+
+      ShopifyAPI::Session.temp(domain: shop_domain, token: shop_token, api_version: api_version) do
+        manager = WebhooksManager.new(webhooks)
+        manager.create_webhooks
+      end
+    rescue UnauthorizedAccess, ResourceNotFound, ForbiddenAccess, PaymentRequired
+      # Ignore
+    end
+  end
+end

data/lib/shopify_graphql/jobs/destroy_webhooks_job.rb

@@ -0,0 +1,19 @@
+module ShopifyGraphql
+  class DestroyWebhooksJob < ActiveJob::Base
+    queue_as do
+      ShopifyGraphql.configuration.webhooks_manager_queue_name
+    end
+
+    def perform(shop_domain:, shop_token:)
+      api_version = ShopifyApp.configuration.api_version
+      webhooks = ShopifyGraphql.configuration.webhooks
+
+      ShopifyAPI::Session.temp(domain: shop_domain, token: shop_token, api_version: api_version) do
+        manager = WebhooksManager.new(webhooks)
+        manager.destroy_webhooks
+      end
+    rescue UnauthorizedAccess, ResourceNotFound, ForbiddenAccess, PaymentRequired
+      # Ignore
+    end
+  end
+end

data/lib/shopify_graphql/jobs/update_webhooks_job.rb

@@ -0,0 +1,19 @@
+module ShopifyGraphql
+  class UpdateWebhooksJob < ActiveJob::Base
+    queue_as do
+      ShopifyGraphql.configuration.webhooks_manager_queue_name
+    end
+
+    def perform(shop_domain:, shop_token:)
+      api_version = ShopifyApp.configuration.api_version
+      webhooks = ShopifyGraphql.configuration.webhooks
+
+      ShopifyAPI::Session.temp(domain: shop_domain, token: shop_token, api_version: api_version) do
+        manager = WebhooksManager.new(webhooks)
+        manager.recreate_webhooks!
+      end
+    rescue UnauthorizedAccess, ResourceNotFound, ForbiddenAccess, PaymentRequired
+      # Ignore
+    end
+  end
+end

data/lib/shopify_graphql/managers/webhooks_manager.rb

@@ -0,0 +1,85 @@
+module ShopifyGraphql
+  class WebhooksManager
+    class << self
+      def queue_create(shop_domain, shop_token)
+        ShopifyGraphql::CreateWebhooksJob.perform_later(
+          shop_domain: shop_domain,
+          shop_token: shop_token,
+        )
+      end
+
+      def queue_destroy(shop_domain, shop_token)
+        ShopifyGraphql::DestroyWebhooksJob.perform_later(
+          shop_domain: shop_domain,
+          shop_token: shop_token,
+        )
+      end
+
+      def queue_update(shop_domain, shop_token)
+        ShopifyGraphql::UpdateWebhooksJob.perform_later(
+          shop_domain: shop_domain,
+          shop_token: shop_token,
+        )
+      end
+    end
+
+    attr_reader :required_webhooks
+
+    def initialize(webhooks)
+      @required_webhooks = webhooks
+    end
+
+    def recreate_webhooks!
+      destroy_webhooks
+      create_webhooks
+    end
+
+    def create_webhooks
+      return unless webhooks_enabled?
+      return unless required_webhooks.present?
+
+      required_webhooks.each do |webhook|
+        create_webhook(webhook) unless webhook_exists?(webhook[:topic])
+      end
+    end
+
+    def destroy_webhooks
+      return unless webhooks_enabled?
+
+      current_webhooks.each do |webhook|
+        ShopifyGraphql::Webhook.delete(webhook.id)
+      end
+
+      @current_webhooks = nil
+    end
+
+    private
+
+    def webhooks_enabled?
+      if ShopifyGraphql.configuration.webhook_enabled_environments.include?(Rails.env)
+        true
+      else
+        Rails.logger.info("[ShopifyGraphql] Webhooks disabled in #{Rails.env} environment. Check you config.")
+        false
+      end
+    end
+
+    def create_webhook(attributes)
+      ShopifyGraphql::Webhook.create(
+        topic: attributes[:topic],
+        address: attributes[:address],
+        include_fields: attributes[:include_fields],
+      )
+    end
+
+    def webhook_exists?(topic)
+      current_webhooks.any? do |webhook|
+        webhook.topic == topic
+      end
+    end
+
+    def current_webhooks
+      @current_webhooks ||= ShopifyGraphql::Webhook.all
+    end
+  end
+end

data/lib/shopify_graphql/mutation.rb

@@ -0,0 +1,15 @@
+module ShopifyGraphql::Mutation
+  extend ActiveSupport::Concern
+
+  class_methods do
+    def call(**kwargs)
+      new.call(**kwargs)
+    end
+  end
+
+  delegate :execute, :handle_user_errors, to: :client
+
+  def client
+    @client ||= ShopifyGraphql::Client.new
+  end
+end

data/lib/shopify_graphql/query.rb

@@ -0,0 +1,15 @@
+module ShopifyGraphql::Query
+  extend ActiveSupport::Concern
+
+  class_methods do
+    def call(**kwargs)
+      new.call(**kwargs)
+    end
+  end
+
+  delegate :execute, :handle_user_errors, to: :client
+
+  def client
+    @client ||= ShopifyGraphql::Client.new
+  end
+end

data/lib/shopify_graphql/resource.rb

@@ -0,0 +1,13 @@
+module ShopifyGraphql
+  module Resource
+    extend ActiveSupport::Concern
+
+    class_methods do
+      delegate :execute, :handle_user_errors, to: :client
+
+      def client
+        ShopifyGraphql::Client.new
+      end
+    end
+  end
+end

data/lib/shopify_graphql/resources/shop.rb

@@ -0,0 +1,21 @@
+module ShopifyGraphql
+  class Shop
+    include Resource
+
+    class << self
+      def current
+        execute <<~GRAPHQL
+          query {
+            shop {
+              id
+              name
+              myshopifyDomain
+              description
+              plan { displayName }
+            }
+          }
+        GRAPHQL
+      end
+    end
+  end
+end

data/lib/shopify_graphql/resources/webhook.rb

@@ -0,0 +1,77 @@
+module ShopifyGraphql
+  class Webhook
+    include Resource
+
+    ALL_WEBHOOKS_QUERY = <<~GRAPHQL
+      query {
+        webhookSubscriptions(first: 250) {
+          edges {
+            node {
+              id
+              topic
+              endpoint {
+                ... on WebhookHttpEndpoint {
+                  callbackUrl
+                }
+              }
+            }
+          }
+        }
+      }
+    GRAPHQL
+
+    CREATE_WEBHOOK_MUTATION = <<~GRAPHQL
+      mutation($topic: WebhookSubscriptionTopic!, $webhookSubscription: WebhookSubscriptionInput!) {
+        webhookSubscriptionCreate(topic: $topic, webhookSubscription: $webhookSubscription) {
+          webhookSubscription {
+            id
+          }
+          userErrors {
+            field
+            message
+          }
+        }
+      }
+    GRAPHQL
+
+    DELETE_WEBHOOK_MUTATION = <<~GRAPHQL
+      mutation($id: ID!) {
+        webhookSubscriptionDelete(id: $id) {
+          deletedWebhookSubscriptionId
+          userErrors {
+            field
+            message
+          }
+        }
+      }
+    GRAPHQL
+
+    class << self
+      def all
+        response = execute(ALL_WEBHOOKS_QUERY)
+        response.data.webhookSubscriptions.edges.map do |edge|
+          edge.node
+        end
+      end
+
+      def create(topic:, address:, include_fields:)
+        response = execute(CREATE_WEBHOOK_MUTATION,
+          topic: topic,
+          webhookSubscription: {
+            callbackUrl: address,
+            format: 'JSON',
+            includeFields: include_fields,
+          },
+        )
+        response = response.data.webhookSubscriptionCreate
+        handle_user_errors(response)
+      end
+
+      def delete(id)
+        response = execute(DELETE_WEBHOOK_MUTATION, id: id)
+        response = response.data.webhookSubscriptionDelete
+        handle_user_errors(response)
+      end
+    end
+  end
+end

data/lib/shopify_graphql/response.rb

@@ -0,0 +1,29 @@
+module ShopifyGraphql
+  class Response
+    attr_reader :raw, :extensions, :errors
+    attr_accessor :data
+
+    def initialize(response)
+      @raw = response
+      @data = response.data
+      @extensions = response.extensions
+      @errors = response.errors
+    end
+
+    def points_left
+      extensions&.cost&.throttleStatus&.currentlyAvailable
+    end
+
+    def points_limit
+      extensions&.cost&.throttleStatus&.maximumAvailable
+    end
+
+    def points_restore_rate
+      extensions&.cost&.throttleStatus&.restoreRate
+    end
+
+    def points_maxed?(threshold: 0)
+      points_left < threshold
+    end
+  end
+end

data/lib/shopify_graphql/version.rb

@@ -0,0 +1,3 @@
+module ShopifyGraphql
+  VERSION = "0.1.0"
+end

data/lib/shopify_graphql.rb

@@ -0,0 +1,28 @@
+require 'faraday'
+require 'faraday_middleware'
+
+require 'shopify_graphql/client'
+require 'shopify_graphql/configuration'
+require 'shopify_graphql/engine'
+require 'shopify_graphql/exceptions'
+require 'shopify_graphql/mutation'
+require 'shopify_graphql/query'
+require 'shopify_graphql/resource'
+require 'shopify_graphql/response'
+require 'shopify_graphql/version'
+
+# controller concerns
+require 'shopify_graphql/controller_concerns/payload_verification'
+require 'shopify_graphql/controller_concerns/webhook_verification'
+
+# jobs
+require 'shopify_graphql/jobs/create_webhooks_job'
+require 'shopify_graphql/jobs/destroy_webhooks_job'
+require 'shopify_graphql/jobs/update_webhooks_job'
+
+# managers
+require 'shopify_graphql/managers/webhooks_manager'
+
+# resources
+require 'shopify_graphql/resources/shop'
+require 'shopify_graphql/resources/webhook'

data/lib/tasks/shopify_graphql_tasks.rake

@@ -0,0 +1,4 @@
+# desc "Explaining what the task does"
+# task :shopify_graphql do
+#   # Task goes here
+# end

metadata

@@ -0,0 +1,129 @@
+--- !ruby/object:Gem::Specification
+name: shopify_graphql
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Kirill Platonov
+autorequire:
+bindir: bin
+cert_chain: []
+date: 2021-10-02 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: rails
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 5.2.0
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: 7.0.0
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 5.2.0
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: 7.0.0
+- !ruby/object:Gem::Dependency
+  name: shopify_app
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">"
+      - !ruby/object:Gem::Version
+        version: '17.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">"
+      - !ruby/object:Gem::Version
+        version: '17.0'
+- !ruby/object:Gem::Dependency
+  name: faraday
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '1.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '1.0'
+- !ruby/object:Gem::Dependency
+  name: faraday_middleware
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+description:
+email:
+- mail@kirillplatonov.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- LICENSE.txt
+- README.md
+- app/controllers/shopify_graphql/graphql_webhooks_controller.rb
+- config/routes.rb
+- lib/shopify_graphql.rb
+- lib/shopify_graphql/client.rb
+- lib/shopify_graphql/configuration.rb
+- lib/shopify_graphql/controller_concerns/payload_verification.rb
+- lib/shopify_graphql/controller_concerns/webhook_verification.rb
+- lib/shopify_graphql/engine.rb
+- lib/shopify_graphql/exceptions.rb
+- lib/shopify_graphql/jobs/create_webhooks_job.rb
+- lib/shopify_graphql/jobs/destroy_webhooks_job.rb
+- lib/shopify_graphql/jobs/update_webhooks_job.rb
+- lib/shopify_graphql/managers/webhooks_manager.rb
+- lib/shopify_graphql/mutation.rb
+- lib/shopify_graphql/query.rb
+- lib/shopify_graphql/resource.rb
+- lib/shopify_graphql/resources/shop.rb
+- lib/shopify_graphql/resources/webhook.rb
+- lib/shopify_graphql/response.rb
+- lib/shopify_graphql/version.rb
+- lib/tasks/shopify_graphql_tasks.rake
+homepage: https://github.com/kirillplatonov/shopify_graphql
+licenses:
+- MIT
+metadata:
+  allowed_push_host: https://rubygems.org
+post_install_message:
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 2.7.0
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.2.22
+signing_key:
+specification_version: 4
+summary: Less painful way to work with Shopify Graphql API in Ruby.
+test_files: []