chore(gatsby): convert sanitize-node to typescript

packages/gatsby/src/redux/actions/public.js

@@ -15,7 +15,7 @@ const {
 const { splitComponentPath } = require(`gatsby-core-utils/parse-component-path`)
 const { hasNodeChanged } = require(`../../utils/nodes`)
 const { getNode, getDataStore } = require(`../../datastore`)
-const sanitizeNode = require(`../../utils/sanitize-node`)
+import sanitizeNode from "../../utils/sanitize-node"
 const { store } = require(`../index`)
 const { validatePageComponent } = require(`../../utils/validate-page-component`)
 import { nodeSchema } from "../../joi-schemas/joi"

packages/gatsby/src/utils/__tests__/sanitize-node.js → packages/gatsby/src/utils/__tests__/sanitize-node.ts

@@ -1,23 +1,25 @@
-const sanitizeNode = require(`../sanitize-node`)
+import sanitizeNode from "../sanitize-node"
 
 describe(`node sanitization`, () => {
   let testNode
 
   beforeEach(() => {
     const circularReference = {}
+    // @ts-ignore edge test case
     circularReference.self = circularReference
     const indirectCircular = {
       down1: {
         down2: {},
       },
     }
+    //  @ts-ignore edge test case
     indirectCircular.down1.down2.deepCircular = indirectCircular
 
     testNode = {
       id: `id1`,
       parent: null,
       children: [],
-      unsupported: () => {},
+      unsupported: (): void => {},
       inlineObject: {
         field: `fieldOfFirstNode`,
         re: /re/,
@@ -26,7 +28,7 @@ describe(`node sanitization`, () => {
       repeat2: `bar`,
       repeat3: {
         repeat3: {
-          test: () => {},
+          test: (): void => {},
           repeat: `bar`,
         },
       },
@@ -46,8 +48,11 @@ describe(`node sanitization`, () => {
   it(`Remove not supported fields / values`, () => {
     const result = sanitizeNode(testNode)
     expect(result).toMatchSnapshot()
+    // @ts-ignore test properties that shouldn't be there are not there
     expect(result.unsupported).not.toBeDefined()
+    // @ts-ignore test properties that shouldn't be there are not there
     expect(result.inlineObject.re).not.toBeDefined()
+    // @ts-ignore test properties that shouldn't be there are not there
     expect(result.inlineArray[3]).not.toBeDefined()
   })
 
@@ -66,7 +71,7 @@ describe(`node sanitization`, () => {
   it(`Doesn't create clones if it doesn't have to`, () => {
     const testNodeWithoutUnserializableData = {
       id: `id1`,
-      parent: null,
+      parent: ``,
       children: [],
       inlineObject: {
         field: `fieldOfFirstNode`,
@@ -76,7 +81,9 @@ describe(`node sanitization`, () => {
         type: `Test`,
         contentDigest: `digest1`,
         owner: `test`,
+        counter: 0,
       },
+      fields: [],
     }
 
     const result = sanitizeNode(testNodeWithoutUnserializableData)

packages/gatsby/src/utils/sanitize-node.js → packages/gatsby/src/utils/sanitize-node.ts

@@ -1,12 +1,60 @@
 import _ from "lodash"
 
+import type { IGatsbyNode } from "../redux/types"
+import type { GatsbyIterable } from "../datastore/common/iterable"
+
+type data = IGatsbyNode | GatsbyIterable<IGatsbyNode>
+
+/**
+ * @param {Object|Array} data
+ * @returns {Object|Array} data without undefined values
+ */
+type omitUndefined = (data: data) => Partial<data>
+
+const omitUndefined: omitUndefined = data => {
+  const isPlainObject = _.isPlainObject(data)
+  if (isPlainObject) {
+    return _.pickBy(data, p => p !== undefined)
+  }
+
+  return (data as GatsbyIterable<IGatsbyNode>).filter(p => p !== undefined)
+}
+
+/**
+ * @param {*} data
+ * @return {boolean}
+ */
+type isTypeSupported = (data: data) => boolean
+
+const isTypeSupported: isTypeSupported = data => {
+  if (data === null) {
+    return true
+  }
+
+  const type = typeof data
+  const isSupported =
+    type === `number` ||
+    type === `string` ||
+    type === `boolean` ||
+    data instanceof Date
+
+  return isSupported
+}
+
 /**
  * Make data serializable
  * @param {(Object|Array)} data to sanitize
  * @param {boolean} isNode = true
  * @param {Set<string>} path = new Set
  */
-const sanitizeNode = (data, isNode = true, path = new Set()) => {
+
+type sanitizeNode = (
+  data: data,
+  isNode?: boolean,
+  path?: Set<unknown>
+) => data | undefined
+
+const sanitizeNode: sanitizeNode = (data, isNode = true, path = new Set()) => {
   const isPlainObject = _.isPlainObject(data)
 
   if (isPlainObject || _.isArray(data)) {
@@ -20,15 +68,15 @@ const sanitizeNode = (data, isNode = true, path = new Set()) => {
         returnData[key] = o
         return
       }
-      returnData[key] = sanitizeNode(o, false, path)
+      returnData[key] = sanitizeNode(o as data, false, path)
 
       if (returnData[key] !== o) {
         anyFieldChanged = true
       }
     })
 
     if (anyFieldChanged) {
-      data = omitUndefined(returnData)
+      data = omitUndefined(returnData as data) as data
     }
 
     // arrays and plain objects are supported - no need to to sanitize
@@ -42,36 +90,4 @@ const sanitizeNode = (data, isNode = true, path = new Set()) => {
   }
 }
 
-/**
- * @param {Object|Array} data
- * @returns {Object|Array} data without undefined values
- */
-const omitUndefined = data => {
-  const isPlainObject = _.isPlainObject(data)
-  if (isPlainObject) {
-    return _.pickBy(data, p => p !== undefined)
-  }
-
-  return data.filter(p => p !== undefined)
-}
-
-/**
- * @param {*} data
- * @return {boolean}
- */
-const isTypeSupported = data => {
-  if (data === null) {
-    return true
-  }
-
-  const type = typeof data
-  const isSupported =
-    type === `number` ||
-    type === `string` ||
-    type === `boolean` ||
-    data instanceof Date
-
-  return isSupported
-}
-
-module.exports = sanitizeNode
+export default sanitizeNode