fix: use latest draft version data when trashing unpublished documents (#15981)

# Overview

Fixes document data being silently lost when bulk-trashing draft-only
documents on collections with `trash: true` and `versions.drafts`
enabled.

Localized fields are the most visible symptom, but any field data that
exists only in the versions table (i.e. never published) is affected.

## Key Changes

- In the bulk `update` operation, `queryDrafts` (versions table) is now
also used when fetching documents for a trash attempt, not only when
`shouldSaveDraft` is true

## Root Cause

Draft saves skip `updateOne` on the main collection table
(`isSavingDraft === true`), so the main table only reflects the last
published state. When bulk-trashing, the operation was reading
`docWithLocales` from the main table via `find()` — picking up
stale/empty data — and creating a new version from that stale snapshot.

Single-document trash (`updateByID`) was unaffected because it uses
`getLatestCollectionVersion()`, which always reads from the versions
table.

## Fix

```typescript
// Before
if (hasDraftsEnabled(collectionConfig) && shouldSaveDraft) {

// After
if (hasDraftsEnabled(collectionConfig) && (shouldSaveDraft || isTrashAttempt)) {
```

Fixes #15980

Author: PatrikKozak

packages/payload/src/collections/operations/update.ts

@@ -179,7 +179,7 @@ export const updateOperation = async <
 
     let docs
 
-    if (hasDraftsEnabled(collectionConfig) && shouldSaveDraft) {
+    if (hasDraftsEnabled(collectionConfig) && (shouldSaveDraft || isTrashAttempt)) {
       const versionsWhere = appendVersionToQueryKey(fullWhere)
 
       await validateQueryPaths({

test/trash/collections/Posts/index.ts

@@ -14,6 +14,11 @@ export const Posts: CollectionConfig = {
       type: 'text',
       required: true,
     },
+    {
+      name: 'localizedField',
+      type: 'text',
+      localized: true,
+    },
   ],
   versions: {
     drafts: true,

test/trash/config.ts

@@ -20,6 +20,10 @@ export default buildConfigWithDefaults({
       baseDir: path.resolve(dirname),
     },
   },
+  localization: {
+    locales: ['en', 'es'],
+    defaultLocale: 'en',
+  },
   editor: lexicalEditor({}),
 
   onInit: async (payload) => {

test/trash/e2e.spec.ts

@@ -10,10 +10,10 @@ import type { PayloadTestSDK } from '../__helpers/shared/sdk/index.js'
 import type { Config, Post } from './payload-types.js'
 
 import {
+  changeLocale,
   closeAllToasts,
   ensureCompilationIsDone,
   initPageConsoleErrorCatch,
-  throttleTest,
 } from '../__helpers/e2e/helpers.js'
 import { AdminUrlUtil } from '../__helpers/shared/adminUrlUtil.js'
 import { initPayloadE2ENoConfig } from '../__helpers/shared/initPayloadE2ENoConfig.js'
@@ -1167,6 +1167,154 @@ describe('Trash', () => {
       )
     })
   })
+
+  test('should preserve localized field data for all locales when trashing a draft document from the edit view', async ({
+    page,
+  }) => {
+    const localizedFieldValueEN = 'Localized Draft Content EN'
+    const localizedFieldValueES = 'Localized Draft Content ES'
+
+    const draftPost = await payload.create({
+      collection: postsSlug,
+      data: {
+        title: 'Draft with Localized Field',
+        _status: 'draft',
+      },
+    })
+
+    await payload.update({
+      collection: postsSlug,
+      id: draftPost.id,
+      locale: 'en',
+      data: {
+        localizedField: localizedFieldValueEN,
+        _status: 'draft',
+      },
+      draft: true,
+    })
+
+    await payload.update({
+      collection: postsSlug,
+      id: draftPost.id,
+      locale: 'es',
+      data: {
+        localizedField: localizedFieldValueES,
+        _status: 'draft',
+      },
+      draft: true,
+    })
+
+    await page.goto(postsUrl.edit(draftPost.id))
+
+    const threeDotMenu = page.locator('.doc-controls__popup')
+    await expect(threeDotMenu).toBeVisible()
+    await threeDotMenu.click()
+
+    await page.locator('.popup__content #action-delete').click()
+
+    await page.locator('.delete-document #confirm-action').click()
+
+    await expect(page.locator('.payload-toast-container .toast-success')).toHaveText(
+      'Post "Draft with Localized Field" moved to trash.',
+    )
+    await closeAllToasts(page)
+
+    await page.goto(postsUrl.trashEdit(draftPost.id))
+    await page.waitForURL(/\/posts\/trash\//)
+
+    const localizedFieldInput = page.locator('#field-localizedField')
+    await expect(localizedFieldInput).toBeVisible()
+    await expect(localizedFieldInput).toHaveValue(localizedFieldValueEN)
+
+    await changeLocale(page, 'es')
+    await expect(localizedFieldInput).toHaveValue(localizedFieldValueES)
+  })
+
+  test('should preserve localized field data for all locales when bulk trashing draft documents', async ({
+    page,
+  }) => {
+    const localizedFieldValueEN = 'Localized Draft Content EN'
+    const localizedFieldValueES = 'Localized Draft Content ES'
+
+    // Create a draft post without localized data initially
+    const draftPost = await payload.create({
+      collection: postsSlug,
+      data: {
+        title: 'Draft with Localized Field',
+        _status: 'draft',
+      },
+    })
+
+    // Update en locale as draft - isSavingDraft = true skips updateOne on the main table,
+    // storing localized data only in the versions table
+    await payload.update({
+      collection: postsSlug,
+      id: draftPost.id,
+      locale: 'en',
+      data: {
+        localizedField: localizedFieldValueEN,
+        _status: 'draft',
+      },
+      draft: true,
+    })
+
+    // Update es locale as draft
+    await payload.update({
+      collection: postsSlug,
+      id: draftPost.id,
+      locale: 'es',
+      data: {
+        localizedField: localizedFieldValueES,
+        _status: 'draft',
+      },
+      draft: true,
+    })
+
+    await page.goto(postsUrl.list)
+
+    const postRow = page.locator('.table tr', { hasText: 'Draft with Localized Field' })
+
+    await expect(postRow.locator('.cell-localizedField')).toHaveText(localizedFieldValueEN)
+
+    await changeLocale(page, 'es')
+    await expect(postRow.locator('.cell-localizedField')).toHaveText(localizedFieldValueES)
+
+    await changeLocale(page, 'en')
+
+    await postRow.locator('.cell-_select input').check()
+    await page.locator('.list-selection__button[aria-label="Delete"]').click()
+
+    await page.locator('#confirm-delete-many-docs #confirm-action').click()
+    await expect(page.locator('.payload-toast-container .toast-success')).toHaveText(
+      '1 Post moved to trash.',
+    )
+    await closeAllToasts(page)
+
+    await page.locator('#trash-view-pill').click()
+    await expect(page).toHaveURL(/\/posts\/trash(\?|$)/)
+
+    const trashedRow = page.locator('.table tr', { hasText: 'Draft with Localized Field' })
+
+    await expect(trashedRow.locator('.cell-localizedField')).toHaveText(localizedFieldValueEN)
+
+    await changeLocale(page, 'es')
+    await expect(trashedRow.locator('.cell-localizedField')).toHaveText(localizedFieldValueES)
+
+    await changeLocale(page, 'en')
+
+    const cellLink = trashedRow.locator('.cell-title a')
+    const linkURL = await cellLink.getAttribute('href')
+    await page.goto(`${serverURL}${linkURL}`)
+
+    await page.waitForURL(/\/posts\/trash\//)
+
+    const localizedFieldInput = page.locator('#field-localizedField')
+    await expect(localizedFieldInput).toBeVisible()
+    await expect(localizedFieldInput).toHaveValue(localizedFieldValueEN)
+
+    await changeLocale(page, 'es')
+    await expect(localizedFieldInput).toHaveValue(localizedFieldValueES)
+  })
 })
 
 async function createPostDoc(data: RequiredDataFromCollectionSlug<'posts'>): Promise<Post> {

test/trash/int.spec.ts

@@ -1147,6 +1147,82 @@ describe('trash', () => {
         expect(result.totalDocs).toEqual(1) // Only postsDocTwo
       })
     })
+
+    it('should preserve localized field data when bulk trashing draft documents', async () => {
+      const localizedFieldValueEN = 'Localized Draft Content EN'
+      const localizedFieldValueES = 'Localized Draft Content ES'
+
+      const post = await payload.create({
+        collection: postsSlug,
+        data: {
+          title: 'Draft with Localized Field',
+          _status: 'draft',
+        },
+      })
+
+      // Update en locale as draft - isSavingDraft = true skips updateOne on the main table,
+      // storing localized data only in the versions table
+      await payload.update({
+        collection: postsSlug,
+        id: post.id,
+        locale: 'en',
+        data: {
+          localizedField: localizedFieldValueEN,
+          _status: 'draft',
+        },
+        draft: true,
+      })
+
+      await payload.update({
+        collection: postsSlug,
+        id: post.id,
+        locale: 'es',
+        data: {
+          localizedField: localizedFieldValueES,
+          _status: 'draft',
+        },
+        draft: true,
+      })
+
+      // Bulk trash the document (simulates list view "Move to Trash")
+      // This reads from the main table which has stale/empty localizedField
+      const trashResult = await payload.update({
+        collection: postsSlug,
+        data: {
+          deletedAt: new Date().toISOString(),
+        },
+        where: {
+          id: {
+            equals: post.id,
+          },
+        },
+      })
+
+      expect(trashResult.docs).toHaveLength(1)
+      expect(trashResult.docs[0]?.deletedAt).toBeTruthy()
+
+      // Fetch the latest draft version of the trashed document for each locale
+      const trashedDocEN = await payload.findByID({
+        collection: postsSlug,
+        id: post.id,
+        locale: 'en',
+        draft: true,
+        trash: true,
+      })
+
+      const trashedDocES = await payload.findByID({
+        collection: postsSlug,
+        id: post.id,
+        locale: 'es',
+        draft: true,
+        trash: true,
+      })
+
+      // localizedField should be preserved from the latest draft version for both locales,
+      // not lost due to stale main table data being used during bulk trash
+      expect(trashedDocEN.localizedField).toBe(localizedFieldValueEN)
+      expect(trashedDocES.localizedField).toBe(localizedFieldValueES)
+    })
   })
 
   describe('REST API', () => {

test/trash/payload-types.ts

@@ -92,10 +92,13 @@ export interface Config {
   db: {
     defaultIDType: string;
   };
-  fallbackLocale: null;
+  fallbackLocale: ('false' | 'none' | 'null') | false | null | ('en' | 'es') | ('en' | 'es')[];
   globals: {};
   globalsSelect: {};
-  locale: null;
+  locale: 'en' | 'es';
+  widgets: {
+    collections: CollectionsWidget;
+  };
   user: User;
   jobs: {
     tasks: unknown;
@@ -138,6 +141,7 @@ export interface Page {
 export interface Post {
   id: string;
   title: string;
+  localizedField?: string | null;
   updatedAt: string;
   createdAt: string;
   deletedAt?: string | null;
@@ -297,6 +301,7 @@ export interface PagesSelect<T extends boolean = true> {
  */
 export interface PostsSelect<T extends boolean = true> {
   title?: T;
+  localizedField?: T;
   updatedAt?: T;
   createdAt?: T;
   deletedAt?: T;
@@ -389,6 +394,16 @@ export interface PayloadMigrationsSelect<T extends boolean = true> {
   updatedAt?: T;
   createdAt?: T;
 }
+/**
+ * This interface was referenced by `Config`'s JSON-Schema
+ * via the `definition` "collections_widget".
+ */
+export interface CollectionsWidget {
+  data?: {
+    [k: string]: unknown;
+  };
+  width: 'full';
+}
 /**
  * This interface was referenced by `Config`'s JSON-Schema
  * via the `definition` "auth".