fix(gatsby): support union types for one-to-one ___NODE relations (#19916)

Author: vladar

packages/gatsby/src/schema/__tests__/rebuild-schema.js

@@ -374,8 +374,7 @@ describe(`build and update individual types`, () => {
     expect(String(field.type)).toEqual(`[Foo]`)
   })
 
-  it(`doesn't change ___NODE relations (defined as string)`, async () => {
-    // FIXME: this behavior seems a bit inconsistent, we should possibly reconsider it
+  it(`changes ___NODE relations (defined as string) from object type to union and back`, async () => {
     const node = {
       id: `Bar1`,
       internal: { type: `Bar`, contentDigest: `0` },
@@ -392,9 +391,9 @@ describe(`build and update individual types`, () => {
     }
     newSchema = await addNodeAndRebuild(node2)
     field = newSchema.getType(`Bar`).getFields().related
-    expect(String(field.type)).toEqual(`Foo`)
+    expect(String(field.type)).toEqual(`FooNestedUnion`)
 
-    newSchema = await deleteNodeAndRebuild(node)
+    newSchema = await deleteNodeAndRebuild(node2)
     field = newSchema.getType(`Bar`).getFields().related
     expect(String(field.type)).toEqual(`Foo`)
   })

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

@@ -680,7 +680,10 @@ describe(`Get example value for type inference`, () => {
         ],
         typeConflictReporter,
       })
-      expect(example.related___NODE).toBe(`foo`)
+      expect(example.related___NODE).toEqual({
+        multiple: false,
+        linkedNodes: [`foo`, `bar`, `baz`],
+      })
     })
 
     it(`aggregates array of related node ids`, () => {
@@ -692,7 +695,10 @@ describe(`Get example value for type inference`, () => {
         ],
         typeConflictReporter,
       })
-      expect(example.related___NODE).toEqual([`foo`, `bar`, `baz`])
+      expect(example.related___NODE).toEqual({
+        multiple: true,
+        linkedNodes: [`foo`, `bar`, `baz`],
+      })
     })
 
     it(`skips nullish values and empty arrays/objects`, () => {
@@ -1033,8 +1039,8 @@ describe(`Type change detection`, () => {
     { object: { foo: `foo`, bar: `bar` } },
     { list: [`item`], bar: `bar` },
     { listOfObjects: [{ foo: `foo`, bar: `bar` }] },
-    { union___NODE: `foo` },
-    { listOfUnion___NODE: [`foo`] },
+    { relatedNode___NODE: `foo` },
+    { relatedNodeList___NODE: [`foo`] },
   ]
 
   const addOne = (node, metadata = initialMetadata) =>
@@ -1125,39 +1131,38 @@ describe(`Type change detection`, () => {
     expect(haveEqualFields(metadata, initialMetadata)).toEqual(true)
   })
 
-  // TODO
-  it.skip(`detects on any change of the union field`, () => {
+  it(`detects on any change of the relatedNode field`, () => {
     // We do not know a type of the node being added hence consider and
     // add/delete to such fields as mutations
-    let metadata = addOne({ union___NODE: `added` })
+    let metadata = addOne({ relatedNode___NODE: `added` })
     expect(metadata.dirty).toEqual(true)
     expect(haveEqualFields(metadata, initialMetadata)).toEqual(true)
     metadata.dirty = false
 
-    metadata = deleteOne({ union___NODE: `added` }, metadata)
+    metadata = deleteOne({ relatedNode___NODE: `added` }, metadata)
     expect(metadata.dirty).toEqual(true)
     expect(haveEqualFields(metadata, initialMetadata)).toEqual(true)
   })
 
-  it.skip(`does not detect when the same node added to the union field`, () => {
-    const metadata = addOne({ union___NODE: `foo` })
+  it(`does not detect when the same node added to the relatedNode field`, () => {
+    const metadata = addOne({ relatedNode___NODE: `foo` })
     expect(metadata.dirty).toEqual(false)
     expect(haveEqualFields(metadata, initialMetadata)).toEqual(true)
   })
 
-  it(`detects on any change of the listOfUnion field`, () => {
-    let metadata = addOne({ listOfUnion___NODE: [`added`] })
+  it(`detects on any change of the relatedNodeList field`, () => {
+    let metadata = addOne({ relatedNodeList___NODE: [`added`] })
     expect(metadata.dirty).toEqual(true)
     expect(haveEqualFields(metadata, initialMetadata)).toEqual(true)
     metadata.dirty = false
 
-    metadata = deleteOne({ listOfUnion___NODE: [`added`] }, metadata)
+    metadata = deleteOne({ relatedNodeList___NODE: [`added`] }, metadata)
     expect(metadata.dirty).toEqual(true)
     expect(haveEqualFields(metadata, initialMetadata)).toEqual(true)
   })
 
-  it(`does not detect when the same node added to the listOfUnion field`, () => {
-    const metadata = addOne({ listOfUnion___NODE: [`foo`] })
+  it(`does not detect when the same node added to the relatedNodeList field`, () => {
+    const metadata = addOne({ relatedNodeList___NODE: [`foo`] })
     expect(metadata.dirty).toEqual(false)
     expect(haveEqualFields(metadata, initialMetadata)).toEqual(true)
   })

packages/gatsby/src/schema/infer/add-inferred-fields.js

@@ -169,6 +169,7 @@ const getFieldConfig = ({
       value: exampleValue,
       key: unsanitizedKey,
     })
+    arrays = arrays + (value.multiple ? 1 : 0)
   } else {
     fieldConfig = getSimpleFieldConfig({
       schemaComposer,
@@ -255,9 +256,7 @@ const getFieldConfigFromFieldNameConvention = ({
       ? nodeStore.getNodes().find(node => _.get(node, foreignKey) === value)
       : nodeStore.getNode(value)
 
-  const linkedNodes = Array.isArray(value)
-    ? value.map(getNodeBy)
-    : [getNodeBy(value)]
+  const linkedNodes = value.linkedNodes.map(getNodeBy)
 
   const linkedTypes = _.uniq(
     linkedNodes.filter(Boolean).map(node => node.internal.type)
@@ -266,7 +265,7 @@ const getFieldConfigFromFieldNameConvention = ({
   invariant(
     linkedTypes.length,
     `Encountered an error trying to infer a GraphQL type for: \`${key}\`. ` +
-      `There is no corresponding node with the \`id\` field matching: "${value}".`
+      `There is no corresponding node with the \`id\` field matching: "${value.linkedNodes}".`
   )
 
   let type

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

@@ -69,7 +69,8 @@ type ValueDescriptor = {
   string?: { total: Count, first: NodeId, example: string, empty: Count },
   boolean?: { total: Count, first: NodeId, example: boolean },
   array?: { total: Count, first: NodeId, item: ValueDescriptor },
-  listOfUnion?: { total: Count, first: NodeId, nodes: { [NodeId]: Count } },
+  relatedNode?: { total: Count, first: NodeId, nodes: { [NodeId]: Count } },
+  relatedNodeList?: { total: Count, first: NodeId, nodes: { [NodeId]: Count } },
   object?: { total: 0, first: NodeId, props: { [string]: ValueDescriptor } },
 }
 ```
@@ -94,6 +95,9 @@ const getType = (value, key) => {
     case `number`:
       return is32BitInteger(value) ? `int` : `float`
     case `string`:
+      if (key.includes(`___NODE`)) {
+        return `relatedNode`
+      }
       return looksLikeADate(value) ? `date` : `string`
     case `boolean`:
       return `boolean`
@@ -105,7 +109,7 @@ const getType = (value, key) => {
         if (value.length === 0) {
           return `null`
         }
-        return key.includes(`___NODE`) ? `listOfUnion` : `array`
+        return key.includes(`___NODE`) ? `relatedNodeList` : `array`
       }
       if (!Object.keys(value).length) return `null`
       return `object`
@@ -115,7 +119,7 @@ const getType = (value, key) => {
 }
 
 const updateValueDescriptor = (
-  { nodeId, key, value, operation = `add` /*: add | del*/, descriptor = {} },
+  { nodeId, key, value, operation = `add` /* add | del */, descriptor = {} },
   path = []
 ) => {
   // The object may be traversed multiple times from root.
@@ -216,15 +220,20 @@ const _updateValueDescriptor = (
       })
       break
     }
-    case `listOfUnion`: {
+    case `relatedNode`:
+    case `relatedNodeList`: {
       const { nodes = {} } = typeInfo
-      value.forEach(nodeId => {
+      const listOfNodeIds = Array.isArray(value) ? value : [value]
+      listOfNodeIds.forEach(nodeId => {
         nodes[nodeId] = (nodes[nodeId] || 0) + delta
 
         // Treat any new related node addition or removal as a structural change
         // FIXME: this will produce false positives as this node can be
-        //  of the same type as another node already in the map (but we don't know it)
-        dirty = dirty || nodes[nodeId] === 0 || nodes[nodeId] === 1
+        //  of the same type as another node already in the map (but we don't know it here)
+        dirty =
+          dirty ||
+          nodes[nodeId] === 0 ||
+          (operation === `add` && nodes[nodeId] === 1)
       })
       typeInfo.nodes = nodes
       break
@@ -284,7 +293,8 @@ const descriptorsAreEqual = (descriptor, otherDescriptor) => {
         )
       )
     }
-    case `listOfUnion`: {
+    case `relatedNode`:
+    case `relatedNodeList`: {
       return isEqual(descriptor.nodes, otherDescriptor.nodes)
     }
     default:
@@ -369,14 +379,21 @@ const resolveWinnerType = descriptor => {
 
 const prepareConflictExamples = (descriptor, isArrayItem) => {
   const typeNameMapper = typeName => {
-    if (typeName === `listOfUnion`) {
+    if (typeName === `relatedNode`) {
+      return `string`
+    }
+    if (typeName === `relatedNodeList`) {
       return `[string]`
     }
     return [`float`, `int`].includes(typeName) ? `number` : typeName
   }
   const reportedValueMapper = typeName => {
-    if (typeName === `listOfUnion`) {
-      const { nodes } = descriptor.listOfUnion
+    if (typeName === `relatedNode`) {
+      const { nodes } = descriptor.relatedNode
+      return Object.keys(nodes).find(key => nodes[key] > 0)
+    }
+    if (typeName === `relatedNodeList`) {
+      const { nodes } = descriptor.relatedNodeList
       return Object.keys(nodes).filter(key => nodes[key] > 0)
     }
     if (typeName === `object`) {
@@ -458,9 +475,13 @@ const buildExampleValue = ({
       return exampleItemValue === null ? null : [exampleItemValue]
     }
 
-    case `listOfUnion`: {
+    case `relatedNode`:
+    case `relatedNodeList`: {
       const { nodes = {} } = typeInfo
-      return Object.keys(nodes).filter(key => nodes[key] > 0)
+      return {
+        multiple: type === `relatedNodeList`,
+        linkedNodes: Object.keys(nodes).filter(key => nodes[key] > 0),
+      }
     }
 
     case `object`: {