feat: support search weight configuration for slug fields

Author: juice49

packages/@sanity/types/src/schema/definition/type/slug.ts

@@ -3,7 +3,11 @@ import {type SlugifierFn, type SlugSourceFn} from '../../../slug'
 import {type SlugIsUniqueValidator} from '../../../validation'
 import {type RuleDef, type ValidationBuilder} from '../../ruleBuilder'
 import {type InitialValueProperty} from '../../types'
-import {type BaseSchemaDefinition, type BaseSchemaTypeOptions} from './common'
+import {
+  type BaseSchemaDefinition,
+  type BaseSchemaTypeOptions,
+  type SearchConfiguration,
+} from './common'
 
 /** @public */
 export interface SlugValue {
@@ -16,7 +20,7 @@ export interface SlugValue {
 export interface SlugRule extends RuleDef<SlugRule, SlugValue> {}
 
 /** @public */
-export interface SlugOptions extends BaseSchemaTypeOptions {
+export interface SlugOptions extends SearchConfiguration, BaseSchemaTypeOptions {
   source?: string | Path | SlugSourceFn
   maxLength?: number
   slugify?: SlugifierFn

packages/sanity/src/core/search/common/__tests__/deriveSearchWeightsFromType.test.ts

@@ -168,6 +168,40 @@ describe('deriveSearchWeightsFromType', () => {
     })
   })
 
+  it('returns a weight of 0 for hidden slug fields', () => {
+    const schema = createSchema({
+      name: 'default',
+      types: [
+        defineType({
+          name: 'testType',
+          type: 'document',
+          preview: {select: {}},
+          fields: [
+            defineField({
+              name: 'someSlug',
+              type: 'slug',
+              hidden: true,
+            }),
+          ],
+        }),
+      ],
+    })
+
+    expect(
+      deriveSearchWeightsFromType({
+        schemaType: schema.get('testType')!,
+        maxDepth: 5,
+      }),
+    ).toEqual({
+      typeName: 'testType',
+      paths: [
+        {path: '_id', weight: 1},
+        {path: '_type', weight: 1},
+        {path: 'someSlug.current', weight: 0},
+      ],
+    })
+  })
+
   it('respects `maxDepth`', () => {
     const schema = createSchema({
       name: 'default',
@@ -253,6 +287,21 @@ describe('deriveSearchWeightsFromType', () => {
             }),
           ],
         }),
+        defineType({
+          name: 'testType2',
+          type: 'document',
+          preview: {
+            select: {
+              title: 'someSlug.current',
+            },
+          },
+          fields: [
+            defineField({
+              name: 'someSlug',
+              type: 'slug',
+            }),
+          ],
+        }),
       ],
     })
 
@@ -271,6 +320,20 @@ describe('deriveSearchWeightsFromType', () => {
         {path: 'descriptionField', weight: 1.5, mapWith: 'pt::text'},
       ],
     })
+
+    expect(
+      deriveSearchWeightsFromType({
+        schemaType: schema.get('testType2')!,
+        maxDepth: 5,
+      }),
+    ).toEqual({
+      typeName: 'testType2',
+      paths: [
+        {path: '_id', weight: 1},
+        {path: '_type', weight: 1},
+        {path: 'someSlug.current', weight: 10},
+      ],
+    })
   })
 
   it('returns special weights for fields that are selected in the preview config for cross dataset reference types', () => {
@@ -341,6 +404,11 @@ describe('deriveSearchWeightsFromType', () => {
               type: 'string',
               options: {search: {weight: 7}},
             }),
+            defineField({
+              name: 'someSlug',
+              type: 'slug',
+              options: {search: {weight: 7}},
+            }),
           ],
         }),
       ],
@@ -361,6 +429,7 @@ describe('deriveSearchWeightsFromType', () => {
         {path: 'subtitleField', weight: 7},
         {path: 'descriptionField', weight: 7},
         {path: 'normalStringField', weight: 7},
+        {path: 'someSlug.current', weight: 7},
       ],
     })
   })

packages/sanity/src/core/search/common/deriveSearchWeightsFromType.ts

@@ -1,4 +1,9 @@
-import {type CrossDatasetType, type SchemaType, type SearchConfiguration} from '@sanity/types'
+import {
+  type CrossDatasetType,
+  type SchemaType,
+  type SearchConfiguration,
+  type SlugSchemaType,
+} from '@sanity/types'
 import {toString as pathToString} from '@sanity/util/paths'
 
 import {isRecord} from '../../util'
@@ -20,7 +25,7 @@ const BASE_WEIGHTS: Record<string, Omit<SearchWeightEntry, 'path'>> = {
   _id: {weight: 1, type: 'string'},
   _type: {weight: 1, type: 'string'},
 }
-const ignoredBuiltInObjectTypes = ['reference', 'crossDatasetReference']
+const ignoredBuiltInObjectTypes = ['reference', 'crossDatasetReference', 'slug']
 
 const getTypeChain = (type: SchemaType | undefined): SchemaType[] =>
   type ? [type, ...getTypeChain(type.type)] : []
@@ -32,13 +37,27 @@ const isPtField = (type: SchemaType | undefined) =>
 const isStringField = (schemaType: SchemaType | undefined): boolean =>
   schemaType ? schemaType?.jsonType === 'string' : false
 
+const isSlugField = (schemaType: SchemaType | undefined): schemaType is SlugSchemaType => {
+  const typeChain = getTypeChain(schemaType)
+  return typeChain.some(({jsonType, name}) => jsonType === 'object' && name === 'slug')
+}
+
 const isSearchConfiguration = (options: unknown): options is SearchConfiguration =>
   isRecord(options) && 'search' in options && isRecord(options.search)
 
 function isSchemaType(input: SchemaType | CrossDatasetType | undefined): input is SchemaType {
   return typeof input !== 'undefined' && 'name' in input
 }
 
+function getFullyQualifiedPath(schemaType: SchemaType, path: string): string {
+  // Slug field weights should be applied to the object's `current` field.
+  if (isSlugField(schemaType)) {
+    return [path, 'current'].join('.')
+  }
+
+  return path
+}
+
 function getLeafWeights(
   schemaType: SchemaType | CrossDatasetType | undefined,
   maxDepth: number,
@@ -61,7 +80,20 @@ function getLeafWeights(
       return [{path, weight, type: isPtField(type) ? 'pt' : 'string'}]
     }
 
+    if (isSlugField(type)) {
+      const weight = getWeight(type, path)
+      if (typeof weight !== 'number') return []
+      return [
+        {
+          path: getFullyQualifiedPath(type, path),
+          weight,
+          type: isPtField(type) ? 'pt' : 'string',
+        },
+      ]
+    }
+
     const results: SearchWeightEntry[] = []
+
     const objectTypes = typeChain.filter(
       (t): t is Extract<SchemaType, {jsonType: 'object'}> =>
         t.jsonType === 'object' &&
@@ -173,8 +205,8 @@ const getPreviewWeights = (
     )
   }
 
-  return getLeafWeights(schemaType, maxDepth, (_, path) => {
-    const nested = nestedWeightsBySelectionPath[path]
+  return getLeafWeights(schemaType, maxDepth, (type, path) => {
+    const nested = nestedWeightsBySelectionPath[getFullyQualifiedPath(type, path)]
     return nested ? nested.weight : null
   })
 }