fix: extract links from rich text field [FUS-556] (#1050)

The Merge App performs a sorting during `apply` command that puts all
entries with links to other entries at the end of the list to ensure
that all the links are published before the main entry. This however was
not the case for rich text fields, which caused issues with merging.

This PR introduces a function that detects links to other entries in
rich text field and sorts them down accordingly.

Author: screamcha

src/engine/utils/sort-entries-by-reference.ts

@@ -1,4 +1,4 @@
-import { AddedChangesetItem } from '../types'
+import { AddedChangesetItem, ChangesetEntityLink } from '../types'
 import { FieldsType } from 'contentful'
 
 type LinksPerEntry = { index: number; linkIndexes: number[] }
@@ -42,6 +42,9 @@ function getLinkedEntries(entries: AddedChangesetItem[]): LinksPerEntry[] {
         return getFieldEntriesIndex(field, entries)
       } else if (isEntryArrayLink(field)) {
         return field.map((item: FieldsType) => getFieldEntriesIndex(item, entries))
+      } else if (isRichTextField(field)) {
+        const links = extractLinksFromContent(field, entry.entity)
+        return links.map((item: FieldsType) => getFieldEntriesIndex(item, entries))
       }
     })
 
@@ -65,6 +68,28 @@ function isEntryArrayLink(item: FieldsType): boolean {
   return Array.isArray(item) && item.length > 0 && isEntryLink(item[0])
 }
 
+function isRichTextField(item: FieldsType): boolean {
+  return item.nodeType === 'document'
+}
+
+function extractLinksFromContent({ content }: FieldsType, sourceEntity: ChangesetEntityLink['entity']) {
+  const { id: sourceId } = sourceEntity.sys
+  const links = content.reduce((acc: FieldsType[], field: FieldsType) => {
+    if (['embedded-entry-block', 'embedded-entry-inline', 'entry-hyperlink'].includes(field.nodeType)) {
+      const { id: targetId } = field.data.target.sys
+      if (targetId !== sourceId) {
+        acc.push(field.data.target)
+      }
+    } else if (field.content?.length) {
+      const linksFromContent = extractLinksFromContent(field, sourceEntity)
+      acc.push(...linksFromContent)
+    }
+    return acc
+  }, [])
+
+  return links
+}
+
 /**
  * From https://github.com/millermedeiros/amd-utils/blob/master/src/array/sort.js
  * MIT Licensed

test/integration/commands/apply/index.test.ts

@@ -6,7 +6,7 @@ import fancy from './../register-plugins'
 import { createChangeset } from '../../../../src/engine/utils/create-changeset'
 import { createAddTwoItemsChangeset } from '../fixtures/add-two-items-changeset'
 
-describe('create command', () => {
+describe('apply command', () => {
   const spaceId = process.env.CONTENTFUL_SPACE_ID!
   if (!spaceId) {
     throw new Error('Please provide a `CONTENTFUL_SPACE_ID`')

test/unit/engine/utils/sort-entries-by-reference.test.ts

@@ -6,6 +6,7 @@ import { createChangesetItemWithData } from '../../../../src/test/helpers/create
 describe('sortEntriesByReference', () => {
   const referencedItem: AddedChangesetItem = createChangesetItemWithData('lesson', 'added-entry')
   const referencedItem1: AddedChangesetItem = createChangesetItemWithData('lesson', 'added-entry1')
+  const referencedItem2: AddedChangesetItem = createChangesetItemWithData('lesson', 'added-entry2')
   const itemWithOneLink: AddedChangesetItem = createChangesetItemWithData('lesson1', 'added-entry-with-one-link', {
     referenceField: {
       'en-US': {
@@ -39,6 +40,68 @@ describe('sortEntriesByReference', () => {
     },
   )
 
+  const itemWithRichTextLinks: AddedChangesetItem = createChangesetItemWithData(
+    'lesson4',
+    'added-entry-with-rich-text-link',
+    {
+      richTextField: {
+        'en-US': {
+          nodeType: 'document',
+          data: {},
+          content: [
+            {
+              nodeType: 'embedded-entry-inline',
+              content: [],
+              data: {
+                target: {
+                  sys: {
+                    type: 'Link',
+                    linkType: 'Entry',
+                    id: 'added-entry',
+                  },
+                },
+              },
+            },
+            { nodeType: 'text', marks: [], value: 'some text', data: {} },
+            {
+              nodeType: 'paragraph',
+              content: [
+                { nodeType: 'text', marks: [], value: 'some text', data: {} },
+                {
+                  nodeType: 'embedded-entry-block',
+                  content: [],
+                  data: {
+                    target: {
+                      sys: {
+                        type: 'Link',
+                        linkType: 'Entry',
+                        id: 'added-entry1',
+                      },
+                    },
+                  },
+                },
+                {
+                  nodeType: 'entry-hyperlink',
+                  content: [],
+                  data: {
+                    target: {
+                      sys: {
+                        type: 'Link',
+                        linkType: 'Entry',
+                        id: 'added-entry2',
+                      },
+                    },
+                  },
+                },
+              ],
+              data: {},
+            },
+          ],
+        },
+      },
+    },
+  )
+
   const nonReferencedItem = createChangesetItemWithData('lesson', 'non-referenced-entry')
 
   it('should order based on references if the linked entry is present in the changeset', () => {
@@ -79,7 +142,7 @@ describe('sortEntriesByReference', () => {
     ])
   })
 
-  it('should not reorder there are no links in the changeset', () => {
+  it('should not reorder if there are no links in the changeset', () => {
     expect(sortEntriesByReference([nonReferencedItem, referencedItem, referencedItem1])).to.deep.equal([
       nonReferencedItem,
       referencedItem,
@@ -120,4 +183,10 @@ describe('sortEntriesByReference', () => {
       itemWithArrayLinks,
     ])
   })
+
+  it('should reorder entries linked in rich text fields', () => {
+    expect(
+      sortEntriesByReference([itemWithRichTextLinks, referencedItem, referencedItem1, referencedItem2]),
+    ).to.deep.equal([referencedItem, referencedItem1, referencedItem2, itemWithRichTextLinks])
+  })
 })