Different behaviour - @dontInfer vs dontInfer in extensions

[tonyhallett]

Skipping schema inference for a node is possible when createTypes

a) From a string - using the directive @dontInfer
b) From a gatsby builder - dontInfer in extensions

When createTypes the inference-metadata reducer will set ignored to true for the dontInfer directive and for extensions dontInfer and infer = false

const incrementalReducer = (
  state: IGatsbyState["inferenceMetadata"]["typeMap"] = {},
  action: ActionsUnion
): IGatsbyState["inferenceMetadata"]["typeMap"] => {
  switch (action.type) {
    case `CREATE_TYPES`: {
      const typeDefs = Array.isArray(action.payload)
        ? action.payload
        : [action.payload]
      const ignoredTypes = typeDefs.reduce(typesWithoutInference, [])
      ignoredTypes.forEach(type => {
        state[type] = ignore(state[type] || initialTypeMetadata())
      })
      return state
    }

typesWithoutInference

const typesWithoutInference = (typeNames = [], typeOrTypeDef) => {
  if (typeof typeOrTypeDef === `string`) {
    typeOrTypeDef = parseTypeDef(typeOrTypeDef)
  }
  if (isASTDocument(typeOrTypeDef)) {
    typeOrTypeDef.definitions.forEach(def => {
      if (!def.directives) return

      def.directives.forEach(directive => {
        if (directive.name.value === dontInferExtensionName && def.name.value) {
          typeNames.push(def.name.value)
        }
      })
    })
    return typeNames
  }
  if (isGatsbyType(typeOrTypeDef) && typeOrTypeDef.config) {
    const { extensions = {}, name } = typeOrTypeDef.config
    if (
      name &&
      (extensions[dontInferExtensionName] ||
        extensions[inferExtensionName] === false)
    ) {
      typeNames.push(name)
    }
  }
  return typeNames
}

When buildInferenceMetadata for types of nodes in the data store, if ignored no nodes are added and when addInferredTypes the type will be ignored as hasNodes returns false.

---

When gatsby processAddedType addExtensions is called which will convert the @infer / @dontInfer directive to the infer extension.

---

When addInferredTypes is called the runInfer condition does not consider the dontInfer extension.

      const runInfer = typeComposer.hasExtension(`infer`)
        ? typeComposer.getExtension(`infer`)
        : true

The same can be said with getInferenceConfig

const getInferenceConfig = ({ typeComposer, defaults }) => {
  return {
    shouldAddFields: typeComposer.hasExtension(`infer`)
      ? typeComposer.getExtension(`infer`)
      : defaults.shouldAddFields,
  }
}

In both of these cases dontInfer in extensions will infer.

dontInfer in extensions is not mentioned in schema-customization docs.
But

This behavior can be
   *   customised with `@infer`, `@dontInfer` directives or extensions.

and

  if (pluginConfig.get(`enableTags`)) {
    contentfulTypes.push(
      schema.buildObjectType({
        name: `ContentfulTag`,
        fields: {
          name: { type: `String!` },
          contentful_id: { type: `String!` },
          id: { type: `ID!` },
        },
        interfaces: [`Node`],
        extensions: { dontInfer: {} },
      })
    )
  }

So if it is indeed necessary to check in extensions then the two areas identified should be updated to consider dontInfer in extensions.