From efa1939707b24d29680c1dc13dd911cf258160be Mon Sep 17 00:00:00 2001 From: Gianluca Elia <34285663+gianlukk994@users.noreply.github.com> Date: Wed, 15 Oct 2025 12:55:16 +0200 Subject: [PATCH 1/2] Add portable metaobject references in schema dumps Convert metaobject definition IDs to types in schema dumps to make them portable across different Shopify stores. Store-specific GIDs are now replaced with metaobject types that can be resolved in any store. Changes: - Add get_metaobject_definition_type_by_gid() method to resolve GIDs to types - Update schema dump to convert metaobject_definition_id validations to metaobject_definition_type - Enhance create_metafield and update_metafield to resolve types back to GIDs - Add precise validation matching for metaobject reference fields only - Support both single and array values for list.metaobject_reference fields - Include MetaobjectStatements in Schema module for type resolution Before: create_metafield :products, :color, :metaobject_reference, validations: [{name: "metaobject_definition_id", value: "gid://shopify/MetaobjectDefinition/123"}] After: create_metafield :products, :color, :metaobject_reference, validations: [{name: "metaobject_definition_type", value: "color_pattern"}] This enables schema files to be shared between different Shopify stores without manual ID updates, as long as the metaobject types exist. --- lib/shopify_toolkit/metafield_statements.rb | 43 +++ lib/shopify_toolkit/metaobject_statements.rb | 19 ++ lib/shopify_toolkit/schema.rb | 40 ++- spec/shopify_toolkit/schema_spec.rb | 260 ++++++++++++++++++- 4 files changed, 354 insertions(+), 8 deletions(-) diff --git a/lib/shopify_toolkit/metafield_statements.rb b/lib/shopify_toolkit/metafield_statements.rb index a8e972f0..a7804075 100644 --- a/lib/shopify_toolkit/metafield_statements.rb +++ b/lib/shopify_toolkit/metafield_statements.rb @@ -20,6 +20,11 @@ def self.log_time(method_name) def create_metafield(owner_type, key, type, namespace: :custom, name:, **options) ownerType = owner_type.to_s.singularize.upcase # Eg. "PRODUCT" + # Process validations to convert metaobject types to GIDs (only for metaobject reference fields) + if options[:validations] && is_metaobject_reference_type?(type) + options[:validations] = convert_validations_types_to_gids(options[:validations]) + end + # Skip creation if metafield already exists if get_metafield_gid(owner_type, key, namespace: namespace) say "Metafield #{namespace}:#{key} already exists for #{owner_type}, skipping creation" @@ -50,6 +55,39 @@ def create_metafield(owner_type, key, type, namespace: :custom, name:, **options .tap { handle_shopify_admin_client_errors(_1, "data.metafieldDefinitionCreate.userErrors") } end + def is_metaobject_reference_type?(type) + type_str = type.to_s + type_str == "metaobject_reference" || type_str == "list.metaobject_reference" + end + + def convert_validations_types_to_gids(validations) + return validations unless validations&.any? + + validations.map do |validation| + validation_name = validation[:name] || validation["name"] + validation_value = validation[:value] || validation["value"] + + if validation_name == "metaobject_definition_type" && validation_value + if validation_value.is_a?(Array) + # Handle array of types (for list.metaobject_reference) + gids = validation_value.map do |type| + gid = get_metaobject_definition_gid(type) + raise "Metaobject type '#{type}' not found" unless gid + gid + end + { name: "metaobject_definition_id", value: gids } + else + # Handle single type + gid = get_metaobject_definition_gid(validation_value) + raise "Metaobject type '#{validation_value}' not found" unless gid + { name: "metaobject_definition_id", value: gid } + end + else + validation + end + end + end + def get_metafield_gid(owner_type, key, namespace: :custom) ownerType = owner_type.to_s.singularize.upcase # Eg. "PRODUCT" @@ -112,6 +150,11 @@ def remove_metafield(owner_type, key, namespace: :custom, delete_associated_meta log_time \ def update_metafield(owner_type, key, namespace: :custom, **options) + # 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 + unless get_metafield_gid(owner_type, key, namespace: namespace) say "Metafield #{namespace}:#{key} not found for #{owner_type}, skipping update" return diff --git a/lib/shopify_toolkit/metaobject_statements.rb b/lib/shopify_toolkit/metaobject_statements.rb index 6c2dcb82..f4c4e3f4 100644 --- a/lib/shopify_toolkit/metaobject_statements.rb +++ b/lib/shopify_toolkit/metaobject_statements.rb @@ -73,6 +73,25 @@ def get_metaobject_definition_gid(type) result.dig("data", "metaobjectDefinitionByType", "id") 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 + def update_metaobject_definition(type, **options) existing_gid = get_metaobject_definition_gid(type) diff --git a/lib/shopify_toolkit/schema.rb b/lib/shopify_toolkit/schema.rb index 9e8370ad..71a40d0f 100644 --- a/lib/shopify_toolkit/schema.rb +++ b/lib/shopify_toolkit/schema.rb @@ -8,6 +8,7 @@ module ShopifyToolkit::Schema extend self include ShopifyToolkit::MetafieldStatements + include ShopifyToolkit::MetaobjectStatements include ShopifyToolkit::Migration::Logging delegate :logger, to: Rails @@ -69,6 +70,43 @@ def define(&block) instance_eval(&block) end + def convert_validations_gids_to_types(validations, metafield_type) + unless validations&.any? && is_metaobject_reference_type?(metafield_type) + return validations + end + + validations.map do |validation| + if validation["name"] == "metaobject_definition_id" + value = validation["value"] + + if value.is_a?(Array) + # Handle array of GIDs (for list.metaobject_reference) + types = value.filter_map do |gid| + if gid&.start_with?("gid://shopify/MetaobjectDefinition/") + get_metaobject_definition_type_by_gid(gid) + else + gid # Keep non-GID values as-is + end + end + validation.merge("name" => "metaobject_definition_type", "value" => types) + elsif value&.start_with?("gid://shopify/MetaobjectDefinition/") + # Handle single GID + type = get_metaobject_definition_type_by_gid(value) + validation.merge("name" => "metaobject_definition_type", "value" => type) + else + validation + end + else + validation + end + end + end + + def is_metaobject_reference_type?(type) + type_str = type.to_s + type_str == "metaobject_reference" || type_str == "list.metaobject_reference" + end + def fetch_definitions(owner_type:) owner_type = owner_type.to_s.singularize.upcase @@ -142,7 +180,7 @@ def generate_schema_content 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) diff --git a/spec/shopify_toolkit/schema_spec.rb b/spec/shopify_toolkit/schema_spec.rb index 4e88ad84..c3d3340b 100644 --- a/spec/shopify_toolkit/schema_spec.rb +++ b/spec/shopify_toolkit/schema_spec.rb @@ -7,21 +7,37 @@ let(:root) { Pathname(Dir.mktmpdir) } let(:definitions_by_owner) do - { products: [product_definition], articles: [article_definition] } + { + products: [ + product_definition, + metaobject_reference_definition, + list_metaobject_reference_definition + ], + articles: [article_definition] + } end before do allow(Rails).to receive(:root).and_return(root) root.join("config/shopify").mkpath - ShopifyToolkit::Schema::OWNER_TYPES.each do |owner_type| - allow(schema).to receive(:fetch_definitions).with( - owner_type: owner_type - ).and_return(definitions_by_owner.fetch(owner_type, [])) - end + # Mock metaobject type resolution + allow(schema).to receive(:get_metaobject_definition_type_by_gid).with( + "gid://shopify/MetaobjectDefinition/123" + ).and_return("color_pattern") + allow(schema).to receive(:get_metaobject_definition_type_by_gid).with( + "gid://shopify/MetaobjectDefinition/456" + ).and_return("size_chart") end describe "#dump!" do + before do + ShopifyToolkit::Schema::OWNER_TYPES.each do |owner_type| + allow(schema).to receive(:fetch_definitions).with( + owner_type: owner_type + ).and_return(definitions_by_owner.fetch(owner_type, [])) + end + end let(:product_definition) do { "id" => "gid://shopify/MetafieldDefinition/1", @@ -80,6 +96,75 @@ } end + let(:metaobject_reference_definition) do + { + "id" => "gid://shopify/MetafieldDefinition/3", + "name" => "Color Pattern", + "key" => "color_pattern", + "type" => { + "name" => "metaobject_reference" + }, + "namespace" => "custom", + "description" => "Product color pattern", + "validations" => [ + { + "name" => "metaobject_definition_id", + "value" => "gid://shopify/MetaobjectDefinition/123" + } + ], + "capabilities" => { + "smartCollectionCondition" => { + "enabled" => false + }, + "adminFilterable" => { + "enabled" => false + } + }, + "access" => { + "admin" => true, + "customerAccount" => false, + "storefront" => false + }, + "ownerType" => "PRODUCT" + } + end + + let(:list_metaobject_reference_definition) do + { + "id" => "gid://shopify/MetafieldDefinition/4", + "name" => "Allowed Patterns", + "key" => "allowed_patterns", + "type" => { + "name" => "list.metaobject_reference" + }, + "namespace" => "custom", + "description" => "List of allowed patterns", + "validations" => [ + { + "name" => "metaobject_definition_id", + "value" => %w[ + gid://shopify/MetaobjectDefinition/123 + gid://shopify/MetaobjectDefinition/456 + ] + } + ], + "capabilities" => { + "smartCollectionCondition" => { + "enabled" => false + }, + "adminFilterable" => { + "enabled" => false + } + }, + "access" => { + "admin" => true, + "customerAccount" => false, + "storefront" => false + }, + "ownerType" => "PRODUCT" + } + end + SCHEMA_FIXTURE_BEFORE_RUBY_3_4 = <<~RUBY.freeze # 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 @@ -90,6 +175,8 @@ # It's strongly recommended that you check this file into your version control system. ShopifyToolkit::Schema.define do create_metafield :articles, :my_metafield_2, :integer, name: "My Metafield 2", namespace: :my_namespace, capabilities: {:smartCollectionCondition=>{:enabled=>false}, :adminFilterable=>{:enabled=>true}} + create_metafield :products, :allowed_patterns, :"list.metaobject_reference", name: "Allowed Patterns", description: "List of allowed patterns", validations: [{:name=>"metaobject_definition_type", :value=>["color_pattern", "size_chart"]}] + create_metafield :products, :color_pattern, :metaobject_reference, name: "Color Pattern", description: "Product color pattern", validations: [{:name=>"metaobject_definition_type", :value=>"color_pattern"}] create_metafield :products, :my_metafield, :single_line_text_field, name: "My Metafield", description: "My description", validations: [{:name=>"min_length", :value=>"1"}, {:name=>"max_length", :value=>"10"}], capabilities: {:smartCollectionCondition=>{:enabled=>true}, :adminFilterable=>{:enabled=>false}} end RUBY @@ -104,6 +191,8 @@ # It's strongly recommended that you check this file into your version control system. ShopifyToolkit::Schema.define do create_metafield :articles, :my_metafield_2, :integer, name: "My Metafield 2", namespace: :my_namespace, capabilities: {smartCollectionCondition: {enabled: false}, adminFilterable: {enabled: true}} + create_metafield :products, :allowed_patterns, :"list.metaobject_reference", name: "Allowed Patterns", description: "List of allowed patterns", validations: [{name: "metaobject_definition_type", value: ["color_pattern", "size_chart"]}] + create_metafield :products, :color_pattern, :metaobject_reference, name: "Color Pattern", description: "Product color pattern", validations: [{name: "metaobject_definition_type", value: "color_pattern"}] create_metafield :products, :my_metafield, :single_line_text_field, name: "My Metafield", description: "My description", validations: [{name: "min_length", value: "1"}, {name: "max_length", value: "10"}], capabilities: {smartCollectionCondition: {enabled: true}, adminFilterable: {enabled: false}} end RUBY @@ -111,8 +200,165 @@ it "dumps the schema to a file" do expect { schema.dump! }.to output(/Generating schema/).to_stdout - expected_schema = RUBY_VERSION.to_f < 3.4 ? SCHEMA_FIXTURE_BEFORE_RUBY_3_4 : SCHEMA_FIXTURE + expected_schema = + ( + if RUBY_VERSION.to_f < 3.4 + SCHEMA_FIXTURE_BEFORE_RUBY_3_4 + else + SCHEMA_FIXTURE + end + ) expect(root.join("config/shopify/schema.rb").read).to eq(expected_schema) end end + + describe "#convert_validations_gids_to_types" do + let(:schema) { described_class } + + before do + allow(schema).to receive(:get_metaobject_definition_type_by_gid).with( + "gid://shopify/MetaobjectDefinition/123" + ).and_return("color_pattern") + allow(schema).to receive(:get_metaobject_definition_type_by_gid).with( + "gid://shopify/MetaobjectDefinition/456" + ).and_return("size_chart") + end + + it "converts single metaobject definition ID to type for metaobject_reference fields" do + validations = [ + { + "name" => "metaobject_definition_id", + "value" => "gid://shopify/MetaobjectDefinition/123" + } + ] + result = + schema.convert_validations_gids_to_types( + validations, + "metaobject_reference" + ) + + expect(result).to eq( + [{ "name" => "metaobject_definition_type", "value" => "color_pattern" }] + ) + end + + it "converts array of metaobject definition IDs to types for list.metaobject_reference fields" do + validations = [ + { + "name" => "metaobject_definition_id", + "value" => %w[ + gid://shopify/MetaobjectDefinition/123 + gid://shopify/MetaobjectDefinition/456 + ] + } + ] + result = + schema.convert_validations_gids_to_types( + validations, + "list.metaobject_reference" + ) + + expect(result).to eq( + [ + { + "name" => "metaobject_definition_type", + "value" => %w[color_pattern size_chart] + } + ] + ) + end + + it "preserves non-GID values in arrays" do + validations = [ + { + "name" => "metaobject_definition_id", + "value" => %w[gid://shopify/MetaobjectDefinition/123 some_other_value] + } + ] + result = + schema.convert_validations_gids_to_types( + validations, + "list.metaobject_reference" + ) + + expect(result).to eq( + [ + { + "name" => "metaobject_definition_type", + "value" => %w[color_pattern some_other_value] + } + ] + ) + end + + it "does not convert validations for non-metaobject reference fields" do + validations = [ + { + "name" => "metaobject_definition_id", + "value" => "gid://shopify/MetaobjectDefinition/123" + } + ] + result = + schema.convert_validations_gids_to_types( + validations, + "single_line_text_field" + ) + + expect(result).to eq(validations) + end + + it "preserves other validation types unchanged" do + validations = [ + { "name" => "min_length", "value" => "1" }, + { + "name" => "metaobject_definition_id", + "value" => "gid://shopify/MetaobjectDefinition/123" + } + ] + result = + schema.convert_validations_gids_to_types( + validations, + "metaobject_reference" + ) + + expect(result).to eq( + [ + { "name" => "min_length", "value" => "1" }, + { "name" => "metaobject_definition_type", "value" => "color_pattern" } + ] + ) + end + end + + describe "#is_metaobject_reference_type?" do + let(:schema) { described_class } + + it "returns true for metaobject_reference" do + expect( + schema.is_metaobject_reference_type?("metaobject_reference") + ).to be true + expect( + schema.is_metaobject_reference_type?(:metaobject_reference) + ).to be true + end + + it "returns true for list.metaobject_reference" do + expect( + schema.is_metaobject_reference_type?("list.metaobject_reference") + ).to be true + expect( + schema.is_metaobject_reference_type?(:"list.metaobject_reference") + ).to be true + end + + it "returns false for other types" do + expect( + schema.is_metaobject_reference_type?("single_line_text_field") + ).to be false + expect(schema.is_metaobject_reference_type?("integer")).to be false + expect( + schema.is_metaobject_reference_type?("list.single_line_text_field") + ).to be false + end + end end From 5f8fb326b4310c7c8710b51cf4b31d9e87f2cc9c Mon Sep 17 00:00:00 2001 From: Gianluca Elia <34285663+gianlukk994@users.noreply.github.com> Date: Wed, 15 Oct 2025 15:15:09 +0200 Subject: [PATCH 2/2] Add metaobject definitions to schema dump Add support for dumping metaobject definitions in schema files with portable cross-store references. Metaobjects are now included before metafields in the schema dump output. Changes: - Add fetch_metaobject_definitions() method to retrieve metaobject schema - Include create_metaobject_definition calls in schema dump output - Convert metaobject references within metaobject fields to portable types - Update schema dump header to mention metaobjects - Order metaobjects before metafields in dump output - Handle metaobject field definitions, access controls, and capabilities - Skip default values (required: false, empty descriptions) for cleaner output Schema now generates: create_metaobject_definition :color_pattern, name: "Color Pattern", field_definitions: [{key: :name, type: :single_line_text_field, ...}], access: {admin: true, storefront: false} create_metafield :products, :color, :metaobject_reference, validations: [{name: "metaobject_definition_type", value: "color_pattern"}] This completes the portable schema dump feature by including both metaobjects and metafields with cross-store compatible references. --- lib/shopify_toolkit/schema.rb | 120 ++++++++++++++++++++++++++-- spec/shopify_toolkit/schema_spec.rb | 60 ++++++++++++-- 2 files changed, 166 insertions(+), 14 deletions(-) diff --git a/lib/shopify_toolkit/schema.rb b/lib/shopify_toolkit/schema.rb index 71a40d0f..76adc61e 100644 --- a/lib/shopify_toolkit/schema.rb +++ b/lib/shopify_toolkit/schema.rb @@ -154,15 +154,64 @@ def fetch_definitions(owner_type:) 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`. # @@ -170,8 +219,63 @@ def generate_schema_content 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? + + # Add access if non-default + if access && (access["admin"] != true || access["storefront"] != true) + kwargs[:access] = access.transform_keys(&:to_sym) + end + + # 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 @@ -190,10 +294,10 @@ def generate_schema_content 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 diff --git a/spec/shopify_toolkit/schema_spec.rb b/spec/shopify_toolkit/schema_spec.rb index c3d3340b..f40acdef 100644 --- a/spec/shopify_toolkit/schema_spec.rb +++ b/spec/shopify_toolkit/schema_spec.rb @@ -17,6 +17,47 @@ } end + let(:metaobject_definitions) do + [ + { + "id" => "gid://shopify/MetaobjectDefinition/123", + "type" => "color_pattern", + "name" => "Color Pattern", + "description" => "Product color patterns", + "fieldDefinitions" => [ + { + "key" => "name", + "name" => "Pattern Name", + "description" => "The name of the pattern", + "type" => { "name" => "single_line_text_field" }, + "required" => true, + "validations" => [ + { "name" => "min_length", "value" => "1" } + ] + }, + { + "key" => "related_pattern", + "name" => "Related Pattern", + "description" => nil, + "type" => { "name" => "metaobject_reference" }, + "required" => false, + "validations" => [ + { "name" => "metaobject_definition_id", "value" => "gid://shopify/MetaobjectDefinition/456" } + ] + } + ], + "access" => { + "admin" => true, + "storefront" => false + }, + "capabilities" => { + "publishable" => { "enabled" => true }, + "translatable" => { "enabled" => false } + } + } + ] + end + before do allow(Rails).to receive(:root).and_return(root) root.join("config/shopify").mkpath @@ -28,6 +69,9 @@ allow(schema).to receive(:get_metaobject_definition_type_by_gid).with( "gid://shopify/MetaobjectDefinition/456" ).and_return("size_chart") + + # Mock metaobject definitions fetch + allow(schema).to receive(:fetch_metaobject_definitions).and_return(metaobject_definitions) end describe "#dump!" do @@ -166,14 +210,16 @@ end SCHEMA_FIXTURE_BEFORE_RUBY_3_4 = <<~RUBY.freeze - # 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`. # # It's strongly recommended that you check this file into your version control system. ShopifyToolkit::Schema.define do + create_metaobject_definition :color_pattern, name: "Color Pattern", description: "Product color patterns", field_definitions: [{:key=>:name, :type=>:single_line_text_field, :name=>"Pattern Name", :description=>"The name of the pattern", :required=>true, :validations=>[{:name=>"min_length", :value=>"1"}]}, {:key=>:related_pattern, :type=>:metaobject_reference, :name=>"Related Pattern", :validations=>[{:name=>"metaobject_definition_type", :value=>"size_chart"}]}], access: {:admin=>true, :storefront=>false}, capabilities: {:publishable=>{:enabled=>true}, :translatable=>{:enabled=>false}} + create_metafield :articles, :my_metafield_2, :integer, name: "My Metafield 2", namespace: :my_namespace, capabilities: {:smartCollectionCondition=>{:enabled=>false}, :adminFilterable=>{:enabled=>true}} create_metafield :products, :allowed_patterns, :"list.metaobject_reference", name: "Allowed Patterns", description: "List of allowed patterns", validations: [{:name=>"metaobject_definition_type", :value=>["color_pattern", "size_chart"]}] create_metafield :products, :color_pattern, :metaobject_reference, name: "Color Pattern", description: "Product color pattern", validations: [{:name=>"metaobject_definition_type", :value=>"color_pattern"}] @@ -182,14 +228,16 @@ RUBY SCHEMA_FIXTURE = <<~RUBY.freeze - # 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`. # # It's strongly recommended that you check this file into your version control system. ShopifyToolkit::Schema.define do + create_metaobject_definition :color_pattern, name: "Color Pattern", description: "Product color patterns", field_definitions: [{key: :name, type: :single_line_text_field, name: "Pattern Name", description: "The name of the pattern", required: true, validations: [{name: "min_length", value: "1"}]}, {key: :related_pattern, type: :metaobject_reference, name: "Related Pattern", validations: [{name: "metaobject_definition_type", value: "size_chart"}]}], access: {admin: true, storefront: false}, capabilities: {publishable: {enabled: true}, translatable: {enabled: false}} + create_metafield :articles, :my_metafield_2, :integer, name: "My Metafield 2", namespace: :my_namespace, capabilities: {smartCollectionCondition: {enabled: false}, adminFilterable: {enabled: true}} create_metafield :products, :allowed_patterns, :"list.metaobject_reference", name: "Allowed Patterns", description: "List of allowed patterns", validations: [{name: "metaobject_definition_type", value: ["color_pattern", "size_chart"]}] create_metafield :products, :color_pattern, :metaobject_reference, name: "Color Pattern", description: "Product color pattern", validations: [{name: "metaobject_definition_type", value: "color_pattern"}]