Extract parsing linked fields into parseTextEntry

So the linking logic in the contentModel/index is thinner — more
abstract. An unfortunate result of extraction is that now two places are
digging into entry fields in the same way. Feels like a tooth cavity.
But it is necessary to dig the array field items one by one to be able
to preserve non-linked items in them.

Author: scriptype

src/compiler/contentModel/index.js

@@ -14,12 +14,6 @@ const models = {
   Asset: require('./asset')
 }
 
-const LINKED_FIELD_SYNTAX = /^\+[^ ]+$/
-
-const parseLink = (value) => {
-  return value.replace(/^\+/g, '').split('/').filter(Boolean)
-}
-
 const findLinkedNode = (allNodes, linkPath) => {
   const leafSlug = linkPath.pop()
   const leafRe = new RegExp(`^${leafSlug}$`, 'i')
@@ -51,17 +45,15 @@ const findLinkedNode = (allNodes, linkPath) => {
 
 const linkNodes = (nodes) => {
   nodes.forEach(node => {
-    const fields = Object.keys(node)
     Object.keys(node).forEach(key => {
       const value = node[key]
       if (Array.isArray(value)) {
         for (let i = 0; i < value.length; i++) {
           let valueItem = value[i]
-          if (!LINKED_FIELD_SYNTAX.test(valueItem)) {
+          if (!valueItem.linkPath) {
             break
           }
-          const link = parseLink(valueItem)
-          const linkedNode = findLinkedNode(nodes, link)
+          const linkedNode = findLinkedNode(nodes, valueItem.linkPath)
           if (linkedNode) {
             node[key][i] = Object.assign({}, linkedNode)
             linkBack(node, linkedNode, key)
@@ -71,11 +63,10 @@ const linkNodes = (nodes) => {
           }
         }
       } else {
-        if (!LINKED_FIELD_SYNTAX.test(value)) {
+        if (!value?.linkPath) {
           return
         }
-        const link = parseLink(value)
-        const linkedNode = findLinkedNode(nodes, link)
+        const linkedNode = findLinkedNode(nodes, value.linkPath)
         if (linkedNode) {
           node[key] = Object.assign({}, linkedNode)
           linkBack(node, linkedNode, key)

src/lib/parseTextEntry.js

@@ -3,6 +3,38 @@ const frontMatter = require('front-matter')
 const slug = require('slug')
 const { removeExtension, Markdown } = require('./contentModelHelpers')
 
+const LINKED_FIELD_SYNTAX = /^\+[^ ]+$/
+
+const parseLinkValue = (value) => {
+  return value.replace(/^\+/g, '').split('/').filter(Boolean)
+}
+
+const parseLinkedFields = (fields) => {
+  Object.keys(fields).forEach(key => {
+    const value = fields[key]
+    if (Array.isArray(value)) {
+      for (let i = 0; i < value.length; i++) {
+        if (!LINKED_FIELD_SYNTAX.test(value[i])) {
+          continue
+        }
+        fields[key][i] = {
+          key,
+          linkPath: parseLinkValue(value[i])
+        }
+      }
+    } else {
+      if (!LINKED_FIELD_SYNTAX.test(value)) {
+        return
+      }
+      fields[key] = {
+        key,
+        linkPath: parseLinkValue(value)
+      }
+    }
+  })
+  return fields
+}
+
 const parseContent = (node, content) => {
   if (node.extension.match(/(html|htm|hbs|handlebars)/i)) {
     return content
@@ -46,6 +78,7 @@ const parseTextEntry = (fsNode, indexNode, isFlatData) => {
   return {
     ..._.omit(fsNode, 'children'),
     ...attributes,
+    ...parseLinkedFields(_.cloneDeep(attributes)),
     __originalAttributes__: attributes,
     hasIndex,
     title: attributes.title || entryName,
@@ -56,6 +89,8 @@ const parseTextEntry = (fsNode, indexNode, isFlatData) => {
 }
 
 module.exports = {
+  parseLinkValue,
+  parseLinkedFields,
   parseContent,
   normalizeEntryName,
   parseFlatData,

src/lib/parseTextEntry.spec.js

@@ -1,11 +1,206 @@
 const test = require('tape')
 const {
-  parseFlatData,
+  parseLinkValue,
+  parseLinkedFields,
   parseContent,
   normalizeEntryName,
+  parseFlatData,
   parseTextEntry
 } = require('./parseTextEntry')
 
+test('parseLinkValue removes leading plus and splits by slash', (t) => {
+  const value = '+folder/subfolder/item'
+
+  const result = parseLinkValue(value)
+
+  t.deepEqual(
+    result,
+    ['folder', 'subfolder', 'item'],
+    'removes plus and splits by slash'
+  )
+
+  t.end()
+})
+
+test('parseLinkValue handles single segment path', (t) => {
+  const value = '+folder'
+
+  const result = parseLinkValue(value)
+
+  t.deepEqual(
+    result,
+    ['folder'],
+    'returns array with single segment'
+  )
+
+  t.end()
+})
+
+test('parseLinkValue filters out empty segments', (t) => {
+  const value = '+folder//item'
+
+  const result = parseLinkValue(value)
+
+  t.deepEqual(
+    result,
+    ['folder', 'item'],
+    'removes empty segments from consecutive slashes'
+  )
+
+  t.end()
+})
+
+test('parseLinkValue preserves case sensitivity', (t) => {
+  const value = '+PEOPLE/users/ADMINS/john/PROFILE'
+
+  const result = parseLinkValue(value)
+
+  t.deepEqual(
+    result,
+    ['PEOPLE', 'users', 'ADMINS', 'john', 'PROFILE'],
+    'preserves mixed case with uppercase and lowercase segments'
+  )
+
+  t.end()
+})
+
+test('parseLinkValue ignores trailing slash', (t) => {
+  const value = '+folder/subfolder/'
+
+  const result = parseLinkValue(value)
+
+  t.deepEqual(
+    result,
+    ['folder', 'subfolder'],
+    'filters out empty segment from trailing slash'
+  )
+
+  t.end()
+})
+
+test('parseLinkedFields converts single string linked field', (t) => {
+  const fields = { author: '+people/users/admins/john' }
+
+  const result = parseLinkedFields(fields)
+
+  t.deepEqual(
+    result.author,
+    { key: 'author', linkPath: ['people', 'users', 'admins', 'john'] },
+    'converts linked field with multiple path segments'
+  )
+
+  t.end()
+})
+
+test('parseLinkedFields converts array of linked fields', (t) => {
+  const fields = { tags: ['+categories/tech/frontend/react', '+categories/js/backend/node'] }
+
+  const result = parseLinkedFields(fields)
+
+  t.deepEqual(
+    result.tags[0],
+    { key: 'tags', linkPath: ['categories', 'tech', 'frontend', 'react'] },
+    'converts first array element with deep path'
+  )
+
+  t.deepEqual(
+    result.tags[1],
+    { key: 'tags', linkPath: ['categories', 'js', 'backend', 'node'] },
+    'converts second array element with deep path'
+  )
+
+  t.end()
+})
+
+test('parseLinkedFields preserves non-linked string fields', (t) => {
+  const fields = { title: 'My Title', description: 'Plain text' }
+
+  const result = parseLinkedFields(fields)
+
+  t.equal(
+    result.title,
+    'My Title',
+    'preserves non-linked string field'
+  )
+
+  t.equal(
+    result.description,
+    'Plain text',
+    'preserves other non-linked fields'
+  )
+
+  t.end()
+})
+
+test('parseLinkedFields converts only the linked items in mixed arrays', (t) => {
+  const fields = { mixed: ['+category/tech', 'plain-text', '+category/other'] }
+
+  const result = parseLinkedFields(fields)
+
+  t.deepEqual(
+    result.mixed[0],
+    { key: 'mixed', linkPath: ['category', 'tech'] },
+    'converts first linked field'
+  )
+
+  t.equal(
+    result.mixed[1],
+    'plain-text',
+    'preserves non-linked item'
+  )
+
+  t.deepEqual(
+    result.mixed[2],
+    { key: 'mixed', linkPath: ['category', 'other'] },
+    'converts linked field that comes after non-linked item'
+  )
+
+  t.end()
+})
+
+test('parseLinkedFields handles mix of linked and non-linked fields', (t) => {
+  const fields = {
+    author: '+users/john',
+    title: 'Article Title',
+    tags: ['+tags/featured', '+tags/new'],
+    description: 'An article'
+  }
+
+  const result = parseLinkedFields(fields)
+
+  t.deepEqual(
+    result.author,
+    { key: 'author', linkPath: ['users', 'john'] },
+    'converts linked field'
+  )
+
+  t.equal(
+    result.title,
+    'Article Title',
+    'preserves non-linked string'
+  )
+
+  t.deepEqual(
+    result.tags[0],
+    { key: 'tags', linkPath: ['tags', 'featured'] },
+    'converts first array element'
+  )
+
+  t.deepEqual(
+    result.tags[1],
+    { key: 'tags', linkPath: ['tags', 'new'] },
+    'converts second array element'
+  )
+
+  t.equal(
+    result.description,
+    'An article',
+    'preserves non-linked fields among linked ones'
+  )
+
+  t.end()
+})
+
 test('parseContent returns content as-is for HTML files', (t) => {
   const node = { extension: '.html' }
   const content = '<div>HTML content</div>'