feat(schema): de-dupe re-used fields in the descriptor

judofyr · judofyr · commit 4afde2a66830 · 2025-11-28T13:08:36.000+01:00
diff --git a/dev/test-studio/schema/standard/portableText/manyEditors.js b/dev/test-studio/schema/standard/portableText/manyEditors.js
@@ -40,6 +40,81 @@ const myStringType = defineField({
   fields: [{type: 'string', name: 'mystring', validation: (Rule) => Rule.required()}],
 })
 
+const bodyMembers = [
+  defineArrayMember({
+    type: 'block',
+    marks: {
+      annotations: [linkType, myStringType],
+    },
+    of: [
+      {type: 'image', name: 'image'},
+      myStringType,
+      {
+        type: 'reference',
+        name: 'strongAuthorRef',
+        title: 'A strong author ref',
+        to: {type: 'author'},
+      },
+    ],
+    validation: (Rule) =>
+      Rule.custom((block) => {
+        const text = extractTextFromBlocks([block])
+        return text.length === 1 ? 'Please write a longer paragraph.' : true
+      }),
+    options: {
+      spellCheck: true,
+    },
+  }),
+  {
+    type: 'image',
+    name: 'image',
+    options: {
+      modal: {
+        // The default `type` of object blocks is 'dialog'
+        // type: 'dialog',
+        // The default `width` of object blocks is 'medium'
+        // width: 'small',
+      },
+    },
+  },
+  {
+    type: 'object',
+    name: 'callout',
+    title: 'Callout',
+    components: {
+      preview: CalloutPreview,
+    },
+    fields: [
+      {
+        type: 'string',
+        name: 'title',
+        title: 'Title',
+      },
+      {
+        type: 'string',
+        name: 'tone',
+        title: 'Tone',
+        options: {
+          list: [
+            {value: 'default', title: 'Default'},
+            {value: 'primary', title: 'Primary'},
+            {value: 'positive', title: 'Positive'},
+            {value: 'caution', title: 'Caution'},
+            {value: 'critical', title: 'Critical'},
+          ],
+        },
+      },
+    ],
+    preview: {
+      select: {
+        title: 'title',
+        tone: 'tone',
+      },
+    },
+  },
+  myStringType,
+]
+
 const createBodyField = (title, name, size = 1) => {
   const fields = []
   for (let i = 1; i <= size; i++) {
@@ -48,80 +123,7 @@ const createBodyField = (title, name, size = 1) => {
         name: `${name}${i}`,
         title: title,
         type: 'array',
-        of: [
-          defineArrayMember({
-            type: 'block',
-            marks: {
-              annotations: [linkType, myStringType],
-            },
-            of: [
-              {type: 'image', name: 'image'},
-              myStringType,
-              {
-                type: 'reference',
-                name: 'strongAuthorRef',
-                title: 'A strong author ref',
-                to: {type: 'author'},
-              },
-            ],
-            validation: (Rule) =>
-              Rule.custom((block) => {
-                const text = extractTextFromBlocks([block])
-                return text.length === 1 ? 'Please write a longer paragraph.' : true
-              }),
-            options: {
-              spellCheck: true,
-            },
-          }),
-          {
-            type: 'image',
-            name: 'image',
-            options: {
-              modal: {
-                // The default `type` of object blocks is 'dialog'
-                // type: 'dialog',
-                // The default `width` of object blocks is 'medium'
-                // width: 'small',
-              },
-            },
-          },
-          {
-            type: 'object',
-            name: 'callout',
-            title: 'Callout',
-            components: {
-              preview: CalloutPreview,
-            },
-            fields: [
-              {
-                type: 'string',
-                name: 'title',
-                title: 'Title',
-              },
-              {
-                type: 'string',
-                name: 'tone',
-                title: 'Tone',
-                options: {
-                  list: [
-                    {value: 'default', title: 'Default'},
-                    {value: 'primary', title: 'Primary'},
-                    {value: 'positive', title: 'Positive'},
-                    {value: 'caution', title: 'Caution'},
-                    {value: 'critical', title: 'Critical'},
-                  ],
-                },
-              },
-            ],
-            preview: {
-              select: {
-                title: 'title',
-                tone: 'tone',
-              },
-            },
-          },
-          myStringType,
-        ],
+        of: bodyMembers,
       }),
     )
   }
diff --git a/packages/@sanity/schema/package.json b/packages/@sanity/schema/package.json
@@ -57,7 +57,7 @@
     "watch": "pkg-utils watch"
   },
   "dependencies": {
-    "@sanity/descriptors": "^1.1.1",
+    "@sanity/descriptors": "^1.2.0",
     "@sanity/generate-help-url": "^3.0.0",
     "@sanity/types": "workspace:*",
     "arrify": "^2.0.1",
diff --git a/packages/@sanity/schema/src/descriptors/convert.ts b/packages/@sanity/schema/src/descriptors/convert.ts
@@ -19,6 +19,7 @@ import {isEqual, isObject} from 'lodash'
 import {Rule} from '../legacy/Rule'
 import {OWN_PROPS_NAME} from '../legacy/types/constants'
 import {
+  type ArrayElement,
   type ArrayTypeDef,
   type CommonTypeDef,
   type CoreTypeDef,
@@ -62,10 +63,42 @@ export class DescriptorConverter {
     let value = this.cache.get(schema)
     if (value) return value
 
-    const builder = new SetBuilder()
-    for (const name of schema.getLocalTypeNames()) {
-      const typeDef = convertTypeDef(schema.get(name)!, {})
-      builder.addObject('sanity.schema.namedType', {name, typeDef})
+    const options: Options = {
+      fields: new Map(),
+      duplicateFields: new Map(),
+      arrayElements: new Map(),
+      duplicateArrayElements: new Map(),
+    }
+
+    const namedTypes = schema.getLocalTypeNames().map((name) => {
+      const typeDef = convertTypeDef(schema.get(name)!, name, options)
+      return {name, typeDef}
+    })
+
+    const rewriteMap = new Map<EncodableObject, EncodableObject>()
+
+    // First we populate the rewrite map with the duplications:
+    for (const [fieldDef, key] of options.duplicateFields.entries()) {
+      rewriteMap.set(fieldDef, {__type: 'hoisted', key})
+    }
+
+    for (const [arrayElem, key] of options.duplicateArrayElements.entries()) {
+      rewriteMap.set(arrayElem, {__type: 'hoisted', key})
+    }
+
+    const builder = new SetBuilder({rewriteMap})
+
+    // Now we can build the de-duplicated objects:
+    for (const [fieldDef, key] of options.duplicateFields.entries()) {
+      builder.addObject('sanity.schema.hoisted', {key, value: {...fieldDef}})
+    }
+
+    for (const [arrayElem, key] of options.duplicateArrayElements.entries()) {
+      builder.addObject('sanity.schema.hoisted', {key, value: {...arrayElem}})
+    }
+
+    for (const namedType of namedTypes) {
+      builder.addObject('sanity.schema.namedType', namedType)
     }
 
     if (schema.parent) {
@@ -78,21 +111,35 @@ export class DescriptorConverter {
   }
 }
 
-function convertCommonTypeDef(schemaType: SchemaType, opts: Options): CommonTypeDef {
+function convertCommonTypeDef(schemaType: SchemaType, path: string, opts: Options): CommonTypeDef {
   // Note that OWN_PROPS_NAME is only set on subtypes, not the core types.
   // We might consider setting OWN_PROPS_NAME on _all_ types to avoid this branch.
   const ownProps = OWN_PROPS_NAME in schemaType ? (schemaType as any)[OWN_PROPS_NAME] : schemaType
 
   let fields: ObjectField[] | undefined
   if (Array.isArray(ownProps.fields)) {
-    fields = (ownProps.fields as ObjectSchemaType['fields']).map(
-      ({name, group, fieldset, type}) => ({
+    fields = (ownProps.fields as ObjectSchemaType['fields']).map((field) => {
+      const fieldPath = `${path}.${field.name}`
+      const value = opts.fields.get(field)
+      if (value) {
+        // We've seen it before. Mark it as duplicate.
+        const otherPath = opts.duplicateFields.get(value)
+        // We always keep the _smallest_ path around.
+        if (!otherPath || isLessCanonicalName(fieldPath, otherPath))
+          opts.duplicateFields.set(value, fieldPath)
+        return value
+      }
+
+      const {name, group, fieldset, type} = field
+      const converted: ObjectField = {
         name,
-        typeDef: convertTypeDef(type, opts),
+        typeDef: convertTypeDef(type, fieldPath, opts),
         groups: arrayifyString(group),
         fieldset,
-      }),
-    )
+      }
+      opts.fields.set(field, converted)
+      return converted
+    })
   }
 
   let fieldsets: ObjectFieldset[] | undefined
@@ -157,15 +204,28 @@ function convertCommonTypeDef(schemaType: SchemaType, opts: Options): CommonType
   }
 }
 
-/**
- * Options used when converting the schema.
- *
- * We know we need this in order to handle validations.
- **/
-export type Options = Record<never, never>
+type Options = {
+  /** Mapping of fields to descriptor value. Used for de-duping. */
+  fields: Map<object, ObjectField>
+
+  /**
+   * Once a field has been seen twice it's inserted into this map.
+   * The value here is the canonical name.
+   **/
+  duplicateFields: Map<ObjectField, string>
+
+  /** Mapping of array element to descriptor value. Used for de-duping. */
+  arrayElements: Map<object, ArrayElement>
+
+  /**
+   * Once an array element has been seen twice it's inserted into this map.
+   * The value here is the canonical name.
+   **/
+  duplicateArrayElements: Map<ArrayElement, string>
+}
 
-export function convertTypeDef(schemaType: SchemaType, opts: Options): TypeDef {
-  const common = convertCommonTypeDef(schemaType, opts)
+export function convertTypeDef(schemaType: SchemaType, path: string, opts: Options): TypeDef {
+  const common = convertCommonTypeDef(schemaType, path, opts)
 
   if (!schemaType.type) {
     return {
@@ -183,10 +243,24 @@ export function convertTypeDef(schemaType: SchemaType, opts: Options): TypeDef {
     case 'array': {
       return {
         extends: 'array',
-        of: (schemaType as ArraySchemaType).of.map((ofType) => ({
-          name: ofType.name,
-          typeDef: convertTypeDef(ofType, opts),
-        })),
+        of: (schemaType as ArraySchemaType).of.map((ofType, idx) => {
+          const itemPath = `${path}.${ofType.name}`
+          const value = opts.arrayElements.get(ofType)
+          if (value) {
+            // We've seen it before. Mark it as duplicate.
+            const otherPath = opts.duplicateArrayElements.get(value)
+            // We always keep the _smallest_ path around.
+            if (!otherPath || isLessCanonicalName(itemPath, otherPath))
+              opts.duplicateArrayElements.set(value, itemPath)
+            return value
+          }
+          const converted: ArrayElement = {
+            name: ofType.name,
+            typeDef: convertTypeDef(ofType, `${path}.${ofType.name}`, opts),
+          }
+          opts.arrayElements.set(ofType, converted)
+          return converted
+        }),
         ...common,
       } satisfies ArrayTypeDef
     }
@@ -727,3 +801,10 @@ function maybeOrderingBy(val: unknown): ObjectOrderingBy | undefined {
 
   return {field, direction}
 }
+
+/**
+ * Checks if `a` is smaller than `b` for determining a canonical name.
+ */
+function isLessCanonicalName(a: string, b: string): boolean {
+  return a.length < b.length || (a.length === b.length && a < b)
+}
diff --git a/packages/@sanity/schema/src/descriptors/types.ts b/packages/@sanity/schema/src/descriptors/types.ts
@@ -18,7 +18,7 @@ export interface CommonTypeDef extends EncodableObject {
   title?: string
   description?: string | JSXMarker
 
-  fields?: ObjectField[]
+  fields?: Array<ObjectField | HoistedMarker>
   groups?: ObjectGroup[]
   fieldsets?: ObjectFieldset[]
 
@@ -68,6 +68,9 @@ export type UnknownMarker = {__type: 'unknown'}
 /** Denotes a number which we've turned into a string for serialization. */
 export type NumberMarker = {__type: 'number'; value: string}
 
+/** Denotes a value which has been hoisted out into its own descriptor. */
+export type HoistedMarker = {__type: 'hoisted'; key: string}
+
 /**
  * Denotes an object. This is only used when we see an object with "__type" and
  * want to avoid it being interpreted as a marker.
@@ -91,7 +94,7 @@ export interface SubtypeDef extends CommonTypeDef {
 
 export interface ArrayTypeDef extends SubtypeDef {
   extends: 'array'
-  of: ArrayElement[]
+  of: Array<ArrayElement | HoistedMarker>
 }
 
 export type ArrayElement = {
diff --git a/packages/sanity/package.json b/packages/sanity/package.json
@@ -280,7 +280,7 @@
     "@repo/test-config": "workspace:*",
     "@repo/tsconfig": "workspace:*",
     "@sanity/codegen": "workspace:*",
-    "@sanity/descriptors": "^1.1.1",
+    "@sanity/descriptors": "^1.2.0",
     "@sanity/eslint-config-i18n": "catalog:",
     "@sanity/generate-help-url": "^3.0.0",
     "@sanity/pkg-utils": "catalog:",
diff --git a/packages/sanity/src/_internal/cli/actions/schema/metafile.ts b/packages/sanity/src/_internal/cli/actions/schema/metafile.ts
@@ -68,5 +68,10 @@ export function generateMetafile(schema: SeralizedSchemaDebug): Metafile {
     processType(fakePath, entry)
   }
 
+  for (const [name, entry] of Object.entries(schema.hoisted)) {
+    const fakePath = `hoisted/${name}`
+    processType(fakePath, entry)
+  }
+
   return {outputs: {root: output}, inputs}
 }
diff --git a/packages/sanity/src/_internal/cli/threads/validateSchema.ts b/packages/sanity/src/_internal/cli/threads/validateSchema.ts
diff --git a/packages/sanity/test/descriptors/schema.test.tsx b/packages/sanity/test/descriptors/schema.test.tsx
diff --git a/pnpm-lock.yaml b/pnpm-lock.yaml

Original file line number	Diff line number	Diff line change
`@@ -68,5 +68,10 @@ export function generateMetafile(schema: SeralizedSchemaDebug): Metafile {`
`68`	`68`	`processType(fakePath, entry)`
`69`	`69`	`}`
`70`	`70`
	`71`	`+ for (const [name, entry] of Object.entries(schema.hoisted)) {`
	`72`	+ const fakePath = `hoisted/${name}`
	`73`	`+ processType(fakePath, entry)`
	`74`	`+ }`
	`75`	`+`
`71`	`76`	`return {outputs: {root: output}, inputs}`
`72`	`77`	`}`