From 5aedde4d29ffd735a0da025328486e4b00b06960 Mon Sep 17 00:00:00 2001
From: Ash <ash@sanity.io>
Date: Thu, 9 May 2024 17:28:36 +0100
Subject: [PATCH 1/3] feat(sanity): memoize initial value resolver

---
 .../_legacy/grants/templatePermissions.ts     |  3 +
 packages/sanity/src/core/templates/resolve.ts | 70 +++++++++++++++----
 2 files changed, 60 insertions(+), 13 deletions(-)

diff --git a/packages/sanity/src/core/store/_legacy/grants/templatePermissions.ts b/packages/sanity/src/core/store/_legacy/grants/templatePermissions.ts
index 87a8dbd6d40..032fd099b35 100644
--- a/packages/sanity/src/core/store/_legacy/grants/templatePermissions.ts
+++ b/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}
diff --git a/packages/sanity/src/core/templates/resolve.ts b/packages/sanity/src/core/templates/resolve.ts
index ccd8f639615..fd39a0d9b93 100644
--- a/packages/sanity/src/core/templates/resolve.ts
+++ b/packages/sanity/src/core/templates/resolve.ts
@@ -21,11 +21,20 @@ 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
@@ -33,10 +42,35 @@ 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,10 +79,11 @@ 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
@@ -56,7 +91,7 @@ export async function resolveInitialValue(
     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 +114,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,20 +160,21 @@ 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>>(
@@ -141,8 +182,9 @@ async function resolveInitialArrayValue<Params extends Record<string, unknown>>(
   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 +196,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 +210,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 +224,7 @@ export async function resolveInitialObjectValue<Params extends Record<string, un
         params,
         maxDepth - 1,
         context,
+        options,
       )
       if (initialFieldValue !== undefined && initialFieldValue !== null) {
         fieldValues[field.name] = initialFieldValue

From 28d997836bddbbaf2b07f11493e9f333bcd36465 Mon Sep 17 00:00:00 2001
From: Ash <ash@sanity.io>
Date: Fri, 10 May 2024 22:46:13 +0100
Subject: [PATCH 2/3] test(sanity): initial value resolution memoization

---
 .../core/templates/__tests__/resolve.test.ts  | 91 ++++++++++++++++++-
 1 file changed, 90 insertions(+), 1 deletion(-)

diff --git a/packages/sanity/src/core/templates/__tests__/resolve.test.ts b/packages/sanity/src/core/templates/__tests__/resolve.test.ts
index 4c1200b52a5..a2d9ce61c05 100644
--- a/packages/sanity/src/core/templates/__tests__/resolve.test.ts
+++ b/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)
+    })
+  })
 })

From 423134b672b041bfe8803e9e0327e290e7e7f6e4 Mon Sep 17 00:00:00 2001
From: Ash <ash@sanity.io>
Date: Fri, 10 May 2024 23:41:28 +0100
Subject: [PATCH 3/3] refactor(sanity): remove unnecessary array

---
 packages/sanity/src/core/templates/resolve.ts | 4 +++-
 1 file changed, 3 insertions(+), 1 deletion(-)

diff --git a/packages/sanity/src/core/templates/resolve.ts b/packages/sanity/src/core/templates/resolve.ts
index fd39a0d9b93..2717058a73d 100644
--- a/packages/sanity/src/core/templates/resolve.ts
+++ b/packages/sanity/src/core/templates/resolve.ts
@@ -51,7 +51,9 @@ export async function resolveValue<Params, InitialValue>(
 
     const key = JSON.stringify([
       params,
-      [context.projectId, context.dataset, context.currentUser?.id],
+      context.projectId,
+      context.dataset,
+      context.currentUser?.id,
     ])
 
     if (useCache && cached?.[key]) {