mobx-keystone 1.25.0 → 2.1.0

package/src/tweaker/typeChecking.ts

@@ -7,6 +7,7 @@ import { fastGetParent } from "../parent/path"
 import { internalApplyPatches } from "../patch/applyPatches"
 import type { InternalPatchRecorder } from "../patch/emitPatch"
 import { internalApplySnapshot } from "../snapshot/applySnapshot"
+import { deferModelTypeCheckToBatch } from "./changeRollback"
 import { runWithoutSnapshotOrPatches } from "./core"
 import { isTypeCheckingAllowed } from "./withoutTypeChecking"
 
@@ -34,14 +35,15 @@ function isModelWithTypeChecker(obj: object): obj is AnyModel {
  * @internal
  *
  * Walks up parent chain from `obj`, calling `callback` for each typed model
- * ancestor (nearest-first / bottom-up). Stops early if the callback throws.
+ * including the target itself (nearest-first / bottom-up). Stops if the callback throws.
  */
-function forEachTypedModelAncestor(obj: object, callback: (model: AnyModel) => void): void {
+export function forEachTypedModelAncestor(obj: object, callback: (model: AnyModel) => void): void {
   // obj might be a $ data object, so resolve to the model if applicable
   const start = dataToModelNode(obj)
 
-  // If we started from a $ data object, check the model itself
-  if (start !== obj && isModelWithTypeChecker(start)) {
+  // Both model-data mutations and whole-model reconciliation must validate
+  // the model itself before checking its ancestors.
+  if (isModelWithTypeChecker(start)) {
     callback(start)
   }
 
@@ -76,20 +78,19 @@ export function runTypeCheckingAfterChange(
     forEachTypedModelAncestor(obj, (model) => {
       const err = model.typeCheck()
       if (err) {
-        // quietly apply inverse patches (do not generate patches, snapshots, actions, etc)
-        // The re-entrancy guard prevents auto type checking during rollback:
-        // rollback mutations trigger observe callbacks which call this function,
-        // and with "all" scope those re-entrant checks could see partially-restored
-        // intermediate state and attempt another rollback, causing infinite recursion.
+        // A rejected individual mutation has not updated its snapshot yet,
+        // so inverse patches must stay quiet. Snapshot reconciliation has
+        // already published changes: its rollback must update snapshots and
+        // emit compensating patches as well.
         isRollingBackTypeCheckFailure = true
         try {
-          runWithoutSnapshotOrPatches(() => {
-            if (patchRecorder) {
+          if (patchRecorder) {
+            runWithoutSnapshotOrPatches(() => {
               internalApplyPatches.call(obj, patchRecorder.invPatches, true)
-            } else if (snapshotBeforeChanges) {
-              internalApplySnapshot.call(obj, snapshotBeforeChanges)
-            }
-          })
+            })
+          } else if (snapshotBeforeChanges) {
+            internalApplySnapshot.call(obj, snapshotBeforeChanges)
+          }
         } finally {
           isRollingBackTypeCheckFailure = false
         }
@@ -98,3 +99,12 @@ export function runTypeCheckingAfterChange(
     })
   }
 }
+
+/** @internal Called only when automatic type checking is enabled. */
+export function typeCheckAfterCreation(model: AnyModel): void {
+  // a change batch validates it once it completes
+  if (!deferModelTypeCheckToBatch(model)) {
+    const error = model.typeCheck()
+    if (error) error.throw()
+  }
+}

package/src/types/TypeCheckError.ts

@@ -1,4 +1,5 @@
-import { fastGetRootPath } from "../parent/path"
+import { dataToModelNode } from "../parent/core"
+import { fastGetParent, fastGetRootPath } from "../parent/path"
 import type { Path } from "../parent/pathTypes"
 import { getSnapshot } from "../snapshot/getSnapshot"
 import { isTweakedObject } from "../tweaker/core"
@@ -10,6 +11,7 @@ import {
 } from "../utils/errorDiagnostics"
 
 export interface TypeCheckErrorData {
+  /** Path relative to the value being type checked. */
   path: Path
   expectedTypeName: string
   actualValue: any
@@ -71,8 +73,15 @@ export class TypeCheckError {
    */
   throw(): never {
     const diagnosticsPath = getErrorPathSnapshot()
+    const hasTreeParent =
+      isTweakedObject(this.typeCheckedValue, true) &&
+      fastGetParent(dataToModelNode(this.typeCheckedValue), false) !== undefined
+    // Attached values supply their location through the tree. Context supplies
+    // the location for detached values, such as models being hydrated.
     const path =
-      diagnosticsPath && diagnosticsPath.length > 0 ? [...diagnosticsPath, ...this.path] : this.path
+      diagnosticsPath && diagnosticsPath.length > 0 && !hasTreeParent
+        ? [...diagnosticsPath, ...this.path]
+        : this.path
 
     throw new TypeCheckErrorFailure({
       path,
@@ -146,7 +155,7 @@ function resolveTypeCheckErrorData(data: TypeCheckErrorData): {
   const modelTrail = data.modelTrail ?? getErrorModelTrailSnapshot()
   const fullPath = resolveFullPath(data.path, data.typeCheckedValue)
   const actualValueSnapshot = isTweakedObject(data.actualValue, true)
-    ? getSnapshot(data.actualValue)
+    ? getSnapshot(dataToModelNode(data.actualValue))
     : data.actualValue
 
   return {
@@ -162,22 +171,11 @@ function resolveTypeCheckErrorData(data: TypeCheckErrorData): {
 }
 
 function resolveFullPath(path: Path, typeCheckedValue: any): Path {
-  let rootPath: Path = []
-  if (typeCheckedValue && isTweakedObject(typeCheckedValue, true)) {
-    rootPath = fastGetRootPath(typeCheckedValue, false).path
-  }
-  return rootPath.length > 0 && !pathStartsWith(path, rootPath) ? [...rootPath, ...path] : path
-}
-
-function pathStartsWith(path: Path, prefix: Path): boolean {
-  if (prefix.length > path.length) {
-    return false
-  }
-
-  for (let i = 0; i < prefix.length; i++) {
-    if (path[i] !== prefix[i]) {
-      return false
+  if (isTweakedObject(typeCheckedValue, true)) {
+    const rootPath = fastGetRootPath(dataToModelNode(typeCheckedValue), false).path
+    if (rootPath.length > 0) {
+      return [...rootPath, ...path]
     }
   }
-  return true
+  return path
 }

package/src/types/arrayBased/typesArray.ts

@@ -1,7 +1,7 @@
 import type { Path } from "../../parent/pathTypes"
 import { isArray } from "../../utils"
 import { withErrorPathSegment } from "../../utils/errorDiagnostics"
-import { createWholeContainerCachedCheck } from "../createCachedTypeCheck"
+import { createChunkedArrayCachedCheck } from "../createCachedTypeCheck"
 import { getTypeInfo } from "../getTypeInfo"
 import { resolveStandardType, resolveTypeChecker } from "../resolveTypeChecker"
 import type { AnyStandardType, AnyType, ArrayType } from "../schemas"
@@ -38,18 +38,17 @@ export function typesArray<T extends AnyType>(itemType: T): ArrayType<T[]> {
     const getTypeName = (...recursiveTypeCheckers: TypeChecker[]) =>
       `Array<${itemChecker.getTypeName(...recursiveTypeCheckers, itemChecker)}>`
 
-    // MobX observable arrays invalidate reads at collection granularity. Per-index
-    // computeds would therefore all be invalidated by the same mutation while adding
-    // a computed and cache entry per item.
-    const checkArrayItems = createWholeContainerCachedCheck((array, path, typeCheckedValue) => {
-      for (let index = 0; index < array.length; index++) {
-        const error = itemChecker.check(array[index], emptyChildPath, typeCheckedValue)
-        if (error) {
-          return prependPathElementToTypeCheckError(error, path, index, typeCheckedValue)
+    const checkArrayItems = createChunkedArrayCachedCheck(
+      (items, firstIndex, path, typeCheckedValue) => {
+        for (let i = 0; i < items.length; i++) {
+          const error = itemChecker.check(items[i], emptyChildPath, typeCheckedValue)
+          if (error) {
+            return prependPathElementToTypeCheckError(error, path, firstIndex + i, typeCheckedValue)
+          }
         }
+        return null
       }
-      return null
-    })
+    )
 
     const thisTc: TypeChecker = new TypeChecker(
       TypeCheckerBaseType.Array,