fix(gatsby): do not cause stack overflow over circular refs

packages/gatsby/src/db/sanitize-node.js

@@ -3,19 +3,25 @@ const _ = require(`lodash`)
 /**
  * Make data serializable
  * @param {(Object|Array)} data to sanitize
+ * @param {boolean} isNode = true
+ * @param {Set<string>} path = new Set
  */
-const sanitizeNode = (data, isNode = true) => {
+const sanitizeNode = (data, isNode = true, path = new Set()) => {
   const isPlainObject = _.isPlainObject(data)
 
   if (isPlainObject || _.isArray(data)) {
+    path.add(data)
+
     const returnData = isPlainObject ? {} : []
     let anyFieldChanged = false
     _.each(data, (o, key) => {
+      if (path.has(o)) return
+
       if (isNode && key === `internal`) {
         returnData[key] = o
         return
       }
-      returnData[key] = sanitizeNode(o, false)
+      returnData[key] = sanitizeNode(o, false, path)
 
       if (returnData[key] !== o) {
         anyFieldChanged = true
@@ -26,13 +32,16 @@ const sanitizeNode = (data, isNode = true) => {
       data = omitUndefined(returnData)
     }
 
+    path.add(data)
+
     // arrays and plain objects are supported - no need to to sanitize
     return data
   }
 
   if (!isTypeSupported(data)) {
     return undefined
   } else {
+    path.add(data)
     return data
   }
 }

packages/gatsby/src/schema/__tests__/node-model.js

@@ -691,4 +691,97 @@ describe(`NodeModel`, () => {
       })
     })
   })
+
+  describe(`circular references`, () => {
+    describe(`directly on a node`, () => {
+      beforeEach(async () => {
+        // This tests whether addRootNodeToInlineObject properly prevents re-traversing the same key-value pair infinitely
+        const circular = { i_am: `recursion!` }
+        circular.circled = circular
+
+        const node = {
+          id: `circleId`,
+          parent: null,
+          children: [],
+          inlineObject: {
+            field: `fieldOfFirstNode`,
+          },
+          inlineArray: [1, 2, 3],
+          circular,
+          internal: {
+            type: `Test`,
+            contentDigest: `digest1`,
+          },
+        }
+        actions.createNode(node, { name: `test` })(store.dispatch)
+
+        await build({})
+        const {
+          schemaCustomization: { composer: schemaComposer },
+        } = store.getState()
+        schema = store.getState().schema
+
+        nodeModel = new LocalNodeModel({
+          schema,
+          schemaComposer,
+          nodeStore,
+          createPageDependency,
+        })
+      })
+
+      it(`trackInlineObjectsInRootNode should not infinitely loop on a circular reference`, () => {
+        const node = nodeModel.getAllNodes({ type: `Test` })[0]
+        const copiedInlineObject = { ...node.inlineObject }
+        nodeModel.trackInlineObjectsInRootNode(copiedInlineObject)
+
+        expect(nodeModel._trackedRootNodes instanceof Set).toBe(true)
+        expect(nodeModel._trackedRootNodes.has(node.id)).toEqual(true)
+      })
+    })
+    describe(`not directly on a node`, () => {
+      beforeEach(async () => {
+        // This tests whether addRootNodeToInlineObject properly prevents re-traversing the same key-value pair infinitely
+        const circular = { i_am: `recursion!` }
+        circular.circled = { bar: { circular } }
+
+        const node = {
+          id: `circleId`,
+          parent: null,
+          children: [],
+          inlineObject: {
+            field: `fieldOfFirstNode`,
+          },
+          inlineArray: [1, 2, 3],
+          foo: { circular },
+          internal: {
+            type: `Test`,
+            contentDigest: `digest1`,
+          },
+        }
+        actions.createNode(node, { name: `test` })(store.dispatch)
+
+        await build({})
+        const {
+          schemaCustomization: { composer: schemaComposer },
+        } = store.getState()
+        schema = store.getState().schema
+
+        nodeModel = new LocalNodeModel({
+          schema,
+          schemaComposer,
+          nodeStore,
+          createPageDependency,
+        })
+      })
+
+      it(`trackInlineObjectsInRootNode should not infinitely loop on a circular reference`, () => {
+        const node = nodeModel.getAllNodes({ type: `Test` })[0]
+        const copiedInlineObject = { ...node.inlineObject }
+        nodeModel.trackInlineObjectsInRootNode(copiedInlineObject)
+
+        expect(nodeModel._trackedRootNodes instanceof Set).toBe(true)
+        expect(nodeModel._trackedRootNodes.has(node.id)).toEqual(true)
+      })
+    })
+  })
 })

packages/gatsby/src/schema/infer/inference-metadata.js

@@ -113,19 +113,47 @@ const getType = (value, key) => {
   }
 }
 
-const updateValueDescriptor = ({
-  nodeId,
-  key,
-  value,
-  operation = `add`,
-  descriptor = {},
-}) => {
+const updateValueDescriptor = (
+  { nodeId, key, value, operation = `add` /*: add | del*/, descriptor = {} },
+  path = []
+) => {
+  // The object may be traversed multiple times from root.
+  // Each time it does it should not revisit the same node twice
+  if (path.includes(value)) {
+    return [descriptor, false]
+  }
+
   const typeName = getType(value, key)
 
   if (typeName === `null`) {
     return [descriptor, false]
   }
 
+  path.push(value)
+
+  const ret = _updateValueDescriptor(
+    nodeId,
+    key,
+    value,
+    operation,
+    descriptor,
+    path,
+    typeName
+  )
+
+  path.pop()
+
+  return ret
+}
+const _updateValueDescriptor = (
+  nodeId,
+  key,
+  value,
+  operation,
+  descriptor,
+  path,
+  typeName
+) => {
   const delta = operation === `del` ? -1 : 1
   const typeInfo = descriptor[typeName] || { total: 0 }
   typeInfo.total += delta
@@ -138,25 +166,31 @@ const updateValueDescriptor = ({
   // Keeping track of the first node for this type. Only used for better conflict reporting.
   // (see Caveats section in the header comments)
   if (operation === `add`) {
-    typeInfo.first = typeInfo.first || nodeId
+    if (!typeInfo.first) {
+      typeInfo.first = nodeId
+    }
   } else if (operation === `del`) {
-    typeInfo.first =
-      typeInfo.first === nodeId || typeInfo.total === 0
-        ? undefined
-        : typeInfo.first
+    if (typeInfo.first === nodeId || typeInfo.total === 0) {
+      typeInfo.first = undefined
+    }
   }
 
   switch (typeName) {
     case `object`: {
       const { props = {} } = typeInfo
       Object.keys(value).forEach(key => {
-        const [propDescriptor, propDirty] = updateValueDescriptor({
-          nodeId,
-          key,
-          value: value[key],
-          operation,
-          descriptor: props[key],
-        })
+        const v = value[key]
+
+        const [propDescriptor, propDirty] = updateValueDescriptor(
+          {
+            nodeId,
+            key,
+            value: v,
+            operation,
+            descriptor: props[key],
+          },
+          path
+        )
         props[key] = propDescriptor
         dirty = dirty || propDirty
       })
@@ -165,13 +199,17 @@ const updateValueDescriptor = ({
     }
     case `array`: {
       value.forEach(item => {
-        const [itemDescriptor, itemDirty] = updateValueDescriptor({
-          nodeId,
-          descriptor: typeInfo.item,
-          operation,
-          value: item,
-          key,
-        })
+        const [itemDescriptor, itemDirty] = updateValueDescriptor(
+          {
+            nodeId,
+            descriptor: typeInfo.item,
+            operation,
+            value: item,
+            key,
+          },
+          path
+        )
+
         typeInfo.item = itemDescriptor
         dirty = dirty || itemDirty
       })

packages/gatsby/src/schema/node-model.js

@@ -703,16 +703,21 @@ const addRootNodeToInlineObject = (
   rootNodeMap,
   data,
   nodeId,
-  isNode = false
+  isNode = false,
+  path = new Set()
 ) => {
+  path.add(data)
+
   const isPlainObject = _.isPlainObject(data)
 
   if (isPlainObject || _.isArray(data)) {
     _.each(data, (o, key) => {
+      if (path.has(o)) return
       if (!isNode || key !== `internal`) {
         addRootNodeToInlineObject(rootNodeMap, o, nodeId)
       }
     })
+
     // don't need to track node itself
     if (!isNode) {
       rootNodeMap.set(data, nodeId)