feat: use @link directive instead of custom resolvers (#242)

We would like to add Sanity support to Netlify Connect, but the
requirements for schemas are stricter than for Gatsby. This PR changes
the schema to use `@link` directives instead of custom resolvers. As
well as supporting Netlify Connect, having a stricter schema allows
Gatsby to use performance optimisations that aren't possible with custom
resolvers. As well as switching reference resolvers to `@link`, this
changes union resolvers to instead add `internal.type` values to union
fields. Doing this means we can remove all of the custom resolvers,
apart from those used for raw fields.

Author: ascorbic

.gitignore

@@ -9,3 +9,4 @@ coverage
 public
 .vercel
 .vscode
+.DS_Store

src/util/getGraphQLResolverMap.ts

@@ -1,10 +1,8 @@
 import {camelCase} from 'lodash'
 import {CreateResolversArgs} from 'gatsby'
 import {GraphQLFieldResolver} from 'gatsby/graphql'
-import {SanityRef} from '../types/sanity'
-import {GatsbyResolverMap, GatsbyNodeModel, GatsbyGraphQLContext} from '../types/gatsby'
+import {GatsbyResolverMap, GatsbyGraphQLContext} from '../types/gatsby'
 import {TypeMap, FieldDef} from './remoteGraphQLSchema'
-import {getTypeName, getConflictFreeFieldName} from './normalize'
 import {resolveReferences} from './resolveReferences'
 import {PluginConfig} from './validateConfig'
 
@@ -26,24 +24,6 @@ export function getGraphQLResolverMap(
         fields[field.fieldName] = {resolve: getRawResolver(field, pluginConfig, context)}
         return fields
       }, resolvers[objectType.name] || {})
-
-    // Add resolvers for lists, referenes and unions
-    resolvers[objectType.name] = fieldNames
-      .map((fieldName) => ({fieldName, ...objectType.fields[fieldName]}))
-      .filter(
-        (field) =>
-          field.isList ||
-          field.isReference ||
-          typeMap.unions[getTypeName(field.namedType.name.value)],
-      )
-      .reduce((fields, field) => {
-        const targetField = objectType.isDocument
-          ? getConflictFreeFieldName(field.fieldName)
-          : field.fieldName
-
-        fields[targetField] = {resolve: getResolver(field)}
-        return fields
-      }, resolvers[objectType.name] || {})
   })
 
   return resolvers
@@ -67,34 +47,3 @@ function getRawResolver(
       : value
   }
 }
-
-function getResolver(
-  field: FieldDef & {fieldName: string},
-): GraphQLFieldResolver<{[key: string]: any}, GatsbyGraphQLContext> {
-  return (source, args, context) => {
-    if (field.isList) {
-      const items: SanityRef[] = source[field.fieldName] || []
-      return items && Array.isArray(items)
-        ? items.map((item) => maybeResolveReference(item, context.nodeModel))
-        : []
-    }
-
-    const item: SanityRef | undefined = source[field.fieldName]
-    return maybeResolveReference(item, context.nodeModel)
-  }
-}
-
-function maybeResolveReference(
-  item: {_ref?: string; _type?: string; internal?: {}} | undefined,
-  nodeModel: GatsbyNodeModel,
-) {
-  if (item && typeof item._ref === 'string') {
-    return nodeModel.getNodeById({id: item._ref})
-  }
-
-  if (item && typeof item._type === 'string' && !item.internal) {
-    return {...item, internal: {type: getTypeName(item._type)}}
-  }
-
-  return item
-}

src/util/normalize.ts

@@ -1,7 +1,7 @@
 import {Actions, NodePluginArgs} from 'gatsby'
 import {extractWithPath} from '@sanity/mutator'
 import {specifiedScalarTypes} from 'gatsby/graphql'
-import {set, startCase, camelCase, cloneDeep, upperFirst} from 'lodash'
+import {get, set, startCase, camelCase, cloneDeep, upperFirst} from 'lodash'
 import {SanityDocument} from '../types/sanity'
 import {safeId, unprefixId} from './documentIds'
 import {TypeMap} from './remoteGraphQLSchema'
@@ -35,6 +35,9 @@ export function toGatsbyNode(doc: SanityDocument, options: ProcessingOptions): S
   const rawAliases = getRawAliases(doc, options)
   const safe = prefixConflictingKeys(doc)
   const withRefs = rewriteNodeReferences(safe, options)
+
+  addInternalTypesToUnionFields(withRefs, options)
+
   const type = getTypeName(doc._type)
   const urlBuilder = imageUrlBuilder(options.client)
 
@@ -149,3 +152,54 @@ function rewriteNodeReferences(doc: SanityDocument, options: ProcessingOptions)
 
   return newDoc
 }
+// Adds `internal: { type: 'TheTypeName' }` to union fields nodes, to allow runtime
+// type resolution.
+function addInternalTypesToUnionFields(doc: SanityDocument, options: ProcessingOptions) {
+  const {typeMap} = options
+  const types = extractWithPath('..[_type]', doc)
+
+  const typeName = getTypeName(doc._type)
+  const thisType = typeMap.objects[typeName]
+  if (!thisType) {
+    return
+  }
+
+  for (const type of types) {
+    // Not needed for references or root objects
+    if (type.value === 'reference' || type.path.length < 2) {
+      continue
+    }
+
+    //  extractWithPath returns integers to indicate array indices for list types
+    const isListType = Number.isInteger(type.path[type.path.length - 2])
+
+    //  For list types we need to go up an extra level to get the actual field name
+    const parentOffset = isListType ? 3 : 2
+
+    const parentNode =
+      type.path.length === parentOffset ? doc : get(doc, type.path.slice(0, -parentOffset))
+    const parentTypeName = getTypeName(parentNode._type)
+    const parentType = typeMap.objects[parentTypeName]
+
+    if (!parentType) {
+      continue
+    }
+
+    const field = parentType.fields[type.path[type.path.length - parentOffset]]
+
+    if (!field) {
+      continue
+    }
+
+    const fieldTypeName = getTypeName(field.namedType.name.value)
+
+    // All this was just to check if we're dealing with a union field
+    if (!typeMap.unions[fieldTypeName]) {
+      continue
+    }
+    const typeName = getTypeName(type.value)
+
+    // Add the internal type to the field
+    set(doc, type.path.slice(0, -1).concat('internal'), {type: typeName})
+  }
+}

src/util/rewriteGraphQLSchema.ts

@@ -19,6 +19,7 @@ import {
   DirectiveNode,
   ScalarTypeDefinitionNode,
   specifiedScalarTypes,
+  Kind,
 } from 'gatsby/graphql'
 import {camelCase} from 'lodash'
 import {RESTRICTED_NODE_FIELDS, getConflictFreeFieldName} from './normalize'
@@ -92,14 +93,14 @@ function transformObjectTypeDefinition(
 
   // Implement Gatsby node interface if it is a document
   if (isDocumentType(node)) {
-    interfaces.push({kind: 'NamedType' as any, name: {kind: 'Name' as any, value: 'Node'}})
+    interfaces.push({kind: Kind.NAMED_TYPE, name: {kind: Kind.NAME, value: 'Node'}})
   }
 
   return {
     ...node,
     name: {...node.name, value: getTypeName(node.name.value)},
     interfaces,
-    directives: [{kind: 'Directive' as any, name: {kind: 'Name' as any, value: 'dontInfer'}}],
+    directives: [{kind: Kind.DIRECTIVE, name: {kind: Kind.NAME, value: 'dontInfer'}}],
     fields: [
       ...fields
         .filter((field) => !isJsonAlias(field))
@@ -122,15 +123,15 @@ function getRawFields(
 
       acc.push({
         kind: field.kind,
-        name: {kind: 'Name' as any, value: '_' + camelCase(`raw ${name}`)},
-        type: {kind: 'NamedType' as any, name: {kind: 'Name' as any, value: 'JSON'}},
+        name: {kind: Kind.NAME, value: '_' + camelCase(`raw ${name}`)},
+        type: {kind: Kind.NAMED_TYPE, name: {kind: Kind.NAME, value: 'JSON'}},
         arguments: [
           {
-            kind: 'InputValueDefinition' as any,
-            name: {kind: 'Name' as any, value: 'resolveReferences'},
+            kind: Kind.INPUT_VALUE_DEFINITION,
+            name: {kind: Kind.NAME, value: 'resolveReferences'},
             type: {
-              kind: 'NamedType' as any,
-              name: {kind: 'Name' as any, value: 'SanityResolveReferencesConfiguration'},
+              kind: Kind.NAMED_TYPE,
+              name: {kind: Kind.NAME, value: 'SanityResolveReferencesConfiguration'},
             },
           },
         ],
@@ -196,19 +197,19 @@ function isJsonAlias(field: FieldDefinitionNode): boolean {
 
 function makeBlockField(name: string): FieldDefinitionNode {
   return {
-    kind: 'FieldDefinition' as any,
+    kind: Kind.FIELD_DEFINITION,
     name: {
-      kind: 'Name' as any,
+      kind: Kind.NAME,
       value: name,
     },
     arguments: [],
     directives: [],
     type: {
-      kind: 'ListType' as any,
+      kind: Kind.LIST_TYPE,
       type: {
-        kind: 'NamedType' as any,
+        kind: Kind.NAMED_TYPE,
         name: {
-          kind: 'Name' as any,
+          kind: Kind.NAME,
           value: 'SanityBlock',
         },
       },
@@ -224,14 +225,18 @@ function makeNullable(nodeType: TypeNode): TypeNode {
   if (nodeType.kind === 'ListType') {
     const unwrapped = maybeRewriteType(unwrapType(nodeType))
     return {
-      kind: 'ListType' as any,
+      kind: Kind.LIST_TYPE,
       type: makeNullable(unwrapped),
     }
   }
 
   return maybeRewriteType(nodeType.type) as NamedTypeNode
 }
 
+function isReferenceField(field: FieldDefinitionNode): boolean {
+  return (field.directives || []).some((dir) => dir.name.value === 'reference')
+}
+
 function transformFieldNodeAst(
   node: FieldDefinitionNode,
   parent: ObjectTypeDefinitionNode | InterfaceTypeDefinitionNode,
@@ -247,8 +252,22 @@ function transformFieldNodeAst(
 
   if (field.type.kind === 'NamedType' && field.type.name.value === 'Date') {
     field.directives.push({
-      kind: 'Directive' as any,
-      name: {kind: 'Name' as any, value: 'dateformat'},
+      kind: Kind.DIRECTIVE,
+      name: {kind: Kind.NAME, value: 'dateformat'},
+    })
+  }
+
+  if (isReferenceField(node)) {
+    field.directives.push({
+      kind: Kind.DIRECTIVE,
+      name: {kind: Kind.NAME, value: 'link'},
+      arguments: [
+        {
+          kind: Kind.ARGUMENT,
+          name: {kind: Kind.NAME, value: 'from'},
+          value: {kind: Kind.STRING, value: `${field.name.value}._ref`},
+        },
+      ],
     })
   }
 
@@ -257,12 +276,11 @@ function transformFieldNodeAst(
 
 function rewireIdType(nodeType: TypeNode): TypeNode {
   if (nodeType.kind === 'NamedType' && nodeType.name.value === 'ID') {
-    return {...nodeType, name: {kind: 'Name' as any, value: 'String'}}
+    return {...nodeType, name: {kind: Kind.NAME, value: 'String'}}
   }
 
   return nodeType
 }
-
 function maybeRewriteType(nodeType: TypeNode): TypeNode {
   const type = nodeType as NamedTypeNode
   if (typeof type.name === 'undefined') {
@@ -271,14 +289,14 @@ function maybeRewriteType(nodeType: TypeNode): TypeNode {
 
   // Gatsby has a date type, but not a datetime, so rewire it
   if (type.name.value === 'DateTime') {
-    return {...type, name: {kind: 'Name' as any, value: 'Date'}}
+    return {...type, name: {kind: Kind.NAME, value: 'Date'}}
   }
 
   if (builtins.includes(type.name.value)) {
     return type
   }
 
-  return {...type, name: {kind: 'Name' as any, value: getTypeName(type.name.value)}}
+  return {...type, name: {kind: Kind.NAME, value: getTypeName(type.name.value)}}
 }
 
 function maybeRewriteFieldName(
@@ -321,17 +339,17 @@ function getTypeName(name: string) {
 
 function getResolveReferencesConfigType(): DefinitionNode {
   return {
-    kind: 'InputObjectTypeDefinition' as any,
-    name: {kind: 'Name' as any, value: 'SanityResolveReferencesConfiguration'},
+    kind: Kind.INPUT_OBJECT_TYPE_DEFINITION,
+    name: {kind: Kind.NAME, value: 'SanityResolveReferencesConfiguration'},
     fields: [
       {
-        kind: 'InputValueDefinition' as any,
-        name: {kind: 'Name' as any, value: 'maxDepth'},
+        kind: Kind.INPUT_VALUE_DEFINITION,
+        name: {kind: Kind.NAME, value: 'maxDepth'},
         type: {
-          kind: 'NonNullType' as any,
-          type: {kind: 'NamedType' as any, name: {kind: 'Name' as any, value: 'Int'}},
+          kind: Kind.NON_NULL_TYPE,
+          type: {kind: Kind.NAMED_TYPE, name: {kind: Kind.NAME, value: 'Int'}},
         },
-        description: {kind: 'StringValue' as any, value: 'Max depth to resolve references to'},
+        description: {kind: Kind.STRING, value: 'Max depth to resolve references to'},
       },
     ],
   }