feat(mapper): reject ,omitempty + ,omitzero on the same field

OR-composing the skip rule made the winner type-dependent (slices got
omitempty, all-zero fixed-size arrays got omitzero), silently reversing
the array preservation in 1550bde. No coherent precedence to defend, so
fail fast at Map time instead of shipping a footgun.

Caught by the third adversarial Codex pass.

Author: klaidliadon

mapper.go

@@ -36,9 +36,9 @@ type MapOptions struct {
 
 // Map converts a struct to (column, value) slices using `db:""` struct tags.
 //
-// Both ,omitempty and ,omitzero skip zero values, but ,omitzero keeps non-nil
-// empty slices/maps so a clear-to-empty UPDATE actually clears the column.
-// Matches encoding/json's omitzero (Go 1.24+).
+// ,omitempty and ,omitzero (mutually exclusive) both skip zero values, but
+// ,omitzero keeps non-nil empty slices/maps so a clear-to-empty UPDATE
+// actually clears the column. Matches encoding/json's omitzero (Go 1.24+).
 func Map(record interface{}) ([]string, []interface{}, error) {
 	return MapWithOptions(record, nil)
 }
@@ -86,6 +86,9 @@ func MapWithOptions(record interface{}, options *MapOptions) ([]string, []interf
 			// Field options
 			_, tagOmitEmpty := fi.Options["omitempty"]
 			_, tagOmitZero := fi.Options["omitzero"]
+			if tagOmitEmpty && tagOmitZero {
+				return nil, nil, fmt.Errorf("field %q has both ,omitempty and ,omitzero tags (mutually exclusive)", fi.Name)
+			}
 
 			fld := reflectx.FieldByIndexesReadOnly(recordV, fi.Index)
 

mapper_test.go

@@ -219,15 +219,18 @@ func TestMap_OmitZero_StructWithoutIsZero(t *testing.T) {
 	assert.Contains(t, got, "inner", "non-zero struct kept")
 }
 
-func TestMap_BothTags_OmitEmptyWins(t *testing.T) {
-	// A field tagged with both options gets the broader omitempty skip
-	// (zero-length non-nil slice is dropped) because (isEmpty && omitempty)
-	// fires when (isStrictZero && omitzero) wouldn't.
+func TestMap_BothTags_Rejected(t *testing.T) {
+	// OR-composing the skip rule made the winner type-dependent (slices
+	// got omitempty, all-zero arrays got omitzero), silently reversing
+	// the array preservation we explicitly fixed earlier. No coherent
+	// precedence, so reject the combination.
 	type Record struct {
 		Slice []string `db:"slice,omitempty,omitzero"`
 	}
-	got := mapFields(t, &Record{Slice: []string{}})
-	assert.NotContains(t, got, "slice", "omitempty wins on non-nil empty slice")
+	_, _, err := pgkit.Map(&Record{})
+	require.Error(t, err)
+	assert.Contains(t, err.Error(), "slice")
+	assert.Contains(t, err.Error(), "mutually exclusive")
 }
 
 func TestMap_MapRecord_Unchanged(t *testing.T) {