mobx-keystone 2.0.0 → 2.2.0

package/src/tweaker/tweak.ts

@@ -1,15 +1,28 @@
-import { action } from "mobx"
+import { action, isObservableArray, isObservableObject } from "mobx"
 import { isDataModel } from "../dataModel/utils"
+import { Frozen } from "../frozen/Frozen"
 import { isModelAutoTypeCheckingEnabled } from "../globalConfig/globalConfig"
+import { getModelMetadata } from "../model/getModelMetadata"
+import { isModel } from "../model/utils"
 import { getObjectChildren } from "../parent/coreObjectChildren"
 import { fastGetParent, type ParentPath } from "../parent/path"
 import { setParent } from "../parent/setParent"
+import { fastIsRootStoreNoAtom } from "../rootStore/rootStore"
 import { unsetInternalSnapshot } from "../snapshot/internal"
 import type { AnyStandardType, TypeToData } from "../types/schemas"
 import { typeCheck } from "../types/typeCheck"
-import { failure, inDevMode, isMap, isObject, isPrimitive, isSet } from "../utils"
+import {
+  failure,
+  inDevMode,
+  isArray,
+  isMap,
+  isObject,
+  isPlainObject,
+  isPrimitive,
+  isSet,
+} from "../utils"
 import { getSafeErrorValuePreview } from "../utils/errorDiagnostics"
-import { isTweakedObject, runTweakedObjectUntweakers } from "./core"
+import { deactivateHandlers, isTweakedObject } from "./core"
 import { registerDefaultTweakers } from "./registerDefaultTweakers"
 import { treeNodeMetadata } from "./treeNodeMetadata"
 
@@ -100,9 +113,7 @@ function internalTweak<T>(value: T, parentPath: ParentPath<any> | undefined): T
 
   // unsupported (must go before plain object tweaker)
   if (isDataModel(value)) {
-    throw failure(
-      "data models are not directly supported. you may insert the data in the tree instead ('$' property)."
-    )
+    throw dataModelsNotSupportedError()
   }
 
   registerDefaultTweakers()
@@ -116,17 +127,23 @@ function internalTweak<T>(value: T, parentPath: ParentPath<any> | undefined): T
     }
   }
 
-  // unsupported
+  throw unsupportedValueError(value)
+}
+
+function dataModelsNotSupportedError() {
+  return failure(
+    "data models are not directly supported. you may insert the data in the tree instead ('$' property)."
+  )
+}
+
+function unsupportedValueError(value: unknown) {
   if (isMap(value)) {
-    throw failure("maps are not directly supported. consider using 'ObjectMap' / 'asMap' instead.")
+    return failure("maps are not directly supported. consider using 'ObjectMap' / 'asMap' instead.")
   }
-
-  // unsupported
   if (isSet(value)) {
-    throw failure("sets are not directly supported. consider using 'ArraySet' / 'asSet' instead.")
+    return failure("sets are not directly supported. consider using 'ArraySet' / 'asSet' instead.")
   }
-
-  throw failure(
+  return failure(
     `tweak can only work over models, observable objects/arrays, or primitives, but got ${getSafeErrorValuePreview(value)} instead`
   )
 }
@@ -141,6 +158,154 @@ export function tweak<T>(value: T, parentPath: ParentPath<any> | undefined): T {
   return isPrimitive(value) ? value : tweakNonPrimitive(value, parentPath)
 }
 
+/**
+ * Tells whether a node that has a parent gets detached by the change being
+ * intercepted before the new values are attached.
+ * @internal
+ */
+export type IsDetachedByChange = (node: object, parentPath: ParentPath<any>) => boolean
+
+// nodes to be attached by the change being checked, since a node cannot be
+// attached twice
+const seenNodes = new Set<object>()
+
+/**
+ * Throws the error `tweak` or `setParent` would throw when attaching `values`
+ * (and whatever they contain) after the change being intercepted detaches its
+ * values, without changing anything. Interceptors call it before detaching, so
+ * a rejected change leaves the tree as it was.
+ * `prepareValue`, when given, replaces each value before it is checked.
+ * @internal
+ */
+export function assertCanAttach(
+  values: unknown[],
+  isDetachedByChange: IsDetachedByChange,
+  prepareValue?: (value: unknown) => unknown
+): void {
+  try {
+    for (let i = 0; i < values.length; i++) {
+      if (prepareValue) {
+        values[i] = prepareValue(values[i])
+      }
+      checkAttach(values[i], isDetachedByChange)
+    }
+  } finally {
+    seenNodes.clear()
+  }
+}
+
+/**
+ * `assertCanAttach` for a single value.
+ * @internal
+ */
+export function assertCanAttachValue(value: unknown, isDetachedByChange: IsDetachedByChange): void {
+  if (isPrimitive(value)) {
+    return
+  }
+  try {
+    checkAttach(value, isDetachedByChange)
+  } finally {
+    seenNodes.clear()
+  }
+}
+
+function checkAttach(value: unknown, isDetachedByChange: IsDetachedByChange): void {
+  if (isPrimitive(value)) {
+    return
+  }
+
+  // (one metadata lookup instead of one per helper)
+  const metadata = treeNodeMetadata.get(value)
+  if (metadata?.tweaked) {
+    if (metadata.dataObjectParent !== undefined) {
+      throw failure("value must be the model object instance instead of the '$' sub-object")
+    }
+    if (fastIsRootStoreNoAtom(value)) {
+      throw failure("root stores cannot be attached to any parents")
+    }
+    if (isModel(value) && getModelMetadata(value).valueType) {
+      // setParent clones it when it has a parent
+      return
+    }
+    const parentPath = metadata.parentPath
+    if (
+      parentPath &&
+      !isDetachedByChange(value, parentPath) &&
+      !isUntweakedByChange(parentPath.parent, isDetachedByChange)
+    ) {
+      throw failure("an object cannot be assigned a new parent when it already has one")
+    }
+    assertNotSeen(value)
+    return
+  }
+
+  // the values internalTweak accepts, most common first
+  if (isPlainObject(value)) {
+    if (isObservableObject(value)) {
+      // (it becomes the tree node itself)
+      assertNotSeen(value)
+    }
+    checkAttachProps(value, isDetachedByChange)
+    return
+  }
+  if (isArray(value)) {
+    if (isObservableArray(value)) {
+      assertNotSeen(value)
+    }
+    for (let i = 0; i < value.length; i++) {
+      checkAttach(value[i], isDetachedByChange)
+    }
+    return
+  }
+  // (data models, frozen values and models can be observable objects too)
+  if (isDataModel(value)) {
+    throw dataModelsNotSupportedError()
+  }
+  if (value instanceof Frozen || isModel(value)) {
+    return
+  }
+  if (isObservableObject(value)) {
+    assertNotSeen(value)
+    checkAttachProps(value as Record<string, unknown>, isDetachedByChange)
+    return
+  }
+  throw unsupportedValueError(value)
+}
+
+function checkAttachProps(obj: Record<string, unknown>, isDetachedByChange: IsDetachedByChange) {
+  const keys = Object.keys(obj)
+  for (let i = 0; i < keys.length; i++) {
+    checkAttach(obj[keys[i]], isDetachedByChange)
+  }
+}
+
+function assertNotSeen(value: object) {
+  if (seenNodes.has(value)) {
+    throw failure("an object cannot be assigned a new parent when it already has one")
+  }
+  seenNodes.add(value)
+}
+
+/**
+ * Detaching a plain object or array untweaks it, which detaches its children.
+ */
+function isUntweakedByChange(node: object, isDetachedByChange: IsDetachedByChange): boolean {
+  for (;;) {
+    const metadata = treeNodeMetadata.get(node)
+    if (!metadata?.handlersActive) {
+      return false
+    }
+    const parentPath = metadata.parentPath
+    if (!parentPath) {
+      return false
+    }
+    if (isDetachedByChange(node, parentPath)) {
+      return true
+    }
+    node = parentPath.parent
+  }
+}
+
 /**
  * @internal
  */
@@ -156,8 +321,7 @@ export function tryUntweak(value: any): (() => void) | undefined {
   }
 
   const metadata = treeNodeMetadata.get(value)
-  const untweaker = metadata?.untweaker
-  if (!untweaker) {
+  if (!metadata?.handlersActive) {
     return undefined
   }
 
@@ -177,14 +341,13 @@ export function tryUntweak(value: any): (() => void) | undefined {
   }
 
   return () => {
-    // post-untweaking, call the untweaker
-    runTweakedObjectUntweakers(untweaker)
+    // post-untweaking
+    deactivateHandlers(value, metadata)
 
     // Match the former independent-map ordering: the node stops being tweaked
     // before its snapshot is unset, but the shared record must stay alive until
     // snapshot cleanup has consumed it.
     metadata.tweaked = false
-    metadata.untweaker = undefined
     unsetInternalSnapshot(value)
     // These associations previously lived in independent WeakMaps and remain
     // valid across untweak/retweak, so keep their shared record when present.

package/src/tweaker/tweakArray.ts

@@ -11,7 +11,10 @@ import {
 import { assertCanWrite } from "../action/protection"
 import { emitArraySpliceDeepChange, emitArrayUpdateDeepChange } from "../deepChange/onDeepChange"
 import { getGlobalConfig } from "../globalConfig"
-import type { ParentPath } from "../parent/path"
+import { getModelMetadata } from "../model/getModelMetadata"
+import { isModel } from "../model/utils"
+import { getArrayPaths, setLazyArrayParentPath } from "../parent/arrayPaths"
+import { fastGetParentPath, type ParentPath } from "../parent/path"
 import { reindexArrayChildren, setParent } from "../parent/setParent"
 import {
   beginPatchEmission,
@@ -21,6 +24,7 @@ import {
   InternalPatchRecorder,
 } from "../patch/emitPatch"
 import type { Patch } from "../patch/Patch"
+import { clone } from "../snapshot/clone"
 import {
   flushInternalSnapshot,
   freezeInternalSnapshot,
@@ -29,20 +33,20 @@ import {
   updateInternalSnapshot,
 } from "../snapshot/internal"
 import { failure, inDevMode, isArray, isPrimitive } from "../utils"
-import {
-  addDelayedError,
-  type DelayedError,
-  throwDelayedError,
-} from "../utils/forEachWithDelayedThrow"
-import { runningWithoutSnapshotOrPatches, setTweakedObjectUntweakers } from "./core"
+import { addDelayedError, type DelayedError } from "../utils/forEachWithDelayedThrow"
+import { recordChangeForRollback, throwDelayedListenerError } from "./changeRollback"
+import { activateHandlers, areHandlersActive, runningWithoutSnapshotOrPatches } from "./core"
 import { TweakerPriority } from "./TweakerPriority"
 import { markAsTweakedObject } from "./treeNodeMetadata"
-import { registerTweaker, tweak } from "./tweak"
 import {
-  isTypeCheckingAfterChangeEnabled,
-  recordTypeCheckingBatchChange,
-  runTypeCheckingAfterChange,
-} from "./typeChecking"
+  assertCanAttach,
+  assertCanAttachValue,
+  type IsDetachedByChange,
+  registerTweaker,
+  tweak,
+} from "./tweak"
+import { notifyTweakedChangeListeners } from "./tweakedChangeListeners"
+import { isTypeCheckingAfterChangeEnabled, runTypeCheckingAfterChange } from "./typeChecking"
 
 /**
  * @internal
@@ -139,27 +143,31 @@ export function tweakArray<T extends any[]>(
   }
   setNewInternalSnapshot(tweakedArr, untransformedSn, undefined)
 
-  const interceptDisposer = intercept(
-    tweakedArr,
-    interceptArrayMutation.bind(undefined, tweakedArr)
-  )
-  const observeDisposer = observe(tweakedArr, arrayDidChange)
-  setTweakedObjectUntweakers(tweakedArr, interceptDisposer, observeDisposer)
+  if (activateHandlers(tweakedArr)) {
+    intercept(tweakedArr, interceptArrayMutation.bind(undefined, tweakedArr))
+    observe(tweakedArr, arrayDidChange)
+  }
 
   return tweakedArr as any
 }
 
-function mutateSet(k: number, v: unknown, sn: unknown[]) {
+function mutateSet(k: number, v: unknown, sn: unknown[]): readonly unknown[] {
   sn[k] = v
+  return [v]
 }
 
 // Conservative bound below every engine's argument-count limit for spread calls.
 const maxSpreadableItems = 8192
 
-function mutateSplice(index: number, removedCount: number, addedItems: any[], sn: any[]) {
+function mutateSplice(
+  index: number,
+  removedCount: number,
+  addedItems: any[],
+  sn: any[]
+): readonly unknown[] {
   if (addedItems.length < maxSpreadableItems) {
     sn.splice(index, removedCount, ...addedItems)
-    return
+    return addedItems
   }
 
   // Splice the tail in a single pass instead of spreading the added items as
@@ -170,11 +178,18 @@ function mutateSplice(index: number, removedCount: number, addedItems: any[], sn
   sn.copyWithin(index + addedItems.length, index + removedCount, oldLength)
   for (let i = 0; i < addedItems.length; i++) sn[index + i] = addedItems[i]
   sn.length = newLength
+  return addedItems
 }
 
 const patchRecorder = new InternalPatchRecorder()
 
 function arrayDidChange(change: IArrayDidChange) {
+  if (!areHandlersActive(change.object)) {
+    // idle handler of an untweaked array
+    return
+  }
+  notifyTweakedChangeListeners(change)
+
   const arr = change.object
 
   patchRecorder.reset()
@@ -183,13 +198,11 @@ function arrayDidChange(change: IArrayDidChange) {
     return
   }
 
-  recordTypeCheckingBatchChange(change)
-
   const oldSnapshot = getInternalSnapshot(arr as Array<unknown>)!.untransformed
   const shouldEmitPatches = hasPatchListenersFor(arr)
   const shouldBuildInversePatches = shouldEmitPatches || isTypeCheckingAfterChangeEnabled()
 
-  let mutate: ((sn: any[]) => void) | undefined
+  let mutate: ((sn: any[]) => readonly unknown[]) | undefined
   switch (change.type) {
     case "splice":
       mutate = arrayDidChangeSplice(
@@ -212,6 +225,8 @@ function arrayDidChange(change: IArrayDidChange) {
   }
 
   runTypeCheckingAfterChange(arr, patchRecorder)
+  // (after type checking, which undoes a rejected change, but before listeners)
+  recordChangeForRollback(change)
   if (mutate) {
     updateInternalSnapshot(arr, mutate)
   }
@@ -260,7 +275,7 @@ function arrayDidChange(change: IArrayDidChange) {
   } catch (error) {
     delayedError = addDelayedError(delayedError, error)
   }
-  throwDelayedError(delayedError)
+  throwDelayedListenerError(delayedError)
 }
 
 const undefinedInsideArrayErrorMsg =
@@ -274,7 +289,6 @@ function arrayDidChangeUpdate(
 ) {
   const k = change.index
   const val = change.newValue
-  const oldVal = oldSnapshot[k]
   let newVal: any
   if (isPrimitive(val)) {
     newVal = val
@@ -284,15 +298,14 @@ function arrayDidChangeUpdate(
   }
   const mutate = mutateSet.bind(undefined, k, newVal)
 
-  if (shouldEmitPatches || shouldBuildInversePatches) {
+  if (shouldBuildInversePatches) {
     const path = [k]
     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(oldSnapshot[k]) },
+    ])
   }
   return mutate
 }
@@ -320,17 +333,16 @@ function arrayDidChangeSplice(
 
   const mutate = mutateSplice.bind(undefined, index, removedCount, addedItems)
 
-  // With neither patch listeners nor type checking, there is no inverse-patch
-  // data to build. The snapshot mutation above is all the post-change work we
-  // need to retain.
-  if (!shouldEmitPatches && !shouldBuildInversePatches) {
+  // With neither patch listeners nor type checking, there is no patch data to
+  // build. The snapshot mutation above is all the post-change work we need.
+  if (!shouldBuildInversePatches) {
     return mutate
   }
 
   const oldLen = oldSnapshot.length
 
   const patches: Patch[] | undefined = shouldEmitPatches ? [] : undefined
-  const invPatches: Patch[] | undefined = shouldBuildInversePatches ? [] : undefined
+  const invPatches: Patch[] = []
 
   // optimization: if we add as many as we remove then remove/readd instead
 
@@ -342,13 +354,13 @@ function arrayDidChangeSplice(
 
   if (addedCount === removedCount) {
     const readdPatches: Patch[] | undefined = shouldEmitPatches ? [] : undefined
-    const readdInvPatches: Patch[] | undefined = shouldBuildInversePatches ? [] : undefined
+    const readdInvPatches: Patch[] = []
     let removed = 0
 
     for (let i = 0; i < addedCount; i++) {
       const realIndex = index + i
 
-      const newVal = getValueAfterSplice(oldSnapshot, realIndex, index, removedCount, addedItems)
+      const newVal = addedItems[i]
       const oldVal = oldSnapshot[realIndex]
 
       if (newVal !== oldVal) {
@@ -357,7 +369,7 @@ function arrayDidChangeSplice(
           op: "remove",
           path: removePath,
         })
-        invPatches?.push({
+        invPatches.push({
           op: "remove",
           path: removePath,
         })
@@ -371,7 +383,7 @@ function arrayDidChangeSplice(
           value: freezeInternalSnapshot(newVal),
         })
 
-        readdInvPatches?.push({
+        readdInvPatches.push({
           op: "add",
           path: readdPath,
           value: freezeInternalSnapshot(oldVal),
@@ -379,17 +391,13 @@ function arrayDidChangeSplice(
       }
     }
 
-    if (patches && readdPatches && readdPatches.length > 0) {
+    if (patches && readdPatches) {
       for (const patch of readdPatches) patches.push(patch)
     }
-    if (invPatches && readdInvPatches && readdInvPatches.length > 0) {
-      for (const patch of readdInvPatches) invPatches.push(patch)
-    }
+    for (const patch of readdInvPatches) invPatches.push(patch)
     // We need to reverse once since inverse patches are applied in reverse.
     // Repeated unshift calls here would make a large splice quadratic.
-    if (invPatches && invPatches.length > 0) {
-      invPatches.reverse()
-    }
+    invPatches.reverse()
   } else {
     const interimLen = oldLen - removedCount
 
@@ -418,7 +426,7 @@ function arrayDidChangeSplice(
         }
 
         // add 0, 1, 2... since inverse patches are applied in reverse
-        invPatches?.push({
+        invPatches.push({
           op: "add",
           path,
           value: freezeInternalSnapshot(oldSnapshot[realIndex]),
@@ -431,7 +439,7 @@ function arrayDidChangeSplice(
       // optimization, for inverse patches, when adding from the end set the length to restore instead
       const restoreUsingSetLength = index >= interimLen
       if (restoreUsingSetLength) {
-        invPatches?.push({
+        invPatches.push({
           op: "replace",
           path: ["length"],
           value: interimLen,
@@ -446,14 +454,12 @@ function arrayDidChangeSplice(
         patches?.push({
           op: "add",
           path,
-          value: freezeInternalSnapshot(
-            getValueAfterSplice(oldSnapshot, realIndex, index, removedCount, addedItems)
-          ),
+          value: freezeInternalSnapshot(addedItems[i]),
         })
 
         // remove ...2, 1, 0 since inverse patches are applied in reverse
         if (!restoreUsingSetLength) {
-          invPatches?.push({
+          invPatches.push({
             op: "remove",
             path,
           })
@@ -462,9 +468,7 @@ function arrayDidChangeSplice(
     }
   }
 
-  if (patches || invPatches) {
-    patchRecorder.record(patches, invPatches)
-  }
+  patchRecorder.record(patches, invPatches)
   return mutate
 }
 
@@ -473,6 +477,10 @@ function interceptArrayMutation(
   array: IObservableArray,
   change: IArrayWillChange | IArrayWillSplice
 ) {
+  if (!areHandlersActive(array)) {
+    // idle handler of an untweaked array
+    return change
+  }
   assertCanWrite()
 
   switch (change.type) {
@@ -509,9 +517,18 @@ function validateArrayMutationUpdate(change: IArrayWillChange) {
 function interceptArrayMutationUpdate(change: IArrayWillChange, array: IObservableArray) {
   // TODO: should be change.object, but mobx is bugged and doesn't send the proxy
   const oldVal = array[change.index]
+  if (change.newValue === oldVal) {
+    return
+  }
+  assertCanAttachValue(change.newValue, (node) => node === oldVal)
   tweak(oldVal, undefined) // set old prop obj parent to undefined
 
-  change.newValue = tweak(change.newValue, { parent: array, path: change.index })
+  const paths = getArrayPaths(array, 0)
+  const entry = paths?.set(change.index, change.newValue)
+  change.newValue = tweak(change.newValue, entry ?? { parent: array, path: change.index })
+  if (entry) {
+    setLazyArrayParentPath(entry, change.newValue)
+  }
 }
 
 function validateArrayMutationSplice(change: IArrayWillSplice) {
@@ -526,12 +543,65 @@ function validateArrayMutationSplice(change: IArrayWillSplice) {
   }
 }
 
+/**
+ * Checks the added items can be attached before the splice detaches anything,
+ * so a rejected splice leaves every item as it was. Value types that are added
+ * to the array at the index they already have get cloned here, since
+ * `setParent` cannot tell they are being added again (it clones them when they
+ * are added anywhere else).
+ */
+function checkAddedItems(change: IArrayWillSplice) {
+  const array = change.object
+  const added = change.added
+  const removedEnd = change.index + change.removedCount
+  const isDetachedByChange: IsDetachedByChange = (_node, parentPath) =>
+    parentPath.parent === array &&
+    (parentPath.path as number) >= change.index &&
+    (parentPath.path as number) < removedEnd
+
+  assertCanAttach(added, isDetachedByChange, (value) => {
+    if (!isPrimitive(value) && isModel(value) && getModelMetadata(value).valueType) {
+      const parentPath = fastGetParentPath(value, false)
+      if (parentPath?.parent === array && !isDetachedByChange(value, parentPath)) {
+        return clone(value, { generateNewIds: true })
+      }
+    }
+    return value
+  })
+}
+
 function interceptArrayMutationSplice(change: IArrayWillSplice) {
+  checkAddedItems(change)
+
+  const array = change.object
+  const oldNextIndex = change.index + change.removedCount
+  const paths =
+    change.removedCount !== change.added.length
+      ? getArrayPaths(array, array.length - oldNextIndex)
+      : getArrayPaths(array, 0)
+
   for (let i = 0; i < change.removedCount; i++) {
     const removedValue = change.object[change.index + i]
     tweak(removedValue, undefined)
   }
 
+  if (paths) {
+    const addedPaths = paths.createPaths(change.index, change.added)
+    for (let i = 0; i < change.added.length; i++) {
+      const addedPath = addedPaths[i]
+      change.added[i] = tweak(
+        change.added[i],
+        addedPath ?? { parent: array, path: change.index + i }
+      )
+      if (addedPath) {
+        setLazyArrayParentPath(addedPath, change.added[i])
+      }
+    }
+    // no reindexing: the items after the splice follow their chunks
+    paths.applySplice(change.index, change.removedCount, addedPaths)
+    return
+  }
+
   for (let i = 0; i < change.added.length; i++) {
     change.added[i] = tweak(change.added[i], {
       parent: change.object,
@@ -540,7 +610,6 @@ function interceptArrayMutationSplice(change: IArrayWillSplice) {
   }
 
   // we might also need to update the parent of the next indexes
-  const oldNextIndex = change.index + change.removedCount
   const newNextIndex = change.index + change.added.length
 
   if (oldNextIndex !== newNextIndex && oldNextIndex < change.object.length) {
@@ -596,22 +665,3 @@ class ObservableArrayReplacementQueue {
     }
   }
 }
-
-function getValueAfterSplice<T>(
-  array: readonly T[],
-  i: number,
-  index: number,
-  remove: number,
-  addedItems: readonly T[]
-) {
-  const base = i - index
-  if (base < 0) {
-    return array[i]
-  }
-
-  if (base < addedItems.length) {
-    return addedItems[base]
-  }
-
-  return array[i - addedItems.length + remove]
-}