fix: populate previousValue correctly in afterChange hooks for nested lexical fields (#15623)

## What
Fixes `previousValue` being `undefined` in `afterChange` hook for nested
Lexical fields.

## Why
We had this issue previously where the wrong `previousValue` data was
being accessed with nested fields, this introduced the fix of
`previousValData` which properly scopes to sibling-level or full
document data.

When the previous fix was done, the `previousValue` in the rich text
case here was missed.

## How
Changed the `richText` case in
`packages/payload/src/fields/hooks/afterChange/promise.ts` to use the
same `previousValData` pattern as other field types:

```diff
- previousValue: previousDoc?.[field.name],
+ previousValue: getNestedValue(previousValData, pathSegments) ?? previousValData?.[field.name],
```

### Testing
Added to `Lexical > lexical.int.spec.ts`

Author: JessRynkar

packages/payload/src/fields/hooks/afterChange/promise.ts

@@ -289,7 +289,8 @@ export const promise = async ({
             path: pathSegments,
             previousDoc,
             previousSiblingDoc,
-            previousValue: previousDoc?.[field.name],
+            previousValue:
+              getNestedValue(previousValData, pathSegments) ?? previousValData?.[field.name],
             req,
             schemaPath: schemaPathSegments,
             siblingData,

test/lexical/baseConfig.ts

@@ -13,6 +13,7 @@ import {
   lexicalInlineBlocks,
 } from './collections/Lexical/index.js'
 import { LexicalAccessControl } from './collections/LexicalAccessControl/index.js'
+import { LexicalAutosave } from './collections/LexicalAutosave/index.js'
 import { LexicalHeadingFeature } from './collections/LexicalHeadingFeature/index.js'
 import { LexicalInBlock } from './collections/LexicalInBlock/index.js'
 import { LexicalJSXConverter } from './collections/LexicalJSXConverter/index.js'
@@ -37,6 +38,7 @@ export const baseConfig: Partial<Config> = {
   // ...extend config here
   collections: [
     LexicalFullyFeatured,
+    LexicalAutosave,
     LexicalLinkFeature,
     LexicalListsFeature,
     LexicalHeadingFeature,

test/lexical/collections/LexicalAutosave/index.ts

@@ -0,0 +1,99 @@
+import type { CollectionConfig } from 'payload'
+
+import { BlocksFeature, lexicalEditor, LinkFeature } from '@payloadcms/richtext-lexical'
+
+import { lexicalAutosaveSlug } from '../../slugs.js'
+
+export const autosaveHookLog: {
+  relationshipField?: { operation: string; previousValue: unknown; value: unknown }
+} = {}
+
+export const clearAutosaveHookLog = (): void => {
+  delete autosaveHookLog.relationshipField
+}
+
+export const LexicalAutosave: CollectionConfig = {
+  slug: lexicalAutosaveSlug,
+  versions: {
+    drafts: {
+      autosave: true,
+    },
+  },
+  fields: [
+    {
+      name: 'title',
+      type: 'text',
+    },
+    // The bug occurs when richText is nested inside an array (like a CTA array)
+    {
+      name: 'cta',
+      type: 'array',
+      fields: [
+        {
+          name: 'richText',
+          type: 'richText',
+          editor: lexicalEditor({
+            features: ({ defaultFeatures }) => [
+              ...defaultFeatures,
+              BlocksFeature({
+                blocks: [
+                  {
+                    slug: 'textBlock',
+                    fields: [
+                      {
+                        name: 'blockTitle',
+                        type: 'text',
+                        hooks: {
+                          afterChange: [
+                            ({ value, previousValue, operation }) => {
+                              autosaveHookLog.relationshipField = {
+                                operation,
+                                previousValue,
+                                value,
+                              }
+                            },
+                          ],
+                        },
+                      },
+                    ],
+                  },
+                ],
+              }),
+              LinkFeature({
+                fields: [
+                  {
+                    type: 'blocks',
+                    name: 'linkBlocks',
+                    blocks: [
+                      {
+                        slug: 'linkBlock',
+                        fields: [
+                          {
+                            name: 'relationshipInLink',
+                            type: 'relationship',
+                            relationTo: 'text-fields',
+                            hooks: {
+                              afterChange: [
+                                ({ value, previousValue, operation }) => {
+                                  autosaveHookLog.relationshipField = {
+                                    operation,
+                                    previousValue,
+                                    value,
+                                  }
+                                },
+                              ],
+                            },
+                          },
+                        ],
+                      },
+                    ],
+                  },
+                ],
+              }),
+            ],
+          }),
+        },
+      ],
+    },
+  ],
+}

test/lexical/lexical.int.spec.ts

@@ -18,10 +18,10 @@ import { beforeAll, beforeEach, describe, expect } from 'vitest'
 
 import type { LexicalField, LexicalMigrateField, RichTextField } from './payload-types.js'
 
-import { devUser } from '../credentials.js'
+import { it } from '../__helpers/int/vitest.js'
 import { initPayloadInt } from '../__helpers/shared/initPayloadInt.js'
 import { NextRESTClient } from '../__helpers/shared/NextRESTClient.js'
-import { it } from '../__helpers/int/vitest.js'
+import { devUser } from '../credentials.js'
 import { lexicalDocData } from './collections/Lexical/data.js'
 import { generateLexicalLocalizedRichText } from './collections/LexicalLocalized/generateLexicalRichText.js'
 import { lexicalMigrateDocData } from './collections/LexicalMigrate/data.js'
@@ -836,4 +836,93 @@ describe('Lexical', () => {
       ).rejects.toBeTruthy()
     })
   })
+
+  describe('Autosave', () => {
+    it('should populate previousValue in afterChange hooks for fields inside lexical', async () => {
+      const { autosaveHookLog, clearAutosaveHookLog } = await import(
+        './collections/LexicalAutosave/index.js'
+      )
+
+      clearAutosaveHookLog()
+
+      const doc = await payload.create({
+        collection: 'lexical-autosave',
+        data: {
+          title: 'Autosave test document',
+          cta: [
+            {
+              richText: {
+                root: {
+                  children: [
+                    {
+                      type: 'block',
+                      version: 2,
+                      format: '',
+                      fields: {
+                        id: 'block-id-1',
+                        blockName: '',
+                        blockTitle: 'Initial block title',
+                        blockType: 'textBlock',
+                      },
+                    },
+                  ],
+                  direction: null,
+                  format: '',
+                  indent: 0,
+                  type: 'root',
+                  version: 1,
+                },
+              },
+            },
+          ],
+        },
+      })
+
+      // Verify create operation has undefined previousValue (expected)
+      expect(autosaveHookLog.relationshipField?.operation).toBe('create')
+      expect(autosaveHookLog.relationshipField?.previousValue).toBeUndefined()
+      expect(autosaveHookLog.relationshipField?.value).toBe('Initial block title')
+
+      clearAutosaveHookLog()
+
+      // Simulate autosave by updating the document
+      await payload.update({
+        collection: 'lexical-autosave',
+        id: doc.id,
+        data: {
+          title: 'Updated via autosave',
+          cta: [
+            {
+              richText: {
+                root: {
+                  children: [
+                    {
+                      type: 'block',
+                      version: 2,
+                      format: '',
+                      fields: {
+                        id: 'block-id-1',
+                        blockName: '',
+                        blockTitle: 'Updated block title',
+                        blockType: 'textBlock',
+                      },
+                    },
+                  ],
+                  direction: null,
+                  format: '',
+                  indent: 0,
+                  type: 'root',
+                  version: 1,
+                },
+              },
+            },
+          ],
+        },
+      })
+
+      expect(autosaveHookLog.relationshipField?.operation).toBe('update')
+      expect(autosaveHookLog.relationshipField?.previousValue).toBe('Initial block title')
+      expect(autosaveHookLog.relationshipField?.value).toBe('Updated block title')
+    })
+  })
 })

test/lexical/slugs.ts

@@ -11,6 +11,7 @@ export const lexicalLocalizedFieldsSlug = 'lexical-localized-fields'
 export const lexicalMigrateFieldsSlug = 'lexical-migrate-fields'
 export const lexicalRelationshipFieldsSlug = 'lexical-relationship-fields'
 export const lexicalAccessControlSlug = 'lexical-access-control'
+export const lexicalAutosaveSlug = 'lexical-autosave'
 export const richTextFieldsSlug = 'rich-text-fields'
 
 // Auxiliary slugs