perf(gatsby): Avoid unnecessary type inference during bootstrap (#19781)

* perf(gatsby): Avoid unnecessary type inference during bootstrap

* Add tests for inference states

* Perf: disable incremental inference for SitePage

Author: vladar

packages/gatsby/src/redux/__tests__/__snapshots__/index.js.snap

@@ -16,7 +16,6 @@ Object {
       "query": "",
     },
   },
-  "inferenceMetadata": Object {},
   "staticQueryComponents": Map {},
   "status": Object {
     "plugins": Object {},

packages/gatsby/src/redux/index.js

@@ -60,7 +60,6 @@ const saveState = () => {
     `components`,
     `staticQueryComponents`,
     `webpackCompilationHash`,
-    `inferenceMetadata`,
   ])
 
   return writeToCache(pickedState)

packages/gatsby/src/redux/reducers/inference-metadata.js

@@ -3,30 +3,98 @@
 const { omit } = require(`lodash`)
 const {
   addNode,
+  addNodes,
   deleteNode,
   ignore,
+  disable,
 } = require(`../../schema/infer/inference-metadata`)
 const { NodeInterfaceFields } = require(`../../schema/types/node-interface`)
 const { typesWithoutInference } = require(`../../schema/types/type-defs`)
 
+const StepsEnum = {
+  initialBuild: `initialBuild`,
+  incrementalBuild: `incrementalBuild`,
+}
+
+const initialState = () => {
+  return {
+    step: StepsEnum.initialBuild, // `initialBuild` | `incrementalBuild`
+    typeMap: {},
+  }
+}
+
+module.exports = (state = initialState(), action) => {
+  switch (action.type) {
+    case `CREATE_NODE`:
+    case `DELETE_NODE`:
+    case `DELETE_NODES`:
+    case `ADD_CHILD_NODE_TO_PARENT_NODE`:
+    case `ADD_FIELD_TO_NODE`: {
+      // Perf: disable incremental inference until the first schema build.
+      // There are plugins which create and delete lots of nodes during bootstrap,
+      // which makes this reducer to do a lot of unnecessary work.
+      // Instead we defer the initial metadata creation until the first schema build
+      // and then enable incremental updates explicitly
+      if (state.step === StepsEnum.initialBuild) {
+        return state
+      }
+      state.typeMap = incrementalReducer(state.typeMap, action)
+      return state
+    }
+
+    case `START_INCREMENTAL_INFERENCE`: {
+      return {
+        ...state,
+        step: StepsEnum.incrementalBuild,
+      }
+    }
+
+    case `DELETE_CACHE`: {
+      return initialState()
+    }
+
+    default: {
+      state.typeMap = incrementalReducer(state.typeMap, action)
+      return state
+    }
+  }
+}
+
 const ignoredFields = new Set([
   ...NodeInterfaceFields,
   `$loki`,
   `__gatsby_resolved`,
 ])
 
-module.exports = (state = {}, action) => {
-  switch (action.type) {
-    case `DELETE_CACHE`:
-      return {}
+const initialTypeMetadata = () => {
+  return { ignoredFields }
+}
 
+const incrementalReducer = (state = {}, action) => {
+  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])
+        state[type] = ignore(state[type] || initialTypeMetadata())
+      })
+      return state
+    }
+
+    case `BUILD_TYPE_METADATA`: {
+      // Overwrites existing metadata
+      const { nodes, typeName } = action.payload
+      state[typeName] = addNodes(initialTypeMetadata(), nodes)
+      return state
+    }
+
+    case `DISABLE_TYPE_INFERENCE`: {
+      // Note: types disabled here will be re-enabled after BUILD_TYPE_METADATA
+      const types = action.payload
+      types.forEach(type => {
+        state[type] = disable(state[type] || initialTypeMetadata())
       })
       return state
     }
@@ -35,17 +103,17 @@ module.exports = (state = {}, action) => {
       const { payload: node, oldNode } = action
       const { type } = node.internal
       if (oldNode) {
-        state[type] = deleteNode(state[type] || { ignoredFields }, oldNode)
+        state[type] = deleteNode(state[type] || initialTypeMetadata(), oldNode)
       }
-      state[type] = addNode(state[type] || { ignoredFields }, node)
+      state[type] = addNode(state[type] || initialTypeMetadata(), node)
       return state
     }
 
     case `DELETE_NODE`: {
       const node = action.payload
       if (!node) return state
       const { type } = node.internal
-      state[type] = deleteNode(state[type] || { ignoredFields }, node)
+      state[type] = deleteNode(state[type] || initialTypeMetadata(), node)
       return state
     }
 
@@ -79,7 +147,7 @@ module.exports = (state = {}, action) => {
       const { fullNodes } = action
       fullNodes.forEach(node => {
         const { type } = node.internal
-        state[type] = deleteNode(state[type] || { ignoredFields }, node)
+        state[type] = deleteNode(state[type] || initialTypeMetadata(), node)
       })
       return state
     }

packages/gatsby/src/schema/__tests__/build-node-connections.js

@@ -66,6 +66,7 @@ const makeNodes = () => [
 describe(`build-node-connections`, () => {
   async function runQuery(query, nodes = makeNodes()) {
     store.dispatch({ type: `DELETE_CACHE` })
+    store.dispatch({ type: `START_INCREMENTAL_INFERENCE` })
     nodes.forEach(node =>
       actions.createNode(node, { name: `test` })(store.dispatch)
     )

packages/gatsby/src/schema/__tests__/build-node-types.js

@@ -75,6 +75,7 @@ const makeNodes = () => [
 describe(`build-node-types`, () => {
   async function runQuery(query, nodes = makeNodes()) {
     store.dispatch({ type: `DELETE_CACHE` })
+    store.dispatch({ type: `START_INCREMENTAL_INFERENCE` })
     nodes.forEach(node =>
       actions.createNode(node, { name: `test` })(store.dispatch)
     )

packages/gatsby/src/schema/__tests__/connection-input-fields.js

@@ -134,6 +134,7 @@ function makeNodes() {
 
 async function queryResult(nodes, query) {
   store.dispatch({ type: `DELETE_CACHE` })
+  store.dispatch({ type: `START_INCREMENTAL_INFERENCE` })
   nodes.forEach(node =>
     actions.createNode(node, { name: `test` })(store.dispatch)
   )

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

@@ -1148,8 +1148,8 @@ describe(`compatibility with createTypes`, () => {
 
   it(`should not collect inference metadata for types with inference disabled`, async () => {
     const { inferenceMetadata } = store.getState()
-    const typesToIgnore = Object.keys(inferenceMetadata).filter(
-      type => inferenceMetadata[type].ignored
+    const typesToIgnore = Object.keys(inferenceMetadata.typeMap).filter(
+      type => inferenceMetadata.typeMap[type].ignored
     )
     expect(typesToIgnore).toEqual([`FooFieldsBaz`, `Bar`, `BarBaz`])
   })

packages/gatsby/src/schema/index.js

@@ -19,10 +19,54 @@ const getAllFieldExtensions = () => {
   }
 }
 
-const build = async ({ parentSpan }) => {
+// Schema building requires metadata for type inference.
+// Technically it means looping through all type nodes, analyzing node structure
+// and then using this aggregated node structure in related GraphQL type.
+// Actual logic for inference located in inferenceMetadata reducer and ./infer
+// Here we just orchestrate the process via redux actions
+const buildInferenceMetadata = ({ types }) =>
+  new Promise(resolve => {
+    if (!types || !types.length) {
+      resolve()
+      return
+    }
+    const typeNames = [...types]
+    // TODO: use async iterators when we switch to node>=10
+    //  or better investigate if we can offload metadata building to worker/Jobs API
+    //  and then feed the result into redux?
+    const processNextType = () => {
+      const typeName = typeNames.pop()
+      store.dispatch({
+        type: `BUILD_TYPE_METADATA`,
+        payload: {
+          typeName,
+          nodes: nodeStore.getNodesByType(typeName),
+        },
+      })
+      if (typeNames.length > 0) {
+        // Give event-loop a break
+        setTimeout(processNextType, 0)
+      } else {
+        resolve()
+      }
+    }
+    processNextType()
+  })
+
+const build = async ({ parentSpan, fullMetadataBuild = true }) => {
   const spanArgs = parentSpan ? { childOf: parentSpan } : {}
   const span = tracer.startSpan(`build schema`, spanArgs)
 
+  if (fullMetadataBuild) {
+    // Build metadata for type inference and start updating it incrementally
+    // except for SitePage type: we rebuild it in rebuildWithSitePage anyway
+    // so it makes little sense to update it incrementally
+    // (and those updates may have significant performance overhead)
+    await buildInferenceMetadata({ types: nodeStore.getTypes() })
+    store.dispatch({ type: `START_INCREMENTAL_INFERENCE` })
+    store.dispatch({ type: `DISABLE_TYPE_INFERENCE`, payload: [`SitePage`] })
+  }
+
   const {
     schemaCustomization: { thirdPartySchemas, types, printConfig },
     inferenceMetadata,
@@ -70,12 +114,22 @@ const build = async ({ parentSpan }) => {
   span.finish()
 }
 
+const rebuild = async ({ parentSpan }) =>
+  await build({ parentSpan, fullMetadataBuild: false })
+
 const rebuildWithSitePage = async ({ parentSpan }) => {
   const spanArgs = parentSpan ? { childOf: parentSpan } : {}
   const span = tracer.startSpan(
     `rebuild schema with SitePage context`,
     spanArgs
   )
+  await buildInferenceMetadata({ types: [`SitePage`] })
+
+  // Disabling incremental inference for SitePage after the initial build
+  // as it has a significant performance cost for zero benefits.
+  // The only benefit is that schema rebuilds when SitePage.context structure changes.
+  // (one can just restart `develop` in this case)
+  store.dispatch({ type: `DISABLE_TYPE_INFERENCE`, payload: [`SitePage`] })
 
   const {
     schemaCustomization: { composer: schemaComposer },
@@ -111,6 +165,6 @@ const rebuildWithSitePage = async ({ parentSpan }) => {
 
 module.exports = {
   build,
-  rebuild: build,
+  rebuild,
   rebuildWithSitePage,
 }

packages/gatsby/src/schema/infer/__tests__/infer-input.js

@@ -34,6 +34,7 @@ jest.mock(`gatsby-cli/lib/reporter`, () => {
 
 const buildTestSchema = async nodes => {
   store.dispatch({ type: `DELETE_CACHE` })
+  store.dispatch({ type: `START_INCREMENTAL_INFERENCE` })
   nodes.forEach(node =>
     actions.createNode(node, { name: `test` })(store.dispatch)
   )