From 7ae1d01d779d38e02bf4c8061a5696c4c191a4ae Mon Sep 17 00:00:00 2001
From: Ash <ash@sanity.io>
Date: Thu, 9 May 2024 17:28:36 +0100
Subject: [PATCH] wip: 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 87a8dbd6d402..032fd099b359 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 ccd8f6396152..fd39a0d9b936 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