shopify_graphql 0.4.2 → 1.1.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: e5c044ffb73a80d80b528b5fa0db311615bce5b39b26fb6c84bbd2fba9a76678
-  data.tar.gz: 8fc1cb0cf055ed4e847dd51fce8d4d52d29db89308e48e930817c8a881c6132c
+  metadata.gz: ae1e8d2f4d571b2b213c2a16b4119aa5067f4eaca441db0893b80cff71b0bde7
+  data.tar.gz: 7246d23c32915ef20166202cf920f811631dd9a47c922bc207eeba7706d85f44
 SHA512:
-  metadata.gz: 1d8e8c1aff9b0517c5ebab5cbe938f87f0040fff6a26a31212b123fdafbe56717442d01d9104cff79fc003a90f762e69f2721f2f55fceb459d600f1a72dfbd22
-  data.tar.gz: c33b10f631685e8031479f90778bef818cd5681767d9043e96ffe050730af3089066f713b78895f95968edc3562eaa049a2dd9c9ef760fb9731327408a63fa29
+  metadata.gz: 744a08c3749b3083d5a3f7214a639102a2fa6a6a817bc416e5ae7688064f797a182555ab0965abaca75353a82464c2e124274585216f3df75665a8511ea37fb6
+  data.tar.gz: aad5f84d8c809cb208d455d4cbf1d25024f254febb3582469b8a65886d357a247f23f94821fc93333767d72bff6dc5cecde57bb87173ae580d8a22bcdd496d58

data/README.md

@@ -1,254 +1,759 @@
 # Shopify Graphql
 
-Less painful way to work with [Shopify Graphql API](https://shopify.dev/api/admin/graphql/reference) in Ruby.
-
-> **NOTE: The library only supports `shopify_api` < 10.0 at the moment.**
+Less painful way to work with [Shopify Graphql API](https://shopify.dev/api/admin-graphql) in Ruby. This library is a tiny wrapper on top of [`shopify_api`](https://github.com/Shopify/shopify-api-ruby) gem. It provides a simple API for Graphql calls, better error handling, and Graphql webhooks integration.
 
 ## Features
 
-- Simple API for Graphql calls
-- Graphql webhooks integration
-- Built-in error handling
-- No schema and no memory issues
-- Buil-in retry on error
-- (Planned) Testing helpers
-- (Planned) Pre-built calls for common Graphql operations
+- Simple API for Graphql queries and mutations
+- Conventions for organizing Graphql code
+- ActiveResource-like error handling
+- Graphql and user error handlers
+- Auto-conversion of responses to OpenStruct
+- Graphql webhooks integration for Rails
+- Wrappers for Graphql rate limit extensions
+- Built-in calls for common Graphql calls
 
-## Usage
+## Dependencies
 
-### Making Graphql calls directly
+- [`shopify_api`](https://github.com/Shopify/shopify-api-ruby) v10+
+- [`shopify_app`](https://github.com/Shopify/shopify_app) v19+
 
-```ruby
-CREATE_WEBHOOK_MUTATION = <<~GRAPHQL
-  mutation($topic: WebhookSubscriptionTopic!, $webhookSubscription: WebhookSubscriptionInput!) {
-    webhookSubscriptionCreate(topic: $topic, webhookSubscription: $webhookSubscription) {
-      webhookSubscription {
-        id
-      }
-      userErrors {
-        field
-        message
-      }
-    }
-  }
-GRAPHQL
+> For `shopify_api` < v10 use [`0-4-stable`](https://github.com/kirillplatonov/shopify_graphql/tree/0-4-stable) branch.
 
-response = ShopifyGraphql.execute(CREATE_WEBHOOK_MUTATION,
-  topic: "TOPIC",
-  webhookSubscription: { callbackUrl: "ADDRESS", format: "JSON" },
-)
-response = response.data.webhookSubscriptionCreate
-ShopifyGraphql.handle_user_errors(response)
+## Installation
+
+Add `shopify_graphql` to your Gemfile:
+
+```bash
+bundle add shopify_graphql
+```
+
+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`:
+
+```rb
+shop.with_shopify_session do
+  # your calls to graphql
+end
 ```
 
-### Creating wrappers for queries, mutations, and fields
+## Conventions
 
-To isolate Graphql boilerplate you can create wrappers. To keep them organized use the following conventions:
-- Put them all into `app/graphql` folder
+To better organize your Graphql code use the following conventions:
+
+- Create wrappers for all of your queries and mutations to isolate them
+- Put all Graphql-related code 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
+## Usage examples
+
+### Simple query
 
+<details><summary>Click to expand</summary>
 Definition:
-```ruby
-class AppSubscriptionFields
-  FRAGMENT = <<~GRAPHQL
-    fragment AppSubscriptionFields on AppSubscription {
-      id
-      name
-      status
-      trialDays
-      currentPeriodEnd
-      test
-      lineItems {
+
+```rb
+# app/graphql/get_product.rb
+
+class GetProduct
+  include ShopifyGraphql::Query
+
+  QUERY = <<~GRAPHQL
+    query($id: ID!) {
+      product(id: $id) {
+        handle
+        title
+        description
+      }
+    }
+  GRAPHQL
+
+  def call(id:)
+    response = execute(QUERY, id: id)
+    response.data = response.data.product
+    response
+  end
+end
+```
+
+Usage:
+
+```rb
+product = GetProduct.call(id: "gid://shopify/Product/12345").data
+puts product.handle
+puts product.title
+```
+</details>
+
+### Query with data parsing
+
+<details><summary>Click to expand</summary>
+Definition:
+
+```rb
+# app/graphql/get_product.rb
+
+class GetProduct
+  include ShopifyGraphql::Query
+
+  QUERY = <<~GRAPHQL
+    query($id: ID!) {
+      product(id: $id) {
         id
-        plan {
-          pricingDetails {
-            __typename
-            ... on AppRecurringPricing {
-              price {
-                amount
-              }
-              interval
-            }
-            ... on AppUsagePricing {
-              balanceUsed {
-                amount
-              }
-              cappedAmount {
-                amount
-              }
-              interval
-              terms
-            }
-          }
+        title
+        featuredImage {
+          source: url
         }
       }
     }
   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
+  def call(id:)
+    response = execute(QUERY, id: id)
+    response.data = parse_data(response.data.product)
+    response
+  end
 
+  private
+
+  def parse_data(data)
     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,
+      title: data.title,
+      featured_image: data.featuredImage&.source
     )
   end
 end
 ```
 
-For usage examples see query and mutation below.
+Usage:
+
+```rb
+product = GetProduct.call(id: "gid://shopify/Product/12345").data
+puts product.id
+puts product.title
+puts product.featured_image
+```
+</details>
 
-#### Example query
+### Query with fields
 
+<details><summary>Click to expand</summary>
 Definition:
-```ruby
-class GetAppSubscription
+
+```rb
+# app/graphql/product_fields.rb
+
+class ProductFields
+  FRAGMENT = <<~GRAPHQL
+    fragment ProductFields on Product {
+      id
+      title
+      featuredImage {
+        source: url
+      }
+    }
+  GRAPHQL
+
+  def self.parse(data)
+    OpenStruct.new(
+      id: data.id,
+      title: data.title,
+      featured_image: data.featuredImage&.source
+    )
+  end
+end
+```
+
+```rb
+# app/graphql/get_product.rb
+
+class GetProduct
   include ShopifyGraphql::Query
 
   QUERY = <<~GRAPHQL
-    #{AppSubscriptionFields::FRAGMENT}
+    #{ProductFields::FRAGMENT}
+
     query($id: ID!) {
-      node(id: $id) {
-        ... AppSubscriptionFields
+      product(id: $id) {
+        ... ProductFields
       }
     }
   GRAPHQL
 
   def call(id:)
     response = execute(QUERY, id: id)
-    response.data = AppSubscriptionFields.parse(response.data.node)
+    response.data = ProductFields.parse(response.data.product)
     response
   end
 end
 ```
 
 Usage:
-```ruby
-shopify_subscription = GetAppSubscription.call(id: @id).data
-shopify_subscription.status
-shopify_subscription.current_period_end
+
+```rb
+product = GetProduct.call(id: "gid://shopify/Product/12345").data
+puts product.id
+puts product.title
+puts product.featured_image
 ```
+</details>
 
-#### Example mutation
+### Simple collection query
 
+<details><summary>Click to expand</summary>
 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
+```rb
+# app/graphql/get_products.rb
+
+class GetProducts
+  include ShopifyGraphql::Query
+
+  QUERY = <<~GRAPHQL
+    query {
+      products(first: 5) {
+        edges {
+          node {
+            id
+            title
+            featuredImage {
+              source: url
+            }
+          }
         }
-        confirmationUrl
-        userErrors {
-          field
-          message
+      }
+    }
+  GRAPHQL
+
+  def call
+    response = execute(QUERY)
+    response.data = parse_data(response.data.products.edges)
+    response
+  end
+
+  private
+
+  def parse_data(data)
+    return [] if data.blank?
+
+    data.compact.map do |edge|
+      OpenStruct.new(
+        id: edge.node.id,
+        title: edge.node.title,
+        featured_image: edge.node.featuredImage&.source
+      )
+    end
+  end
+end
+```
+
+Usage:
+
+```rb
+products = GetProducts.call.data
+products.each do |product|
+  puts product.id
+  puts product.title
+  puts product.featured_image
+end
+```
+</details>
+
+### Collection query with fields
+
+<details><summary>Click to expand</summary>
+Definition:
+
+```rb
+# app/graphql/product_fields.rb
+
+class ProductFields
+  FRAGMENT = <<~GRAPHQL
+    fragment ProductFields on Product {
+      id
+      title
+      featuredImage {
+        source: url
+      }
+    }
+  GRAPHQL
+
+  def self.parse(data)
+    OpenStruct.new(
+      id: data.id,
+      title: data.title,
+      featured_image: data.featuredImage&.source
+    )
+  end
+end
+```
+
+```rb
+# app/graphql/get_products.rb
+
+class GetProducts
+  include ShopifyGraphql::Query
+
+  QUERY = <<~GRAPHQL
+    #{ProductFields::FRAGMENT}
+
+    query {
+      products(first: 5) {
+        edges {
+          cursor
+          node {
+            ... ProductFields
+          }
         }
       }
     }
   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
+  def call
+    response = execute(QUERY)
+    response.data = parse_data(response.data.products.edges)
+    response
+  end
+
+  private
+
+  def parse_data(data)
+    return [] if data.blank?
+
+    data.compact.map do |edge|
+      OpenStruct.new(
+        cursor: edge.cursor,
+        node: ProductFields.parse(edge.node)
+      )
+    end
+  end
+end
+```
+
+Usage:
+
+```rb
+products = GetProducts.call.data
+products.each do |edge|
+  puts edge.cursor
+  puts edge.node.id
+  puts edge.node.title
+  puts edge.node.featured_image
+end
+```
+</details>
+
+### Collection query with pagination
+
+<details><summary>Click to expand</summary>
+Definition:
+
+```rb
+# app/graphql/product_fields.rb
+
+class ProductFields
+  FRAGMENT = <<~GRAPHQL
+    fragment ProductFields on Product {
+      id
+      title
+      featuredImage {
+        source: url
+      }
+    }
+  GRAPHQL
+
+  def self.parse(data)
+    OpenStruct.new(
+      id: data.id,
+      title: data.title,
+      featured_image: data.featuredImage&.source
+    )
+  end
+end
+```
+
+```rb
+# app/graphql/get_products.rb
+
+class GetProducts
+  include ShopifyGraphql::Query
+
+  LIMIT = 5
+  QUERY = <<~GRAPHQL
+    #{ProductFields::FRAGMENT}
+
+    query {
+      products(first: #{LIMIT}) {
+        edges {
+          node {
+            ... ProductFields
+          }
+        }
+        pageInfo {
+          hasNextPage
+          endCursor
+        }
+      }
+    }
+  GRAPHQL
+  QUERY_WITH_CURSOR = <<~GRAPHQL
+    #{ProductFields::FRAGMENT}
+
+    query($cursor: String!) {
+      products(first: #{LIMIT}, after: $cursor) {
+        edges {
+          node {
+            ... ProductFields
+          }
+        }
+        pageInfo {
+          hasNextPage
+          endCursor
         }
       }
-    }]
-    payload[:trialDays] = trial_days if trial_days
-    payload[:test] = test if test
+    }
+  GRAPHQL
 
-    response = execute(MUTATION, **payload)
-    response.data = response.data.appSubscriptionCreate
-    handle_user_errors(response.data)
-    response.data = parse_data(response.data)
+  def call
+    response = execute(QUERY)
+    data = parse_data(response.data.products.edges)
+
+    while response.data.products.pageInfo.hasNextPage
+      response = execute(QUERY_WITH_CURSOR, cursor: response.data.products.pageInfo.endCursor)
+      data += parse_data(response.data.products.edges)
+    end
+
+    response.data = data
     response
   end
 
   private
 
   def parse_data(data)
+    return [] if data.blank?
+
+    data.compact.map do |edge|
+      ProductFields.parse(edge.node)
+    end
+  end
+end
+```
+
+Usage:
+
+```rb
+products = GetProducts.call.data
+products.each do |product|
+  puts product.id
+  puts product.title
+  puts product.featured_image
+end
+```
+</details>
+
+### Collection query with block
+
+<details><summary>Click to expand</summary>
+Definition:
+
+```rb
+# app/graphql/product_fields.rb
+
+class ProductFields
+  FRAGMENT = <<~GRAPHQL
+    fragment ProductFields on Product {
+      id
+      title
+      featuredImage {
+        source: url
+      }
+    }
+  GRAPHQL
+
+  def self.parse(data)
     OpenStruct.new(
-      subscription: AppSubscriptionFields.parse(data.appSubscription),
-      confirmation_url: data.confirmationUrl,
+      id: data.id,
+      title: data.title,
+      featured_image: data.featuredImage&.source
     )
   end
 end
 ```
 
+```rb
+# app/graphql/get_products.rb
+
+class GetProducts
+  include ShopifyGraphql::Query
+
+  LIMIT = 5
+  QUERY = <<~GRAPHQL
+    #{ProductFields::FRAGMENT}
+
+    query {
+      products(first: #{LIMIT}) {
+        edges {
+          node {
+            ... ProductFields
+          }
+        }
+        pageInfo {
+          hasNextPage
+          endCursor
+        }
+      }
+    }
+  GRAPHQL
+  QUERY_WITH_CURSOR = <<~GRAPHQL
+    #{ProductFields::FRAGMENT}
+
+    query($cursor: String!) {
+      products(first: #{LIMIT}, after: $cursor) {
+        edges {
+          node {
+            ... ProductFields
+          }
+        }
+        pageInfo {
+          hasNextPage
+          endCursor
+        }
+      }
+    }
+  GRAPHQL
+
+  def call(&block)
+    response = execute(QUERY)
+    response.data.products.edges.each do |edge|
+      block.call ProductFields.parse(edge.node)
+    end
+
+    while response.data.products.pageInfo.hasNextPage
+      response = execute(QUERY_WITH_CURSOR, cursor: response.data.products.pageInfo.endCursor)
+      response.data.products.edges.each do |edge|
+        block.call ProductFields.parse(edge.node)
+      end
+    end
+
+    response
+  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
+
+```rb
+GetProducts.call do |product|
+  puts product.id
+  puts product.title
+  puts product.featured_image
+end
 ```
+</details>
 
-## Installation
+### Collection query with nested pagination
+
+<details><summary>Click to expand</summary>
+Definition:
+
+```rb
+# app/graphql/get_collections_with_products.rb
 
-In Gemfile, add:
+class GetCollectionsWithProducts
+  include ShopifyGraphql::Query
+
+  COLLECTIONS_LIMIT = 1
+  PRODUCTS_LIMIT = 25
+  QUERY = <<~GRAPHQL
+    query {
+      collections(first: #{COLLECTIONS_LIMIT}) {
+        edges {
+          node {
+            id
+            title
+            products(first: #{PRODUCTS_LIMIT}) {
+              edges {
+                node {
+                  id
+                }
+              }
+            }
+          }
+        }
+        pageInfo {
+          hasNextPage
+          endCursor
+        }
+      }
+    }
+  GRAPHQL
+  QUERY_WITH_CURSOR = <<~GRAPHQL
+    query ($cursor: String!) {
+      collections(first: #{COLLECTIONS_LIMIT}, after: $cursor) {
+        edges {
+          node {
+            id
+            title
+            products(first: #{PRODUCTS_LIMIT}) {
+              edges {
+                node {
+                  id
+                }
+              }
+            }
+          }
+        }
+        pageInfo {
+          hasNextPage
+          endCursor
+        }
+      }
+    }
+  GRAPHQL
+
+  def call
+    response = execute(QUERY)
+    data = parse_data(response.data.collections.edges)
+
+    while response.data.collections.pageInfo.hasNextPage
+      response = execute(QUERY_WITH_CURSOR, cursor: response.data.collections.pageInfo.endCursor)
+      data += parse_data(response.data.collections.edges)
+    end
+
+    response.data = data
+    response
+  end
+
+  private
+
+  def parse_data(data)
+    return [] if data.blank?
+
+    data.compact.map do |edge|
+      OpenStruct.new(
+        id: edge.node.id,
+        title: edge.node.title,
+        products: edge.node.products.edges.map do |product_edge|
+          OpenStruct.new(id: product_edge.node.id)
+        end
+      )
+    end
+  end
+end
 ```
-gem 'shopify_graphql', github: 'kirillplatonov/shopify_graphql', branch: 'main'
+
+Usage:
+
+```rb
+collections = GetCollectionsWithProducts.call.data
+collections.each do |collection|
+  puts collection.id
+  puts collection.title
+  collection.products.each do |product|
+    puts product.id
+  end
+end
 ```
+</details>
 
-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
+### Mutation
+
+<details><summary>Click to expand</summary>
+
+Definition:
+
+```rb
+# app/graphql/update_product.rb
+
+class UpdateProduct
+  include ShopifyGraphql::Mutation
+
+  MUTATION = <<~GRAPHQL
+    mutation($input: ProductInput!) {
+      productUpdate(input: $input) {
+        product {
+          id
+          title
+        }
+        userErrors {
+          field
+          message
+        }
+      }
+    }
+  GRAPHQL
+
+  def call(input:)
+    response = execute(MUTATION, input: input)
+    response.data = response.data.productUpdate
+    handle_user_errors(response.data)
+    response
+  end
 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
+Usage:
+
+```rb
+response = UpdateProduct.call(input: { id: "gid://shopify/Product/123", title: "New title" })
+puts response.data.product.title
+```
+</details>
+
+### Graphql call without wrapper
+
+<details><summary>Click to expand</summary>
+
+```rb
+PRODUCT_UPDATE_MUTATION = <<~GRAPHQL
+  mutation($input: ProductInput!) {
+    productUpdate(input: $input) {
+      product {
+        id
+        title
+      }
+      userErrors {
+        field
+        message
+      }
+    }
+  }
+GRAPHQL
+
+response = ShopifyGraphql.execute(
+  PRODUCT_UPDATE_MUTATION,
+  input: { id: "gid://shopify/Product/12345", title: "New title" }
+)
+response = response.data.productUpdate
+ShopifyGraphql.handle_user_errors(response)
+```
+</details>
+
+## Built-in Graphql calls
+
+- `ShopifyGraphql::CancelSubscription`
+- `ShopifyGraphql::CreateRecurringSubscription`
+- `ShopifyGraphql::CreateUsageSubscription`
+- `ShopifyGraphql::GetAppSubscription`
+- `ShopifyGraphql::UpsertPrivateMetafield`
+- `ShopifyGraphql::DeletePrivateMetafield`
+
+Built-in wrappers are located in [`app/graphql/shopify_graphql`](/app/graphql/shopify_graphql/) folder. You can use them directly in your apps or as an example to create your own wrappers.
+
+## Graphql webhooks
+
+> Since version 10 `shopify_api` gem includes built-in support for Graphql webhooks. If you are using `shopify_api` version 10 or higher you don't need to use this gem to handle Graphql webhooks. See [`shopify_app` documentation](https://github.com/Shopify/shopify_app/blob/main/docs/shopify_app/webhooks.md) for more details.
+
+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`:
+
+```rb
 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.webhook_enabled_environments = ['development', 'staging', 'production']
   config.webhooks = [
     { topic: 'SHOP_UPDATE', address: "#{webhooks_prefix}/shop_update" },
     { topic: 'APP_SUBSCRIPTIONS_UPDATE', address: "#{webhooks_prefix}/app_subscriptions_update" },
@@ -257,7 +762,51 @@ ShopifyGraphql.configure do |config|
 end
 ```
 
-You can also use `WEBHOOKS_ENABLED=true` env variable to enable webhooks (useful in development).
+And add the following routes to `config/routes.rb`:
+
+```rb
+mount ShopifyGraphql::Engine, at: '/'
+```
+
+To register defined webhooks you need to call `ShopifyGraphql::UpdateWebhooksJob`. You can call it manually or use `AfterAuthenticateJob` from `shopify_app`:
+
+```rb
+# config/initializers/shopify_app.rb
+ShopifyApp.configure do |config|
+  # ...
+  config.after_authenticate_job = {job: "AfterAuthenticateJob", inline: true}
+end
+```
+
+```rb
+# app/jobs/after_install_job.rb
+class AfterInstallJob < ApplicationJob
+  def perform(shop)
+    # ...
+    update_webhooks(shop)
+  end
+
+  def update_webhooks(shop)
+    ShopifyGraphql::UpdateWebhooksJob.perform_later(
+      shop_domain: shop.shopify_domain,
+      shop_token: shop.shopify_token
+    )
+  end
+end
+```
+
+To handle webhooks create jobs in `app/jobs/webhooks` folder. The gem will automatically call them when new webhooks are received. The job name should match the webhook topic name. For example, to handle `APP_UNINSTALLED` webhook create `app/jobs/webhooks/app_uninstalled_job.rb`:
+
+```rb
+class Webhooks::AppUninstalledJob < ApplicationJob
+  queue_as :default
+
+  def perform(shop_domain:, webhook:)
+    shop = Shop.find_by!(shopify_domain: shop_domain)
+    # handle shop uninstall
+  end
+end
+```
 
 ## License
 

data/app/graphql/shopify_graphql/delete_private_metafield.rb

@@ -0,0 +1,36 @@
+module ShopifyGraphql
+  class DeletePrivateMetafield
+    include ShopifyGraphql::Mutation
+
+    MUTATION = <<~GRAPHQL
+      mutation privateMetafieldDelete($input: PrivateMetafieldDeleteInput!) {
+        privateMetafieldDelete(input: $input) {
+          deletedPrivateMetafieldId
+          userErrors {
+            field
+            message
+          }
+        }
+      }
+    GRAPHQL
+
+    def call(namespace:, key:, owner: nil)
+      input = {namespace: namespace, key: key}
+      input[:owner] = owner if owner
+
+      response = execute(MUTATION, input: input)
+      handle_user_errors(response.data.privateMetafieldDelete)
+      response.data = parse_data(response.data)
+      response
+    end
+
+    private
+
+    def parse_data(data)
+      id = data.privateMetafieldDelete.deletedPrivateMetafieldId
+      OpenStruct.new(
+        deleted_private_metafield_id: id
+      )
+    end
+  end
+end

data/app/graphql/shopify_graphql/upsert_private_metafield.rb

@@ -0,0 +1,58 @@
+module ShopifyGraphql
+  class UpsertPrivateMetafield
+    include ShopifyGraphql::Mutation
+
+    MUTATION = <<~GRAPHQL
+      mutation privateMetafieldUpsert($input: PrivateMetafieldInput!) {
+        privateMetafieldUpsert(input: $input) {
+          privateMetafield {
+            id
+            namespace
+            key
+            value
+            valueType
+          }
+          userErrors {
+            field
+            message
+          }
+        }
+      }
+    GRAPHQL
+
+    def call(namespace:, key:, value:, owner: nil)
+      input = {namespace: namespace, key: key}
+      input[:owner] = owner if owner
+
+      case value
+      when Hash, Array
+        value = value.to_json
+        value_type = "JSON_STRING"
+      when Integer
+        value_type = "INTEGER"
+      else
+        value = value.to_s
+        value_type = "STRING"
+      end
+      input[:valueInput] = {value: value, valueType: value_type}
+
+      response = execute(MUTATION, input: input)
+      handle_user_errors(response.data.privateMetafieldUpsert)
+      response.data = parse_data(response.data)
+      response
+    end
+
+    private
+
+    def parse_data(data)
+      metafield = data.privateMetafieldUpsert.privateMetafield
+      OpenStruct.new(
+        id: metafield.id,
+        namespace: metafield.namespace,
+        key: metafield.key,
+        value: metafield.value,
+        value_type: metafield.valueType
+      )
+    end
+  end
+end

data/lib/shopify_graphql/client.rb

@@ -1,81 +1,60 @@
 module ShopifyGraphql
   class Client
-    RETRIABLE_EXCEPTIONS = [
-      Errno::ETIMEDOUT,
-      Errno::ECONNREFUSED,
-      Errno::EHOSTUNREACH,
-      'Timeout::Error',
-      Faraday::TimeoutError,
-      Faraday::RetriableResponse,
-      Faraday::ParsingError,
-      Faraday::ConnectionFailed,
-    ].freeze
-
-    def initialize(api_version = ShopifyAPI::Base.api_version)
-      @api_version = api_version
+    def client
+      @client ||= ShopifyAPI::Clients::Graphql::Admin.new(session: ShopifyAPI::Context.active_session)
     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
+      response = client.query(query: query, variables: variables)
+      Response.new(handle_response(response))
+    rescue ShopifyAPI::Errors::HttpResponseError => e
+      Response.new(handle_response(e.response))
+    rescue JSON::ParserError => e
+      raise ServerError.new(e, "Invalid JSON response")
+    rescue Errno::ECONNRESET, Errno::EPIPE, Net::ReadTimeout, Net::OpenTimeout, OpenSSL::SSL::SSLError => e
+      raise ConnectionError.new(e, "Network error")
     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 }
-        conn.request :retry, max: 3, interval: 1, backoff_factor: 2, exceptions: RETRIABLE_EXCEPTIONS
+    def parsed_body(response)
+      if response.body.is_a?(Hash)
+        JSON.parse(response.body.to_json, object_class: OpenStruct)
+      else
+        response.body
       end
     end
 
     def handle_response(response)
-      case response.status
+      case response.code
       when 200..400
-        handle_graphql_errors(response.body)
+        handle_graphql_errors(parsed_body(response))
       when 400
-        raise BadRequest.new(response.body, code: response.status)
+        raise BadRequest.new(parsed_body(response), code: response.code)
       when 401
-        raise UnauthorizedAccess.new(response.body, code: response.status)
+        raise UnauthorizedAccess.new(parsed_body(response), code: response.code)
       when 402
-        raise PaymentRequired.new(response.body, code: response.status)
+        raise PaymentRequired.new(parsed_body(response), code: response.code)
       when 403
-        raise ForbiddenAccess.new(response.body, code: response.status)
+        raise ForbiddenAccess.new(parsed_body(response), code: response.code)
       when 404
-        raise ResourceNotFound.new(response.body, code: response.status)
+        raise ResourceNotFound.new(parsed_body(response), code: response.code)
       when 405
-        raise MethodNotAllowed.new(response.body, code: response.status)
+        raise MethodNotAllowed.new(parsed_body(response), code: response.code)
       when 409
-        raise ResourceConflict.new(response.body, code: response.status)
+        raise ResourceConflict.new(parsed_body(response), code: response.code)
       when 410
-        raise ResourceGone.new(response.body, code: response.status)
+        raise ResourceGone.new(parsed_body(response), code: response.code)
       when 412
-        raise PreconditionFailed.new(response.body, code: response.status)
+        raise PreconditionFailed.new(parsed_body(response), code: response.code)
       when 422
-        raise ResourceInvalid.new(response.body, code: response.status)
+        raise ResourceInvalid.new(parsed_body(response), code: response.code)
       when 429
-        raise TooManyRequests.new(response.body, code: response.status)
+        raise TooManyRequests.new(parsed_body(response), code: response.code)
       when 401...500
-        raise ClientError.new(response.body, code: response.status)
+        raise ClientError.new(parsed_body(response), code: response.code)
       when 500...600
-        raise ServerError.new(response.body, code: response.status)
+        raise ServerError.new(parsed_body(response), code: response.code)
       else
-        raise ConnectionError.new(response.body, "Unknown response code: #{response.status}")
+        raise ConnectionError.new(parsed_body(response), "Unknown response code: #{response.code}")
       end
     end
 
@@ -90,6 +69,8 @@ module ShopifyGraphql
       case error_code
       when "THROTTLED"
         raise TooManyRequests.new(response, error_message, code: error_code, doc: error_doc)
+      when "INTERNAL_SERVER_ERROR"
+        raise ServerError.new(response, error_message, code: error_code, doc: error_doc)
       else
         raise ConnectionError.new(response, error_message, code: error_code, doc: error_doc)
       end
@@ -110,8 +91,8 @@ module ShopifyGraphql
   class << self
     delegate :execute, :handle_user_errors, to: :client
 
-    def client(api_version = ShopifyAPI::Base.api_version)
-      Client.new(api_version)
+    def client
+      Client.new
     end
   end
 end

data/lib/shopify_graphql/jobs/create_webhooks_job.rb

@@ -5,10 +5,9 @@ module ShopifyGraphql
     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
+      ShopifyAPI::Auth::Session.temp(shop: shop_domain, access_token: shop_token) do
         manager = WebhooksManager.new(webhooks)
         manager.create_webhooks
       end

data/lib/shopify_graphql/jobs/destroy_webhooks_job.rb

@@ -5,10 +5,9 @@ module ShopifyGraphql
     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
+      ShopifyAPI::Auth::Session.temp(shop: shop_domain, access_token: shop_token) do
         manager = WebhooksManager.new(webhooks)
         manager.destroy_webhooks
       end

data/lib/shopify_graphql/jobs/update_webhooks_job.rb

@@ -5,10 +5,9 @@ module ShopifyGraphql
     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
+      ShopifyAPI::Auth::Session.temp(shop: shop_domain, access_token: shop_token) do
         manager = WebhooksManager.new(webhooks)
         manager.recreate_webhooks!
       end

data/lib/shopify_graphql/version.rb

@@ -1,3 +1,3 @@
 module ShopifyGraphql
-  VERSION = "0.4.2"
+  VERSION = "1.1.0"
 end

data/lib/shopify_graphql.rb

@@ -1,6 +1,4 @@
 require 'shopify_api'
-require 'faraday'
-require 'faraday_middleware'
 
 require 'shopify_graphql/client'
 require 'shopify_graphql/configuration'

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: shopify_graphql
 version: !ruby/object:Gem::Version
-  version: 0.4.2
+  version: 1.1.0
 platform: ruby
 authors:
 - Kirill Platonov
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2022-07-13 00:00:00.000000000 Z
+date: 2023-03-16 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rails
@@ -16,70 +16,42 @@ dependencies:
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: 5.2.0
+        version: 6.0.0
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: 5.2.0
+        version: 6.0.0
 - !ruby/object:Gem::Dependency
   name: shopify_api
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - "<"
+    - - ">="
       - !ruby/object:Gem::Version
         version: '10.0'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - "<"
+    - - ">="
       - !ruby/object:Gem::Version
         version: '10.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'
+        version: '19.0'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: '0'
+        version: '19.0'
 description:
 email:
 - mail@kirillplatonov.com
@@ -94,7 +66,9 @@ files:
 - app/graphql/shopify_graphql/cancel_subscription.rb
 - app/graphql/shopify_graphql/create_recurring_subscription.rb
 - app/graphql/shopify_graphql/create_usage_subscription.rb
+- app/graphql/shopify_graphql/delete_private_metafield.rb
 - app/graphql/shopify_graphql/get_app_subscription.rb
+- app/graphql/shopify_graphql/upsert_private_metafield.rb
 - config/routes.rb
 - lib/shopify_graphql.rb
 - lib/shopify_graphql/client.rb
@@ -135,7 +109,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.3.7
+rubygems_version: 3.4.3
 signing_key:
 specification_version: 4
 summary: Less painful way to work with Shopify Graphql API in Ruby.