shopify_api-graphql-metafields 0.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 5e493b7cb3098ec7dd032a55e47d6ddf3a9537c7c98a4ad057f81ea236c25ed0
+  data.tar.gz: 4de07ec76fc07d3cfac3f75a32fdb938db3342d6ad122ffda1f0b0f7a53f852b
+SHA512:
+  metadata.gz: b601b92ce0407b819fcf72c9fe8921eeee55bc55a0ac45ab53f6764dfeac61e0001d715ab3e51f86e9f7beab6a2e9c7e7a9d9a6bd6ff7b00b5cea29eeb1eca6b
+  data.tar.gz: b24e57743b0d5db7b4c31231e86820b76dca0513ba96c1726bfb97640410c8ad4e9a5c4411006c3a2663b308044f9bc9a432241ba7546e6ca647ea04272241ca

data/.env.template

@@ -0,0 +1,2 @@
+SHOPIFY_DOMAIN=
+SHOPIFY_ADMIN_TOKEN=

data/LICENSE.txt

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2026 ScreenStaring
+
+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,239 @@
+# ShopifyAPI::GraphQL::Metafields
+
+User-friendly metafield wrapper around Shopify's GraphQL Admin API with built-in retry, batching, and error handling.
+
+[![CI](https://github.com/ScreenStaring/shopify_api-graphql-metafields/actions/workflows/main.yml/badge.svg)](https://github.com/ScreenStaring/shopify_api-graphql-metafields/actions)
+
+## Installation
+
+```bash
+bundle add shopify_api-graphql-metafields
+```
+
+If bundler is not being used to manage dependencies:
+
+```bash
+gem install shopify_api-graphql-metafields
+```
+
+## Usage
+
+`ShopifyAPI::GraphQL::Metafields` supports CRUD operations on Metafields and Metafield Definitions, and supports setting metafields in bulk.
+
+### Metafields
+
+#### Upsert Metafields
+
+You can upsert a single metafield or multiple metafields:
+
+```rb
+require "shopify_api/graphql/metafields"
+
+metafields = [
+  {
+    :owner_id => "gid://shopify/Product/123",
+    :namespace => "something",
+    :key => "foo",
+    # Not required if there's a metafield definition
+    :type => "number_integer",
+    :value => "123"
+  },
+  {
+    :owner_id => "gid://shopify/Shop/123",
+    :namespace => "whatever",
+    :key => "bar",
+    :type => "json",
+    :value => JSON.dump(:a => 123, :b => "bee")
+  }
+]
+
+mf = ShopifyAPI::GraphQL::Metafields.new(shop, token)
+
+begin
+  results = mf.set(metafields)
+  results.each do |result|
+    # result is a Hash with underscored Symbol keys
+    p result.slice(:id, :value)
+  end
+rescue ShopifyAPI::GraphQL::Metafields::Error => e
+  p e
+end
+```
+
+To override the fields returned see [Field Selection](#field-selection).
+
+#### Delete Metafields
+
+```rb
+metafields = [
+  {
+    :owner_id => "gid://shopify/Product/123",
+    :namespace => "something",
+    :key => "foo"
+  },
+  {
+    :owner_id => "gid://shopify/Shop/123",
+    :namespace => "whatever",
+    :key => "bar"
+  }
+]
+
+mf = ShopifyAPI::GraphQL::Metafields.new(shop, token)
+
+begin
+  results = mf.delete(metafields)
+  results.each do |result|
+    # result is a Hash
+    p result.slice(:key, :namespace)
+  end
+rescue ShopifyAPI::GraphQL::Metafields::Error => e
+  p e
+end
+```
+
+To override the fields returned see [Field Selection](#field-selection).
+
+### Field Selection
+
+Use the `:fields` option to select what fields are returned. This accepts an `Array` of field names:
+
+```rb
+mf = ShopifyAPI::GraphQL::Metafields.new(shop, token)
+mf.set(metafield, :fields => %w[compare_digest legacy_resource_id description])
+```
+
+Or a String containing literal GraphQL fields:
+
+```rb
+mf.set(metafield, :fields => "legacyResourceId constraints { key }")
+```
+
+### Setting Metafields in Bulk
+
+```rb
+require "shopify_api/graphql/metafields"
+
+set = ShopifyAPI::GraphQL::Metafields::Batch::Set.new(shop, token)
+set << metafield1
+set << metafield2
+# ...
+set << metafield100
+
+begin
+  result = set.flush!
+rescue ShopifyAPI::GraphQL::Metafields::Batch::Error => e
+  p "Bulk set failed: #{e}"
+  if e.results.any?
+    p "We did have _some_ success:"
+    pp e.results
+  end
+
+  if e.errors.any?
+    p "We encountered some errors:"
+    pp e.errors
+  end
+
+  if e.user_errors.any?
+    p "We encountered some user errors:"
+    pp e.user_errors
+  end
+end
+```
+
+Note that this _does not_ use the Shopify Bulk API. If you want to use the Bulk API for metafields or other operations
+see [`ShopifyAPI::GraphQL::Bulk`](https://github.com/ScreenStaring/shopify_api-graphql-bulk).
+
+Once `#flush!` is called worker threads (if needed) will be spawned and metafields will be set 25 at a time, per Shopify's `Mutations.metafieldsSet` call limit.
+You can control the number of threads via the `:worker_count` option:
+
+```rb
+set = ShopifyAPI::GraphQL::Metafields::Bulk.new(shop, token, :worker_count => 8)
+```
+
+Workers are spawned based on the batch size. If you have 50 metafields only 2 workers will be spawned. If you have 25 or less only no workers are spawned.
+
+The default number of workers is 4.
+
+The return value is an `Array` of results like one gets with `Metafield#set`. The indices will align with the input metafields' indices.
+A `nil` value means that position errored.
+
+### Deleting Metafields in Bulk
+
+TODO!
+
+If you need this you can use Shopify's Bulk API via [`ShopifyAPI::GraphQL::Bulk`](https://github.com/ScreenStaring/shopify_api-graphql-bulk).
+
+### Metafield Definitions
+
+```rb
+require "shopify_api/graphql/metafields"
+
+dfn = ShopifyAPI::GraphQL::Metafields::Definition.new(shop, token)
+result = dfn.create(
+  :name => "My amaaaazing definition",
+  :namespace => "sshaw",
+  :key => "ingredients",
+  :description => "A product's ingredients",
+  :type => "multi_line_text_field",
+  :owner_type => "PRODUCT"
+)
+
+id = result.dig(:created_definition, :id)
+
+result = dfn.update(
+  :namespace => "sshaw",
+  :key => "ingredients",
+  :owner_type => "PRODUCT",
+  :description => "A products SUPER SECRET ingredients"
+)
+
+# More CRUD operations...
+```
+
+#### Field Selection
+
+Similar to other metafield operation you can specify the returned fields:
+
+```rb
+id = { :namespace => "sshaw", :key => "ingredients", :owner_type => "PRODUCT" }
+dfn.get(id, :fields => %w[id pinned_position])
+
+# Or, specify a String:
+dfn.get(id, :fields => "id pinnedPosition constraints { key value }")
+```
+
+## Why Use This Instead of Shopify's API Client?
+
+- Easy-to-use
+- Built-in retry
+- Batching
+- Lightweight
+- You can use :snake_case hash keys
+
+Overall, Shopify's API client is bloated trash that will give you development headaches and long-term maintenance nightmares.
+
+We used to use it, staring way back in 2015, but eventually had to pivot away from their Ruby libraries due to developer frustration
+and high maintenance cost (and don't get us started on the ShopifyApp gem!@#).
+
+For more information see: Shopify/shopify-api-ruby#1181
+
+## Development
+
+[Shopify Development Tools](https://github.com/ScreenStaring/shopify-dev-tools/) is used to import the product fixtures and retrieve values. The `sdt` executable must be in your path.
+
+A Shopify test store is required. `cp .env.template .env` and fill-in the values. Requests will be made to the given store. The token needs permission to create metafields and metafield definitions.
+
+## See Also
+
+- [Shopify Dev Tools](https://github.com/ScreenStaring/shopify-dev-tools/) - Command-line program to assist with the development and/or maintenance of Shopify apps and stores
+- [`ShopifyAPI::GraphQL::Tiny`](https://github.com/ScreenStaring/shopify_api-graphql-tiny/) - Lightweight, no-nonsense, Shopify GraphQL Admin API client with built-in pagination and retry
+- [`ShopifyAPI::GraphQL::Request`](https://github.com/ScreenStaring/shopify_api-graphql-request) - A higher-level wrapper around `Tiny` with improved exception handling and `:snake_case` hash key conversion
+- [`TinyGID`](https://github.com/sshaw/tiny_gid/) - Build Global ID (`gid://`) URI strings from scalar values
+
+## License
+
+The gem is available as open source under the terms of the [MIT License](https://opensource.org/licenses/MIT).
+
+---
+
+Made by [ScreenStaring](https://screenstaring.com)

data/Rakefile

@@ -0,0 +1,8 @@
+# frozen_string_literal: true
+
+require "bundler/gem_tasks"
+require "rspec/core/rake_task"
+
+RSpec::Core::RakeTask.new(:spec)
+
+task default: :spec

data/lib/shopify_api/graphql/metafields/batch/set.rb

@@ -0,0 +1,114 @@
+# frozen_string_literal: true
+
+require "shopify_api/graphql/request"
+
+module ShopifyAPI
+  module GraphQL
+    module Metafields
+      module Batch
+        # TODO: Similar operation for delete
+        class Set < ShopifyAPI::GraphQL::Request
+          DEFAULT_UPLOAD_GROUPS = 4
+
+          def initialize(shop, token, options = nil)
+            super(shop, token, options)
+
+            @shop = shop
+            @token = token
+
+            @metafields = []
+            @options = options || {}
+
+            raise ArgumentError, "worker_count must be greater than 0" if @options[:worker_count] && @options[:worker_count].to_i < 1
+          end
+
+          def <<(*metafields)
+            metafields.flatten!
+
+            # TODO: autoflush?
+            @metafields.concat(metafields)
+
+            nil
+          end
+
+          def flush!
+            return false unless @metafields.any?
+
+            batches = @metafields.each_slice(Metafields::Set::MAX)
+            # Round so we don't end up with a fractional (or 0) slice size
+            groups = (batches.size / worker_count.to_f).round
+            groups = 1 if groups < 1
+
+            workers = batches.each_slice(groups).with_index.map { |batch, i| spawn_worker(batch, i) }
+            workers.each(&:join)
+
+            collect_results(workers)
+          ensure
+            @metafields.clear
+          end
+
+          private
+
+          def worker_count
+            @options[:worker_count] || DEFAULT_UPLOAD_GROUPS
+          end
+
+          def collect_results(workers)
+            results = []
+            errors = []
+            user_errors = []
+
+            # Name contains its position within the batch, zero-padded so sorting by name
+            # is the same as sorting by position.
+            # The goal is for the success results' indices to align with input values'
+            workers.sort_by(&:name).each do |worker|
+              worker_results, worker_errors = worker.value
+
+              results.concat(worker_results)
+              errors.concat(worker_errors)
+
+              worker_errors.each do |error|
+                user_errors.concat(error.errors) if error.is_a?(ShopifyAPI::GraphQL::Request::UserError)
+              end
+            end
+
+            if errors.any?
+              message = errors.map(&:message).join(", ")
+              raise Error.new("Failed to set all metafields: #{errors.size} error(s): #{message}", results, errors, user_errors)
+            end
+
+            results
+          end
+
+          def spawn_worker(batches, id)
+            Thread.new do
+              Thread.current.name = sprintf("%s-batch-%06d", self.class, id)
+
+              errors = []
+              # We treat the result like the metafieldSet mutation where each position holds the input position's result.
+              # If there was no result the position is nil. This will be put back together across all threads and returned to
+              # the caller as if it was a single metafieldSet call
+              results = Array.new(batches.sum(&:size))
+
+              set = Metafields::Set.new(@shop, @token, @options)
+
+              offset = 0
+
+              batches.each do |batch|
+                begin
+                  results[offset, batch.size] = set.execute(batch).dig(:data, :metafields_set, :metafields)
+                rescue => e
+                  errors << e
+                end
+
+                offset += batch.size
+              end
+
+              [results, errors]
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/shopify_api/graphql/metafields/batch.rb

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+require_relative "batch/set"
+
+module ShopifyAPI
+  module GraphQL
+    module Metafields
+      module Batch
+        class Error < ShopifyAPI::GraphQL::Metafields::Error
+          # Array containing results of any successfully executed set calls
+          attr_reader :results
+
+          # Array containing errors, if any
+          attr_reader :errors
+
+          # Array containing user errors, if any
+          attr_reader :user_errors
+
+          def initialize(message, results = nil, errors = nil, user_errors = nil)
+            super message
+
+            @results = results || []
+            @errors = errors || []
+            @user_errors = user_errors || []
+          end
+        end
+      end
+    end
+  end
+end

data/lib/shopify_api/graphql/metafields/definition.rb

@@ -0,0 +1,118 @@
+# frozen_string_literal: true
+
+module ShopifyAPI
+  module GraphQL
+    module Metafields
+      class Definition < Request
+        GET = <<-GQL
+          query MetafieldsCount($id: ID $identifier: MetafieldDefinitionIdentifierInput) {
+            metafieldDefinition(id: $id identifier: $identifier) {
+              %s
+            }
+          }
+        GQL
+
+        DEFAULT_GET_FIELDS = %w[id namespace key owner_type name description type { name }].freeze
+
+        CREATE =<<-GQL
+          mutation CreateMetafieldDefinition($definition: MetafieldDefinitionInput!) {
+            metafieldDefinitionCreate(definition: $definition) {
+              createdDefinition { %s }
+              #{Metafields::USER_ERRORS}
+            }
+          }
+        GQL
+
+        DEFAULT_CREATE_FIELDS = DEFAULT_GET_FIELDS.dup
+
+        UPDATE =<<-GQL
+          mutation UpdateMetafieldDefinition($definition: MetafieldDefinitionUpdateInput!) {
+            metafieldDefinitionUpdate(definition: $definition) {
+              updatedDefinition { %s }
+              #{Metafields::USER_ERRORS}
+            }
+          }
+        GQL
+
+        DEFAULT_UPDATE_FIELDS = DEFAULT_CREATE_FIELDS.dup.freeze
+
+        DELETE =<<-GQL
+          mutation DeleteMetafieldDefinition($id: ID $identifier: MetafieldDefinitionIdentifierInput $deleteMetafields: Boolean) {
+            metafieldDefinitionDelete(
+              id: $id
+              identifier: $identifier
+              deleteAllAssociatedMetafields: $deleteMetafields
+            ) {
+              %s
+              #{Metafields::USER_ERRORS}
+            }
+          }
+        GQL
+
+        DEFAULT_DELETE_FIELDS =<<-GQL
+          deletedDefinitionId
+          deletedDefinition {
+            key
+            namespace
+            ownerType
+          }
+        GQL
+
+        def create(definition, options = nil)
+          fields = options&.dig(:fields) || DEFAULT_CREATE_FIELDS
+
+          result = execute(
+            sprintf(CREATE, field_string(fields)),
+            :definition => definition
+          ).dig(:data, :metafield_definition_create)
+
+          # We can use #except after 2.7
+          result.delete(:user_errors)
+          result
+        end
+
+        def delete(id_or_identifier, options = nil)
+          fields = options&.dig(:fields) || DEFAULT_DELETE_FIELDS
+
+          result = execute(
+            sprintf(DELETE, field_string(fields)),
+            id_key(id_or_identifier) => id_or_identifier,
+            :delete_metafields => options && options[:delete_metafields] == true
+          ).dig(:data, :metafield_definition_delete)
+
+          # We can use #except after 2.7
+          result.delete(:user_errors)
+          result
+        end
+
+        def get(id_or_identifier, options = nil)
+          fields = options&.dig(:fields) || DEFAULT_GET_FIELDS
+
+          execute(
+            sprintf(GET, field_string(fields)),
+            id_key(id_or_identifier) => id_or_identifier,
+          ).dig(:data, :metafield_definition)
+        end
+
+        def update(definition, options = nil)
+          fields = options&.dig(:fields) || DEFAULT_UPDATE_FIELDS
+
+          result = execute(
+            sprintf(UPDATE, field_string(fields)),
+            :definition => definition
+          ).dig(:data, :metafield_definition_update)
+
+          # We can use #except after 2.7
+          result.delete(:user_errors)
+          result
+        end
+
+        private
+
+        def id_key(id_or_identifier)
+          id_or_identifier.is_a?(Hash) ? :identifier : :id
+        end
+      end
+    end
+  end
+end

data/lib/shopify_api/graphql/metafields/delete.rb

@@ -0,0 +1,38 @@
+# frozen_string_literal: true
+
+require_relative "request"
+
+module ShopifyAPI
+  module GraphQL
+    module Metafields
+      class Delete < Request      # :nodoc: all
+        MAX = 250
+
+        MUTATION =<<-GQL
+          mutation metafieldsDelete($metafields: [MetafieldIdentifierInput!]!) {
+            metafieldsDelete(metafields: $metafields) {
+              deletedMetafields { %s }
+              userErrors { field message }
+            }
+          }
+        GQL
+
+        DEFAULT_FIELDS = %w[key namespace owner_id].freeze
+
+        def execute(metafields, options = nil)
+          metafields = wrap_array(metafields)
+          raise ArgumentError, "metafields required" if metafields.size == 0
+          raise ArgumentError, "#{metafields.size} metafields provided: Shopify allows a maximum of #{MAX}" if metafields.size > MAX
+
+          options = (options || {}).dup
+          fields = options.delete(:fields) || DEFAULT_FIELDS
+          super(
+            sprintf(MUTATION, field_string(fields)),
+            { :metafields => metafields },
+            options
+          )
+        end
+      end
+    end
+  end
+end

data/lib/shopify_api/graphql/metafields/metafield.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+require_relative "delete"
+require_relative "set"
+
+module ShopifyAPI
+  module GraphQL
+    module Metafields
+      class Metafield           # :nodoc: all
+        def initialize(shop, token, options = nil)
+          @delete = Metafields::Delete.new(shop, token, options)
+          @set = Metafields::Set.new(shop, token, options)
+        end
+
+        def set(metafields, options = nil)
+          @set.execute(metafields, options).dig(:data, :metafields_set, :metafields)
+        rescue *WRAPPED_ERRORS => e
+          raise Error, "failed to set metafields: #{e}"
+        end
+
+        def delete(metafields, options = nil)
+          @delete.execute(metafields, options).dig(:data, :metafields_delete, :deleted_metafields)
+        rescue *WRAPPED_ERRORS => e
+          raise Error, "failed to delete metafields: #{e}"
+        end
+      end
+    end
+  end
+end

data/lib/shopify_api/graphql/metafields/request.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+require "shopify_api/graphql/request"
+
+module ShopifyAPI
+  module GraphQL
+    module Metafields
+      class Request < ShopifyAPI::GraphQL::Request
+        protected
+
+        def wrap_array(object)
+          (object.is_a?(Array) ? object : [object]).compact
+        end
+
+        def field_string(fields)
+          return fields unless fields.respond_to?(:map)
+          # TODO: check for breakage across the set of accepted fields
+          fields.map { |f| Strings::Case.camelcase(f.to_s) }.join("\n")
+        end
+      end
+    end
+  end
+end

data/lib/shopify_api/graphql/metafields/set.rb

@@ -0,0 +1,39 @@
+# frozen_string_literal: true
+
+require_relative "request"
+
+module ShopifyAPI
+  module GraphQL
+    module Metafields
+      class Set < Request      # :nodoc: all
+        # Shopify limit per call
+        MAX = 25
+
+        MUTATION =<<-GQL
+          mutation metafieldsSet($metafields: [MetafieldsSetInput!]!) {
+            metafieldsSet(metafields: $metafields) {
+              metafields { %s }
+              #{Metafields::USER_ERRORS}
+            }
+          }
+        GQL
+
+        DEFAULT_FIELDS = %w[id namespace key value].freeze
+
+        def execute(metafields, options = nil)
+          metafields = wrap_array(metafields)
+          raise ArgumentError, "metafields required" if metafields.size == 0
+          raise ArgumentError, "#{metafields.size} metafields provided: Shopify allows a maximum of #{MAX}. Use the Batch::Set class instead" if metafields.size > MAX
+
+          options = (options || {}).dup
+          fields = options.delete(:fields) || DEFAULT_FIELDS
+          super(
+            sprintf(MUTATION, field_string(fields)),
+            { :metafields => metafields },
+            options
+          )
+        end
+      end
+    end
+  end
+end

data/lib/shopify_api/graphql/metafields/version.rb

@@ -0,0 +1,9 @@
+# frozen_string_literal: true
+
+module ShopifyAPI
+  module GraphQL
+    module Metafields
+      VERSION = "0.0.1"
+    end
+  end
+end

data/lib/shopify_api/graphql/metafields.rb

@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+
+require "shopify_api/graphql/tiny"
+require "shopify_api/graphql/request"
+
+require_relative "metafields/version"
+
+module ShopifyAPI
+  module GraphQL
+    module Metafields
+      Error = Class.new(StandardError)
+
+      WRAPPED_ERRORS = [
+        ShopifyAPI::GraphQL::Tiny::Error,
+        ShopifyAPI::GraphQL::Request::Error
+      ].freeze
+
+      USER_ERRORS =<<-GQL
+        userErrors {
+          field
+          message
+          code
+        }
+      GQL
+
+      def self.new(shop, token, options = nil)
+        Metafield.new(shop, token, options)
+      end
+    end
+  end
+end
+
+require_relative "metafields/metafield"
+require_relative "metafields/batch"
+require_relative "metafields/definition"

metadata

@@ -0,0 +1,174 @@
+--- !ruby/object:Gem::Specification
+name: shopify_api-graphql-metafields
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+platform: ruby
+authors:
+- Skye Shaw
+autorequire:
+bindir: bin
+cert_chain: []
+date: 2026-10-16 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: shopify_api-graphql-request
+  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'
+- !ruby/object:Gem::Dependency
+  name: shopify_api-graphql-tiny
+  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'
+- !ruby/object:Gem::Dependency
+  name: strings-case
+  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'
+- !ruby/object:Gem::Dependency
+  name: csv
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: dotenv
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: tiny_gid
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+description:
+email:
+- skye.shaw@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".env.template"
+- LICENSE.txt
+- README.md
+- Rakefile
+- lib/shopify_api/graphql/metafields.rb
+- lib/shopify_api/graphql/metafields/batch.rb
+- lib/shopify_api/graphql/metafields/batch/set.rb
+- lib/shopify_api/graphql/metafields/definition.rb
+- lib/shopify_api/graphql/metafields/delete.rb
+- lib/shopify_api/graphql/metafields/metafield.rb
+- lib/shopify_api/graphql/metafields/request.rb
+- lib/shopify_api/graphql/metafields/set.rb
+- lib/shopify_api/graphql/metafields/version.rb
+homepage: https://github.com/ScreenStaring/shopify_api-graphql-metafields
+licenses:
+- MIT
+metadata:
+  bug_tracker_uri: https://github.com/ScreenStaring/shopify_api-graphql-metafields/issues
+  changelog_uri: https://github.com/ScreenStaring/shopify_api-graphql-metafields/blob/master/Changes
+  documentation_uri: https://rubydoc.info/gems/shopify_api-graphql-metafields
+  source_code_uri: https://github.com/ScreenStaring/shopify_api-graphql-metafields
+  homepage_uri: https://github.com/ScreenStaring/shopify_api-graphql-metafields
+post_install_message:
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 2.5.0
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.5.16
+signing_key:
+specification_version: 4
+summary: User-friendly metafield wrapper around Shopify's GraphQL Admin API with built-in
+  retry, batching, and error handling
+test_files: []