mobx-keystone 1.22.0 → 1.23.0

package/src/types/createCachedTypeCheck.ts

@@ -0,0 +1,181 @@
+import { computed, type IComputedValue, type IObjectDidChange, observe } from "mobx"
+import type { Path } from "../parent/pathTypes"
+import { isTweakedObject } from "../tweaker/core"
+import { TypeCheckError } from "./TypeCheckError"
+
+const emptyPath: Path = []
+
+function contextualizeCachedError(
+  error: TypeCheckError | null,
+  path: Path,
+  typeCheckedValue: any
+): TypeCheckError | null {
+  if (!error) {
+    return null
+  }
+
+  return new TypeCheckError({
+    path: [...path, ...error.path],
+    expectedTypeName: error.expectedTypeName,
+    actualValue: error.actualValue,
+    typeCheckedValue,
+  })
+}
+
+type CachedEntry = IComputedValue<TypeCheckError | null>
+
+interface EntryCache<K> {
+  get(key: K): CachedEntry | undefined
+  set(key: K, entry: CachedEntry): void
+}
+
+type IterateEntries<K> = (
+  value: any,
+  checkEntry: (entryKey: K) => TypeCheckError | null
+) => TypeCheckError | null
+
+type CheckEntry<K> = (
+  value: any,
+  entryKey: K,
+  path: Path,
+  typeCheckedValue: any
+) => TypeCheckError | null
+
+function createAdaptivePerEntryCachedCheck<K>(
+  iterateEntries: IterateEntries<K>,
+  checkEntry: CheckEntry<K>,
+  createEntryCache: (value: object) => EntryCache<K>
+): (value: any, path: Path, typeCheckedValue: any) => TypeCheckError | null {
+  const aggregationCache = new WeakMap<object, IComputedValue<TypeCheckError | null>>()
+
+  const checkAllEntries = (value: any, path: Path, typeCheckedValue: any) =>
+    iterateEntries(value, (key) => checkEntry(value, key, path, typeCheckedValue))
+
+  return (value, path, typeCheckedValue) => {
+    if (!isTweakedObject(value, true)) {
+      return checkAllEntries(value, path, typeCheckedValue)
+    }
+
+    let aggregation = aggregationCache.get(value)
+    if (!aggregation) {
+      let entries: EntryCache<K> | undefined
+      let isFirstEvaluation = true
+      const cachedCheckEntry = (key: K): TypeCheckError | null => {
+        if (!entries) {
+          entries = createEntryCache(value)
+        }
+
+        let entry = entries.get(key)
+        if (!entry) {
+          entry = computed(() => checkEntry(value, key, emptyPath, undefined))
+          entries.set(key, entry)
+        }
+        return entry.get()
+      }
+
+      aggregation = computed(
+        () => {
+          if (isFirstEvaluation) {
+            isFirstEvaluation = false
+            return checkAllEntries(value, emptyPath, undefined)
+          }
+          return iterateEntries(value, cachedCheckEntry)
+        },
+        { keepAlive: true }
+      )
+      aggregationCache.set(value, aggregation)
+    }
+
+    return contextualizeCachedError(aggregation.get(), path, typeCheckedValue)
+  }
+}
+
+/**
+ * @internal
+ *
+ * Creates an adaptive check for dynamic records.
+ *
+ * For tweaked (observable) values:
+ * 1. The first complete check is cached without allocating per-entry state.
+ * 2. After the first invalidation, per-entry computeds each read one property, so
+ *    changing property A only invalidates property A's computed.
+ * 3. The aggregation computed iterates per-entry computeds. Thanks to MobX's propagation,
+ *    if a per-entry computed re-evaluates but returns the same result (e.g. null → null),
+ *    the aggregation body is skipped entirely.
+ * 4. A pruning observer is installed when the promoted entry cache is first used
+ *    and removes stale entries immediately when record keys are deleted.
+ *
+ * Cached checks produce context-free errors. A fresh error is contextualized
+ * with the current path and checked root without executing user checkers again.
+ *
+ * For non-tweaked values (plain snapshots), the entry iterator and checker run
+ * directly with the caller's context.
+ *
+ * @param iterateEntries Iterates the promoted per-entry computeds and returns
+ *   the first error, or null.
+ * @param checkEntry Checks a single entry. The utility wraps it in a
+ *   non-keepAlive computed automatically after promotion.
+ */
+export function createAdaptiveRecordCachedCheck(
+  iterateEntries: IterateEntries<PropertyKey>,
+  checkEntry: CheckEntry<PropertyKey>
+): (value: any, path: Path, typeCheckedValue: any) => TypeCheckError | null {
+  return createAdaptivePerEntryCachedCheck(iterateEntries, checkEntry, (value) => {
+    const entries = new Map<PropertyKey, CachedEntry>()
+    observe(value, (change: IObjectDidChange) => {
+      if (change.type === "remove") {
+        entries.delete(change.name)
+      }
+    })
+    return entries
+  })
+}
+
+/**
+ * Creates one reactive computed for a complete container check.
+ *
+ * @internal
+ */
+export function createWholeContainerCachedCheck(
+  check: (value: any, path: Path, typeCheckedValue: any) => TypeCheckError | null
+): (value: any, path: Path, typeCheckedValue: any) => TypeCheckError | null {
+  const cache = new WeakMap<object, IComputedValue<TypeCheckError | null>>()
+
+  return (value, path, typeCheckedValue) => {
+    if (!isTweakedObject(value, true)) {
+      return check(value, path, typeCheckedValue)
+    }
+
+    let cached = cache.get(value)
+    if (!cached) {
+      cached = computed(() => check(value, emptyPath, undefined), { keepAlive: true })
+      cache.set(value, cached)
+    }
+    const error = cached.get()
+    return contextualizeCachedError(error, path, typeCheckedValue)
+  }
+}
+
+/**
+ * Fixed-schema per-entry cache. Numeric entry keys use
+ * array slots, and the aggregation closure owns that array, so only one
+ * WeakMap is needed for each checked object. The aggregation caches one
+ * complete check first and promotes itself to per-entry computeds after its
+ * first dependency invalidation.
+ *
+ * @internal
+ */
+export function createIndexedPerEntryCachedCheck(
+  iterateEntries: IterateEntries<number>,
+  checkEntry: CheckEntry<number>
+): (value: any, path: Path, typeCheckedValue: any) => TypeCheckError | null {
+  return createAdaptivePerEntryCachedCheck(iterateEntries, checkEntry, () => {
+    const entries: Array<CachedEntry | undefined> = []
+    return {
+      get: (index) => entries[index],
+      set: (index, entry) => {
+        entries[index] = entry
+      },
+    }
+  })
+}

package/src/types/objectBased/typesArraySet.ts

@@ -10,6 +10,7 @@ import type { AnyStandardType, AnyType, ModelType, TypeToData } from "../schemas
 import { TypeCheckError } from "../TypeCheckError"
 import {
   lateTypeChecker,
+  snapshotProcessorPlan,
   TypeChecker,
   TypeCheckerBaseType,
   TypeInfo,
@@ -31,13 +32,13 @@ import { typesObject } from "./typesObject"
  * @returns
  */
 export function typesArraySet<T extends AnyType>(valueType: T): ModelType<ArraySet<TypeToData<T>>> {
-  const typeInfoGen: TypeInfoGen = (t) => new ArraySetTypeInfo(t, resolveStandardType(valueType))
-
+  const resolvedValueType = resolveStandardType(valueType)
+  const typeInfoGen: TypeInfoGen = (t) => new ArraySetTypeInfo(t, resolvedValueType)
   return lateTypeChecker(() => {
     const modelInfo = modelInfoByClass.get(ArraySet)!
 
-    const valueChecker = resolveTypeChecker(valueType)
-    const valueSupport = resolveCodecSupport(valueType)
+    const valueChecker = resolveTypeChecker(resolvedValueType)
+    const valueSupport = resolveCodecSupport(resolvedValueType)
     const storedValueChecker = resolveTypeChecker(valueSupport.storedType)
 
     const getTypeName = (...recursiveTypeCheckers: TypeChecker[]) =>
@@ -81,34 +82,43 @@ export function typesArraySet<T extends AnyType>(valueType: T): ModelType<ArrayS
         return resolvedTc.snapshotType(obj) ? thisTc : null
       },
 
-      (sn: { items: unknown[] }) => {
-        const items = withErrorPathSegment("items", () =>
-          sn.items.map((v, i) =>
-            withErrorPathSegment(i, () => storedValueChecker.fromSnapshotProcessor(v))
-          )
-        )
-
-        return {
-          ...sn,
-          [modelTypeKey]: modelInfo.name,
-          items,
-        }
-      },
-
-      (sn: { items: unknown[]; [modelTypeKey]?: string }) => {
-        const items = withErrorPathSegment("items", () =>
-          sn.items.map((v, i) =>
-            withErrorPathSegment(i, () => storedValueChecker.toSnapshotProcessor(v))
-          )
-        )
-
-        const snCopy = {
-          ...sn,
-          items,
-        }
-
-        return snCopy
-      }
+      snapshotProcessorPlan(
+        () => [storedValueChecker],
+        ([itemProcessor]) =>
+          (sn: { items: unknown[] }) => {
+            const items = itemProcessor
+              ? withErrorPathSegment("items", () =>
+                  sn.items.map((v, i) => withErrorPathSegment(i, () => itemProcessor(v)))
+                )
+              : sn.items
+
+            return {
+              ...sn,
+              [modelTypeKey]: modelInfo.name,
+              items,
+            }
+          },
+        true
+      ),
+
+      snapshotProcessorPlan(
+        () => [storedValueChecker],
+        ([itemProcessor]) =>
+          itemProcessor
+            ? (sn: { items: unknown[]; [modelTypeKey]?: string }) => {
+                const items = withErrorPathSegment("items", () =>
+                  sn.items.map((v, i) => withErrorPathSegment(i, () => itemProcessor(v)))
+                )
+
+                const snCopy = {
+                  ...sn,
+                  items,
+                }
+
+                return snCopy
+              }
+            : undefined
+      )
     )
 
     return thisTc

package/src/types/objectBased/typesDataModelData.ts

@@ -12,10 +12,15 @@ import { getInternalModelClassPropsInfo } from "../../modelShared/modelPropsInfo
 import { noDefaultValue } from "../../modelShared/prop"
 import { failure, lazy } from "../../utils"
 import { getTypeInfo } from "../getTypeInfo"
-import { registerStandardTypeResolver, resolveTypeChecker } from "../resolveTypeChecker"
+import {
+  registerStandardTypeResolver,
+  resolveStandardType,
+  resolveTypeChecker,
+} from "../resolveTypeChecker"
 import type { AnyStandardType, IdentityType } from "../schemas"
 import {
   lateTypeChecker,
+  snapshotProcessorPlan,
   TypeChecker,
   TypeCheckerBaseType,
   TypeInfo,
@@ -71,19 +76,19 @@ export function typesDataModelData<M = never, K = M>(
     }
 
     const typeInfoGen: TypeInfoGen = (t) => new DataModelDataTypeInfo(t, modelClazz)
-
+    const dataType = getDataModelMetadata(modelClazz).dataType
+    const standardDataType = dataType ? resolveStandardType(dataType) : undefined
     const tc = lateTypeChecker(() => {
       const modelInfo = modelInfoByClass.get(modelClazz)!
       const typeName = `DataModelData(${modelInfo.name})`
 
-      const dataTypeChecker = getDataModelMetadata(modelClazz).dataType
-      if (!dataTypeChecker) {
+      if (!standardDataType) {
         throw failure(
           `type checking cannot be performed over data model data of type '${modelInfo.name}' since that model type has no data type declared, consider adding a data type or using types.unchecked() instead`
         )
       }
 
-      const resolvedDataTypeChecker = resolveTypeChecker(dataTypeChecker)
+      const resolvedDataTypeChecker = resolveTypeChecker(standardDataType)
 
       const thisTc: TypeChecker = new TypeChecker(
         TypeCheckerBaseType.Object,
@@ -99,13 +104,15 @@ export function typesDataModelData<M = never, K = M>(
           return resolvedDataTypeChecker.snapshotType(value) ? thisTc : null
         },
 
-        (sn: Record<string, unknown>) => {
-          return resolvedDataTypeChecker.fromSnapshotProcessor(sn)
-        },
+        snapshotProcessorPlan(
+          () => [resolvedDataTypeChecker],
+          ([processor]) => processor
+        ),
 
-        (sn: Record<string, unknown>) => {
-          return resolvedDataTypeChecker.toSnapshotProcessor(sn)
-        }
+        snapshotProcessorPlan(
+          () => [resolvedDataTypeChecker],
+          ([processor]) => processor
+        )
       )
 
       return thisTc

package/src/types/objectBased/typesModel.ts

@@ -122,7 +122,7 @@ export function typesModel<M = never, K = M>(modelClass: _ClassOrObject<M, K>):
           }
         },
 
-        (sn) => sn
+        undefined
       )
 
       return thisTc

package/src/types/objectBased/typesObject.ts

@@ -1,9 +1,10 @@
+import { isObservableObject, keys } from "mobx"
 import type { O } from "ts-toolbelt"
 import { Frozen } from "../../frozen/Frozen"
 import type { Path } from "../../parent/pathTypes"
-import { assertIsFunction, assertIsObject, isObject, lazy } from "../../utils"
+import { assertIsFunction, assertIsObject, getMobxVersion, isObject, lazy } from "../../utils"
 import { withErrorPathSegment } from "../../utils/errorDiagnostics"
-import { createPerEntryCachedCheck } from "../createPerEntryCachedCheck"
+import { createIndexedPerEntryCachedCheck } from "../createCachedTypeCheck"
 import { getTypeInfo } from "../getTypeInfo"
 import { resolveStandardType, resolveTypeChecker } from "../resolveTypeChecker"
 import type {
@@ -17,6 +18,8 @@ import { TypeCheckError } from "../TypeCheckError"
 import {
   type LateTypeChecker,
   lateTypeChecker,
+  type SnapshotProcessor,
+  snapshotProcessorPlan,
   TypeChecker,
   TypeCheckerBaseType,
   TypeInfo,
@@ -24,6 +27,8 @@ import {
 } from "../TypeChecker"
 import { prependPathElementToTypeCheckError } from "../typeCheckErrorUtils"
 
+const needsObservableObjectKeyTracking = getMobxVersion() < 5
+
 function typesObjectHelper<S>(objFn: S, frozen: boolean, typeInfoGen: TypeInfoGen): S {
   assertIsFunction(objFn, "objFn")
 
@@ -33,6 +38,7 @@ function typesObjectHelper<S>(objFn: S, frozen: boolean, typeInfoGen: TypeInfoGe
 
     type SchemaEntry = Readonly<{
       propName: string
+      processorIndex: number
       getResolvedChecker: () => TypeChecker
     }>
     type CheckedSchemaEntry = Readonly<{
@@ -41,10 +47,11 @@ function typesObjectHelper<S>(objFn: S, frozen: boolean, typeInfoGen: TypeInfoGe
     }>
 
     const schemaEntries: ReadonlyArray<SchemaEntry> = Object.entries(objectSchema).map(
-      ([propName, unresolvedChecker]) => {
+      ([propName, unresolvedChecker], processorIndex) => {
         let resolvedChecker: TypeChecker | undefined
         return {
           propName,
+          processorIndex,
           getResolvedChecker: () => {
             if (!resolvedChecker) {
               resolvedChecker = resolveTypeChecker(unresolvedChecker)
@@ -95,7 +102,10 @@ function typesObjectHelper<S>(objFn: S, frozen: boolean, typeInfoGen: TypeInfoGe
       return `{ ${propsMsg.join(" ")} }`
     }
 
-    const applySnapshotProcessor = (obj: Record<string, unknown>, mode: "from" | "to") => {
+    const applySnapshotProcessor = (
+      obj: Record<string, unknown>,
+      processors: ReadonlyArray<SnapshotProcessor | undefined>
+    ) => {
       const newObj: typeof obj = {}
 
       // note: we allow excess properties when checking objects
@@ -104,10 +114,8 @@ function typesObjectHelper<S>(objFn: S, frozen: boolean, typeInfoGen: TypeInfoGe
         const k = keys[i]
         const schemaEntry = schemaEntryByPropName[k]
         if (schemaEntry) {
-          const tc = schemaEntry.getResolvedChecker()
-          newObj[k] = withErrorPathSegment(k, () =>
-            mode === "from" ? tc.fromSnapshotProcessor(obj[k]) : tc.toSnapshotProcessor(obj[k])
-          )
+          const processor = processors[schemaEntry.processorIndex]
+          newObj[k] = processor ? withErrorPathSegment(k, () => processor(obj[k])) : obj[k]
         } else {
           // unknown prop, copy as is
           newObj[k] = obj[k]
@@ -130,17 +138,26 @@ function typesObjectHelper<S>(objFn: S, frozen: boolean, typeInfoGen: TypeInfoGe
       return null
     }
 
-    // No setupCachePruning needed: iterates fixed schemaEntries, not dynamic object keys,
-    // so entries never become stale.
-    const checkObjectProps = createPerEntryCachedCheck<number>(
-      (_obj, checkEntry) => {
-        const entries = checkedSchemaEntries()
-        for (let i = 0; i < entries.length; i++) {
-          const error = checkEntry(i)
-          if (error) return error
-        }
-        return null
-      },
+    const iterateObjectProps = (
+      obj: any,
+      checkEntry: (entryIndex: number) => TypeCheckError | null
+    ): TypeCheckError | null => {
+      const entries = checkedSchemaEntries()
+      // MobX 4 does not track reads of absent properties. Newer versions can
+      // avoid the extra key-set read.
+      if (needsObservableObjectKeyTracking && isObservableObject(obj)) {
+        void keys(obj)
+      }
+
+      for (let i = 0; i < entries.length; i++) {
+        const error = checkEntry(i)
+        if (error) return error
+      }
+      return null
+    }
+
+    const checkObjectProps = createIndexedPerEntryCachedCheck(
+      iterateObjectProps,
       (obj, entryIndex, path, typeCheckedValue) => {
         const entry = checkedSchemaEntries()[entryIndex]
         if (!entry) {
@@ -189,13 +206,21 @@ function typesObjectHelper<S>(objFn: S, frozen: boolean, typeInfoGen: TypeInfoGe
         return thisTc
       },
 
-      (obj: Record<string, unknown>) => {
-        return applySnapshotProcessor(obj, "from")
-      },
-
-      (obj: Record<string, unknown>) => {
-        return applySnapshotProcessor(obj, "to")
-      }
+      snapshotProcessorPlan(
+        () => schemaEntries.map((entry) => entry.getResolvedChecker()),
+        (processors) =>
+          processors.some(Boolean)
+            ? (obj: Record<string, unknown>) => applySnapshotProcessor(obj, processors)
+            : undefined
+      ),
+
+      snapshotProcessorPlan(
+        () => schemaEntries.map((entry) => entry.getResolvedChecker()),
+        (processors) =>
+          processors.some(Boolean)
+            ? (obj: Record<string, unknown>) => applySnapshotProcessor(obj, processors)
+            : undefined
+      )
     )
 
     return thisTc
@@ -223,6 +248,9 @@ export function typesObject<T>(objectFunction: T): T {
   // we can't type this function or else we won't be able to make it work recursively
   const typeInfoGen: TypeInfoGen = (t) => new ObjectTypeInfo(t, objectFunction as any)
 
+  // The schema callback cannot be evaluated here because it may reference the
+  // object type recursively. Keep the unresolved capability conservative; the
+  // concrete checker still omits processors when every schema entry is identity-only.
   return typesObjectHelper(objectFunction, false, typeInfoGen) as any
 }
 
@@ -281,12 +309,13 @@ export class ObjectTypeInfo extends TypeInfo {
  * @returns
  */
 export function typesFrozen<T extends AnyType>(dataType: T): ModelType<Frozen<TypeToData<T>>> {
+  const resolvedDataType = resolveStandardType(dataType)
   return typesObjectHelper(
     () => ({
-      data: dataType,
+      data: resolvedDataType,
     }),
     true,
-    (t) => new FrozenTypeInfo(t, resolveStandardType(dataType))
+    (t) => new FrozenTypeInfo(t, resolvedDataType)
   ) as any
 }
 

package/src/types/objectBased/typesObjectMap.ts

@@ -9,6 +9,7 @@ import type { AnyStandardType, AnyType, ModelType, TypeToData } from "../schemas
 import { TypeCheckError } from "../TypeCheckError"
 import {
   lateTypeChecker,
+  snapshotProcessorPlan,
   TypeChecker,
   TypeCheckerBaseType,
   TypeInfo,
@@ -33,13 +34,13 @@ import { typesRecord } from "./typesRecord"
 export function typesObjectMap<T extends AnyType>(
   valueType: T
 ): ModelType<ObjectMap<TypeToData<T>>> {
-  const typeInfoGen: TypeInfoGen = (t) => new ObjectMapTypeInfo(t, resolveStandardType(valueType))
-
+  const resolvedValueType = resolveStandardType(valueType)
+  const typeInfoGen: TypeInfoGen = (t) => new ObjectMapTypeInfo(t, resolvedValueType)
   return lateTypeChecker(() => {
     const modelInfo = modelInfoByClass.get(ObjectMap)!
 
-    const valueChecker = resolveTypeChecker(valueType)
-    const valueSupport = resolveCodecSupport(valueType)
+    const valueChecker = resolveTypeChecker(resolvedValueType)
+    const valueSupport = resolveCodecSupport(resolvedValueType)
     const storedValueChecker = resolveTypeChecker(valueSupport.storedType)
 
     const getTypeName = (...recursiveTypeCheckers: TypeChecker[]) =>
@@ -82,42 +83,52 @@ export function typesObjectMap<T extends AnyType>(
         return resolvedDataTypeChecker.snapshotType(obj) ? thisTc : null
       },
 
-      (sn: { items: Record<string, unknown> }) => {
-        const newItems: (typeof sn)["items"] = {}
-
-        withErrorPathSegment("items", () => {
-          for (const k of Object.keys(sn.items)) {
-            newItems[k] = withErrorPathSegment(k, () =>
-              storedValueChecker.fromSnapshotProcessor(sn.items[k])
-            )
-          }
-        })
-
-        return {
-          ...sn,
-          [modelTypeKey]: modelInfo.name,
-          items: newItems,
-        }
-      },
-
-      (sn: { items: Record<string, unknown>; [modelTypeKey]?: string }) => {
-        const newItems: (typeof sn)["items"] = {}
-
-        withErrorPathSegment("items", () => {
-          for (const k of Object.keys(sn.items)) {
-            newItems[k] = withErrorPathSegment(k, () =>
-              storedValueChecker.toSnapshotProcessor(sn.items[k])
-            )
-          }
-        })
-
-        const snCopy = {
-          ...sn,
-          items: newItems,
-        }
-
-        return snCopy
-      }
+      snapshotProcessorPlan(
+        () => [storedValueChecker],
+        ([itemProcessor]) =>
+          (sn: { items: Record<string, unknown> }) => {
+            let items = sn.items
+
+            if (itemProcessor) {
+              items = {}
+              withErrorPathSegment("items", () => {
+                for (const k of Object.keys(sn.items)) {
+                  items[k] = withErrorPathSegment(k, () => itemProcessor(sn.items[k]))
+                }
+              })
+            }
+
+            return {
+              ...sn,
+              [modelTypeKey]: modelInfo.name,
+              items,
+            }
+          },
+        true
+      ),
+
+      snapshotProcessorPlan(
+        () => [storedValueChecker],
+        ([itemProcessor]) =>
+          itemProcessor
+            ? (sn: { items: Record<string, unknown>; [modelTypeKey]?: string }) => {
+                const newItems: (typeof sn)["items"] = {}
+
+                withErrorPathSegment("items", () => {
+                  for (const k of Object.keys(sn.items)) {
+                    newItems[k] = withErrorPathSegment(k, () => itemProcessor(sn.items[k]))
+                  }
+                })
+
+                const snCopy = {
+                  ...sn,
+                  items: newItems,
+                }
+
+                return snCopy
+              }
+            : undefined
+      )
     )
 
     return thisTc