fix(plugin-search): serialize reindexing to prevent locale data race conditions (#15917)

## Description

This PR fixes a race condition in the plugin-search's reindexing
functionality that caused missing locale data when reindexing multiple
collections simultaneously.

### Changes

- Replaced `Promise.all` with sequential processing of collections in
`generateReindexHandler.ts`
- This change ensures proper handling of locale data during reindexing
operations

### Motivation

The previous implementation used concurrent execution for collection
reindexing, which led to race conditions and incomplete locale data
being persisted. The issue was causing non-deterministic failures in
localized search indexing.

Fixes #15884

---------

Co-authored-by: Paul Popus <paul@payloadcms.com>

Author: ossaidqadri

packages/plugin-search/src/utilities/generateReindexHandler.ts

@@ -89,10 +89,6 @@ export const generateReindexHandler =
         equals: 'published',
       },
     }
-    let aggregateDocsWithDrafts = 0
-    let aggregateErrors = 0
-    let aggregateDocs = 0
-
     async function countDocuments(collection: string, drafts?: boolean): Promise<number> {
       const { totalDocs } = await payload.count({
         collection,
@@ -113,7 +109,9 @@ export const generateReindexHandler =
       })
     }
 
-    async function reindexCollection(collection: string) {
+    async function reindexCollection(
+      collection: string,
+    ): Promise<{ docs: number; docsWithDrafts: number; errors: number }> {
       const draftsEnabled = Boolean(payload.collections[collection]?.config.versions?.drafts)
 
       const totalDocsWithDrafts = await countDocuments(collection, true)
@@ -123,8 +121,7 @@ export const generateReindexHandler =
           : await countDocuments(collection, !draftsEnabled)
       const totalBatches = Math.ceil(totalDocs / batchSize)
 
-      aggregateDocsWithDrafts += totalDocsWithDrafts
-      aggregateDocs += totalDocs
+      let localErrors = 0
 
       // Loop through batches, then documents, then locales per document
       for (let i = 0; i < totalBatches; i++) {
@@ -183,37 +180,49 @@ export const generateReindexHandler =
               data: doc,
               doc,
               locale: localeToSync,
-              onSyncError: () => operation === 'create' && aggregateErrors++,
+              onSyncError: () => operation === 'create' && localErrors++,
               operation,
               pluginConfig,
               req,
             })
           }
         }
       }
+
+      return { docs: totalDocs, docsWithDrafts: totalDocsWithDrafts, errors: localErrors }
     }
 
     const shouldCommit = await initTransaction(req)
 
+    // Collections are processed sequentially to avoid race conditions within the shared transaction.
+    // Concurrent writes to the search collection interleave on the same DB connection and can cause
+    // locale data to be missing non-deterministically.
+    const results: Array<{ docs: number; docsWithDrafts: number; errors: number }> = []
     try {
-      const promises = collections.map(async (collection) => {
+      for (const collection of collections) {
         try {
           await deleteIndexes(collection)
-          await reindexCollection(collection)
+          results.push(await reindexCollection(collection))
         } catch (err) {
           const message = t('error:unableToReindexCollection', { collection })
           payload.logger.error({ err, msg: message })
+          results.push({ docs: 0, docsWithDrafts: 0, errors: 0 })
         }
-      })
-
-      await Promise.all(promises)
-    } catch (err: any) {
+      }
+    } catch (err: unknown) {
       if (shouldCommit) {
         await killTransaction(req)
       }
-      return Response.json({ message: err.message }, { headers, status: 500 })
+      return Response.json(
+        { message: err instanceof Error ? err.message : String(err) },
+        { headers, status: 500 },
+      )
     }
 
+    const aggregateDocsWithDrafts = results.reduce((sum, r) => sum + r.docsWithDrafts, 0)
+    const aggregateDocs = results.reduce((sum, r) => sum + r.docs, 0)
+    const aggregateErrors = results.reduce((sum, r) => sum + r.errors, 0)
+
     const message = t('general:successfullyReindexed', {
       collections: collections.join(', '),
       count: aggregateDocs - aggregateErrors,

test/plugin-search/int.spec.ts

@@ -1,14 +1,14 @@
-import { describe, beforeAll, beforeEach, afterAll, it, expect } from 'vitest'
 import type { Payload } from 'payload'
 
 import path from 'path'
 import { wait } from 'payload/shared'
 import { fileURLToPath } from 'url'
+import { afterAll, beforeAll, beforeEach, describe, expect, it } from 'vitest'
 
 import type { NextRESTClient } from '../__helpers/shared/NextRESTClient.js'
 
-import { devUser } from '../credentials.js'
 import { initPayloadInt } from '../__helpers/shared/initPayloadInt.js'
+import { devUser } from '../credentials.js'
 import { pagesSlug, postsSlug } from './shared.js'
 
 let payload: Payload
@@ -538,6 +538,96 @@ describe('@payloadcms/plugin-search', () => {
     expect(totalAfterReindex).toBe(totalBeforeReindex)
   })
 
+  it('should report correct aggregate counts when reindexing multiple collections', async () => {
+    await Promise.all([
+      payload.create({
+        collection: postsSlug,
+        data: { title: 'Post one', _status: 'published' },
+      }),
+      payload.create({
+        collection: postsSlug,
+        data: { title: 'Post two', _status: 'published' },
+      }),
+      payload.create({
+        collection: pagesSlug,
+        data: { title: 'Page one', _status: 'published' },
+      }),
+    ])
+
+    const endpointRes = await restClient.POST(`/search/reindex`, {
+      body: JSON.stringify({ collections: [postsSlug, pagesSlug] }),
+      headers: { Authorization: `JWT ${token}` },
+    })
+
+    expect(endpointRes.status).toBe(200)
+
+    const data = await endpointRes.json()
+
+    // 2 posts + 1 page = 3 total, all published, 0 drafts skipped, 0 errors
+    expect((data as { message: string }).message).toBe(
+      `Successfully reindexed 3 of 3 documents from ${postsSlug}, ${pagesSlug} and skipped 0 drafts.`,
+    )
+  })
+
+  it('should index locale-specific data for all locales when reindexing multiple collections', async () => {
+    // Create a post with distinct slugs per locale — these are mapped into the search doc via beforeSync
+    const { id: postId } = await payload.create({
+      collection: postsSlug,
+      data: { title: 'Locale test post', _status: 'published', slug: 'post-slug-en' },
+      locale: 'en',
+    })
+
+    await payload.update({
+      collection: postsSlug,
+      id: postId,
+      data: { slug: 'post-slug-es' },
+      locale: 'es',
+    })
+    await payload.update({
+      collection: postsSlug,
+      id: postId,
+      data: { slug: 'post-slug-de' },
+      locale: 'de',
+    })
+
+    // Create a page so both collections are reindexed together, exercising the multi-collection path
+    await payload.create({
+      collection: pagesSlug,
+      data: { title: 'Locale test page', _status: 'published' },
+    })
+
+    const endpointRes = await restClient.POST(`/search/reindex`, {
+      body: JSON.stringify({ collections: [postsSlug, pagesSlug] }),
+      headers: { Authorization: `JWT ${token}` },
+    })
+
+    expect(endpointRes.status).toBe(200)
+
+    const { docs: searchDocs } = await payload.find({
+      collection: 'search',
+      depth: 0,
+      where: {
+        and: [{ 'doc.relationTo': { equals: postsSlug } }, { 'doc.value': { equals: postId } }],
+      },
+    })
+
+    expect(searchDocs).toHaveLength(1)
+
+    const searchDocId = searchDocs[0]!.id
+
+    const [enDoc, esDoc, deDoc] = await Promise.all([
+      payload.findByID({ collection: 'search', id: searchDocId, locale: 'en' }),
+      payload.findByID({ collection: 'search', id: searchDocId, locale: 'es' }),
+      payload.findByID({ collection: 'search', id: searchDocId, locale: 'de' }),
+    ])
+
+    // With localization fallback: true, a missing locale update would silently fall back to 'en'
+    // making these assertions fail — catching any regression to concurrent reindexing
+    expect(enDoc.slug).toBe('post-slug-en')
+    expect(esDoc.slug).toBe('post-slug-es')
+    expect(deDoc.slug).toBe('post-slug-de')
+  })
+
   it('should exclude drafts from reindexing by default', async () => {
     await Promise.all([
       payload.create({