fix: preserve locale data in unnamed groups with localizeStatus (#15658)

Author: JarrodMFlesch

packages/payload/src/utilities/mergeLocalizedData.spec.ts

@@ -749,5 +749,178 @@ describe('mergeLocalizedData', () => {
         es: 'Spanish Description',
       })
     })
+
+    it('should not lose other locale data when processing unnamed groups', () => {
+      // https://github.com/payloadcms/payload/issues/15642
+      const fields: Field[] = [
+        {
+          name: 'textFieldRoot',
+          type: 'text',
+        },
+        {
+          name: 'textFieldRootLocalized',
+          type: 'text',
+          localized: true,
+        },
+        // Unnamed group - fields at same data level as root
+        {
+          type: 'group',
+          fields: [
+            {
+              name: 'textFieldNested',
+              type: 'text',
+            },
+            {
+              name: 'textFieldNestedLocalized',
+              type: 'text',
+              localized: true,
+            },
+          ],
+        },
+      ]
+
+      // Document already has English data published
+      const docWithLocales = {
+        textFieldRoot: 'Root Value',
+        textFieldRootLocalized: {
+          en: 'English Root Localized',
+          es: 'Spanish Root Localized',
+        },
+        textFieldNested: 'Nested Value',
+        textFieldNestedLocalized: {
+          en: 'English Nested Localized',
+          es: 'Spanish Nested Localized',
+        },
+      }
+
+      // Publishing only English locale with updated data
+      const dataWithLocales = {
+        textFieldRoot: 'Updated Root Value',
+        textFieldRootLocalized: {
+          en: 'Updated English Root Localized',
+        },
+        textFieldNested: 'Updated Nested Value',
+        textFieldNestedLocalized: {
+          en: 'Updated English Nested Localized',
+        },
+      }
+
+      const result = mergeLocalizedData({
+        configBlockReferences: [],
+        dataWithLocales,
+        docWithLocales,
+        fields,
+        selectedLocales: ['en'],
+      })
+
+      // Root non-localized field should be updated
+      expect(result.textFieldRoot).toBe('Updated Root Value')
+
+      // Root localized field should merge: update en, preserve es
+      expect(result.textFieldRootLocalized).toEqual({
+        en: 'Updated English Root Localized',
+        es: 'Spanish Root Localized',
+      })
+
+      // Nested non-localized field should be updated
+      expect(result.textFieldNested).toBe('Updated Nested Value')
+
+      // Nested localized field should merge: update en, preserve es
+      // This is the bug - es data is lost
+      expect(result.textFieldNestedLocalized).toEqual({
+        en: 'Updated English Nested Localized',
+        es: 'Spanish Nested Localized',
+      })
+    })
+
+    it('should not lose other locale data when processing row fields', () => {
+      const fields: Field[] = [
+        {
+          type: 'row',
+          fields: [
+            {
+              name: 'rowFieldLocalized',
+              type: 'text',
+              localized: true,
+            },
+          ],
+        },
+      ]
+
+      const docWithLocales = {
+        rowFieldLocalized: {
+          en: 'English Value',
+          es: 'Spanish Value',
+        },
+      }
+
+      const dataWithLocales = {
+        rowFieldLocalized: {
+          en: 'Updated English Value',
+        },
+      }
+
+      const result = mergeLocalizedData({
+        configBlockReferences: [],
+        dataWithLocales,
+        docWithLocales,
+        fields,
+        selectedLocales: ['en'],
+      })
+
+      expect(result.rowFieldLocalized).toEqual({
+        en: 'Updated English Value',
+        es: 'Spanish Value',
+      })
+    })
+
+    it('should preserve other locale data when updating through unnamed tabs', () => {
+      const fields: Field[] = [
+        {
+          type: 'tabs',
+          tabs: [
+            {
+              label: 'Tab 1',
+              fields: [
+                {
+                  name: 'tabFieldLocalized',
+                  type: 'text',
+                  localized: true,
+                },
+              ],
+            },
+          ],
+        },
+      ]
+
+      // Document has both en and es data
+      const docWithLocales = {
+        tabFieldLocalized: {
+          en: 'English Value',
+          es: 'Spanish Value',
+        },
+      }
+
+      // Only updating en
+      const dataWithLocales = {
+        tabFieldLocalized: {
+          en: 'Updated English Value',
+        },
+      }
+
+      const result = mergeLocalizedData({
+        configBlockReferences: [],
+        dataWithLocales,
+        docWithLocales,
+        fields,
+        selectedLocales: ['en'],
+      })
+
+      // es should be preserved
+      expect(result.tabFieldLocalized).toEqual({
+        en: 'Updated English Value',
+        es: 'Spanish Value',
+      })
+    })
   })
 })

packages/payload/src/utilities/mergeLocalizedData.ts

@@ -4,6 +4,35 @@ import type { JsonObject } from '../types/index.js'
 
 import { fieldAffectsData, fieldShouldBeLocalized, tabHasName } from '../fields/config/types.js'
 
+/**
+ * Collects field names at the current data level, recursing through pass-through fields
+ * (row, collapsible, unnamed group, unnamed tab) but stopping at named fields.
+ */
+function collectFlattenedFieldNames(fields: Field[]): Set<string> {
+  const names = new Set<string>()
+  for (const field of fields) {
+    if (fieldAffectsData(field)) {
+      names.add(field.name)
+    } else if ('fields' in field && Array.isArray(field.fields)) {
+      // Pass-through fields (row, collapsible, unnamed group)
+      for (const name of collectFlattenedFieldNames(field.fields)) {
+        names.add(name)
+      }
+    } else if (field.type === 'tabs') {
+      for (const tab of field.tabs) {
+        if (tabHasName(tab)) {
+          names.add(tab.name)
+        } else {
+          for (const name of collectFlattenedFieldNames(tab.fields)) {
+            names.add(name)
+          }
+        }
+      }
+    }
+  }
+  return names
+}
+
 type MergeDataToSelectedLocalesArgs = {
   configBlockReferences: SanitizedConfig['blocks']
   dataWithLocales: JsonObject
@@ -178,17 +207,6 @@ export function mergeLocalizedData({
                 })
               }
             }
-          } else {
-            // Unnamed groups pass through the same data level
-            const merged = mergeLocalizedData({
-              configBlockReferences,
-              dataWithLocales,
-              docWithLocales: result, // Use current result to avoid re-processing already-handled fields
-              fields: field.fields,
-              parentIsLocalized,
-              selectedLocales,
-            })
-            Object.assign(result, merged)
           }
           break
         }
@@ -234,17 +252,24 @@ export function mergeLocalizedData({
       // Layout-only fields that don't affect data structure
       switch (field.type) {
         case 'collapsible':
+        case 'group':
         case 'row': {
           // These pass through the same data level
           const merged = mergeLocalizedData({
             configBlockReferences,
             dataWithLocales,
-            docWithLocales: result, // Use current result to avoid re-processing already-handled fields
+            docWithLocales,
             fields: field.fields,
             parentIsLocalized,
             selectedLocales,
           })
-          Object.assign(result, merged)
+          // Only copy fields that belong to this layout field to avoid overwriting already-processed fields
+          const fieldNames = collectFlattenedFieldNames(field.fields)
+          for (const name of fieldNames) {
+            if (name in merged) {
+              result[name] = merged[name]
+            }
+          }
           break
         }
 
@@ -290,12 +315,18 @@ export function mergeLocalizedData({
               const merged = mergeLocalizedData({
                 configBlockReferences,
                 dataWithLocales,
-                docWithLocales: result, // Use current result to avoid re-processing already-handled fields
+                docWithLocales,
                 fields: tab.fields,
                 parentIsLocalized,
                 selectedLocales,
               })
-              Object.assign(result, merged)
+              // Only copy fields that belong to this tab to avoid overwriting already-processed fields
+              const tabFieldNames = collectFlattenedFieldNames(tab.fields)
+              for (const name of tabFieldNames) {
+                if (name in merged) {
+                  result[name] = merged[name]
+                }
+              }
             }
           }
           break