mobx-keystone 2.0.0 → 2.2.0

package/src/tweaker/tweakPlainObject.ts

@@ -13,10 +13,12 @@ import {
   emitObjectUpdateDeepChange,
 } from "../deepChange/onDeepChange"
 import type { AnyModel } from "../model/BaseModel"
+import { getModelIdPropertyName } from "../model/getModelMetadata"
 import { modelTypeKey } from "../model/metadata"
 import type { ModelClass } from "../modelShared/BaseModelShared"
 import { getModelInfoForName, getModelNotRegisteredErrorMessage } from "../modelShared/modelInfo"
 import { dataToModelNode } from "../parent/core"
+import { onModelIdChanged } from "../parent/coreObjectChildren"
 import type { ParentPath } from "../parent/path"
 import { setParent } from "../parent/setParent"
 import {
@@ -36,22 +38,16 @@ import {
 } from "../snapshot/internal"
 import { takeModelInitialDataSnapshot } from "../snapshot/modelInitialData"
 import { withoutCachedTypeChecking } from "../types/createCachedTypeCheck"
-import { failure, isPlainObject, isPrimitive, setProtoProp } from "../utils"
-import {
-  addDelayedError,
-  type DelayedError,
-  throwDelayedError,
-} from "../utils/forEachWithDelayedThrow"
+import { failure, isPlainObject, isPrimitive, nodeObservableOptions, setProtoProp } from "../utils"
+import { addDelayedError, type DelayedError } from "../utils/forEachWithDelayedThrow"
 import { setIfDifferent } from "../utils/setIfDifferent"
-import { runningWithoutSnapshotOrPatches, setTweakedObjectUntweakers } from "./core"
+import { recordChangeForRollback, throwDelayedListenerError } from "./changeRollback"
+import { activateHandlers, runningWithoutSnapshotOrPatches } from "./core"
 import { TweakerPriority } from "./TweakerPriority"
-import { markAsTweakedObject } from "./treeNodeMetadata"
-import { registerTweaker, tweak } from "./tweak"
-import {
-  isTypeCheckingAfterChangeEnabled,
-  recordTypeCheckingBatchChange,
-  runTypeCheckingAfterChange,
-} from "./typeChecking"
+import { markAsTweakedObject, treeNodeMetadata } from "./treeNodeMetadata"
+import { assertCanAttachValue, registerTweaker, tweak } from "./tweak"
+import { notifyTweakedChangeListeners } from "./tweakedChangeListeners"
+import { isTypeCheckingAfterChangeEnabled, runTypeCheckingAfterChange } from "./typeChecking"
 
 /**
  * @internal
@@ -67,7 +63,7 @@ export function tweakPlainObject<T extends Record<string, any>>(
   const originalIsObservableObject = isObservableObject(originalObj)
   const tweakedObj = originalIsObservableObject
     ? originalObj
-    : observable.object({}, undefined, observableOptions)
+    : observable.object({}, undefined, nodeObservableOptions)
 
   // Mark it as tweaked before processing children. The cleanup functions are
   // installed after the MobX handlers have been registered.
@@ -150,38 +146,57 @@ export function tweakPlainObject<T extends Record<string, any>>(
     transformFn
   )
 
-  const interceptDisposer = intercept(tweakedObj, interceptObjectMutation)
-  const observeDisposer = observe(tweakedObj, objectDidChange)
-  setTweakedObjectUntweakers(tweakedObj, interceptDisposer, observeDisposer)
+  if (activateHandlers(tweakedObj)) {
+    intercept(tweakedObj, interceptObjectMutation)
+    observe(tweakedObj, objectDidChange)
+  }
 
   return tweakedObj as any
 }
 
-const observableOptions = {
-  deep: false,
-}
-
-function mutateSet(k: PropertyKey, v: unknown, sn: Record<PropertyKey, unknown>) {
+function mutateSet(
+  k: PropertyKey,
+  v: unknown,
+  sn: Record<PropertyKey, unknown>
+): readonly unknown[] {
   if (k === "__proto__") {
     setProtoProp(sn, v)
   } else {
     sn[k] = v
   }
+  return [v]
 }
 
-function mutateDelete(k: PropertyKey, sn: Record<PropertyKey, unknown>) {
+const noValues: readonly unknown[] = []
+
+function mutateDelete(k: PropertyKey, sn: Record<PropertyKey, unknown>): readonly unknown[] {
   delete sn[k]
+  return noValues
 }
 
 const patchRecorder = new InternalPatchRecorder()
 
 function objectDidChange(change: IObjectDidChange): void {
+  const obj = change.object
+  const metadata = treeNodeMetadata.get(obj)
+  if (!metadata?.handlersActive) {
+    // idle handler of an untweaked object
+    return
+  }
   if (typeof change.name !== "string") {
     throw failure("change.name is not a string")
   }
 
-  const obj = change.object
-  const actualNode = dataToModelNode(obj)
+  notifyTweakedChangeListeners(change)
+
+  const actualNode = metadata.dataObjectParent ?? obj
+
+  if (
+    actualNode !== obj &&
+    change.name === getModelIdPropertyName(actualNode.constructor as ModelClass<AnyModel>)
+  ) {
+    onModelIdChanged(actualNode)
+  }
 
   patchRecorder.reset()
 
@@ -189,13 +204,11 @@ function objectDidChange(change: IObjectDidChange): void {
     return
   }
 
-  recordTypeCheckingBatchChange(change)
-
   const oldUntransformedSn = getInternalSnapshot(actualNode)!.untransformed
   const shouldEmitPatches = hasPatchListenersFor(actualNode)
   const shouldBuildInversePatches = shouldEmitPatches || isTypeCheckingAfterChangeEnabled()
 
-  let mutate: ((sn: any) => void) | undefined
+  let mutate: ((sn: any) => readonly unknown[]) | undefined
   switch (change.type) {
     case "add":
     case "update":
@@ -226,6 +239,8 @@ function objectDidChange(change: IObjectDidChange): void {
   } else {
     runTypeCheckingAfterChange(obj, patchRecorder)
   }
+  // (after type checking, which undoes a rejected change, but before listeners)
+  recordChangeForRollback(change)
   updateInternalSnapshot(actualNode, mutate)
 
   // Listeners may mutate another node and reuse the shared recorder.
@@ -270,7 +285,7 @@ function objectDidChange(change: IObjectDidChange): void {
   } catch (error) {
     delayedError = addDelayedError(delayedError, error)
   }
-  throwDelayedError(delayedError)
+  throwDelayedListenerError(delayedError)
 }
 
 function objectDidChangeRemove(
@@ -280,16 +295,14 @@ function objectDidChangeRemove(
   shouldBuildInversePatches: boolean
 ) {
   const k = change.name
-  const oldVal = oldUntransformedSn[k]
   const mutate = mutateDelete.bind(undefined, k)
 
-  if (shouldEmitPatches || shouldBuildInversePatches) {
+  if (shouldBuildInversePatches) {
     const path = [k as string]
     const patches = shouldEmitPatches ? [{ op: "remove" as const, path }] : undefined
-    const invPatches = shouldBuildInversePatches
-      ? [{ op: "add" as const, path, value: freezeInternalSnapshot(oldVal) }]
-      : undefined
-    patchRecorder.record(patches, invPatches)
+    patchRecorder.record(patches, [
+      { op: "add" as const, path, value: freezeInternalSnapshot(oldUntransformedSn[k]) },
+    ])
   }
   return mutate
 }
@@ -303,8 +316,6 @@ function objectDidChangeAddOrUpdate(
   const k = change.name
   const val = change.newValue
 
-  const oldVal = oldUntransformedSn[k]
-
   let newVal: any
   if (isPrimitive(val)) {
     newVal = val
@@ -315,29 +326,34 @@ function objectDidChangeAddOrUpdate(
 
   const mutate = mutateSet.bind(undefined, k, newVal)
 
-  if (shouldEmitPatches || shouldBuildInversePatches) {
+  if (shouldBuildInversePatches) {
     const path = [k as string]
     if (change.type === "add") {
       const patches = shouldEmitPatches
         ? [{ op: "add" as const, path, value: freezeInternalSnapshot(newVal) }]
         : undefined
-      const invPatches = shouldBuildInversePatches ? [{ op: "remove" as const, path }] : undefined
-      patchRecorder.record(patches, invPatches)
+      patchRecorder.record(patches, [{ op: "remove" as const, path }])
     } else {
       const patches = shouldEmitPatches
         ? [{ op: "replace" as const, path, value: freezeInternalSnapshot(newVal) }]
         : undefined
-      const invPatches = shouldBuildInversePatches
-        ? [{ op: "replace" as const, path, value: freezeInternalSnapshot(oldVal) }]
-        : undefined
-      patchRecorder.record(patches, invPatches)
+      patchRecorder.record(patches, [
+        { op: "replace" as const, path, value: freezeInternalSnapshot(oldUntransformedSn[k]) },
+      ])
     }
   }
 
   return mutate
 }
 
+const noneDetached = () => false
+
 function interceptObjectMutation(change: IObjectWillChange) {
+  const metadata = treeNodeMetadata.get(change.object)
+  if (!metadata?.handlersActive) {
+    // idle handler of an untweaked object
+    return change
+  }
   assertCanWrite()
 
   if (typeof change.name === "symbol") {
@@ -347,10 +363,11 @@ function interceptObjectMutation(change: IObjectWillChange) {
   // This must happen before detach/reparent work below. It keeps the old value
   // available for inverse patches and folds a departing dirty child into its
   // parent snapshot while its parent path still exists.
-  flushInternalSnapshot(dataToModelNode(change.object), false)
+  flushInternalSnapshot(metadata.dataObjectParent ?? change.object, false)
 
   switch (change.type) {
     case "add":
+      assertCanAttachValue(change.newValue, noneDetached)
       change.newValue = tweak(change.newValue, {
         parent: change.object,
         path: String(change.name),
@@ -366,6 +383,8 @@ function interceptObjectMutation(change: IObjectWillChange) {
       const oldVal = change.object[change.name]
       const newVal = change.newValue
       if (newVal !== oldVal) {
+        // (first, so a value that cannot be attached leaves the old one in place)
+        assertCanAttachValue(newVal, (node) => node === oldVal)
         tweak(oldVal, undefined)
 
         change.newValue = tweak(newVal, {

package/src/tweaker/tweakedChangeListeners.ts

@@ -0,0 +1,61 @@
+import type { IArrayDidChange, IObjectDidChange } from "mobx"
+
+type TweakedChange = IArrayDidChange | IObjectDidChange
+
+/**
+ * @internal
+ */
+export interface TweakedChangeListener<C extends TweakedChange> {
+  applyChange(change: C): void
+  /**
+   * Called when the target is tweaked again after being untweaked, since the
+   * changes made in between were not received.
+   */
+  resync(): void
+}
+
+const changeListeners = new WeakMap<object, TweakedChangeListener<any>[]>()
+
+/**
+ * Listens to the changes of a tweaked array or plain object, in order, before
+ * anything else reacts to them (including the type checks after the change).
+ * Unlike `observe`, changes made while reacting to a change (such as a
+ * type-check rollback) are received after it.
+ *
+ * @internal
+ */
+export function addTweakedChangeListener<T extends object>(
+  target: T,
+  listener: TweakedChangeListener<T extends readonly unknown[] ? IArrayDidChange : IObjectDidChange>
+): void {
+  let listeners = changeListeners.get(target)
+  if (!listeners) {
+    listeners = []
+    changeListeners.set(target, listeners)
+  }
+  listeners.push(listener)
+}
+
+/**
+ * @internal
+ */
+export function notifyTweakedChangeListeners(change: TweakedChange): void {
+  const listeners = changeListeners.get(change.object)
+  if (listeners) {
+    for (const listener of listeners) {
+      listener.applyChange(change)
+    }
+  }
+}
+
+/**
+ * @internal
+ */
+export function resyncTweakedChangeListeners(target: object): void {
+  const listeners = changeListeners.get(target)
+  if (listeners) {
+    for (const listener of listeners) {
+      listener.resync()
+    }
+  }
+}

package/src/tweaker/typeChecking.ts

@@ -1,4 +1,3 @@
-import { type IArrayDidChange, type IObjectDidChange, remove, set } from "mobx"
 import { isModelAutoTypeCheckingEnabled } from "../globalConfig/globalConfig"
 import type { AnyModel } from "../model/BaseModel"
 import { getModelMetadata } from "../model/getModelMetadata"
@@ -8,8 +7,9 @@ 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, withoutTypeChecking } from "./withoutTypeChecking"
+import { isTypeCheckingAllowed } from "./withoutTypeChecking"
 
 // Re-entrancy guard: when true, we are inside a type-check rollback.
 // During rollback, observe callbacks still fire, but we skip the auto
@@ -37,7 +37,7 @@ function isModelWithTypeChecker(obj: object): obj is AnyModel {
  * Walks up parent chain from `obj`, calling `callback` for each typed model
  * 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)
 
@@ -100,110 +100,11 @@ export function runTypeCheckingAfterChange(
   }
 }
 
-interface TypeCheckingBatch {
-  models: Set<AnyModel>
-  undo: (() => void)[]
-  recording: boolean
-  /** Last recorded change target, so a run of changes to it walks ancestors once. */
-  previousTarget?: object
-}
-
-let typeCheckingBatch: TypeCheckingBatch | undefined
-
 /** @internal Called only when automatic type checking is enabled. */
 export function typeCheckAfterCreation(model: AnyModel): void {
-  if (typeCheckingBatch?.recording) {
-    typeCheckingBatch.models.add(model)
-  } else {
+  // a change batch validates it once it completes
+  if (!deferModelTypeCheckToBatch(model)) {
     const error = model.typeCheck()
     if (error) error.throw()
   }
 }
-
-/**
- * @internal
- * Capture stored values before any listener can mutate them again. Restoring
- * live values preserves identity and literal data, without snapshot processors
- * or model defaults changing the state being restored.
- */
-export function recordTypeCheckingBatchChange(change: IObjectDidChange | IArrayDidChange): void {
-  const batch = typeCheckingBatch
-  if (!batch?.recording) return
-  if (
-    change.type === "splice" &&
-    change.addedCount === change.removedCount &&
-    change.added.every((value, index) => value === change.removed[index])
-  )
-    return
-
-  const target = change.object
-  if (target !== batch.previousTarget) {
-    forEachTypedModelAncestor(target, (model) => batch.models.add(model))
-    batch.previousTarget = target
-  }
-
-  if (change.type === "splice") {
-    const { object, index, addedCount } = change
-    const removed = change.removed.slice()
-    batch.undo.push(() => object.spliceWithArray(index, addedCount, removed))
-  } else if ("index" in change) {
-    const { object, index, oldValue } = change
-    batch.undo.push(() => {
-      object[index] = oldValue
-    })
-  } else {
-    const { object } = change
-    const key = change.name as string
-    if (change.type === "add") {
-      batch.undo.push(() => remove(object, key))
-    } else {
-      const { oldValue } = change
-      batch.undo.push(() => set(object, key, oldValue))
-    }
-  }
-}
-
-/**
- * @internal
- * Nested calls and synchronous listener edits join the same validation batch.
- * Rollback publishes compensating changes, just like snapshot reconciliation.
- */
-export function withTypeCheckingBatch(fn: () => void): void {
-  if (typeCheckingBatch || !isTypeCheckingAfterChangeEnabled()) {
-    fn()
-    return
-  }
-
-  const batch: TypeCheckingBatch = { models: new Set(), undo: [], recording: true }
-  typeCheckingBatch = batch
-  let validating = false
-  try {
-    withoutTypeChecking(fn)
-    // MobX has now invalidated dependencies, including added/removed keys.
-    validating = true
-    for (const model of batch.models) {
-      const error = model.typeCheck()
-      if (error) error.throw()
-    }
-  } catch (error) {
-    // Only a rejected validation rolls back. Errors thrown by the batch body
-    // itself (an invalid patch, a throwing listener) keep the same partial
-    // application they produce while automatic type checking is disabled.
-    if (validating) {
-      batch.recording = false
-      withoutTypeChecking(() => {
-        for (let i = batch.undo.length - 1; i >= 0; i--) {
-          try {
-            batch.undo[i]()
-          } catch {
-            // Keep restoring after a rollback listener throws. The original
-            // failure takes precedence over errors from compensating changes.
-          }
-        }
-      })
-    }
-    throw error
-  } finally {
-    typeCheckingBatch = undefined
-  }
-}

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,27 @@ 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 processorPlan = snapshotProcessorPlan(
+      () => [itemChecker],
+      ([itemProcessor]) =>
+        itemProcessor
+          ? (sn: unknown[]) => {
+              return sn.map((item, i) => withErrorPathSegment(i, () => itemProcessor(item)))
+            }
+          : undefined
+    )
 
     const thisTc: TypeChecker = new TypeChecker(
       TypeCheckerBaseType.Array,
@@ -90,25 +99,9 @@ export function typesArray<T extends AnyType>(itemType: T): ArrayType<T[]> {
         return thisTc
       },
 
-      snapshotProcessorPlan(
-        () => [itemChecker],
-        ([itemProcessor]) =>
-          itemProcessor
-            ? (sn: unknown[]) => {
-                return sn.map((item, i) => withErrorPathSegment(i, () => itemProcessor(item)))
-              }
-            : undefined
-      ),
-
-      snapshotProcessorPlan(
-        () => [itemChecker],
-        ([itemProcessor]) =>
-          itemProcessor
-            ? (sn: unknown[]) => {
-                return sn.map((item, i) => withErrorPathSegment(i, () => itemProcessor(item)))
-              }
-            : undefined
-      )
+      processorPlan,
+
+      processorPlan
     )
 
     return thisTc

package/src/types/arrayBased/typesTuple.ts

@@ -68,6 +68,19 @@ export function typesTuple<T extends AnyType[]>(...itemTypes: T): ArrayType<T> {
     // computeds cannot isolate tuple-item changes and only add allocation overhead.
     const checkTupleItems = createWholeContainerCachedCheck(checkTupleItemsImperatively)
 
+    const processorPlan = snapshotProcessorPlan(
+      () => checkers,
+      (processors) =>
+        processors.some(Boolean)
+          ? (array: unknown[]) => {
+              return array.map((item, i) => {
+                const processor = processors[i]
+                return processor ? withErrorPathSegment(i, () => processor(item)) : item
+              })
+            }
+          : undefined
+    )
+
     const thisTc: TypeChecker = new TypeChecker(
       TypeCheckerBaseType.Array,
 
@@ -102,31 +115,9 @@ export function typesTuple<T extends AnyType[]>(...itemTypes: T): ArrayType<T> {
         return thisTc
       },
 
-      snapshotProcessorPlan(
-        () => checkers,
-        (processors) =>
-          processors.some(Boolean)
-            ? (array: unknown[]) => {
-                return array.map((item, i) => {
-                  const processor = processors[i]
-                  return processor ? withErrorPathSegment(i, () => processor(item)) : item
-                })
-              }
-            : undefined
-      ),
-
-      snapshotProcessorPlan(
-        () => checkers,
-        (processors) =>
-          processors.some(Boolean)
-            ? (array: unknown[]) => {
-                return array.map((item, i) => {
-                  const processor = processors[i]
-                  return processor ? withErrorPathSegment(i, () => processor(item)) : item
-                })
-              }
-            : undefined
-      )
+      processorPlan,
+
+      processorPlan
     )
 
     return thisTc