mobx-keystone 1.24.1 → 2.0.0

package/src/tweaker/typeChecking.ts

@@ -1,15 +1,15 @@
+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"
 import { isModel } from "../model/utils"
 import { dataToModelNode } from "../parent/core"
-import { fastGetParentPathIncludingDataObjects } from "../parent/path"
-import type { PathElement } from "../parent/pathTypes"
+import { fastGetParent } from "../parent/path"
 import { internalApplyPatches } from "../patch/applyPatches"
 import type { InternalPatchRecorder } from "../patch/emitPatch"
 import { internalApplySnapshot } from "../snapshot/applySnapshot"
 import { runWithoutSnapshotOrPatches } from "./core"
-import { isTypeCheckingAllowed } from "./withoutTypeChecking"
+import { isTypeCheckingAllowed, withoutTypeChecking } 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
@@ -35,33 +35,25 @@ 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 {
   // obj might be a $ data object, so resolve to the model if applicable
-  let current: object | undefined = dataToModelNode(obj)
-  let lastAncestor: AnyModel | undefined
+  const start = dataToModelNode(obj)
 
-  // If we started from a $ data object, check the model itself
-  if (current !== obj && isModelWithTypeChecker(current)) {
-    lastAncestor = current
-    callback(current)
+  // Both model-data mutations and whole-model reconciliation must validate
+  // the model itself before checking its ancestors.
+  if (isModelWithTypeChecker(start)) {
+    callback(start)
   }
 
-  // Walk up parent chain
-  while (current !== undefined) {
-    const parentPath: { parent: object; path: PathElement } | undefined =
-      fastGetParentPathIncludingDataObjects(current, false)
-    if (!parentPath) break
-
-    const parent: object = parentPath.parent
-
-    if (isModelWithTypeChecker(parent) && parent !== lastAncestor) {
-      lastAncestor = parent
+  // Raw parents never point to model $ objects, so each model is visited once.
+  let parent: object | undefined = fastGetParent(start, false)
+  while (parent) {
+    if (isModelWithTypeChecker(parent)) {
       callback(parent)
     }
-
-    current = parent
+    parent = fastGetParent(parent, false)
   }
 }
 
@@ -86,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
         }
@@ -108,3 +99,111 @@ 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 {
+    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/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/createCachedTypeCheck.ts

@@ -1,8 +1,32 @@
 import { computed, type IComputedValue, type IObjectDidChange, observe } from "mobx"
+import { dataToModelNode, modelToDataNode } from "../parent/core"
+import { fastGetParent } from "../parent/path"
 import type { Path } from "../parent/pathTypes"
 import { isTweakedObject } from "../tweaker/core"
 import { TypeCheckError } from "./TypeCheckError"
 
+let uncachedTypeCheckObjects: Set<object> | undefined
+
+/** @internal */
+export function withoutCachedTypeChecking(obj: object, fn: () => void): void {
+  const previous = uncachedTypeCheckObjects
+  const affected = new Set(previous)
+  // Only these containers can retain a cached result for the old shape.
+  // Model schema checks run on $ data, while refinements can check the model.
+  let current: object | undefined = dataToModelNode(obj)
+  while (current) {
+    affected.add(current)
+    affected.add(modelToDataNode(current))
+    current = fastGetParent(current, false)
+  }
+  uncachedTypeCheckObjects = affected
+  try {
+    fn()
+  } finally {
+    uncachedTypeCheckObjects = previous
+  }
+}
+
 const emptyPath: Path = []
 
 function contextualizeCachedError(
@@ -16,6 +40,7 @@ function contextualizeCachedError(
 
   return new TypeCheckError({
     path: [...path, ...error.path],
+    modelTrail: error.modelTrail,
     expectedTypeName: error.expectedTypeName,
     actualValue: error.actualValue,
     typeCheckedValue,
@@ -52,7 +77,7 @@ function createAdaptivePerEntryCachedCheck<K>(
     iterateEntries(value, (key) => checkEntry(value, key, path, typeCheckedValue))
 
   return (value, path, typeCheckedValue) => {
-    if (!isTweakedObject(value, true)) {
+    if (uncachedTypeCheckObjects?.has(value) || !isTweakedObject(value, true)) {
       return checkAllEntries(value, path, typeCheckedValue)
     }
 
@@ -142,7 +167,7 @@ export function createWholeContainerCachedCheck(
   const cache = new WeakMap<object, IComputedValue<TypeCheckError | null>>()
 
   return (value, path, typeCheckedValue) => {
-    if (!isTweakedObject(value, true)) {
+    if (uncachedTypeCheckObjects?.has(value) || !isTweakedObject(value, true)) {
       return check(value, path, typeCheckedValue)
     }
 

package/src/types/objectBased/typesDataModelData.ts

@@ -10,7 +10,7 @@ import type {
 import { modelInfoByClass } from "../../modelShared/modelInfo"
 import { getInternalModelClassPropsInfo } from "../../modelShared/modelPropsInfo"
 import { noDefaultValue } from "../../modelShared/prop"
-import { failure, lazy } from "../../utils"
+import { failure, lazy, setProtoProp } from "../../utils"
 import { getTypeInfo } from "../getTypeInfo"
 import {
   registerStandardTypeResolver,
@@ -168,12 +168,14 @@ export class DataModelDataTypeInfo extends TypeInfo {
         hasDefault = true
       }
 
-      propTypes[propName] = {
+      const propInfo = {
         type,
         typeInfo,
         hasDefault,
         default: defaultValue,
       }
+      if (propName === "__proto__") setProtoProp(propTypes, propInfo)
+      else propTypes[propName] = propInfo
     })
     return propTypes
   })

package/src/types/objectBased/typesModel.ts

@@ -7,7 +7,7 @@ import type { ModelClass } from "../../modelShared/BaseModelShared"
 import { modelInfoByClass } from "../../modelShared/modelInfo"
 import { getInternalModelClassPropsInfo } from "../../modelShared/modelPropsInfo"
 import { noDefaultValue } from "../../modelShared/prop"
-import { isObject, lazy } from "../../utils"
+import { isObject, lazy, setProtoProp } from "../../utils"
 import { getTypeInfo } from "../getTypeInfo"
 import { registerStandardTypeResolver, resolveTypeChecker } from "../resolveTypeChecker"
 import type { AnyStandardType, ModelType } from "../schemas"
@@ -178,12 +178,14 @@ export class ModelTypeInfo extends TypeInfo {
         hasDefault = true
       }
 
-      propTypes[propName] = {
+      const propInfo = {
         type,
         typeInfo,
         hasDefault,
         default: defaultValue,
       }
+      if (propName === "__proto__") setProtoProp(propTypes, propInfo)
+      else propTypes[propName] = propInfo
     })
     return propTypes
   })

package/src/types/objectBased/typesObject.ts

@@ -2,7 +2,16 @@ 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, getMobxVersion, isObject, lazy } from "../../utils"
+import {
+  assertIsFunction,
+  assertIsObject,
+  copyOwnEnumerableProps,
+  getMobxVersion,
+  isArray,
+  isObject,
+  lazy,
+  setProtoProp,
+} from "../../utils"
 import { withErrorPathSegment } from "../../utils/errorDiagnostics"
 import { createIndexedPerEntryCachedCheck } from "../createCachedTypeCheck"
 import { getTypeInfo } from "../getTypeInfo"
@@ -106,27 +115,20 @@ function typesObjectHelper<S>(objFn: S, frozen: boolean, typeInfoGen: TypeInfoGe
       obj: Record<string, unknown>,
       processors: ReadonlyArray<SnapshotProcessor | undefined>
     ) => {
-      const newObj: typeof obj = {}
-
       // note: we allow excess properties when checking objects
-      const keys = Object.keys(obj)
-      for (let i = 0; i < keys.length; i++) {
-        const k = keys[i]
+      return copyOwnEnumerableProps({}, obj, (value, k) => {
         const schemaEntry = schemaEntryByPropName[k]
         if (schemaEntry) {
           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]
+          return processor ? withErrorPathSegment(k, () => processor(value)) : value
         }
-      }
-
-      return newObj
+        // unknown prop, copy as is
+        return value
+      })
     }
 
     const checkObjectType = (obj: any, path: Path, typeCheckedValue: any) => {
-      if (!isObject(obj) || (frozen && !(obj instanceof Frozen))) {
+      if (!isObject(obj) || isArray(obj) || (frozen && !(obj instanceof Frozen))) {
         return new TypeCheckError({
           path,
           expectedTypeName: getTypeName(thisTc),
@@ -187,7 +189,7 @@ function typesObjectHelper<S>(objFn: S, frozen: boolean, typeInfoGen: TypeInfoGe
       typeInfoGen,
 
       (obj) => {
-        if (!isObject(obj)) {
+        if (!isObject(obj) || isArray(obj)) {
           return null
         }
 
@@ -278,7 +280,9 @@ export class ObjectTypeInfo extends TypeInfo {
     const propTypes: O.Writable<ObjectTypeInfoProps> = {}
     Object.keys(objSchema).forEach((propName) => {
       const type = resolveStandardType(objSchema[propName])
-      propTypes[propName] = { type, typeInfo: getTypeInfo(type) }
+      const propInfo = { type, typeInfo: getTypeInfo(type) }
+      if (propName === "__proto__") setProtoProp(propTypes, propInfo)
+      else propTypes[propName] = propInfo
     })
     return propTypes
   })

package/src/types/objectBased/typesRecord.ts

@@ -1,6 +1,6 @@
 import { isObservableObject, keys } from "mobx"
 import type { Path } from "../../parent/pathTypes"
-import { failure, isObject } from "../../utils"
+import { copyOwnEnumerableProps, failure, isArray, isObject } from "../../utils"
 import { withErrorPathSegment } from "../../utils/errorDiagnostics"
 import { createAdaptiveRecordCachedCheck } from "../createCachedTypeCheck"
 import { getTypeInfo } from "../getTypeInfo"
@@ -48,16 +48,9 @@ export function typesRecord<T extends AnyType>(valueType: T): RecordType<T> {
         return obj
       }
 
-      const newObj: typeof obj = {}
-
-      const keys = Object.keys(obj)
-      for (let i = 0; i < keys.length; i++) {
-        const k = keys[i]
-        const v = withErrorPathSegment(k, () => processor(obj[k]))
-        newObj[k] = v
-      }
-
-      return newObj
+      return copyOwnEnumerableProps({}, obj, (value, key) =>
+        withErrorPathSegment(key, () => processor(value))
+      )
     }
 
     const iterateRecordEntries = (
@@ -97,7 +90,7 @@ export function typesRecord<T extends AnyType>(valueType: T): RecordType<T> {
       TypeCheckerBaseType.Object,
 
       (obj, path, typeCheckedValue) => {
-        if (!isObject(obj)) {
+        if (!isObject(obj) || isArray(obj)) {
           return new TypeCheckError({
             path,
             expectedTypeName: getTypeName(thisTc),
@@ -117,7 +110,7 @@ export function typesRecord<T extends AnyType>(valueType: T): RecordType<T> {
       typeInfoGen,
 
       (obj) => {
-        if (!isObject(obj)) {
+        if (!isObject(obj) || isArray(obj)) {
           return null
         }
 

package/src/types/objectBased/typesRef.ts

@@ -1,6 +1,6 @@
 import { modelTypeKey } from "../../model/metadata"
 import { modelInfoByClass } from "../../modelShared/modelInfo"
-import { Ref, type RefConstructor } from "../../ref/Ref"
+import type { Ref, RefConstructor } from "../../ref/Ref"
 import { isObject } from "../../utils"
 import { typesString } from "../primitiveBased/typesPrimitive"
 import { resolveTypeChecker } from "../resolveTypeChecker"
@@ -36,7 +36,7 @@ export function typesRef<O extends object>(refConstructor: RefConstructor<O>): M
     TypeCheckerBaseType.Object,
 
     (value, path, typeCheckedValue) => {
-      if (!(value instanceof Ref)) {
+      if (!(value instanceof refConstructor.refClass)) {
         return new TypeCheckError({
           path,
           expectedTypeName: typeName,

package/src/types/primitiveBased/typesEnum.ts

@@ -1,4 +1,4 @@
-import { assertIsObject } from "../../utils"
+import { assertIsObject, isEqualOrBothNaN } from "../../utils"
 import type { IdentityType } from "../schemas"
 import { typesOr } from "../utility/typesOr"
 import { typesLiteral } from "./typesPrimitive"
@@ -17,6 +17,7 @@ export interface EnumLike {
  */
 export function enumValues(e: EnumLike): (string | number)[] {
   const vals: (string | number)[] = []
+  const seen = new Set<string | number>()
   for (const k of Object.keys(e)) {
     const v = e[k]
     // we have to do this since TS does something weird
@@ -24,7 +25,8 @@ export function enumValues(e: EnumLike): (string | number)[] {
     // Hi = 0 -> { Hi: 0, 0: "Hi" }
     // and SWC currently generates enum code inconsistent with TS/Babel
     // https://github.com/swc-project/swc/issues/3711
-    if (!vals.includes(v) && ((typeof v !== "string" && v !== +k) || e[v] !== +k)) {
+    if (!seen.has(v) && ((typeof v !== "string" && v !== +k) || !isEqualOrBothNaN(e[v], +k))) {
+      seen.add(v)
       vals.push(v)
     }
   }

package/src/types/primitiveBased/typesPrimitive.ts

@@ -1,4 +1,4 @@
-import { assertIsPrimitive } from "../../utils"
+import { assertIsPrimitive, isEqualOrBothNaN } from "../../utils"
 import type { PrimitiveValue } from "../../utils/types"
 import { registerStandardTypeResolver, type StandardTypeResolverFn } from "../resolveTypeChecker"
 import type { AnyStandardType, IdentityType } from "../schemas"
@@ -31,7 +31,12 @@ export function typesLiteral<T extends PrimitiveValue>(literal: T): IdentityType
       typeName = "null"
       break
     default:
-      typeName = JSON.stringify(literal)
+      typeName =
+        typeof literal === "bigint"
+          ? `${literal}n`
+          : typeof literal === "number" && !Number.isFinite(literal)
+            ? String(literal)
+            : JSON.stringify(literal)
       break
   }
 
@@ -41,7 +46,7 @@ export function typesLiteral<T extends PrimitiveValue>(literal: T): IdentityType
     TypeCheckerBaseType.Primitive,
 
     (value, path, typeCheckedValue) =>
-      value === literal
+      isEqualOrBothNaN(value, literal)
         ? null
         : new TypeCheckError({
             path,
@@ -53,7 +58,7 @@ export function typesLiteral<T extends PrimitiveValue>(literal: T): IdentityType
     () => typeName,
     typeInfoGen,
 
-    (value) => (value === literal ? thisTc : null),
+    (value) => (isEqualOrBothNaN(value, literal) ? thisTc : null),
     undefined,
     undefined
   )

package/src/types/typeCheckErrorUtils.ts

@@ -16,6 +16,7 @@ export function prependPathElementToTypeCheckError(
 
   return new TypeCheckError({
     path: fullPath,
+    modelTrail: valueError.modelTrail,
     expectedTypeName: valueError.expectedTypeName,
     actualValue: valueError.actualValue,
     typeCheckedValue,