Resolve links into node.__links

So CMS can avoid circular references by omitting __links from each node
in contentModel. Find a better way for this omission though.

Extract linking related logic into its own lib/linking.js. And
ContentModelEntryNode implements some linking related methods.

Resolve all links as soon as contentModel subtree is built. The links
are kept all together in nodes's __link attribute. Serialize links into
nodes only during render. Posts need to update their linked-field
facets, so now they do it also just for rendering.

Tests needed for the new linking.js

Author: scriptype

src/cms/api/models/contentModel.js

@@ -1,6 +1,14 @@
 const createContentModelModel = ({ getContentModel }) => {
   return {
-    get: getContentModel
+    get() {
+      // TODO: find a nicer way for contentModel to serialize for cms
+      return JSON.parse(JSON.stringify(getContentModel(), (key, value) => {
+        if (key === '__links') {
+          return undefined
+        }
+        return value
+      }))
+    }
   }
 }
 

src/compiler/contentModel/collection/category.js

@@ -43,6 +43,7 @@ class Category extends ContentModelEntryNode {
   static serialize(category) {
     const data = {
       ...category,
+      ...category.serializeLinks(),
       facets: category.facets.map(models.facet().serialize),
       posts: category.subtree.posts.map(models.Post.serialize),
       levelPosts: category.subtree.levelPosts.map(models.Post.serialize),
@@ -188,7 +189,10 @@ class Category extends ContentModelEntryNode {
       })
 
       this.facets = models.facet().collectFacets(
-        this.subtree.posts,
+        this.subtree.posts.map(post => ({
+          ...post,
+          ...post.serializeLinks()
+        })),
         this.settings.facetKeys,
         childContext
       )

src/compiler/contentModel/collection/index.js

@@ -50,6 +50,7 @@ class Collection extends ContentModelEntryNode {
   static serialize(collection) {
     const data = {
       ...collection,
+      ...collection.serializeLinks(),
       facets: collection.facets.map(models.facet().serialize),
       categories: collection.subtree.categories.map(models.Category.serialize),
       posts: collection.subtree.posts.map(models.Post.serialize),
@@ -258,7 +259,10 @@ class Collection extends ContentModelEntryNode {
       })
 
       this.facets = models.facet().collectFacets(
-        this.subtree.posts,
+        this.subtree.posts.map(post => ({
+          ...post,
+          ...post.serializeLinks()
+        })),
         facetKeys,
         childContext
       )

src/compiler/contentModel/collection/post.js

@@ -16,8 +16,19 @@ const defaultSettings = {
 }
 class Post extends ContentModelEntryNode {
   static serialize(post) {
-    return {
+    const postWithSerializedLinks = {
       ...post,
+      ...post.serializeLinks()
+    }
+    // TODO: feels like collection should handle this
+    models.facet().linkWithEntryFields(
+      postWithSerializedLinks,
+      post.collectionFacets,
+      post.settings.facetKeys
+    )
+
+    return {
+      ...postWithSerializedLinks,
       attachments: post.subtree.attachments.map(models.Attachment.serialize)
     }
   }
@@ -52,9 +63,7 @@ class Post extends ContentModelEntryNode {
   }
 
   afterEffects(contentModel, collectionFacets) {
-    // TODO: feels like collection should handle this
-    models.facet().linkWithEntryFields(this, collectionFacets, this.settings.facetKeys)
-
+    this.collectionFacets = collectionFacets
     this.subtree.attachments.forEach(attachment => {
       attachment.afterEffects(contentModel)
     })

src/compiler/contentModel/homepage.js

@@ -14,6 +14,7 @@ class Homepage extends ContentModelEntryNode {
   static serialize(homepage) {
     return {
       ...homepage,
+      ...homepage.serializeLinks(),
       attachments: homepage.subtree.attachments.map(models.Attachment.serialize)
     }
   }

src/compiler/contentModel/index.js

@@ -14,104 +14,6 @@ const models = {
   Asset: require('./asset')
 }
 
-const findLinkedNode = (allNodes, linkPath) => {
-  const leafSlug = linkPath.pop()
-  const leafRe = new RegExp(`^${leafSlug}$`, 'i')
-  const leafMatches = allNodes.filter(p => p.slug.match(leafRe))
-
-  if (!leafMatches.length) {
-    return undefined
-  }
-
-  if (leafMatches.length === 1) {
-    return leafMatches[0]
-  }
-
-  if (!linkPath.length) {
-    return undefined
-  }
-
-  const paths = linkPath.reverse()
-  return leafMatches.find(node => {
-    let ctx = node.context
-    for (const path of paths) {
-      ctx = ctx.throwUntil(item => {
-        return item.slug?.match(new RegExp(`^${path}$`, 'i'))
-      })
-    }
-    return !!ctx.items.length
-  })
-}
-
-const linkNodes = (nodes) => {
-  nodes.forEach(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 (!valueItem.linkPath) {
-            break
-          }
-          const linkedNode = findLinkedNode(nodes, valueItem.linkPath)
-          if (linkedNode) {
-            node[key][i] = Object.assign({}, linkedNode)
-            linkBack(node, linkedNode, key)
-          } else {
-            node[key].splice(i, 1)
-            i--
-          }
-        }
-      } else {
-        if (!value?.linkPath) {
-          return
-        }
-        const linkedNode = findLinkedNode(nodes, value.linkPath)
-        if (linkedNode) {
-          node[key] = Object.assign({}, linkedNode)
-          linkBack(node, linkedNode, key)
-        } else {
-          node[key] = undefined
-        }
-      }
-    })
-  })
-}
-
-const linkBack = (post, entry, key) => {
-  if (entry.schema) {
-    Object.keys(entry.schema).forEach(schemaKey => {
-      const schemaValue = entry.schema[schemaKey]
-      const isSchemaValueArray = Array.isArray(schemaValue)
-      const re = new RegExp(`^\\+(${post.contentType}|):${key}$`)
-      const match = isSchemaValueArray ?
-        schemaValue.find(v => re.test(v)) :
-        re.test(schemaValue)
-      if (match) {
-        if (isSchemaValueArray) {
-          // console.log('linking', post.title, 'to', schemaKey, 'field of', entry.title)
-          entry[schemaKey] = entry[schemaKey] || []
-          entry[schemaKey].push(post)
-        } else {
-          entry[schemaKey] = post
-        }
-      }
-    })
-    return
-  }
-  entry.links = entry.links || {}
-  entry.links.relations = entry.links.relations || []
-  const relation = entry.links.relations.find(r => r.key === key)
-  if (relation) {
-    relation.entries.push(post)
-  } else {
-    entry.links.relations.push({
-      key,
-      entries: [post]
-    })
-  }
-}
-
 const defaultSettings = {
   permalinkPrefix: '/',
   out: resolve('.'),
@@ -129,6 +31,8 @@ const defaultSettings = {
 class ContentModel extends ContentModelEntryNode {
   static serialize(contentModel) {
     return {
+      ...contentModel,
+      ...contentModel.serializeLinks(),
       homepage: models.Homepage.serialize(contentModel.subtree.homepage),
       subpages: contentModel.subtree.subpages.map(models.Subpage.serialize),
       collections: contentModel.subtree.collections.map(models.Collection.serialize),
@@ -286,7 +190,7 @@ class ContentModel extends ContentModelEntryNode {
     }]
   }
 
-  afterEffects() {
+  linkNodes() {
     const flatMapDeepCategories = (container) => {
       return _.flatMapDeep(container, ({ subtree }) => {
         if (subtree.categories.length) {
@@ -299,12 +203,18 @@ class ContentModel extends ContentModelEntryNode {
       })
     }
 
-    linkNodes([
+    const nodes = [
       ...this.subtree.subpages,
       ...this.subtree.collections,
       ...flatMapDeepCategories(this.subtree.collections),
       ..._.flatMap(this.subtree.collections, ({ subtree }) => subtree.posts)
-    ])
+    ]
+
+    nodes.forEach(node => node.resolveLinks(nodes))
+  }
+
+  afterEffects() {
+    this.linkNodes()
 
     this.subtree.collections.forEach(collection => {
       collection.afterEffects(this.subtree)

src/compiler/contentModel/subpage.js

@@ -14,6 +14,7 @@ class Subpage extends ContentModelEntryNode {
   static serialize(subpage) {
     return {
       ...subpage,
+      ...subpage.serializeLinks(),
       attachments: subpage.subtree.attachments.map(models.Attachment.serialize)
     }
   }

src/lib/ContentModelEntryNode.js

@@ -1,13 +1,21 @@
 const { join } = require('path')
 const makeSlug = require('slug')
+const _ = require('lodash')
 const { makePermalink } = require('./contentModelHelpers')
 const { parseTextEntry } = require('./parseTextEntry')
+const {
+  findLinkedNode,
+  addLinkBack,
+  serializeLinks,
+  resolveLinks
+} = require('./linking')
 const ContentModelNode = require('./ContentModelNode')
 
 class ContentModelEntryNode extends ContentModelNode {
   constructor(fsNode, context, settings = {}) {
     super(fsNode, context, settings)
 
+    this.__links = []
     this.indexFile = this.getIndexFile()
 
     const isFlatData = !fsNode.stats?.birthtime
@@ -107,6 +115,26 @@ class ContentModelEntryNode extends ContentModelNode {
     return this.settings.mode === 'start' || !entry.draft
   }
 
+  getLinks() {
+    return this.__links
+  }
+
+  addLink(keyPath, node) {
+    this.__links.push({ keyPath, node })
+  }
+
+  addLinkBack(post, key) {
+    addLinkBack(this, post, key)
+  }
+
+  resolveLinks(nodes) {
+    resolveLinks(this, nodes)
+  }
+
+  serializeLinks() {
+    return serializeLinks(this)
+  }
+
   afterEffects(contentModel) {}
 
   render(renderer) {}