Provide defaults for attributes

Author: nirebu

lib/active_shopify_graphql/base.rb

@@ -38,8 +38,9 @@ def graphql_type_for_loader(loader_class)
       # @param path [String] The GraphQL field path (auto-inferred if not provided)
       # @param type [Symbol] The type for coercion (:string, :integer, :float, :boolean, :datetime). Arrays are preserved automatically.
       # @param null [Boolean] Whether the attribute can be null (default: true)
+      # @param default [Object] Default value to use when the GraphQL response is nil
       # @param transform [Proc] Custom transform block for the value
-      def attribute(name, path: nil, type: :string, null: true, transform: nil)
+      def attribute(name, path: nil, type: :string, null: true, default: nil, transform: nil)
         @base_attributes ||= {}
 
         # Auto-infer GraphQL path for simple cases: display_name -> displayName
@@ -49,6 +50,7 @@ def attribute(name, path: nil, type: :string, null: true, transform: nil)
           path: path,
           type: type,
           null: null,
+          default: default,
           transform: transform
         }
 
@@ -62,8 +64,9 @@ def attribute(name, path: nil, type: :string, null: true, transform: nil)
       # @param key [String] The metafield key
       # @param type [Symbol] The type for coercion (:string, :integer, :float, :boolean, :datetime, :json). Arrays are preserved automatically.
       # @param null [Boolean] Whether the attribute can be null (default: true)
+      # @param default [Object] Default value to use when the GraphQL response is nil
       # @param transform [Proc] Custom transform block for the value
-      def metafield_attribute(name, namespace:, key:, type: :string, null: true, transform: nil)
+      def metafield_attribute(name, namespace:, key:, type: :string, null: true, default: nil, transform: nil)
         @base_attributes ||= {}
         @metafields ||= {}
 
@@ -83,6 +86,7 @@ def metafield_attribute(name, namespace:, key:, type: :string, null: true, trans
           path: path,
           type: type,
           null: null,
+          default: default,
           transform: transform,
           is_metafield: true,
           metafield_alias: alias_name,
@@ -135,13 +139,13 @@ def metafields
       private
 
       # Override attribute method to handle loader context
-      def attribute_with_context(name, path: nil, type: :string, null: true, transform: nil)
+      def attribute_with_context(name, path: nil, type: :string, null: true, default: nil, transform: nil)
         if @current_loader_context
           # Auto-infer path if not provided
           path ||= infer_path(name)
-          @loader_contexts[@current_loader_context][name] = { path: path, type: type, null: null, transform: transform }
+          @loader_contexts[@current_loader_context][name] = { path: path, type: type, null: null, default: default, transform: transform }
         else
-          attribute_without_context(name, path: path, type: type, null: null, transform: transform)
+          attribute_without_context(name, path: path, type: type, null: null, default: default, transform: transform)
         end
 
         # Always create attr_accessor for the attribute on base model
@@ -174,6 +178,7 @@ def metafield_attribute_with_context(name, **options)
             path: path,
             type: type,
             null: options[:null] || true,
+            default: options[:default],
             transform: options[:transform],
             is_metafield: true,
             metafield_alias: alias_name,

lib/active_shopify_graphql/loader.rb

@@ -31,7 +31,7 @@ def model_class
       attr_writer :model_class
 
       # For backward compatibility - loaders can still define attributes directly
-      def attribute(name, path: nil, type: :string, null: true, transform: nil)
+      def attribute(name, path: nil, type: :string, null: true, default: nil, transform: nil)
         @attributes ||= {}
 
         # Auto-infer GraphQL path for simple cases: display_name -> displayName
@@ -41,12 +41,13 @@ def attribute(name, path: nil, type: :string, null: true, transform: nil)
           path: path,
           type: type,
           null: null,
+          default: default,
           transform: transform
         }
       end
 
       # For backward compatibility - loaders can still define metafield attributes directly
-      def metafield_attribute(name, namespace:, key:, type: :string, null: true, transform: nil)
+      def metafield_attribute(name, namespace:, key:, type: :string, null: true, default: nil, transform: nil)
         @attributes ||= {}
         @metafields ||= {}
 
@@ -66,6 +67,7 @@ def metafield_attribute(name, namespace:, key:, type: :string, null: true, trans
           path: path,
           type: type,
           null: null,
+          default: default,
           transform: transform,
           is_metafield: true,
           metafield_alias: alias_name,
@@ -436,18 +438,25 @@ def map_response_from_attributes(response_data)
         # Use dig to safely extract the value
         value = root_data.dig(*path_parts)
 
-        # Validate null constraint
-        raise ArgumentError, "Attribute '#{attr_name}' (GraphQL path: '#{path}') cannot be null but received nil" if !config[:null] && value.nil?
-
-        # Apply type coercion if value is not nil
+        # Handle nil values with defaults or transforms
         if value.nil?
-          result[attr_name] = nil
-        else
-          # Apply custom transform first, then type coercion
-          value = config[:transform].call(value) if config[:transform]
-
-          result[attr_name] = coerce_value(value, config[:type], attr_name, path)
+          # Use default value if provided (more efficient than transform for simple defaults)
+          if !config[:default].nil?
+            value = config[:default]
+          elsif config[:transform]
+            # Only call transform if no default is provided
+            value = config[:transform].call(value)
+          end
+        elsif config[:transform]
+          # Apply transform to non-nil values
+          value = config[:transform].call(value)
         end
+
+        # Validate null constraint after applying defaults/transforms
+        raise ArgumentError, "Attribute '#{attr_name}' (GraphQL path: '#{path}') cannot be null but received nil" if !config[:null] && value.nil?
+
+        # Apply type coercion
+        result[attr_name] = value.nil? ? nil : coerce_value(value, config[:type], attr_name, path)
       end
 
       result

spec/active_shopify_graphql/metafield_attributes_spec.rb

@@ -199,6 +199,110 @@ def execute_graphql_query(_query, **_variables)
       expect(attributes[:tags]).to eq(%w[TAG1 TAG2])
     end
 
+    it "handles nil metafields with default values" do
+      default_loader = Class.new(ActiveShopifyGraphQL::Loader) do
+        graphql_type "Product"
+
+        metafield_attribute :missing_string, namespace: 'custom', key: 'missing_str', type: :string,
+                                             default: "default_value"
+
+        metafield_attribute :missing_json, namespace: 'custom', key: 'missing_json', type: :json,
+                                           default: { "default" => true }
+
+        metafield_attribute :missing_integer, namespace: 'custom', key: 'missing_int', type: :integer,
+                                              default: 42
+
+        def execute_graphql_query(_query, **_variables)
+          {
+            "data" => {
+              "product" => {
+                "missing_stringMetafield" => nil,
+                "missing_jsonMetafield" => nil,
+                "missing_integerMetafield" => nil
+              }
+            }
+          }
+        end
+      end
+
+      loader = default_loader.new
+      attributes = loader.load_attributes("test-id")
+
+      expect(attributes[:missing_string]).to eq("default_value")
+      expect(attributes[:missing_json]).to eq({ "default" => true })
+      expect(attributes[:missing_integer]).to eq(42)
+    end
+
+    it "handles nil metafields with transform blocks providing defaults" do
+      transform_loader = Class.new(ActiveShopifyGraphQL::Loader) do
+        graphql_type "Product"
+
+        metafield_attribute :missing_string, namespace: 'custom', key: 'missing', type: :string,
+                                             transform: ->(value) { value.nil? ? "transform_default" : value }
+
+        metafield_attribute :missing_json, namespace: 'custom', key: 'json', type: :json,
+                                           transform: ->(value) { value.nil? ? { "transform" => true } : value }
+
+        def execute_graphql_query(_query, **_variables)
+          {
+            "data" => {
+              "product" => {
+                "missing_stringMetafield" => nil,
+                "missing_jsonMetafield" => nil
+              }
+            }
+          }
+        end
+      end
+
+      loader = transform_loader.new
+      attributes = loader.load_attributes("test-id")
+
+      expect(attributes[:missing_string]).to eq("transform_default")
+      expect(attributes[:missing_json]).to eq({ "transform" => true })
+    end
+
+    it "prefers default over transform for nil values (optimization)" do
+      call_count = 0
+
+      mixed_loader = Class.new(ActiveShopifyGraphQL::Loader) do
+        graphql_type "Product"
+
+        # This should use default and NOT call transform
+        metafield_attribute :with_default, namespace: 'custom', key: 'def', type: :string,
+                                           default: "default_used",
+                                           transform: lambda { |value|
+                                             call_count += 1
+                                             "transform_should_not_be_called"
+                                           }
+
+        # This should call transform since no default
+        metafield_attribute :with_transform, namespace: 'custom', key: 'trans', type: :string,
+                                             transform: lambda { |value|
+                                               call_count += 1
+                                               "transform_called"
+                                             }
+
+        def execute_graphql_query(_query, **_variables)
+          {
+            "data" => {
+              "product" => {
+                "with_defaultMetafield" => nil,
+                "with_transformMetafield" => nil
+              }
+            }
+          }
+        end
+      end
+
+      loader = mixed_loader.new
+      attributes = loader.load_attributes("test-id")
+
+      expect(attributes[:with_default]).to eq("default_used")
+      expect(attributes[:with_transform]).to eq("transform_called")
+      expect(call_count).to eq(1) # Only transform should be called once
+    end
+
     it "generates unique aliases for metafields with same namespace/key but different names" do
       multi_loader = Class.new(ActiveShopifyGraphQL::Loader) do
         graphql_type "Product"