feat(sanity): memoize initial value resolver

packages/sanity/src/core/store/_legacy/grants/templatePermissions.ts

@@ -76,6 +76,9 @@ export function getTemplatePermissions({
           template,
           item.parameters,
           context,
+          {
+            useCache: true,
+          },
         )
 
         return {template, item, resolvedInitialValue}

packages/sanity/src/core/templates/__tests__/resolve.test.ts

@@ -3,11 +3,16 @@ import {Schema as SchemaBuilder} from '@sanity/schema'
 import {type InitialValueResolverContext} from '@sanity/types'
 import {omit} from 'lodash'
 
-import {resolveInitialValue, type Template} from '../'
+import {type resolveInitialValue as resolveInitialValueType, type Template} from '../'
 import {schema} from './schema'
 
+let resolveInitialValue: typeof resolveInitialValueType
+
 beforeEach(() => {
   jest.resetModules()
+  jest.clearAllMocks()
+
+  resolveInitialValue = require('../').resolveInitialValue
 })
 
 const example: Template = {
@@ -333,4 +338,88 @@ describe('resolveInitialValue', () => {
       })
     })
   })
+
+  describe('memoizes function calls', () => {
+    const initialValue = jest.fn().mockReturnValue('Name')
+
+    const testSchema = SchemaBuilder.compile({
+      name: 'default',
+      types: [
+        {
+          name: 'author',
+          title: 'Author',
+          type: 'document',
+          fields: [
+            {
+              name: 'name',
+              type: 'string',
+              initialValue,
+            },
+          ],
+        },
+      ],
+    })
+
+    test('memoizes function calls', async () => {
+      for (let index = 0; index < 2; index++) {
+        await resolveInitialValue(testSchema, example, {}, mockConfigContext, {useCache: true})
+      }
+
+      expect(initialValue).toHaveBeenCalledTimes(1)
+    })
+
+    test('calls function again if params change', async () => {
+      for (let index = 0; index < 2; index++) {
+        await resolveInitialValue(testSchema, example, {index}, mockConfigContext, {useCache: true})
+      }
+
+      expect(initialValue).toHaveBeenCalledTimes(2)
+    })
+
+    test('calls function again if context.projectId changes', async () => {
+      for (let index = 0; index < 2; index++) {
+        await resolveInitialValue(
+          testSchema,
+          example,
+          {},
+          {projectId: index.toString()} as InitialValueResolverContext,
+          {useCache: true},
+        )
+      }
+
+      expect(initialValue).toHaveBeenCalledTimes(2)
+    })
+
+    test('calls function again if context.dataset changes', async () => {
+      for (let index = 0; index < 2; index++) {
+        await resolveInitialValue(
+          testSchema,
+          example,
+          {},
+          {dataset: index.toString()} as InitialValueResolverContext,
+          {useCache: true},
+        )
+      }
+
+      expect(initialValue).toHaveBeenCalledTimes(2)
+    })
+
+    test('calls function again if context.currentUser.id changes', async () => {
+      for (let index = 0; index < 2; index++) {
+        await resolveInitialValue(
+          testSchema,
+          example,
+          {},
+          {
+            currentUser: {
+              id: index.toString(),
+            },
+          } as InitialValueResolverContext,
+          {useCache: true},
+        )
+      }
+
+      expect(initialValue).toHaveBeenCalledTimes(2)
+    })
+  })
 })

packages/sanity/src/core/templates/resolve.ts

@@ -21,22 +21,58 @@ export type Serializeable<T> = {
   serialize(): T
 }
 
+interface Options {
+  useCache?: boolean
+}
+
 /** @internal */
 export function isBuilder(template: unknown): template is Serializeable<Template> {
   return isRecord(template) && typeof template.serialize === 'function'
 }
 
+const cache = new WeakMap<
+  InitialValueResolver<unknown, unknown>,
+  Record<string, unknown | Promise<unknown>>
+>()
+
 /** @internal */
 // returns the "resolved" value from an initial value property (e.g. type.initialValue)
 // eslint-disable-next-line require-await
 export async function resolveValue<Params, InitialValue>(
   initialValueOpt: InitialValueProperty<Params, InitialValue>,
   params: Params | undefined,
   context: InitialValueResolverContext,
+  options?: Options,
 ): Promise<InitialValue | undefined> {
-  return typeof initialValueOpt === 'function'
-    ? (initialValueOpt as InitialValueResolver<Params, InitialValue>)(params, context)
-    : initialValueOpt
+  const useCache = options?.useCache
+
+  if (typeof initialValueOpt === 'function') {
+    const cached = cache.get(initialValueOpt as InitialValueResolver<unknown, unknown>)
+
+    const key = JSON.stringify([
+      params,
+      context.projectId,
+      context.dataset,
+      context.currentUser?.id,
+    ])
+
+    if (useCache && cached?.[key]) {
+      return cached[key] as InitialValue | Promise<InitialValue>
+    }
+
+    const value = (initialValueOpt as InitialValueResolver<Params, InitialValue>)(params, context)
+
+    if (useCache) {
+      cache.set(initialValueOpt as InitialValueResolver<unknown, unknown>, {
+        ...cached,
+        [key]: value,
+      })
+    }
+
+    return value
+  }
+
+  return initialValueOpt
 }
 
 /** @internal */
@@ -45,18 +81,19 @@ export async function resolveInitialValue(
   template: Template,
   params: {[key: string]: any} = {},
   context: InitialValueResolverContext,
+  options?: Options,
 ): Promise<{[key: string]: any}> {
   // Template builder?
   if (isBuilder(template)) {
-    return resolveInitialValue(schema, template.serialize(), params, context)
+    return resolveInitialValue(schema, template.serialize(), params, context, options)
   }
 
   const {id, schemaType: schemaTypeName, value} = template
   if (!value) {
     throw new Error(`Template "${id}" has invalid "value" property`)
   }
 
-  let resolvedValue = await resolveValue(value, params, context)
+  let resolvedValue = await resolveValue(value, params, context, options)
 
   if (!isRecord(resolvedValue)) {
     throw new Error(
@@ -79,8 +116,13 @@ export async function resolveInitialValue(
   }
 
   const newValue = deepAssign(
-    (await resolveInitialValueForType(schemaType, params, DEFAULT_MAX_RECURSION_DEPTH, context)) ||
-      {},
+    (await resolveInitialValueForType(
+      schemaType,
+      params,
+      DEFAULT_MAX_RECURSION_DEPTH,
+      context,
+      options,
+    )) || {},
     resolvedValue as Record<string, unknown>,
   )
 
@@ -120,29 +162,31 @@ export function resolveInitialValueForType<Params extends Record<string, unknown
    */
   maxDepth = DEFAULT_MAX_RECURSION_DEPTH,
   context: InitialValueResolverContext,
+  options?: Options,
 ): Promise<any> {
   if (maxDepth <= 0) {
     return Promise.resolve(undefined)
   }
 
   if (isObjectSchemaType(type)) {
-    return resolveInitialObjectValue(type, params, maxDepth, context)
+    return resolveInitialObjectValue(type, params, maxDepth, context, options)
   }
 
   if (isArraySchemaType(type)) {
-    return resolveInitialArrayValue(type, params, maxDepth, context)
+    return resolveInitialArrayValue(type, params, maxDepth, context, options)
   }
 
-  return resolveValue(type.initialValue, params, context)
+  return resolveValue(type.initialValue, params, context, options)
 }
 
 async function resolveInitialArrayValue<Params extends Record<string, unknown>>(
   type: SchemaType,
   params: Params,
   maxDepth: number,
   context: InitialValueResolverContext,
+  options?: Options,
 ): Promise<any> {
-  const initialArray = await resolveValue(type.initialValue, undefined, context)
+  const initialArray = await resolveValue(type.initialValue, undefined, context, options)
 
   if (!Array.isArray(initialArray)) {
     return undefined
@@ -154,7 +198,7 @@ async function resolveInitialArrayValue<Params extends Record<string, unknown>>(
       return isObjectSchemaType(itemType)
         ? {
             ...initialItem,
-            ...(await resolveInitialValueForType(itemType, params, maxDepth - 1, context)),
+            ...(await resolveInitialValueForType(itemType, params, maxDepth - 1, context, options)),
             _key: randomKey(),
           }
         : initialItem
@@ -168,9 +212,10 @@ export async function resolveInitialObjectValue<Params extends Record<string, un
   params: Params,
   maxDepth: number,
   context: InitialValueResolverContext,
+  options?: Options,
 ): Promise<any> {
   const initialObject: Record<string, unknown> = {
-    ...((await resolveValue(type.initialValue, params, context)) || {}),
+    ...((await resolveValue(type.initialValue, params, context, options)) || {}),
   }
 
   const fieldValues: Record<string, any> = {}
@@ -181,6 +226,7 @@ export async function resolveInitialObjectValue<Params extends Record<string, un
         params,
         maxDepth - 1,
         context,
+        options,
       )
       if (initialFieldValue !== undefined && initialFieldValue !== null) {
         fieldValues[field.name] = initialFieldValue