mobx-keystone 1.24.1 → 2.0.0

package/src/types/utility/typesCodecSupport.ts

@@ -1,6 +1,6 @@
 import { isObservableArray, isObservableObject, remove } from "mobx"
 import type { ModelPropTransform } from "../../modelShared/prop"
-import { isArray, isObject, lazy } from "../../utils"
+import { copyOwnEnumerableProps, isArray, isObject, lazy } from "../../utils"
 import { setIfDifferent } from "../../utils/setIfDifferent"
 import { ArrayTypeInfo, typesArray } from "../arrayBased/typesArray"
 import { TupleTypeInfo, typesTuple } from "../arrayBased/typesTuple"
@@ -19,23 +19,26 @@ import {
   type RuntimeAdapter,
 } from "./typesCodecCore"
 import { OrTypeInfo, typesOr } from "./typesOr"
-import { RefinementTypeInfo } from "./typesRefinement"
+import { RefinementTypeInfo, typesRefinement } from "./typesRefinement"
 import { SkipCheckTypeInfo, typesSkipCheck } from "./typesSkipCheck"
 import { TagTypeInfo, typesTag } from "./typesTag"
 
 const codecSupportCache = new WeakMap<AnyStandardType, ResolvedCodecSupport>()
 
 function getArrayIndex(prop: PropertyKey): number | undefined {
-  // Proxy get/set traps always receive string|symbol keys (ECMAScript ToPropertyKey),
-  // so we only need to check for string numeric indices.
-  if (typeof prop === "string" && /^(0|[1-9]\d*)$/.test(prop)) {
-    return Number(prop)
-  }
-
-  return undefined
+  // Proxy traps receive string or symbol keys, including strings for numeric indices.
+  if (typeof prop !== "string") return undefined
+  const first = prop.charCodeAt(0)
+  if (first < 48 || first > 57) return undefined
+
+  const index = Number(prop)
+  return Number.isInteger(index) && index >= 0 && index < 0xffffffff && String(index) === prop
+    ? index
+    : undefined
 }
 
 function normalizeArrayIndex(index: number, length: number): number {
+  index = Math.trunc(index) || 0
   if (index < 0) {
     return Math.max(length + index, 0)
   }
@@ -44,6 +47,7 @@ function normalizeArrayIndex(index: number, length: number): number {
 }
 
 function resolveArrayAtIndex(index: number, length: number): number | undefined {
+  index = Math.trunc(index) || 0
   const resolvedIndex = index < 0 ? length + index : index
 
   if (resolvedIndex < 0 || resolvedIndex >= length) {
@@ -90,11 +94,7 @@ function objectLikeToStored(
     return runtime as never
   }
 
-  const stored: Record<string, unknown> = {}
-  for (const key of Object.keys(runtime)) {
-    stored[key] = convertValue(key, runtime[key])
-  }
-  return stored
+  return copyOwnEnumerableProps({}, runtime, (value, key) => convertValue(key, value))
 }
 
 /**
@@ -155,8 +155,7 @@ function createObjectRuntimeAdapter(
             }
           }
 
-          Reflect.set(target, prop, value)
-          return true
+          return Reflect.set(target, prop, value)
         },
 
         ...objectRecordProxyTraps,
@@ -217,8 +216,7 @@ function createRecordRuntimeAdapter(
             return true
           }
 
-          Reflect.set(target, prop, value)
-          return true
+          return Reflect.set(target, prop, value)
         },
 
         ...objectRecordProxyTraps,
@@ -250,7 +248,9 @@ function createArrayLikeRuntimeAdapter(
   const storedByRuntime = new WeakMap<unknown[], unknown[]>()
 
   const decodeIndex = (target: unknown[], index: number) =>
-    index < 0 || index >= target.length || !Reflect.has(target, index)
+    index < 0 ||
+    index >= target.length ||
+    (!isObservableArray(target) && !Reflect.has(target, index))
       ? undefined
       : getItemAdapter(index).toRuntime(target[index], (newStoredValue) => {
           target[index] = newStoredValue
@@ -265,13 +265,18 @@ function createArrayLikeRuntimeAdapter(
     return Reflect.apply(method, receiver, args)
   }
   const materializeRuntimeValues = (target: unknown[]) =>
-    Array.from({ length: target.length }, (_, index) => decodeIndex(target, index))
+    target.map((_value, index) => decodeIndex(target, index))
   const replaceStoredValues = (target: unknown[], runtimeValues: unknown[]) => {
-    target.splice(
-      0,
-      target.length,
-      ...runtimeValues.map((value, index) => getItemAdapter(index).toStored(value))
-    )
+    const storedValues = runtimeValues.map((value, index) => getItemAdapter(index).toStored(value))
+    if (isObservableArray(target)) {
+      target.replace(storedValues)
+    } else {
+      target.length = storedValues.length
+      for (let i = 0; i < storedValues.length; i++) {
+        if (i in storedValues) target[i] = storedValues[i]
+        else delete target[i]
+      }
+    }
   }
   const mutateViaRuntime = (
     target: unknown[],
@@ -296,6 +301,11 @@ function createArrayLikeRuntimeAdapter(
       }
 
       const proxy: unknown[] = new Proxy(stored, {
+        has(target, prop) {
+          const index = getArrayIndex(prop)
+          if (index !== undefined && isObservableArray(target)) return index < target.length
+          return Reflect.has(target, prop)
+        },
         get(target, prop, receiver) {
           const index = getArrayIndex(prop)
           if (index !== undefined) {
@@ -332,8 +342,9 @@ function createArrayLikeRuntimeAdapter(
                 }
 
                 const indexValue = target.length - 1
+                const present = isObservableArray(target) || indexValue in target
                 const value = target.pop()
-                return getItemAdapter(indexValue).toRuntime(value)
+                return present ? getItemAdapter(indexValue).toRuntime(value) : undefined
               }
             case "shift":
               return () => {
@@ -341,8 +352,9 @@ function createArrayLikeRuntimeAdapter(
                   return undefined
                 }
 
+                const present = isObservableArray(target) || 0 in target
                 const value = target.shift()
-                return getItemAdapter(0).toRuntime(value)
+                return present ? getItemAdapter(0).toRuntime(value) : undefined
               }
             case "unshift":
               return (...items: unknown[]) =>
@@ -350,12 +362,21 @@ function createArrayLikeRuntimeAdapter(
                   ...items.map((item, indexValue) => getItemAdapter(indexValue).toStored(item))
                 )
             case "splice":
-              return (start: number, deleteCount?: number, ...items: unknown[]) => {
+              return (...args: [start?: number, deleteCount?: number, ...items: unknown[]]) => {
+                const [start = 0, deleteCount, ...items] = args
                 const normalizedStart = normalizeArrayIndex(start, target.length)
                 const actualDeleteCount =
-                  deleteCount === undefined
-                    ? target.length - normalizedStart
-                    : Math.max(0, Math.min(deleteCount, target.length - normalizedStart))
+                  args.length === 0
+                    ? 0
+                    : args.length === 1
+                      ? target.length - normalizedStart
+                      : Math.max(
+                          0,
+                          Math.min(
+                            Math.trunc(deleteCount ?? 0) || 0,
+                            target.length - normalizedStart
+                          )
+                        )
 
                 const removedValues = target
                   .slice(normalizedStart, normalizedStart + actualDeleteCount)
@@ -443,8 +464,7 @@ function createArrayLikeRuntimeAdapter(
             return true
           }
 
-          Reflect.set(target, prop, value)
-          return true
+          return Reflect.set(target, prop, value)
         },
       })
 
@@ -461,7 +481,7 @@ function createArrayLikeRuntimeAdapter(
           return cachedStored
         }
 
-        return Array.from(runtime, (value, index) => getItemAdapter(index).toStored(value))
+        return runtime.map((value, index) => getItemAdapter(index).toStored(value))
       }
 
       return runtime as never
@@ -490,44 +510,55 @@ function createCodecLeafRuntimeAdapter(
     toRuntime(stored, setStored) {
       const cachedRuntime = isObject(stored) ? runtimeByStored.get(stored) : undefined
 
-      const runtime = transform.transform({
+      // Declared up front (rather than initialized from the call) so that a setter invoked
+      // while decoding can read it without hitting the temporal dead zone.
+      let runtime: unknown
+      let storedChanged = false
+      runtime = transform.transform({
         originalValue: stored,
         cachedTransformedValue: cachedRuntime,
         setOriginalValue(newStoredValue) {
           if (setStored) {
-            setStored(newStoredValue)
+            try {
+              setStored(newStoredValue)
+            } finally {
+              // A retained codec setter can replace the value after decoding. Neither
+              // direction of the cache may keep associating it with the old stored value.
+              storedChanged = true
+              if (isObject(runtime)) storedByRuntime.delete(runtime)
+              if (isObject(stored)) runtimeByStored.delete(stored)
+            }
           }
         },
       })
 
-      if (isObject(runtime)) {
-        storedByRuntime.set(runtime, stored)
-      }
-
-      if (isObject(stored)) {
-        runtimeByStored.set(stored, runtime)
+      if (!storedChanged) {
+        if (isObject(runtime)) storedByRuntime.set(runtime, stored)
+        if (isObject(stored)) runtimeByStored.set(stored, runtime)
       }
 
       return runtime
     },
 
     toStored(runtime) {
-      const cachedStored = isObject(runtime) ? storedByRuntime.get(runtime) : undefined
-      if (cachedStored !== undefined) {
-        return cachedStored
+      if (isObject(runtime)) {
+        const cachedStored = storedByRuntime.get(runtime)
+        if (cachedStored !== undefined || storedByRuntime.has(runtime)) {
+          return cachedStored
+        }
       }
 
+      let cacheResult = false
       const stored = transform.untransform({
         transformedValue: runtime,
-        cacheTransformedValue: () => {},
+        cacheTransformedValue: () => {
+          cacheResult = true
+        },
       })
 
-      if (isObject(runtime)) {
-        storedByRuntime.set(runtime, stored)
-      }
-
-      if (isObject(stored)) {
-        runtimeByStored.set(stored, runtime)
+      if (cacheResult) {
+        if (isObject(runtime)) storedByRuntime.set(runtime, stored)
+        if (isObject(stored)) runtimeByStored.set(stored, runtime)
       }
 
       return stored
@@ -536,7 +567,7 @@ function createCodecLeafRuntimeAdapter(
     toStoredIfCached(runtime) {
       if (isObject(runtime)) {
         const cachedStored = storedByRuntime.get(runtime)
-        if (cachedStored !== undefined) {
+        if (cachedStored !== undefined || storedByRuntime.has(runtime)) {
           return { found: true, value: cachedStored }
         }
       }
@@ -675,7 +706,7 @@ function resolveCodecSupportForStandardType(type: AnyStandardType): ResolvedCode
           }
     } else if (typeInfo instanceof ObjectTypeInfo) {
       const childSupports = lazy(() => {
-        const supports: Record<string, ResolvedCodecSupport> = {}
+        const supports: Record<string, ResolvedCodecSupport> = Object.create(null)
         const props = typeInfo.props
         for (const propName of Object.keys(props)) {
           supports[propName] = resolveCodecSupportForStandardType(props[propName].type)
@@ -690,7 +721,7 @@ function resolveCodecSupportForStandardType(type: AnyStandardType): ResolvedCode
         : {
             hasCodec: true,
             storedType: typesObject(() => {
-              const storedProps: Record<string, AnyStandardType> = {}
+              const storedProps: Record<string, AnyStandardType> = Object.create(null)
               const props = typeInfo.props
               for (const propName of Object.keys(props)) {
                 storedProps[propName] = childSupports()[propName].storedType
@@ -722,7 +753,17 @@ function resolveCodecSupportForStandardType(type: AnyStandardType): ResolvedCode
     } else if (typeInfo instanceof RefinementTypeInfo) {
       const baseSupport = resolveCodecSupportForStandardType(typeInfo.baseType)
 
-      resolvedSupport = baseSupport.hasCodec ? baseSupport : noCodecSupport(type)
+      resolvedSupport = !baseSupport.hasCodec
+        ? noCodecSupport(type)
+        : {
+            hasCodec: true,
+            storedType: typesRefinement(
+              baseSupport.storedType,
+              (stored) => typeInfo.checkFunction(baseSupport.adapter.toRuntime(stored)),
+              typeInfo.typeName
+            ),
+            adapter: baseSupport.adapter,
+          }
     } else if (typeInfo instanceof SkipCheckTypeInfo) {
       const baseSupport = resolveCodecSupportForStandardType(typeInfo.baseType)
 

package/src/types/utility/typesMap.ts

@@ -1,5 +1,5 @@
 import type { ModelPropTransform } from "../../modelShared/prop"
-import { isMap } from "../../utils"
+import { isMap, setProtoProp } from "../../utils"
 import { asMap } from "../../wrappers/asMap"
 import { typesArray } from "../arrayBased/typesArray"
 import { typesTuple } from "../arrayBased/typesTuple"
@@ -19,6 +19,15 @@ function makeMapProxy<TKeyStored, TKeyRuntime, TValueStored, TValueRuntime>(
   keyAdapter: RuntimeAdapter<TKeyStored, TKeyRuntime>,
   valueAdapter: RuntimeAdapter<TValueStored, TValueRuntime>
 ): Map<TKeyRuntime, TValueRuntime> {
+  // Writes through the decoded value must land back on the entry it came from.
+  const toRuntimeValue = (storedKey: TKeyStored, storedValue: TValueStored): TValueRuntime =>
+    valueAdapter.toRuntime(storedValue, (newStoredValue) => {
+      storedMap.set(storedKey, newStoredValue)
+    })
+
+  const getValue = (storedKey: TKeyStored): TValueRuntime =>
+    toRuntimeValue(storedKey, storedMap.get(storedKey) as TValueStored)
+
   return new Proxy(storedMap, {
     get(target, prop, receiver) {
       switch (prop) {
@@ -29,43 +38,24 @@ function makeMapProxy<TKeyStored, TKeyRuntime, TValueStored, TValueRuntime>(
               return undefined
             }
 
-            return valueAdapter.toRuntime(
-              target.get(storedKey) as TValueStored,
-              (newStoredValue) => {
-                target.set(storedKey, newStoredValue)
-              }
-            )
+            return getValue(storedKey)
           }
         case "getOrInsert":
           return (key: TKeyRuntime, defaultValue: TValueRuntime) => {
             const storedKey = keyAdapter.toStored(key)
-            if (target.has(storedKey)) {
-              return valueAdapter.toRuntime(
-                target.get(storedKey) as TValueStored,
-                (newStoredValue) => {
-                  target.set(storedKey, newStoredValue)
-                }
-              )
+            if (!target.has(storedKey)) {
+              target.set(storedKey, valueAdapter.toStored(defaultValue))
             }
-
-            target.set(storedKey, valueAdapter.toStored(defaultValue))
-            return defaultValue
+            return getValue(storedKey)
           }
         case "getOrInsertComputed":
           return (key: TKeyRuntime, callback: (key: TKeyRuntime) => TValueRuntime) => {
             const storedKey = keyAdapter.toStored(key)
-            if (target.has(storedKey)) {
-              return valueAdapter.toRuntime(
-                target.get(storedKey) as TValueStored,
-                (newStoredValue) => {
-                  target.set(storedKey, newStoredValue)
-                }
-              )
+            if (!target.has(storedKey)) {
+              const value = callback(key)
+              target.set(storedKey, valueAdapter.toStored(value))
             }
-
-            const value = callback(key)
-            target.set(storedKey, valueAdapter.toStored(value))
-            return value
+            return getValue(storedKey)
           }
         case "set":
           return (key: TKeyRuntime, value: TValueRuntime) => {
@@ -92,9 +82,7 @@ function makeMapProxy<TKeyStored, TKeyRuntime, TValueStored, TValueRuntime>(
             target.forEach((value, key) => {
               callback.call(
                 thisArg,
-                valueAdapter.toRuntime(value, (newStoredValue) => {
-                  target.set(key, newStoredValue)
-                }),
+                toRuntimeValue(key, value),
                 keyAdapter.toRuntime(key),
                 receiver
               )
@@ -104,12 +92,7 @@ function makeMapProxy<TKeyStored, TKeyRuntime, TValueStored, TValueRuntime>(
         case Symbol.iterator:
           return function* () {
             for (const [key, value] of target.entries()) {
-              yield [
-                keyAdapter.toRuntime(key),
-                valueAdapter.toRuntime(value, (newStoredValue) => {
-                  target.set(key, newStoredValue)
-                }),
-              ] as const
+              yield [keyAdapter.toRuntime(key), toRuntimeValue(key, value)] as const
             }
           }
         case "keys":
@@ -121,9 +104,7 @@ function makeMapProxy<TKeyStored, TKeyRuntime, TValueStored, TValueRuntime>(
         case "values":
           return function* () {
             for (const [key, value] of target.entries()) {
-              yield valueAdapter.toRuntime(value, (newStoredValue) => {
-                target.set(key, newStoredValue)
-              })
+              yield toRuntimeValue(key, value)
             }
           }
         default:
@@ -158,7 +139,9 @@ function makeObjectBackedMapTransform<TStoredValue, TRuntimeValue>(
 
       const result: Record<string, TStoredValue> = {}
       transformedValue.forEach((value, key) => {
-        result[key] = valueAdapter.toStored(value)
+        const storedValue = valueAdapter.toStored(value)
+        if (key === "__proto__") setProtoProp(result, storedValue)
+        else result[key] = storedValue
       })
       return result
     },

package/src/types/utility/typesRefinement.ts

@@ -41,8 +41,8 @@ import {
  * @template T Base type.
  * @param baseType Base type.
  * @param checkFn Function that will receive the data (if it passes the base type
- * check) and return null or false if there were no errors or either a TypeCheckError instance or
- * true if there were.
+ * check) and return null or true if there were no errors or either a TypeCheckError instance or
+ * false if there were.
  * @returns
  */
 export function typesRefinement<T extends AnyType>(
@@ -89,6 +89,7 @@ export function typesRefinement<T extends AnyType>(
           // override typeCheckedValue
           return new TypeCheckError({
             path: refinementErr.path,
+            modelTrail: refinementErr.modelTrail,
             expectedTypeName: refinementErr.expectedTypeName,
             actualValue: refinementErr.actualValue,
             typeCheckedValue,

package/src/types/utility/typesSet.ts

@@ -1,6 +1,15 @@
 import type { ObservableSet } from "mobx"
 import type { ModelPropTransform } from "../../modelShared/prop"
 import { isSet } from "../../utils"
+import {
+  isSetLikeDisjointFrom,
+  isSetLikeSubsetOf,
+  isSetLikeSupersetOf,
+  setLikeDifference,
+  setLikeIntersection,
+  setLikeSymmetricDifference,
+  setLikeUnion,
+} from "../../utils/setLike"
 import { asSet } from "../../wrappers/asSet"
 import { typesArray } from "../arrayBased/typesArray"
 import type { AnyType, ArrayType, TypeToData } from "../schemas"
@@ -52,6 +61,21 @@ function makeArrayBackedSetTransform<TStored, TRuntime>(
                   callback.call(thisArg, runtimeValue, runtimeValue, receiver)
                 })
               }
+            case "union":
+              return (other: ReadonlySetLike<unknown>) => setLikeUnion(receiver, other)
+            case "intersection":
+              return (other: ReadonlySetLike<unknown>) => setLikeIntersection(receiver, other)
+            case "difference":
+              return (other: ReadonlySetLike<unknown>) => setLikeDifference(receiver, other)
+            case "symmetricDifference":
+              return (other: ReadonlySetLike<unknown>) =>
+                setLikeSymmetricDifference(receiver, other)
+            case "isSubsetOf":
+              return (other: ReadonlySetLike<unknown>) => isSetLikeSubsetOf(receiver, other)
+            case "isSupersetOf":
+              return (other: ReadonlySetLike<unknown>) => isSetLikeSupersetOf(receiver, other)
+            case "isDisjointFrom":
+              return (other: ReadonlySetLike<unknown>) => isSetLikeDisjointFrom(receiver, other)
             case "entries":
               return function* () {
                 for (const value of target.values()) {

package/src/utils/ModelPool.ts

@@ -24,7 +24,7 @@ export class ModelPool {
   }
 
   findModelByTypeAndId(modelType: string, modelId: string | undefined): AnyModel | undefined {
-    return modelId ? this.pool.get(modelType)?.get(modelId) : undefined
+    return modelId !== undefined ? this.pool.get(modelType)?.get(modelId) : undefined
   }
 
   findModelForSnapshot(sn: any): AnyModel | undefined {
@@ -36,7 +36,7 @@ export class ModelPool {
     const modelInfo = getModelInfoForName(modelType)!
     const modelIdPropertyName = getModelIdPropertyName(modelInfo.class as ModelClass<AnyModel>)
 
-    return modelIdPropertyName
+    return modelIdPropertyName !== undefined
       ? this.findModelByTypeAndId(modelType, (sn as any)[modelIdPropertyName])
       : undefined
   }
@@ -56,7 +56,7 @@ let getDeepChildrenModels: GetDeepChildrenModels = (data) => {
     addNode(node, extensionData) {
       if (isModel(node)) {
         const id = node[modelIdKey]
-        if (id) {
+        if (id !== undefined) {
           const modelType = node[modelTypeKey]
           let modelsById = extensionData.get(modelType)
           if (!modelsById) {

package/src/utils/chainFns.ts

@@ -4,6 +4,10 @@ export function chainFns<F extends Function>(...fns: (F | undefined)[]): F | und
     return undefined
   }
 
+  if (definedFns.length === 1) {
+    return definedFns[0]
+  }
+
   const chainedFn = (v: any, ...args: any[]) => {
     let ret = v
 

package/src/utils/decorators.ts

@@ -110,7 +110,7 @@ export function decorateWrapMethodOrField(
     const baseDescriptor: PropertyDescriptor | undefined = args[2]
 
     checkModelDecoratorTaget(decoratorName, target)
-    checkDecoratorContext("transaction", propertyKey, false)
+    checkDecoratorContext(decoratorName, propertyKey, false)
 
     const data = getActionNameAndContextOverride(target, propertyKey, true)
 

package/src/utils/errorDiagnostics.ts

@@ -190,7 +190,7 @@ function formatErrorPathForMessage(path: Path | undefined = getErrorPathSnapshot
 /**
  * @internal
  */
-function getSafeErrorValuePreview(value: unknown, maxLen = 200): string {
+export function getSafeErrorValuePreview(value: unknown, maxLen = 200): string {
   let str: string | undefined
   try {
     str = JSON.stringify(value)
@@ -203,7 +203,11 @@ function getSafeErrorValuePreview(value: unknown, maxLen = 200): string {
     try {
       str = String(value)
     } catch {
-      str = Object.prototype.toString.call(value)
+      try {
+        str = Object.prototype.toString.call(value)
+      } catch {
+        str = "<unprintable value>"
+      }
     }
   }
 

package/src/utils/forEachWithDelayedThrow.ts

@@ -0,0 +1,83 @@
+import { MobxKeystoneAggregateError } from "./index"
+
+/**
+ * A failure kept aside while the rest of a delivery runs. It is boxed so that a thrown
+ * `undefined` / `null` can still be rethrown as is, and holds a `MobxKeystoneAggregateError`
+ * once more than one callback of the same delivery has failed.
+ * @internal
+ */
+export type DelayedError =
+  | { value: unknown; aggregateErrors?: undefined }
+  | { value: MobxKeystoneAggregateError; aggregateErrors: unknown[] }
+  | undefined
+
+/**
+ * Adds a failure to the ones already kept aside for the same delivery: a lone failure is kept
+ * as is, several are grouped in a `MobxKeystoneAggregateError`. Nested delivery is flattened,
+ * so `errors` is always a flat list of callback failures. The accumulator is updated in place.
+ * @internal
+ */
+export function addDelayedError(
+  current: DelayedError,
+  error: unknown,
+  msg = "multiple callbacks failed"
+): DelayedError {
+  if (!current) {
+    return { value: error }
+  }
+
+  let errors = current.aggregateErrors
+  if (!errors) {
+    // Start from a copy: an aggregate thrown by a callback is not ours to mutate.
+    errors = flattenDelayedError(current.value)
+    current = { value: new MobxKeystoneAggregateError(errors, msg), aggregateErrors: errors }
+  }
+
+  pushDelayedError(errors, error)
+  return current
+}
+
+/**
+ * Reports the failures kept aside for a delivery, if there were any.
+ * @internal
+ */
+export function throwDelayedError(delayedError: DelayedError): void {
+  if (delayedError) {
+    throw delayedError.value
+  }
+}
+
+/**
+ * Runs every callback, then reports the failures (if any) once delivery has finished.
+ * Iterates the collection directly, so appended array items are also visited.
+ * @internal
+ */
+export function forEachWithDelayedThrow<T>(items: Iterable<T>, fn: (item: T) => void): void {
+  let delayedError: DelayedError
+  for (const item of items) {
+    try {
+      fn(item)
+    } catch (error) {
+      delayedError = addDelayedError(delayedError, error)
+    }
+  }
+  throwDelayedError(delayedError)
+}
+
+/** @internal */
+export function flattenDelayedError(error: unknown): unknown[] {
+  return error instanceof MobxKeystoneAggregateError ? [...error.errors] : [error]
+}
+
+/** @internal */
+export function pushDelayedError(errors: unknown[], error: unknown): void {
+  if (error instanceof MobxKeystoneAggregateError) {
+    const nestedErrors = error.errors
+    const length = nestedErrors.length
+    for (let i = 0; i < length; i++) {
+      errors.push(nestedErrors[i])
+    }
+  } else {
+    errors.push(error)
+  }
+}