mobx-keystone 2.1.0 → 2.3.0

package/src/snapshot/reconcilePlainObjectSnapshot.ts

@@ -48,7 +48,9 @@ function reconcilePlainObjectSnapshot(
       const k = snKeys[i]
       const v = sn[k]
 
-      const oldValue = plainObj[k]
+      // an inherited member such as `toString` is no old value (but `__proto__`
+      // still reads the prototype, which is rejected as it is no tree node)
+      const oldValue = k === "__proto__" || hasOwnProp(plainObj, k) ? plainObj[k] : undefined
       const newValue = withErrorPathSegment(k, () =>
         reconcileSnapshot(oldValue, v, modelPool, plainObj)
       )

package/src/treeUtils/draft.ts

@@ -6,7 +6,7 @@ import { applySnapshot } from "../snapshot/applySnapshot"
 import { fromSnapshot } from "../snapshot/fromSnapshot"
 import { getSnapshot } from "../snapshot/getSnapshot"
 import { assertTweakedObject } from "../tweaker/core"
-import { failure, mobxAction, mobxComputed } from "../utils"
+import { failure, getMobxVersion, makeObservableCompat, mobxAction, mobxComputed } from "../utils"
 import { deepEquals } from "./deepEquals"
 
 /**
@@ -157,6 +157,11 @@ export class Draft<T extends object> {
     assertTweakedObject(original, "original")
 
     this.originalData = original
+
+    if (getMobxVersion() >= 6) {
+      makeObservableCompat(this)
+    }
+
     this.data = fromSnapshot(this.originalSnapshot, { generateNewIds: false })
   }
 }

package/src/treeUtils/sandbox.ts

@@ -233,9 +233,11 @@ export class SandboxManager {
           // see the reverted intermediate state.
           runInAction(() => {
             this.allowWrite(() => {
-              for (let i = events.length - 1; i >= 0; i--) {
-                applyPatches(this.subtreeRootClone, events[i].inversePatches, true)
-              }
+              applyPatches(
+                this.subtreeRootClone,
+                events.map((event) => event.inversePatches),
+                true
+              )
             })
             applyPatches(
               this.subtreeRoot,
@@ -249,10 +251,11 @@ export class SandboxManager {
             const wasRecording = recorder.recording
             recorder.recording = false
             try {
-              let i = recorder.events.length
-              while (i-- > numRecorderEvents) {
-                applyPatches(this.subtreeRootClone, recorder.events[i].inversePatches, true)
-              }
+              applyPatches(
+                this.subtreeRootClone,
+                recorder.events.slice(numRecorderEvents).map((event) => event.inversePatches),
+                true
+              )
               recorder.events.splice(numRecorderEvents)
             } finally {
               recorder.recording = wasRecording

package/src/tweaker/tweakArray.ts

@@ -289,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
@@ -299,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
 }
@@ -335,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
 
@@ -357,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) {
@@ -372,7 +369,7 @@ function arrayDidChangeSplice(
           op: "remove",
           path: removePath,
         })
-        invPatches?.push({
+        invPatches.push({
           op: "remove",
           path: removePath,
         })
@@ -386,7 +383,7 @@ function arrayDidChangeSplice(
           value: freezeInternalSnapshot(newVal),
         })
 
-        readdInvPatches?.push({
+        readdInvPatches.push({
           op: "add",
           path: readdPath,
           value: freezeInternalSnapshot(oldVal),
@@ -394,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
 
@@ -433,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]),
@@ -446,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,
@@ -461,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,
           })
@@ -477,9 +468,7 @@ function arrayDidChangeSplice(
     }
   }
 
-  if (patches || invPatches) {
-    patchRecorder.record(patches, invPatches)
-  }
+  patchRecorder.record(patches, invPatches)
   return mutate
 }
 
@@ -676,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]
-}

package/src/tweaker/tweakPlainObject.ts

@@ -295,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
 }
@@ -318,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
@@ -330,22 +326,20 @@ 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]) },
+      ])
     }
   }
 

package/src/types/SnapshotTypeMismatchError.ts

@@ -14,7 +14,9 @@ export interface SnapshotTypeMismatchErrorData {
 }
 
 /**
- * Thrown when a snapshot value does not match any of the expected types in a union (extends `MobxKeystoneError`).
+ * Thrown when a snapshot value does not match any of the expected types in a union, or when a
+ * model snapshot names a model (`$modelType`) that is not the expected model or a subclass of it
+ * (extends `MobxKeystoneError`).
  *
  * Use `instanceof SnapshotTypeMismatchError` to distinguish snapshot type-mismatch errors
  * from other `MobxKeystoneError` instances.

package/src/types/arrayBased/typesArray.ts

@@ -50,6 +50,16 @@ export function typesArray<T extends AnyType>(itemType: T): ArrayType<T[]> {
       }
     )
 
+    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,
 
@@ -89,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

package/src/types/createCachedTypeCheck.ts

@@ -19,6 +19,7 @@ import {
 } from "../tweaker/tweakedChangeListeners"
 import { getMobxVersion } from "../utils"
 import { ChunkedSequence, ChunkedSet, chunkSize, type SequenceChunk } from "../utils/chunks"
+import { getOrCreate } from "../utils/mapUtils"
 import { TypeCheckError } from "./TypeCheckError"
 
 /**
@@ -79,11 +80,7 @@ function checkUncached(
   typeCheckedValue: any,
   check: () => TypeCheckError | null
 ): TypeCheckError | null {
-  let results = uncachedResults!.get(checker)
-  if (!results) {
-    results = new Map()
-    uncachedResults!.set(checker, results)
-  }
+  const results = getOrCreate(uncachedResults!, checker, () => new Map())
   let error = results.get(value)
   if (error === undefined) {
     error = check()
@@ -152,11 +149,9 @@ export function createWholeContainerCachedCheck(
       )
     }
 
-    let cached = cache.get(value)
-    if (!cached) {
-      cached = computed(() => check(value, emptyPath, undefined), { keepAlive: true })
-      cache.set(value, cached)
-    }
+    const cached = getOrCreate(cache, value, () =>
+      computed(() => check(value, emptyPath, undefined), { keepAlive: true })
+    )
     const error = cached.get()
     return contextualizeCachedError(error, path, typeCheckedValue)
   }
@@ -167,6 +162,10 @@ export function createWholeContainerCachedCheck(
 // check new chunks twice.
 const needsBatchToCacheChunks = getMobxVersion() < 6
 
+function checkChunks<T>(fn: () => T): T {
+  return needsBatchToCacheChunks ? transaction(fn) : fn()
+}
+
 /**
  * Checks the items of an array, starting at `firstIndex`, and returns the first
  * error, or null.
@@ -328,14 +327,8 @@ class RecordChunks
   readonly atom = createAtom("recordTypeCheckChunks")
   private readonly record: object
   private readonly checkKey: (key: string) => TypeCheckError | null
-  private readonly getEntry = (key: string): CachedEntry => {
-    let entry = this.entries.get(key)
-    if (!entry) {
-      entry = computed(() => this.checkKey(key))
-      this.entries.set(key, entry)
-    }
-    return entry
-  }
+  private readonly getEntry = (key: string): CachedEntry =>
+    getOrCreate(this.entries, key, () => computed(() => this.checkKey(key)))
 
   constructor(record: object, checkKey: (key: string) => TypeCheckError | null) {
     super()
@@ -458,10 +451,7 @@ export function createChunkedRecordCachedCheck(
       const chunks = cached?.chunks
       return checkUncached(cache, value, path, typeCheckedValue, () => {
         if (chunks && typeof key === "string") {
-          const hasError = needsBatchToCacheChunks
-            ? transaction(() => chunks.hasError(key))
-            : chunks.hasError(key)
-          if (!hasError) {
+          if (!checkChunks(() => chunks.hasError(key))) {
             return null
           }
         }
@@ -475,11 +465,10 @@ export function createChunkedRecordCachedCheck(
       addTweakedChangeListener<object>(value, chunks)
       const check = computed(
         () => {
-          const hasError = needsBatchToCacheChunks
-            ? transaction(() => chunks.hasError())
-            : chunks.hasError()
           // any added or removed key changes a chunk, so this runs again then
-          return hasError ? checkAllEntries(value, emptyPath, undefined) : null
+          return checkChunks(() => chunks.hasError())
+            ? checkAllEntries(value, emptyPath, undefined)
+            : null
         },
         { keepAlive: true }
       )
@@ -535,9 +524,7 @@ export function createChunkedArrayCachedCheck(
         if (!chunks || typeof index !== "number") {
           return checkItems(array, 0, emptyPath, undefined)
         }
-        return needsBatchToCacheChunks
-          ? transaction(() => chunks.check(index))
-          : chunks.check(index)
+        return checkChunks(() => chunks.check(index))
       })
     }
 
@@ -561,7 +548,7 @@ export function createChunkedArrayCachedCheck(
             }
 
             const chunks = state.chunks
-            return needsBatchToCacheChunks ? transaction(() => chunks.check()) : chunks.check()
+            return checkChunks(() => chunks.check())
           },
           { keepAlive: true }
         ),

package/src/types/index.ts

@@ -4,3 +4,4 @@ export * from "./TypeCheckError"
 export * from "./tProp"
 export { typeCheck } from "./typeCheck"
 export * from "./types"
+export type { CodecFromEncoded } from "./utility/typesCodecCore"