fix(plugin-nested-docs): await populateBreadcrumbs in resaveChildren (#15582)

Fixes #14943

## Summary

The async `populateBreadcrumbs()` function was not being awaited in
`resaveChildren`. This caused `payload.update()` to receive a Promise
instead of the child document's data, so updates couldn't preserve the
`_status` field and defaulted to the main document's draft status.

When a parent was saved, all child updates created draft versions
instead of preserving the published/draft distinction. Querying with
`draft: false` then returned draft data, making the published version
"disappear."

The fix adds `await` to the `populateBreadcrumbs()` call.

---------

Co-authored-by: Cursor <cursoragent@cursor.com>
Co-authored-by: Jarrod Flesch <jarrodmflesch@gmail.com>

Author: 3 people

packages/plugin-nested-docs/src/hooks/resaveChildren.ts

@@ -71,7 +71,7 @@ export const resaveChildren =
           await req.payload.update({
             id: child.id,
             collection: collection.slug,
-            data: populateBreadcrumbs({
+            data: await populateBreadcrumbs({
               collection,
               data: child,
               generateLabel: pluginConfig.generateLabel,

test/plugin-nested-docs/int.spec.ts

@@ -2,7 +2,7 @@ import type { ArrayField, Payload, RelationshipField } from 'payload'
 
 import path from 'path'
 import { fileURLToPath } from 'url'
-import { afterAll, beforeAll, describe, expect, it } from 'vitest'
+import { afterAll, afterEach, beforeAll, describe, expect, it } from 'vitest'
 
 import type { Page } from './payload-types.js'
 
@@ -192,6 +192,206 @@ describe('@payloadcms/plugin-nested-docs', () => {
     })
   })
 
+  describe('versions', () => {
+    const createdPageIDs: (number | string)[] = []
+
+    afterEach(async () => {
+      // Clean up in reverse order (children before parents)
+      for (const id of [...createdPageIDs].reverse()) {
+        await payload.delete({ collection: 'pages', id })
+      }
+      createdPageIDs.length = 0
+    })
+
+    it('should preserve published version of child when parent is saved and child has unpublished draft', async () => {
+      // Step 1: Create parent page and publish it
+      const parentDoc = await payload.create({
+        collection: 'pages',
+        data: {
+          title: 'Version Parent',
+          slug: 'version-parent',
+          _status: 'published',
+        },
+      })
+      createdPageIDs.push(parentDoc.id)
+
+      // Step 2: Create child page and publish it
+      const childDoc = await payload.create({
+        collection: 'pages',
+        data: {
+          title: 'Version Child',
+          slug: 'version-child',
+          parent: parentDoc.id,
+          _status: 'published',
+        },
+      })
+      createdPageIDs.push(childDoc.id)
+
+      // Verify initial published state
+      const initialPublished = await payload.findByID({
+        id: childDoc.id,
+        collection: 'pages',
+        draft: false,
+      })
+      expect(initialPublished._status).toBe('published')
+      expect(initialPublished.breadcrumbs).toHaveLength(2)
+
+      // Step 3: Make unpublished changes to child (creates a draft version)
+      await payload.update({
+        id: childDoc.id,
+        collection: 'pages',
+        data: {
+          title: 'Version Child Draft Edit',
+        },
+        draft: true,
+      })
+
+      // Step 4: Re-publish the parent (triggers resaveChildren)
+      await payload.update({
+        id: parentDoc.id,
+        collection: 'pages',
+        data: {
+          title: 'Version Parent Updated',
+          slug: 'version-parent-updated',
+          _status: 'published',
+        },
+      })
+
+      // Step 5: Verify the child's published version is still accessible
+      const publishedChild = await payload.findByID({
+        id: childDoc.id,
+        collection: 'pages',
+        draft: false,
+      })
+
+      expect(publishedChild).toBeDefined()
+      expect(publishedChild._status).toBe('published')
+      expect(publishedChild.breadcrumbs).toHaveLength(2)
+      expect(publishedChild.breadcrumbs?.[0]?.url).toBe('/version-parent-updated')
+
+      // Step 6: Verify the draft version is also still accessible
+      const draftChild = await payload.findByID({
+        id: childDoc.id,
+        collection: 'pages',
+        draft: true,
+      })
+
+      expect(draftChild).toBeDefined()
+      expect(draftChild.title).toBe('Version Child Draft Edit')
+    })
+
+    it('should update breadcrumbs for draft-only children when parent is saved', async () => {
+      const parentDoc = await payload.create({
+        collection: 'pages',
+        data: {
+          title: 'Draft Parent',
+          slug: 'draft-parent',
+          _status: 'published',
+        },
+      })
+      createdPageIDs.push(parentDoc.id)
+
+      // Create a child that is never published (draft-only)
+      const draftChild = await payload.create({
+        collection: 'pages',
+        data: {
+          title: 'Draft Only Child',
+          slug: 'draft-only-child',
+          parent: parentDoc.id,
+          _status: 'draft',
+        },
+      })
+      createdPageIDs.push(draftChild.id)
+
+      expect(draftChild._status).toBe('draft')
+
+      // Update the parent
+      await payload.update({
+        id: parentDoc.id,
+        collection: 'pages',
+        data: {
+          title: 'Draft Parent Updated',
+          slug: 'draft-parent-updated',
+          _status: 'published',
+        },
+      })
+
+      // Draft-only child should have updated breadcrumbs
+      const updatedDraftChild = await payload.findByID({
+        id: draftChild.id,
+        collection: 'pages',
+        draft: true,
+      })
+
+      expect(updatedDraftChild.breadcrumbs).toHaveLength(2)
+      expect(updatedDraftChild.breadcrumbs?.[0]?.url).toBe('/draft-parent-updated')
+    })
+
+    it('should update breadcrumbs for both published and draft versions when parent changes', async () => {
+      const parent = await payload.create({
+        collection: 'pages',
+        data: {
+          title: 'Breadcrumb Parent',
+          slug: 'breadcrumb-parent',
+          _status: 'published',
+        },
+      })
+      createdPageIDs.push(parent.id)
+
+      const child = await payload.create({
+        collection: 'pages',
+        data: {
+          title: 'Breadcrumb Child',
+          slug: 'breadcrumb-child',
+          parent: parent.id,
+          _status: 'published',
+        },
+      })
+      createdPageIDs.push(child.id)
+
+      // Create draft edit on child
+      await payload.update({
+        id: child.id,
+        collection: 'pages',
+        data: {
+          title: 'Breadcrumb Child Draft',
+        },
+        draft: true,
+      })
+
+      // Update parent slug
+      await payload.update({
+        id: parent.id,
+        collection: 'pages',
+        data: {
+          slug: 'breadcrumb-parent-updated',
+          _status: 'published',
+        },
+      })
+
+      // Published child has updated breadcrumbs and is accessible
+      const published = await payload.findByID({
+        id: child.id,
+        collection: 'pages',
+        draft: false,
+      })
+
+      expect(published._status).toBe('published')
+      expect(published.breadcrumbs?.[0]?.url).toBe('/breadcrumb-parent-updated')
+
+      // Draft child also has updated breadcrumbs
+      const draft = await payload.findByID({
+        id: child.id,
+        collection: 'pages',
+        draft: true,
+      })
+
+      expect(draft._status).toBe('draft')
+      expect(draft.title).toBe('Breadcrumb Child Draft')
+      expect(draft.breadcrumbs?.[0]?.url).toBe('/breadcrumb-parent-updated')
+    })
+  })
+
   describe('overrides', () => {
     let collection
     beforeAll(() => {