fix(richtext-lexical): migrate scripts not working due to migration hooks running during migrate script

docs/lexical/migration.mdx

@@ -18,6 +18,7 @@ IMPORTANT: This will overwrite all slate data. We recommend doing the following
 1. Take a backup of your entire database. If anything goes wrong and you do not have a backup, you are on your own and will not receive any support.
 2. Make every richText field a lexical editor. This script will only convert lexical richText fields with old Slate data
 3. Add the SlateToLexicalFeature (as seen below) first, and test it out by loading up the Admin Panel, to see if the migrator works as expected. You might have to build some custom converters for some fields first in order to convert custom Slate nodes. The SlateToLexicalFeature is where the converters are stored. Only fields with this feature added will be migrated.
+4. If this works as expected, add the `disableHooks: true` prop everywhere you're initializing `SlateToLexicalFeature`. Example: `SlateToLexicalFeature({ disableHooks: true })`. Once you did that, you're ready to run the migration script.
 
 ```ts
 import { migrateSlateToLexical } from '@payloadcms/richtext-lexical/migrate'

packages/drizzle/src/upsertRow/index.ts

@@ -351,6 +351,7 @@ export const upsertRow = async <T extends Record<string, unknown> | TypeWithID>(
     throw error.code === '23505'
       ? new ValidationError(
           {
+            id,
             errors: [
               {
                 field: adapter.fieldConstraints[tableName][error.constraint],

packages/payload/src/errors/ValidationError.ts

@@ -21,7 +21,12 @@ export class ValidationError extends APIError<{
   global?: string
 }> {
   constructor(
-    results: { collection?: string; errors: ValidationFieldError[]; global?: string },
+    results: {
+      collection?: string
+      errors: ValidationFieldError[]
+      global?: string
+      id?: number | string
+    },
     t?: TFunction,
   ) {
     const message = t

packages/payload/src/fields/hooks/beforeChange/index.ts

@@ -71,6 +71,7 @@ export const beforeChange = async <T extends JsonObject>({
   if (errors.length > 0) {
     throw new ValidationError(
       {
+        id,
         collection: collection?.slug,
         errors,
         global: global?.slug,

packages/richtext-lexical/src/features/migrations/lexicalPluginToLexical/converter/index.ts

@@ -47,7 +47,7 @@ export function convertLexicalPluginNodesToLexical({
   parentNodeType: string
   quiet?: boolean
 }): SerializedLexicalNode[] {
-  if (!lexicalPluginNodes?.length) {
+  if (!lexicalPluginNodes?.length || !converters?.length) {
     return []
   }
   const unknownConverter = converters.find((converter) => converter.nodeTypes.includes('unknown'))

packages/richtext-lexical/src/features/migrations/lexicalPluginToLexical/feature.server.ts

@@ -13,6 +13,7 @@ export type LexicalPluginToLexicalFeatureProps = {
         defaultConverters: LexicalPluginNodeConverter[]
       }) => LexicalPluginNodeConverter[])
     | LexicalPluginNodeConverter[]
+  disableHooks?: boolean
   quiet?: boolean
 }
 
@@ -37,23 +38,25 @@ export const LexicalPluginToLexicalFeature =
 
       return {
         ClientFeature: '@payloadcms/richtext-lexical/client#LexicalPluginToLexicalFeatureClient',
-        hooks: {
-          afterRead: [
-            ({ value }) => {
-              if (!value || !('jsonContent' in value)) {
-                // incomingEditorState null or not from Lexical Plugin
-                return value
-              }
+        hooks: props.disableHooks
+          ? undefined
+          : {
+              afterRead: [
+                ({ value }) => {
+                  if (!value || !('jsonContent' in value)) {
+                    // incomingEditorState null or not from Lexical Plugin
+                    return value
+                  }
 
-              // Lexical Plugin => convert to lexical
-              return convertLexicalPluginToLexical({
-                converters: props.converters as LexicalPluginNodeConverter[],
-                lexicalPluginData: value as PayloadPluginLexicalData,
-                quiet: props?.quiet,
-              })
+                  // Lexical Plugin => convert to lexical
+                  return convertLexicalPluginToLexical({
+                    converters: props.converters as LexicalPluginNodeConverter[],
+                    lexicalPluginData: value as PayloadPluginLexicalData,
+                    quiet: props?.quiet,
+                  })
+                },
+              ],
             },
-          ],
-        },
         nodes: [
           {
             node: UnknownConvertedNode,

packages/richtext-lexical/src/features/migrations/slateToLexical/converter/index.ts

@@ -47,7 +47,7 @@ export function convertSlateNodesToLexical({
   parentNodeType: string
   slateNodes: SlateNode[]
 }): SerializedLexicalNode[] {
-  if (!converters?.length) {
+  if (!converters?.length || !slateNodes?.length) {
     return []
   }
   const unknownConverter = converters.find((converter) => converter.nodeTypes.includes('unknown'))

packages/richtext-lexical/src/features/migrations/slateToLexical/feature.server.ts

@@ -9,6 +9,7 @@ export type SlateToLexicalFeatureProps = {
   converters?:
     | (({ defaultConverters }: { defaultConverters: SlateNodeConverter[] }) => SlateNodeConverter[])
     | SlateNodeConverter[]
+  disableHooks?: boolean
 }
 
 export const SlateToLexicalFeature = createServerFeature<
@@ -35,22 +36,24 @@ export const SlateToLexicalFeature = createServerFeature<
 
     return {
       ClientFeature: '@payloadcms/richtext-lexical/client#SlateToLexicalFeatureClient',
-      hooks: {
-        afterRead: [
-          ({ value }) => {
-            if (!value || !Array.isArray(value) || 'root' in value) {
-              // incomingEditorState null or not from Slate
-              return value
-            }
+      hooks: props.disableHooks
+        ? undefined
+        : {
+            afterRead: [
+              ({ value }) => {
+                if (!value || !Array.isArray(value) || 'root' in value) {
+                  // incomingEditorState null or not from Slate
+                  return value
+                }
 
-            // Slate => convert to lexical
-            return convertSlateToLexical({
-              converters: props.converters as SlateNodeConverter[],
-              slateData: value,
-            })
+                // Slate => convert to lexical
+                return convertSlateToLexical({
+                  converters: props.converters as SlateNodeConverter[],
+                  slateData: value,
+                })
+              },
+            ],
           },
-        ],
-      },
       nodes: [
         {
           node: UnknownConvertedNode,

packages/richtext-lexical/src/utilities/migrateSlateToLexical/index.ts

@@ -64,12 +64,20 @@ async function migrateGlobal({
   })
 
   if (found) {
-    await payload.updateGlobal({
-      slug: global.slug,
-      data: document,
-      depth: 0,
-      locale: locale || undefined,
-    })
+    try {
+      await payload.updateGlobal({
+        slug: global.slug,
+        data: document,
+        depth: 0,
+        locale: locale || undefined,
+      })
+      // Catch it, because some errors were caused by the user previously (e.g. invalid relationships) and will throw an error now, even though they are not related to the migration
+    } catch (e) {
+      console.log('Error updating global', e, {
+        id: document.id,
+        slug: global.slug,
+      })
+    }
   }
 }
 
@@ -136,13 +144,21 @@ async function migrateCollection({
       })
 
       if (found) {
-        await payload.update({
-          id: document.id,
-          collection: collection.slug,
-          data: document,
-          depth: 0,
-          locale: locale || undefined,
-        })
+        try {
+          await payload.update({
+            id: document.id,
+            collection: collection.slug,
+            data: document,
+            depth: 0,
+            locale: locale || undefined,
+          })
+          // Catch it, because some errors were caused by the user previously (e.g. invalid relationships) and will throw an error now, even though they are not related to the migration
+        } catch (e) {
+          console.log('Error updating collection', e, {
+            id: document.id,
+            slug: collection.slug,
+          })
+        }
       }
     }
     page++

packages/richtext-lexical/src/validate/index.ts

@@ -20,15 +20,24 @@ export const richTextValidateHOC = ({
     } = options
 
     if (required) {
-      const hasChildren = value?.root?.children?.length
-
-      const hasOnlyEmptyParagraph =
-        (value?.root?.children?.length === 1 &&
-          value?.root?.children[0]?.type === 'paragraph' &&
-          (value?.root?.children[0] as SerializedParagraphNode)?.children?.length === 0) ||
-        ((value?.root?.children[0] as SerializedParagraphNode)?.children?.length === 1 &&
-          (value?.root?.children[0] as SerializedParagraphNode)?.children[0]?.type === 'text' &&
-          (value?.root?.children[0] as SerializedParagraphNode)?.children[0]?.['text'] === '')
+      const hasChildren = !!value?.root?.children?.length
+
+      let hasOnlyEmptyParagraph = false
+      if (value?.root?.children?.length === 1) {
+        if (value?.root?.children[0]?.type === 'paragraph') {
+          const paragraphNode = value?.root?.children[0] as SerializedParagraphNode
+          if (paragraphNode?.children?.length === 0) {
+            hasOnlyEmptyParagraph = true
+          } else if (paragraphNode?.children?.length === 1) {
+            const paragraphNodeChild = paragraphNode?.children[0]
+            if (paragraphNodeChild.type === 'text') {
+              if (!paragraphNodeChild?.['text']?.length) {
+                hasOnlyEmptyParagraph = true
+              }
+            }
+          }
+        }
+      }
 
       if (!hasChildren || hasOnlyEmptyParagraph) {
         return t('validation:required')