fix(drizzle): groups inside localized tabs are not working correctly (#15936)

Fixes #11651

The issue was related to 2 things:
1. `forceLocalized` was not passed through if the current field is not
localized but had `forceLocalized: true` because the parent field is
localized, e.g: localized tab -> non localized group -> non localized
text - in the DB schema we need to have the text field in the `_locales`
table.
2. `forceLocale` was not passed through in `transform/write` for
tab/group fields

Author: r1tsuu

packages/drizzle/src/schema/traverseFields.ts

@@ -668,7 +668,7 @@ export const traverseFields = ({
           disableUnique,
           fieldPrefix: `${fieldName}.`,
           fields: field.flattenedFields,
-          forceLocalized: isFieldLocalized,
+          forceLocalized: isFieldLocalized || Boolean(forceLocalized),
           indexes,
           localesColumns,
           localesIndexes,

packages/drizzle/src/transform/write/traverseFields.ts

@@ -356,9 +356,11 @@ export const traverseFields = ({
             blocksToDelete,
             columnPrefix: `${columnName}_`,
             data: groupData,
+            enableAtomicWrites,
             existingLocales,
             fieldPrefix: `${fieldName}_`,
             fields: field.flattenedFields,
+            forcedLocale,
             insideArrayOrBlock,
             locales,
             numbers,

test/localization/collections/Tab/index.ts

@@ -26,6 +26,16 @@ export const Tab: CollectionConfig = {
                 },
               ],
             },
+            {
+              name: 'group',
+              type: 'group',
+              fields: [
+                {
+                  name: 'heading',
+                  type: 'text',
+                },
+              ],
+            },
           ],
         },
         {

test/localization/int.spec.ts

@@ -14,8 +14,8 @@ import type {
   WithLocalizedRelationship,
 } from './payload-types.js'
 
-import { devUser } from '../credentials.js'
 import { isMongoose, mongooseList } from '../__helpers/shared/isMongoose.js'
+import { devUser } from '../credentials.js'
 
 // eslint-disable-next-line payload/no-relative-monorepo-imports
 import { copyDataFromLocaleHandler } from '../../packages/ui/src/utilities/copyDataFromLocale.js'
@@ -1273,13 +1273,15 @@ describe('Localization', () => {
         })
 
         if (isMongoose(payload)) {
+          // eslint-disable-next-line vitest/no-conditional-expect
           expect(docWithoutFallback.items).toStrictEqual(null)
         } else {
           // TODO: build out compatability with SQL databases
           // Currently SQL databases always fallback since the localized values are joined in.
           // The join only has 2 states, undefined or the localized value of the requested locale.
           // If the localized value is not in the DB, there is no way to know if the value should fallback or not so we fallback if fallbackLocale is truthy.
           // In MongoDB the value can be set to null, which allows us to know that the value should fallback.
+          // eslint-disable-next-line vitest/no-conditional-expect
           expect(docWithoutFallback.items).toStrictEqual(englishDoc.items)
         }
       })
@@ -2020,6 +2022,48 @@ describe('Localization', () => {
         expect(docEs.deep.array[0].title).toBe('hello es')
         expect(docEs.deep.blocks[0].title).toBe('hello es')
       })
+
+      it('should properly isolate locales for a group inside a localized tab', async () => {
+        const docEs = await payload.create({
+          collection: tabSlug,
+          locale: spanishLocale,
+          data: {
+            tabLocalized: {
+              group: {
+                heading: 'Spanish heading',
+              },
+            },
+          },
+        })
+
+        await payload.update({
+          collection: tabSlug,
+          locale: englishLocale,
+          id: docEs.id,
+          data: {
+            tabLocalized: {
+              group: {
+                heading: 'English heading',
+              },
+            },
+          },
+        })
+
+        const readEn = await payload.findByID({
+          collection: tabSlug,
+          locale: englishLocale,
+          id: docEs.id,
+        })
+
+        const readEs = await payload.findByID({
+          collection: tabSlug,
+          locale: spanishLocale,
+          id: docEs.id,
+        })
+
+        expect(readEn.tabLocalized.group.heading).toBe('English heading')
+        expect(readEs.tabLocalized.group.heading).toBe('Spanish heading')
+      })
     })
 
     // Nested localized fields do no longer have their localized property stripped in

test/localization/payload-types.ts

@@ -762,6 +762,9 @@ export interface Tab {
           id?: string | null;
         }[]
       | null;
+    group?: {
+      heading?: string | null;
+    };
   };
   tab?: {
     title?: string | null;
@@ -1586,6 +1589,11 @@ export interface TabsSelect<T extends boolean = true> {
               title?: T;
               id?: T;
             };
+        group?:
+          | T
+          | {
+              heading?: T;
+            };
       };
   tab?:
     | T