feat(schema): cache generated field objects

This makes sure that the same field definition always ends up becoming the
exact same field object, making it possible to use `===` to compare them.

Author: judofyr

packages/@sanity/schema/src/legacy/Schema.ts

@@ -1,4 +1,16 @@
+import {startCase} from 'lodash'
+
 import * as types from './types'
+import {lazyGetter} from './types/utils'
+
+interface ExtendHelper {
+  /** Creates a new type based on the definition. */
+  (memberDef: any): any
+
+  cached(def: any): any
+  cachedField(fieldDef: any): any
+  cachedObjectField(fieldDef: any): any
+}
 
 function compileRegistry(schemaDef: any) {
   const registry = Object.create(null)
@@ -21,6 +33,56 @@ function compileRegistry(schemaDef: any) {
     return acc
   }, {})
 
+  const memberCache = new Map()
+  const fieldCache = new Map()
+  const objectFieldCache = new Map()
+
+  const extendHelper: ExtendHelper = Object.assign(extendMember, {
+    cached(def: any) {
+      let member = memberCache.get(def)
+      if (!member) {
+        member = extendMember(def)
+        memberCache.set(def, member)
+      }
+      return member
+    },
+
+    cachedField(fieldDef: any) {
+      let field = fieldCache.get(fieldDef)
+      if (!field) {
+        const {name, ...type} = fieldDef
+        field = {
+          name,
+          type: extendMember(type),
+        }
+        fieldCache.set(fieldDef, field)
+      }
+      return field
+    },
+
+    cachedObjectField(fieldDef: any) {
+      let field = objectFieldCache.get(fieldDef)
+      if (!field) {
+        const {name, fieldset, group, ...rest} = fieldDef
+
+        field = {
+          name,
+          group,
+          fieldset,
+        }
+
+        lazyGetter(field, 'type', () => {
+          return extendMember({
+            ...rest,
+            title: fieldDef.title || startCase(name),
+          })
+        })
+        objectFieldCache.set(fieldDef, field)
+      }
+      return field
+    },
+  })
+
   schemaDef.types.forEach(add)
 
   return {
@@ -39,7 +101,7 @@ function compileRegistry(schemaDef: any) {
 
   function extendMember(memberDef: any) {
     ensure(memberDef.type)
-    return registry[memberDef.type].extend(memberDef, extendMember).get()
+    return registry[memberDef.type].extend(memberDef, extendHelper).get()
   }
 
   function add(typeDef: any) {

packages/@sanity/schema/src/legacy/types/array.ts

@@ -21,9 +21,7 @@ export const ArrayType = {
       type: ARRAY_CORE,
     })
     lazyGetter(parsed, 'of', () => {
-      return subTypeDef.of.map((ofTypeDef: any) => {
-        return createMemberType(ofTypeDef)
-      })
+      return subTypeDef.of.map((ofTypeDef: any) => createMemberType.cached(ofTypeDef))
     })
     lazyGetter(parsed, OWN_PROPS_NAME, () => ({...subTypeDef, of: parsed.of}), {
       enumerable: false,

packages/@sanity/schema/src/legacy/types/blocks/block.ts

@@ -72,13 +72,7 @@ export const BlockType = {
     })
 
     lazyGetter(parsed, 'fields', () => {
-      return fields.map((fieldDef) => {
-        const {name, ...type} = fieldDef
-        return {
-          name: name,
-          type: extendMember(type),
-        }
-      })
+      return fields.map((fieldDef) => extendMember.cachedField(fieldDef))
     })
 
     lazyGetter(parsed, 'preview', createPreviewGetter(subTypeDef))

packages/@sanity/schema/src/legacy/types/blocks/span.ts

@@ -56,13 +56,7 @@ export const SpanType = {
     })
 
     lazyGetter(parsed, 'fields', () => {
-      return fields.map((fieldDef) => {
-        const {name, ...type} = fieldDef
-        return {
-          name: name,
-          type: extendMember(type),
-        }
-      })
+      return fields.map((fieldDef) => extendMember.cachedField(fieldDef))
     })
 
     lazyGetter(parsed, 'annotations', () => annotations.map(extendMember))

packages/@sanity/schema/src/legacy/types/crossDatasetReference.ts

@@ -79,13 +79,7 @@ export const CrossDatasetReferenceType = {
     )
 
     lazyGetter(parsed, 'fields', () => {
-      return REFERENCE_FIELDS.map((fieldDef) => {
-        const {name, ...type} = fieldDef
-        return {
-          name: name,
-          type: createMemberType(type),
-        }
-      })
+      return REFERENCE_FIELDS.map((fieldDef) => createMemberType.cachedField(fieldDef))
     })
 
     lazyGetter(parsed, 'to', () => {

packages/@sanity/schema/src/legacy/types/globalDocumentReference.ts

@@ -66,13 +66,7 @@ export const GlobalDocumentReferenceType = {
     )
 
     lazyGetter(parsed, 'fields', () => {
-      return REFERENCE_FIELDS.map((fieldDef) => {
-        const {name, ...type} = fieldDef
-        return {
-          name: name,
-          type: createMemberType(type),
-        }
-      })
+      return REFERENCE_FIELDS.map((fieldDef) => createMemberType.cachedField(fieldDef))
     })
 
     lazyGetter(parsed, 'to', () => {

packages/@sanity/schema/src/legacy/types/object.ts

@@ -42,22 +42,9 @@ export const ObjectType = {
       title: subTypeDef.title || (subTypeDef.name ? startCase(subTypeDef.name) : 'Object'),
       options: options,
       orderings: subTypeDef.orderings || guessOrderingConfig(subTypeDef),
-      fields: subTypeDef.fields.map((fieldDef: any) => {
-        const {name, fieldset, group, ...rest} = fieldDef
-
-        const compiledField = {
-          name,
-          group,
-          fieldset,
-        }
-
-        return lazyGetter(compiledField, 'type', () => {
-          return createMemberType({
-            ...rest,
-            title: fieldDef.title || startCase(name),
-          })
-        })
-      }),
+      fields: subTypeDef.fields.map((fieldDef: any) =>
+        createMemberType.cachedObjectField(fieldDef),
+      ),
     }
 
     const parsed = Object.assign(pick(this.get(), OVERRIDABLE_FIELDS), ownProps, {

packages/@sanity/schema/src/legacy/types/reference.ts

@@ -63,13 +63,7 @@ export const ReferenceType = {
     })
 
     lazyGetter(parsed, 'fields', () => {
-      return REFERENCE_FIELDS.map((fieldDef) => {
-        const {name, ...type} = fieldDef
-        return {
-          name: name,
-          type: createMemberType(type),
-        }
-      })
+      return REFERENCE_FIELDS.map((fieldDef) => createMemberType.cachedField(fieldDef))
     })
 
     lazyGetter(parsed, 'fieldsets', () => {