Add conditional normalizes support to Solid::Model

diegolinhares · diegolinhares · commit ea286d3af3bd · 2026-01-27T20:05:00.000-03:00
diff --git a/docs/040_ADVANCED_USAGE.md b/docs/040_ADVANCED_USAGE.md
@@ -94,3 +94,77 @@ class User::Registration < Solid::Process
   end
 end
 ```
+
+## Input Normalization
+
+### Using `before_validation` (all Rails versions)
+
+The example above uses `before_validation` to normalize the email attribute. This approach works on all supported Rails versions, but normalization only runs when `valid?` is called:
+
+```ruby
+input do
+  attribute :email, :string
+
+  before_validation do
+    self.email = email.downcase.strip
+  end
+end
+```
+
+### Using `normalizes` (Rails 8.1+)
+
+Rails 8.1 introduced `ActiveModel::Attributes::Normalization`, which provides a declarative way to normalize attributes. When available, `Solid::Model` automatically includes it.
+
+Unlike `before_validation`, `normalizes` applies on attribute assignment, so the value is normalized immediately:
+
+```ruby
+input do
+  attribute :email, :string
+
+  normalizes :email, with: -> { _1.strip.downcase }
+end
+```
+
+#### Normalize multiple attributes with the same rule
+
+```ruby
+input do
+  attribute :email, :string
+  attribute :username, :string
+
+  normalizes :email, :username, with: -> { _1.strip.downcase }
+end
+```
+
+#### Different normalizations per attribute
+
+```ruby
+input do
+  attribute :email, :string
+  attribute :phone, :string
+
+  normalizes :email, with: -> { _1.strip.downcase }
+  normalizes :phone, with: -> { _1.delete("^0-9").delete_prefix("1") }
+end
+```
+
+#### Apply normalization to `nil` values
+
+By default, `normalizes` skips `nil` values. Use `apply_to_nil: true` to change this:
+
+```ruby
+input do
+  attribute :phone, :string
+
+  normalizes :phone, with: -> { _1&.delete("^0-9") || "" }, apply_to_nil: true
+end
+```
+
+#### Normalize a value without instantiation
+
+Use `normalize_value_for` on the input class to normalize a value directly:
+
+```ruby
+UserRegistration.input.normalize_value_for(:email, " FOO@BAR.COM\n")
+# => "foo@bar.com"
+```
diff --git a/lib/solid/model.rb b/lib/solid/model.rb
@@ -20,6 +20,11 @@ def inherited(subclass)
     include ::ActiveModel.const_defined?(:Access, false) ? ::ActiveModel::Access : ::Solid::Model::Access
 
     include ::ActiveModel::Attributes
+
+    if ::ActiveModel::Attributes.const_defined?(:Normalization, false)
+      include ::ActiveModel::Attributes::Normalization
+    end
+
     include ::ActiveModel::Dirty
     include ::ActiveModel::Validations::Callbacks
 
diff --git a/lib/solid/value.rb b/lib/solid/value.rb
@@ -17,6 +17,10 @@ def attribute(...)
     def validates(...)
       super(:value, ...)
     end
+
+    def normalizes(...)
+      super(:value, ...)
+    end
   end
 
   def self.included(subclass)
diff --git a/test/solid/model/class_test.rb b/test/solid/model/class_test.rb
@@ -78,8 +78,30 @@ class ModelWithValidation
       assert_includes ancestors, Solid::Model::Access
     end
 
+    if ActiveModel::Attributes.const_defined?(:Normalization, false)
+      assert_includes ancestors, ActiveModel::Attributes::Normalization
+    end
+
     assert_includes ancestors, ActiveModel::Attributes
     assert_includes ancestors, ActiveModel::Dirty
     assert_includes ancestors, ActiveModel::Validations::Callbacks
   end
+
+  if ActiveModel::Attributes.const_defined?(:Normalization, false)
+    class ModelWithNormalizes
+      include Solid::Model
+
+      attribute :uuid, :string
+
+      normalizes :uuid, with: -> { _1.strip.downcase }
+    end
+
+    test "model with normalizes" do
+      uuid = SecureRandom.uuid
+
+      model = ModelWithNormalizes.new(uuid: " #{uuid.upcase}  ")
+
+      assert_equal uuid, model.uuid
+    end
+  end
 end
diff --git a/test/solid/value/class_test.rb b/test/solid/value/class_test.rb
@@ -58,4 +58,22 @@ class ValueWithValidation
 
     assert_predicate uuid4, :valid?
   end
+
+  if ActiveModel::Attributes.const_defined?(:Normalization, false)
+    class ValueWithNormalizes
+      include Solid::Value
+
+      attribute :string
+
+      normalizes with: -> { _1.strip.downcase }
+    end
+
+    test "value with normalizes" do
+      uuid_str = SecureRandom.uuid
+
+      uuid = ValueWithNormalizes.new(" #{uuid_str.upcase}  ")
+
+      assert_equal uuid_str, uuid.value
+    end
+  end
 end
