Add raise_on_unknown_attributes configuration option

lib/couchbase-orm/base.rb

@@ -53,6 +53,10 @@ class Document
 
         class MismatchTypeError < RuntimeError; end
 
+        # Configuration option to control whether unknown attributes should raise an error
+        # Set to false to silently ignore unknown attributes during mass assignment
+        class_attribute :raise_on_unknown_attributes, default: true
+
         def initialize(model = nil, ignore_doc_type: false, **attributes)
             CouchbaseOrm.logger.debug { "Initialize model #{model} with #{attributes.to_s.truncate(200)}" }
             @__metadata__   = Metadata.new
@@ -100,6 +104,17 @@ def []=(key, value)
             send(:"#{key}=", value)
         end
 
+        # Handle assignment to unknown attributes based on raise_on_unknown_attributes configuration
+        # If raise_on_unknown_attributes is false, unknown attributes are silently ignored
+        # If raise_on_unknown_attributes is true (default), ActiveModel::UnknownAttributeError is raised
+        def attribute_writer_missing(name, value)
+            if self.class.raise_on_unknown_attributes
+                super
+            else
+                CouchbaseOrm.logger.warn "Ignoring unknown attribute '#{name}' for #{self.class.name}"
+            end
+        end
+
         protected
 
         def serialized_attributes

lib/couchbase-orm/persistence.rb

@@ -155,7 +155,18 @@ def update_attribute(name, value)
 
         def assign_attributes(hash)
             hash = hash.with_indifferent_access if hash.is_a?(Hash)
-            super(hash.except("type"))
+
+            # Filter unknown attributes if raise_on_unknown_attributes is false
+            if !self.class.raise_on_unknown_attributes
+                known_attrs = hash.slice(*self.class.attribute_names).except("type")
+                unknown_attrs = hash.keys - self.class.attribute_names - ["type"]
+                if unknown_attrs.any?
+                    CouchbaseOrm.logger.warn "Ignoring unknown attribute(s) for #{self.class.name}: #{unknown_attrs.join(', ')}"
+                end
+                super(known_attrs)
+            else
+                super(hash.except("type"))
+            end
         end
 
         # Updates the attributes of the model from the passed-in hash and saves the

spec/base_spec.rb

@@ -22,6 +22,12 @@ class BaseTestWithIgnoredProperties < CouchbaseOrm::Base
     attribute :job, :string
 end
 
+class BaseTestWithUnknownAttributesAllowed < CouchbaseOrm::Base
+    self.raise_on_unknown_attributes = false
+    attribute :name, :string
+    attribute :job, :string
+end
+
 class BaseTestWithPropertiesAlwaysExistsInDocument < CouchbaseOrm::Base
     self.properties_always_exists_in_document = true
     attribute :name, :string
@@ -349,6 +355,65 @@ class InvalidNested < CouchbaseOrm::NestedDocument
         end
     end
 
+    describe 'handling unknown attributes' do
+        context 'when raise_on_unknown_attributes is set to false' do
+            it 'returns false when queried' do
+                expect(BaseTestWithUnknownAttributesAllowed.raise_on_unknown_attributes).to be(false)
+            end
+
+            it 'silently ignores unknown attributes in new' do
+                model = BaseTestWithUnknownAttributesAllowed.new(name: 'test', job: 'dev', unknown_attr: 'value')
+                expect(model.name).to eq('test')
+                expect(model.job).to eq('dev')
+                expect(model.respond_to?(:unknown_attr)).to be(false)
+            end
+
+            it 'silently ignores unknown attributes in assign_attributes' do
+                model = BaseTestWithUnknownAttributesAllowed.new(name: 'test')
+                expect {
+                    model.assign_attributes(name: 'updated', job: 'engineer', foo: 'bar', baz: 'qux')
+                }.not_to raise_error
+                expect(model.name).to eq('updated')
+                expect(model.job).to eq('engineer')
+                expect(model.respond_to?(:foo)).to be(false)
+                expect(model.respond_to?(:baz)).to be(false)
+            end
+
+            it 'only stores known attributes' do
+                model = BaseTestWithUnknownAttributesAllowed.new(
+                    name: 'Alice',
+                    job: 'Developer',
+                    unknown_field_1: 'value1',
+                    unknown_field_2: 'value2'
+                )
+                # Only known attributes should be stored
+                expect(model.name).to eq('Alice')
+                expect(model.job).to eq('Developer')
+                expect(model.respond_to?(:unknown_field_1)).to be(false)
+                expect(model.respond_to?(:unknown_field_2)).to be(false)
+            end
+        end
+
+        context 'default behavior (raise_on_unknown_attributes = true)' do
+            it 'returns true by default' do
+                expect(BaseTest.raise_on_unknown_attributes).to be(true)
+            end
+
+            it 'raises ActiveModel::UnknownAttributeError on unknown attributes in new' do
+                expect {
+                    BaseTest.new(name: 'bob', job: 'dev', foo: 'bar')
+                }.to raise_error(ActiveModel::UnknownAttributeError)
+            end
+
+            it 'raises ActiveModel::UnknownAttributeError on unknown attributes in assign_attributes' do
+                model = BaseTest.new(name: 'bob')
+                expect {
+                    model.assign_attributes(job: 'dev', foo: 'bar')
+                }.to raise_error(ActiveModel::UnknownAttributeError)
+            end
+        end
+    end
+
     describe '.properties_always_exists_in_document' do
         it 'Uses NOT VALUED when properties_always_exists_in_document = false' do
             where_clause = BaseTest.where(name: nil)