shopify_toolkit 0.5.0 → 0.5.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: fbc1361f6cf3ce45a4b6d004f55cc98b4c9f748c2863e281874cc48f085e7b9d
-  data.tar.gz: 2e9a2fc920f7f7178f5f4ea3ccc945e6ac0c4fb1d50a426d77708888837a4941
+  metadata.gz: 767c783d8c115219c9b25c83e6defa01772cc321a411c072e149ed82e10bc2ba
+  data.tar.gz: 576dfd3753579fac15388f5b22186a5b35b9298d974875ace256532b0af2063d
 SHA512:
-  metadata.gz: 44168636617828f3420d2fd0da7322c962f0b1a7a34e57cf9fe8642acc67d1dfe22dd5fabc934f0ba671e83eecf1623f47dd99f37c98821ef8689b81df91bc7f
-  data.tar.gz: 3fa125127d19a08be48ef8a2165628816653527f272fb0cd352962ff1f5bdb55d5c2a2d8ea08bf3eabd174278e4d9d5777fcee2988d0ee6956b52ff464686c8e
+  metadata.gz: e441dfcdffb2552f0773d132db88a8204a0f60c2624f40f8cff2b0d01304de480e92a95d8d6db5f396bec0c1bce7179d1315fb49b3bb0347f59c14070d4b1685
+  data.tar.gz: 14786f1aa5d5d4e27274f591996f90960c6fdd326f1613088fb54f52f26ebf447b06eeaea4ebf3455c0f868bd9d5f1e71e176c58b75d15c499dd0dd9186caf2f

data/README.md

@@ -24,6 +24,10 @@ A toolkit for working with Custom Shopify Apps built on Rails.
 - [ ] GraphQL Admin API client with built-in caching
 - [ ] GraphQL Admin API client with built-in error handling
 - [ ] GraphQL Admin API client with built-in logging
+- [ ] Bulk Operations
+  - [ ] Interface for uploading and getting results for query / mutation
+  - [ ] Error handling and Logging
+  - [ ] Callbacks
 
 ## Installation
 
@@ -40,10 +44,11 @@ bundle add shopify_toolkit
 Within a Rails application created with ShopifyApp, generate a new migration file:
 
 ```bash
-touch config/shopify/migrate/$(date +%Y%m%d%H%M%S)_add_product_press_releases.rb
+bundle exec shopify-toolkit generate_migration AddProductPressReleases
 ```
 
 Then, add the following code to the migration file:
+
 ```ruby
 # config/shopify/migrate/20250528130134_add_product_press_releases.rb
 class AddProductPressReleases < ShopifyToolkit::Migration
@@ -96,6 +101,40 @@ ShopifyToolkit::MetafieldSchema.define do
 end
 ```
 
+### Monkey Patching for Specific Use Cases
+
+In some scenarios, you may need to customize the behavior of ShopifyToolkit to handle specific limitations or requirements. For example, you might want to skip certain Shopify-managed metaobject definitions that cannot be created due to reserved namespaces or limited access permissions.
+
+```rb
+# config/initializers/shopify_toolkit_patches.rb
+
+require "shopify_toolkit/metaobject_statements"
+
+module ShopifyToolkit
+  module MetaobjectStatements
+    # Override create_metaobject_definition to skip Shopify-managed definitions
+    alias_method :original_create_metaobject_definition, :create_metaobject_definition
+
+    def create_metaobject_definition(type, **options)
+      # Skip Shopify-managed metaobject definitions during schema load
+      if type.to_s.start_with?("shopify--")
+        say "Skipping Shopify-managed metaobject definition: #{type}"
+        return
+      end
+
+      original_create_metaobject_definition(type, **options)
+    end
+  end
+end
+```
+
+This approach allows you to:
+
+- Skip creation of reserved metaobject types (e.g., those prefixed with `shopify--`)
+- Handle cases where certain metaobjects cannot be created due to API limitations
+- Customize validation logic for specific metaobject types
+- Filter out problematic metafield references during schema loading
+
 ### Analyzing a Matrixify CSV Result files
 
 Matrixify is a popular Shopify app that allows you to import/export data from Shopify using CSV files. The CSV files that Matrixify generates are very verbose and can be difficult to work with. This tool allows you to analyze the CSV files and extract the data you need.
@@ -104,8 +143,10 @@ The tool will import the file into a local SQLite database
 and open a console for you to run queries against the data
 using ActiveRecord.
 
+> Note: To use it with `bundle exec`, sqlite3 must be included in the project’s bundle
+
 ```shell
-shopify-csv analyze products-result.csv --force-import
+shopify-toolkit analyze products-result.csv --force-import
 ==> Importing products-result.csv into /var/folders/hn/z7b7s1kj3js4k7_qk3lj27kr0000gn/T/shopify-toolkit-analyze-products_result_csv.sqlite3
 -- create_table(:results, {:force=>true})
    -> 0.0181s
@@ -119,7 +160,7 @@ shopify-csv analyze products-result.csv --force-import
  "UPDATE: Found by Handle | Assuming MERGE for Variant Command | Assuming MERGE for Tags Command | Variants updated by SKU: 1 | Warning: The following media were not uploaded to Shopify: [https://mymedia.com/image.jpg: Error downloading from Web: 302 Moved Temporarily]",
  ...]
 >> first
-#<ShopifyCSV::Result:0x0000000300bf1668
+#<ShopifyToolkit::Result:0x0000000300bf1668
  id: 1,
  data: nil,
  handle: "my-product",

data/lib/shopify_toolkit/command_line.rb

@@ -1,9 +1,12 @@
 require 'csv'
 require 'active_record'
 require 'thor'
+require 'thor/actions'
 require 'tmpdir'
 
 class ShopifyToolkit::CommandLine < Thor
+  include Thor::Actions
+
   RESERVED_COLUMN_NAMES = %w[select type id]
 
   class Result < ActiveRecord::Base
@@ -83,6 +86,31 @@ class ShopifyToolkit::CommandLine < Thor
     ::Shop.sole.with_shopify_session { ShopifyToolkit::Schema.dump! }
   end
 
+  desc "generate_migration NAME", "Generate a migration with the given NAME"
+  def generate_migration(name)
+    require "./config/environment"
+    migrations_dir = Rails.root.join("config/shopify/migrate")
+    file_name = "#{Time.now.utc.strftime('%Y%m%d%H%M%S')}_#{name.underscore}.rb"
+
+    if migrations_dir.entries.map(&:to_s).grep(/\A\d+_#{Regexp.escape name.underscore}\.rb\z/).any?
+      raise Thor::Error, "Migration class already exists: #{file_name}"
+    end
+
+    create_file migrations_dir.join(file_name) do
+      <<~RUBY
+        class #{name.camelize} < ShopifyToolkit::Migration
+          def up
+            # Add your migration code here
+          end
+
+          def down
+            # Add your rollback code here
+          end
+        end
+      RUBY
+    end
+  end
+
   def self.exit_on_failure?
     true
   end

data/lib/shopify_toolkit/metafield_statements.rb

@@ -6,6 +6,7 @@ module ShopifyToolkit::MetafieldStatements
   extend ActiveSupport::Concern
   include ShopifyToolkit::Migration::Logging
   include ShopifyToolkit::AdminClient
+  include ShopifyToolkit::MetaobjectUtilities
 
   def self.log_time(method_name)
     current_method = instance_method(method_name)
@@ -26,6 +27,21 @@ module ShopifyToolkit::MetafieldStatements
       return
     end
 
+    # Process validations to convert metaobject types to GIDs (only for metaobject reference fields)
+    if options[:validations] && is_metaobject_reference_type?(type)
+      begin
+        options[:validations] = convert_validations_types_to_gids(options[:validations])
+      rescue RuntimeError => e
+        if e.message.include?("not found")
+          say "ERROR: Cannot create metafield #{namespace}:#{key} - references non-existent metaobject. This suggests the metaobject was filtered out or failed to create."
+          say "       Original error: #{e.message}"
+          return
+        else
+          raise e
+        end
+      end
+    end
+
     # https://shopify.dev/docs/api/admin-graphql/2024-10/mutations/metafieldDefinitionCreate
     query =
       "# GraphQL
@@ -117,6 +133,11 @@ module ShopifyToolkit::MetafieldStatements
       return
     end
 
+    # Process validations to convert metaobject types to GIDs (only for metaobject reference fields)
+    if options[:validations] && options[:type] && is_metaobject_reference_type?(options[:type])
+      options[:validations] = convert_validations_types_to_gids(options[:validations])
+    end
+
     shopify_admin_client
       .query(
         # Documentation: https://shopify.dev/docs/api/admin-graphql/2024-10/mutations/metafieldDefinitionUpdate

data/lib/shopify_toolkit/metaobject_statements.rb

@@ -6,6 +6,9 @@ module ShopifyToolkit::MetaobjectStatements
   extend ActiveSupport::Concern
   include ShopifyToolkit::Migration::Logging
   include ShopifyToolkit::AdminClient
+  include ShopifyToolkit::MetaobjectUtilities
+
+  @@pending_field_validations = []
 
   def self.log_time(method_name)
     current_method = instance_method(method_name)
@@ -14,18 +17,152 @@ module ShopifyToolkit::MetaobjectStatements
     end
   end
 
-  # create_metafield :products, :my_metafield, :single_line_text_field, name: "Prova"
-  # @param namespace: if nil the metafield will be app-specific (default: :custom)
+  def apply_pending_field_validations
+    return if @@pending_field_validations.empty?
+    
+    say "Applying #{@@pending_field_validations.size} pending field validations"
+    
+    @@pending_field_validations.reject! do |item|
+      metaobject_type = item[:metaobject_type]
+      field_key = item[:field_key]
+      validations = item[:validations]
+      
+      begin
+        success = add_field_validations_to_metaobject(metaobject_type, field_key, validations, item)
+        unless success
+          say "-- Deferring field '#{field_key}' in '#{metaobject_type}' (missing dependencies)"
+        end
+        success
+      rescue StandardError => e
+        say "-- Failed to process field '#{field_key}' in '#{metaobject_type}': #{e.message}"
+        true # Remove from array (don't retry errors)
+      end
+    end
+  end
+
   log_time \
   def create_metaobject_definition(type, **options)
-    # Skip creation if metafield already exists
+    # Skip creation if metaobject already exists
     existing_gid = get_metaobject_definition_gid(type)
     if existing_gid
       say "Metaobject #{type} already exists, skipping creation"
       return existing_gid
     end
 
-    # https://shopify.dev/docs/api/admin-graphql/2024-10/mutations/metafieldDefinitionCreate
+    # Transform options for GraphQL API
+    definition = options.merge(type: type.to_s)
+
+    begin
+      # Convert field_definitions to fieldDefinitions and transform field structure
+      if options[:field_definitions]
+        definition[:fieldDefinitions] = options[:field_definitions].filter_map do |field|
+          field_def = build_field_definition(field)
+          field_needs_validations = is_metaobject_reference_type?(field[:type])
+          
+          if field[:validations]
+            begin
+              converted_validations = convert_validations_types_to_gids(field[:validations])
+              field_def[:validations] = converted_validations if converted_validations&.any?
+            rescue RuntimeError => e
+              if e.message.include?("not found")
+                @@pending_field_validations << {
+                  metaobject_type: type,
+                  field_key: field[:key],
+                  field_definition: field,
+                  validations: field[:validations]
+                }
+                say "Deferring field '#{field[:key]}' in '#{type}' (missing dependency)"
+                
+                if field_needs_validations
+                  next # Skip this field entirely
+                end
+              end
+            end
+          elsif field_needs_validations
+            next # Skip fields that need validations but don't have any
+          end
+
+          field_def
+        end
+        
+        definition.delete(:field_definitions)
+      end
+
+      # Remove admin access to avoid API restrictions
+      if definition[:access]&.is_a?(Hash)
+        definition[:access] = definition[:access].dup
+        definition[:access].delete("admin") if definition[:access]["admin"]
+        definition.delete(:access) if definition[:access].empty?
+      end
+
+      # Clean up empty validations arrays that cause API errors
+      if definition[:fieldDefinitions]
+        definition[:fieldDefinitions].each do |field_def|
+          field_def.delete(:validations) if field_def[:validations]&.empty?
+        end
+      end
+      
+      result = create_metaobject_definition_immediate(definition)
+      result
+    end
+  end
+
+  def add_field_validations_to_metaobject(metaobject_type, field_key, validations, item = nil)
+    # Get the existing metaobject definition
+    existing_gid = get_metaobject_definition_gid(metaobject_type)
+    unless existing_gid
+      say "Error: Cannot add validations to '#{metaobject_type}' - metaobject not found"
+      return false
+    end
+
+    begin
+      converted_validations = convert_validations_types_to_gids(validations)
+      
+      if converted_validations&.any?
+        # Use the passed item, or try to find it (for backward compatibility)
+        if item.nil?
+          item = @@pending_field_validations.find { |pending_item| 
+            pending_item[:metaobject_type] == metaobject_type && pending_item[:field_key] == field_key 
+          }
+        end
+        
+        if item && item[:field_definition]
+          field_def = item[:field_definition]
+          new_field = build_field_definition(field_def, converted_validations)
+          
+          field_operation = { create: new_field }
+          update_metaobject_definition(metaobject_type, fieldDefinitions: [field_operation])
+          
+          say "Added field '#{field_key}' to '#{metaobject_type}'"
+          return true
+        else
+          return false
+        end
+      else
+        return false
+      end
+      
+    rescue RuntimeError
+      return false # Keep trying later or don't retry errors
+    end
+  end
+
+  private
+
+  def build_field_definition(field, validations = nil)
+    field_def = {
+      key: field[:key].to_s,
+      name: field[:name],
+      type: field[:type].to_s
+    }
+    field_def[:description] = field[:description] if field[:description]
+    field_def[:required] = field[:required] if field[:required]
+    field_def[:validations] = validations if validations&.any?
+    field_def
+  end
+
+  def create_metaobject_definition_immediate(definition)
+    # https://shopify.dev/docs/api/admin-graphql/2024-10/mutations/metaobjectDefinitionCreate
     query =
       "# GraphQL
       mutation CreateMetaobjectDefinition($definition: MetaobjectDefinitionCreateInput!) {
@@ -47,32 +184,13 @@ module ShopifyToolkit::MetaobjectStatements
         }
       }
       "
-    variables = { definition: { type:, **options } }
+    variables = { definition: definition }
 
     shopify_admin_client
       .query(query:, variables:)
       .tap { handle_shopify_admin_client_errors(_1, "data.metaobjectDefinitionCreate.userErrors") }
   end
 
-  def get_metaobject_definition_gid(type)
-    result =
-      shopify_admin_client
-        .query(
-          query:
-            "# GraphQL
-              query GetMetaobjectDefinitionID($type: String!) {
-                metaobjectDefinitionByType(type: $type) {
-                  id
-                }
-              }",
-          variables: { type: type.to_s },
-        )
-        .tap { handle_shopify_admin_client_errors(_1) }
-        .body
-
-    result.dig("data", "metaobjectDefinitionByType", "id")
-  end
-
   def update_metaobject_definition(type, **options)
     existing_gid = get_metaobject_definition_gid(type)
 

data/lib/shopify_toolkit/metaobject_utilities.rb

@@ -0,0 +1,107 @@
+# frozen_string_literal: true
+
+require "active_support/concern"
+
+module ShopifyToolkit::MetaobjectUtilities
+  extend ActiveSupport::Concern
+  include ShopifyToolkit::AdminClient
+
+  def is_metaobject_reference_type?(type)
+    type.to_sym.in?([:metaobject_reference, :"list.metaobject_reference", :mixed_reference, :"list.mixed_reference"])
+  end
+
+  def convert_validations_types_to_gids(validations)
+    return validations unless validations&.any?
+
+    validations.filter_map do |validation|
+      convert_metaobject_validation(validation)
+    end
+  end
+
+  def get_metaobject_definition_gid(type)
+    result =
+      shopify_admin_client
+        .query(
+          query:
+            "# GraphQL
+              query GetMetaobjectDefinitionID($type: String!) {
+                metaobjectDefinitionByType(type: $type) {
+                  id
+                }
+              }",
+          variables: { type: type.to_s },
+        )
+        .tap { handle_shopify_admin_client_errors(_1) }
+        .body
+
+    gid = result.dig("data", "metaobjectDefinitionByType", "id")
+
+    return gid
+  end
+
+  def get_metaobject_definition_type_by_gid(gid)
+    result =
+      shopify_admin_client
+        .query(
+          query:
+            "# GraphQL
+              query GetMetaobjectDefinitionType($id: ID!) {
+                metaobjectDefinition(id: $id) {
+                  type
+                }
+              }",
+          variables: { id: gid },
+        )
+        .tap { handle_shopify_admin_client_errors(_1) }
+        .body
+
+    result.dig("data", "metaobjectDefinition", "type")
+  end
+
+  private
+
+  def convert_metaobject_validation(validation)
+    name = validation[:name] || validation["name"]
+    value = validation[:value] || validation["value"]
+
+    return validation unless metaobject_type_validation?(name) && value
+
+    parsed_value = parse_json_if_needed(value)
+    convert_types_to_gids(parsed_value)
+  end
+
+  def metaobject_type_validation?(name)
+    name.in?(["metaobject_definition_type", "metaobject_definition_types"])
+  end
+
+  def parse_json_if_needed(value)
+    return value unless value.is_a?(String) && value.start_with?("[") && value.end_with?("]")
+
+    JSON.parse(value)
+  rescue JSON::ParserError
+    value
+  end
+
+  def convert_types_to_gids(value)
+    if value.is_a?(Array)
+      convert_array_types_to_gids(value)
+    else
+      convert_single_type_to_gid(value)
+    end
+  end
+
+  def convert_array_types_to_gids(types)
+    gids = types.map do |type|
+      gid = get_metaobject_definition_gid(type)
+      raise "Metaobject type '#{type}' not found" unless gid
+      gid
+    end
+    { name: "metaobject_definition_ids", value: gids.to_json }
+  end
+
+  def convert_single_type_to_gid(type)
+    gid = get_metaobject_definition_gid(type)
+    raise "Metaobject type '#{type}' not found" unless gid
+    { name: "metaobject_definition_id", value: gid }
+  end
+end

data/lib/shopify_toolkit/migrator.rb

@@ -6,6 +6,7 @@ require "active_support/core_ext/module/delegation"
 class ShopifyToolkit::Migrator # :nodoc:
   include ShopifyToolkit::AdminClient
   include ShopifyToolkit::MetafieldStatements
+  include ShopifyToolkit::MetaobjectStatements
 
   singleton_class.attr_accessor :migrations_paths
   self.migrations_paths = ["config/shopify/migrate"]

data/lib/shopify_toolkit/schema.rb

@@ -8,6 +8,8 @@ require "active_support/core_ext/module/delegation"
 module ShopifyToolkit::Schema
   extend self
   include ShopifyToolkit::MetafieldStatements
+  include ShopifyToolkit::MetaobjectStatements
+  include ShopifyToolkit::MetaobjectUtilities
   include ShopifyToolkit::Migration::Logging
 
   delegate :logger, to: Rails
@@ -50,8 +52,19 @@ module ShopifyToolkit::Schema
     end
 
     announce "Loading metafield schema from #{path}"
-    say_with_time "Executing schema statements" do
-      load path
+
+    # Parse the schema file to separate metaobject and metafield definitions
+    schema_content = File.read(path)
+
+    say_with_time "Executing metaobject definitions" do
+      # Execute only metaobject definitions first
+      execute_metaobject_definitions(schema_content)
+      apply_pending_field_validations
+    end
+
+    say_with_time "Executing metafield definitions" do
+      # Execute only metafield definitions after all metaobjects exist
+      execute_metafield_definitions(schema_content)
     end
   end
 
@@ -69,6 +82,66 @@ module ShopifyToolkit::Schema
     instance_eval(&block)
   end
 
+  def convert_validations_gids_to_types(validations, metafield_type)
+    return validations unless validations&.any? && is_metaobject_reference_type?(metafield_type)
+
+    validations.filter_map do |validation|
+      convert_metaobject_validation_to_type(validation)
+    end
+  end
+
+  private
+
+  def convert_metaobject_validation_to_type(validation)
+    name = validation["name"]
+    value = validation["value"]
+
+    return validation unless metaobject_gid_validation?(name)
+
+    parsed_value = parse_json_if_needed(value)
+    convert_gids_to_types(validation, parsed_value)
+  end
+
+  def metaobject_gid_validation?(name)
+    name.in?(["metaobject_definition_id", "metaobject_definition_ids"])
+  end
+
+  def convert_gids_to_types(validation, value)
+    if value.is_a?(Array)
+      convert_array_gids_to_types(validation, value)
+    else
+      convert_single_gid_to_type(validation, value)
+    end
+  end
+
+  def convert_array_gids_to_types(validation, gids)
+    types = gids.filter_map { |gid| convert_gid_to_type_if_valid(gid) }
+
+    return nil unless types.any?
+
+    validation.merge("name" => "metaobject_definition_types", "value" => types)
+  end
+
+  def convert_single_gid_to_type(validation, gid)
+    type = convert_gid_to_type_if_valid(gid)
+
+    return nil unless type
+
+    validation.merge("name" => "metaobject_definition_type", "value" => type)
+  end
+
+  def convert_gid_to_type_if_valid(gid)
+    return gid unless gid&.start_with?("gid://shopify/MetaobjectDefinition/")
+
+    type = get_metaobject_definition_type_by_gid(gid)
+
+    if type.nil?
+      say "Warning: Metafield validation references unknown metaobject GID #{gid} - excluding from portable schema"
+    end
+
+    type
+  end
+
   def fetch_definitions(owner_type:)
     owner_type = owner_type.to_s.singularize.upcase
 
@@ -116,15 +189,64 @@ module ShopifyToolkit::Schema
     result.dig("data", "metafieldDefinitions", "nodes") || []
   end
 
+  def fetch_metaobject_definitions
+    query = <<~GRAPHQL
+      query {
+        metaobjectDefinitions(first: 250) {
+          nodes {
+            id
+            type
+            name
+            description
+            fieldDefinitions {
+              key
+              name
+              description
+              type {
+                name
+              }
+              required
+              validations {
+                name
+                value
+              }
+            }
+            access {
+              admin
+              storefront
+            }
+            capabilities {
+              publishable {
+                enabled
+              }
+              translatable {
+                enabled
+              }
+            }
+          }
+        }
+      }
+    GRAPHQL
+
+    result =
+      shopify_admin_client
+        .query(query:)
+        .tap { handle_shopify_admin_client_errors(_1) }
+        .body
+
+    result.dig("data", "metaobjectDefinitions", "nodes") || []
+  end
+
   def generate_schema_content
-    definitions =
+    metaobject_definitions = fetch_metaobject_definitions
+    metafield_definitions =
       OWNER_TYPES.flat_map { |owner_type| fetch_definitions(owner_type:) }
 
     content = StringIO.new
     content << <<~RUBY
-      # This file is auto-generated from the current state of the Shopify metafields.
-      # Instead of editing this file, please use the metafields migration feature of ShopifyToolkit
-      # to incrementally modify your metafields, and then regenerate this schema definition.
+      # This file is auto-generated from the current state of the Shopify metafields and metaobjects.
+      # Instead of editing this file, please use the migration features of ShopifyToolkit
+      # to incrementally modify your metafields and metaobjects, and then regenerate this schema definition.
       #
       # This file is the source used to define your metafields when running `bin/rails shopify:schema:load`.
       #
@@ -132,8 +254,59 @@ module ShopifyToolkit::Schema
       ShopifyToolkit::Schema.define do
     RUBY
 
-    # Sort for consistent output
-    definitions
+    # Add metaobject definitions first
+    metaobject_definitions
+      .sort_by { _1["type"] }
+      .each do |definition|
+        type = definition["type"]
+        name = definition["name"]
+        description = definition["description"]
+
+        field_definitions = definition["fieldDefinitions"]&.map do |field|
+          field_hash = {
+            key: field["key"].to_sym,
+            type: field["type"]["name"].to_sym,
+            name: field["name"]
+          }
+          field_hash[:description] = field["description"] if field["description"] && !field["description"].empty?
+          field_hash[:required] = field["required"] if field["required"] == true
+
+          # Convert validations for metaobject reference fields within metaobjects
+          if field["validations"]&.any? && is_metaobject_reference_type?(field["type"]["name"])
+            field_hash[:validations] = convert_validations_gids_to_types(field["validations"], field["type"]["name"])&.map { |v| v.transform_keys(&:to_sym) }
+          elsif field["validations"]&.any?
+            field_hash[:validations] = field["validations"]&.map { |v| v.transform_keys(&:to_sym) }
+          end
+
+          field_hash
+        end
+
+        access = definition["access"]
+        capabilities = definition["capabilities"]
+
+        args = [type.to_sym]
+        kwargs = { name: name }
+        kwargs[:description] = description if description && !description.empty?
+        kwargs[:field_definitions] = field_definitions if field_definitions&.any?
+        kwargs[:access] = access if access&.any?
+
+        # Add capabilities if non-default
+        if capabilities&.any? { |_, v| v["enabled"] == true }
+          kwargs[:capabilities] = capabilities.transform_keys(&:to_sym).transform_values { |v| v.transform_keys(&:to_sym) }
+        end
+
+        args_string = args.map(&:inspect).join(", ")
+        kwargs_string = kwargs.map { |k, v| "#{k}: #{v.inspect}" }.join(", ")
+        content.puts "  create_metaobject_definition #{args_string}, #{kwargs_string}"
+      end
+
+    # Add blank line between metaobjects and metafields if both exist
+    if metaobject_definitions.any? && metafield_definitions.any?
+      content.puts ""
+    end
+
+    # Add metafield definitions
+    metafield_definitions
       .sort_by { [_1["ownerType"], _1["namespace"], _1["key"]] }
       .each do
         owner_type = _1["ownerType"].downcase.pluralize.to_sym
@@ -142,7 +315,7 @@ module ShopifyToolkit::Schema
         name = _1["name"]
         namespace = _1["namespace"]&.to_sym
         description = _1["description"]
-        validations = _1["validations"]&.map { |v| v.transform_keys(&:to_sym) }
+        validations = convert_validations_gids_to_types(_1["validations"], type)&.map { |v| v.transform_keys(&:to_sym) }
         capabilities =
           _1["capabilities"]
             &.transform_keys(&:to_sym)
@@ -152,10 +325,10 @@ module ShopifyToolkit::Schema
         kwargs = { name: name }
         kwargs[:namespace] = namespace if namespace && namespace != :custom
         kwargs[:description] = description if description
-        kwargs[:validations] = validations if validations.present?
+        kwargs[:validations] = validations if validations&.any?
 
         # Only include capabilities if they have non-default values
-        if capabilities.present?
+        if capabilities&.any?
           has_non_default_capabilities =
             capabilities.any? do |cap, value|
               case cap
@@ -176,4 +349,43 @@ module ShopifyToolkit::Schema
     content.puts "end"
     content.string
   end
+
+  def execute_metaobject_definitions(schema_content)
+    # Create a filtered version that only includes metaobject definitions
+    metaobject_content = filter_schema_content(schema_content, :metaobject)
+    eval_schema_content(metaobject_content)
+  end
+
+  def execute_metafield_definitions(schema_content)
+    # Create a filtered version that only includes metafield definitions
+    metafield_content = filter_schema_content(schema_content, :metafield)
+    eval_schema_content(metafield_content)
+  end
+
+  def filter_schema_content(schema_content, type)
+    lines = schema_content.lines
+    filtered_lines = []
+
+    # Always include the header and footer
+    filtered_lines << lines.first(8) # Header lines up to "ShopifyToolkit::Schema.define do"
+    filtered_lines.flatten!
+
+    lines.each do |line|
+      case type
+      when :metaobject
+        if line.strip.start_with?("create_metaobject_definition")
+          filtered_lines << line
+        end
+      when :metafield
+        filtered_lines << line if line.strip.start_with?("create_metafield")
+      end
+    end
+
+    filtered_lines << "end\n" # Closing line
+    filtered_lines.join
+  end
+
+  def eval_schema_content(content)
+    instance_eval(content)
+  end
 end

data/lib/shopify_toolkit/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module ShopifyToolkit
-  VERSION = "0.5.0"
+  VERSION = "0.5.2"
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: shopify_toolkit
 version: !ruby/object:Gem::Version
-  version: 0.5.0
+  version: 0.5.2
 platform: ruby
 authors:
 - Elia Schito
@@ -9,7 +9,7 @@ authors:
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2025-06-03 00:00:00.000000000 Z
+date: 2025-10-31 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: railties
@@ -114,6 +114,7 @@ files:
 - lib/shopify_toolkit/command_line.rb
 - lib/shopify_toolkit/metafield_statements.rb
 - lib/shopify_toolkit/metaobject_statements.rb
+- lib/shopify_toolkit/metaobject_utilities.rb
 - lib/shopify_toolkit/migration.rb
 - lib/shopify_toolkit/migration/logging.rb
 - lib/shopify_toolkit/migrator.rb
@@ -144,7 +145,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.5.3
+rubygems_version: 3.5.16
 signing_key:
 specification_version: 4
 summary: A collection of tools for dealing with Shopify apps.