mobx-keystone 1.22.0 → 1.24.0

package/src/utils/ModelPool.ts

@@ -4,28 +4,27 @@ import { modelIdKey, modelTypeKey } from "../model/metadata"
 import { getSnapshotModelType, isModel } from "../model/utils"
 import type { ModelClass } from "../modelShared/BaseModelShared"
 import { getModelInfoForName } from "../modelShared/modelInfo"
-import { dataObjectParent } from "../parent/core"
+import { dataToModelNode } from "../parent/core"
 import {
   getDeepObjectChildren,
   registerDeepObjectChildrenExtension,
 } from "../parent/coreObjectChildren"
 
-function byModelTypeAndIdKey(modelType: string, modelId: string) {
-  return JSON.stringify([modelType, modelId])
-}
+type ModelsById = Map<string, AnyModel>
+type ModelsByTypeAndId = Map<string, ModelsById>
 
 export class ModelPool {
-  private pool: ReadonlyMap<string, AnyModel>
+  private pool: ReadonlyMap<string, ReadonlyMap<string, AnyModel>>
 
   constructor(root: object) {
     // make sure we don't use the sub-data $ object
-    root = dataObjectParent.get(root) ?? root
+    root = dataToModelNode(root)
 
     this.pool = getDeepChildrenModels(getDeepObjectChildren(root))
   }
 
   findModelByTypeAndId(modelType: string, modelId: string | undefined): AnyModel | undefined {
-    return modelId ? this.pool.get(byModelTypeAndIdKey(modelType, modelId)) : undefined
+    return modelId ? this.pool.get(modelType)?.get(modelId) : undefined
   }
 
   findModelForSnapshot(sn: any): AnyModel | undefined {
@@ -43,17 +42,33 @@ export class ModelPool {
   }
 }
 
-const getDeepChildrenModels = registerDeepObjectChildrenExtension<Map<string, AnyModel>>({
-  initData() {
-    return new Map()
-  },
+type GetDeepChildrenModels = (data: ReturnType<typeof getDeepObjectChildren>) => ModelsByTypeAndId
+
+let getDeepChildrenModels: GetDeepChildrenModels = (data) => {
+  // Register on first use to keep ModelPool out of the coreObjectChildren
+  // module-initialization cycle. The extension getter backfills its index from
+  // data.deep, so registering after a deep-children set already exists is safe.
+  const getRegisteredDeepChildrenModels = registerDeepObjectChildrenExtension<ModelsByTypeAndId>({
+    initData() {
+      return new Map()
+    },
 
-  addNode(node, data) {
-    if (isModel(node)) {
-      const id = node[modelIdKey]
-      if (id) {
-        data.set(byModelTypeAndIdKey(node[modelTypeKey], id), node)
+    addNode(node, extensionData) {
+      if (isModel(node)) {
+        const id = node[modelIdKey]
+        if (id) {
+          const modelType = node[modelTypeKey]
+          let modelsById = extensionData.get(modelType)
+          if (!modelsById) {
+            modelsById = new Map()
+            extensionData.set(modelType, modelsById)
+          }
+          modelsById.set(id, node)
+        }
       }
-    }
-  },
-})
+    },
+  })
+
+  getDeepChildrenModels = getRegisteredDeepChildrenModels
+  return getRegisteredDeepChildrenModels(data)
+}

package/src/utils/errorDiagnostics.ts

@@ -1,13 +1,59 @@
 import type { Path, PathElement, WritablePath } from "../parent/pathTypes"
 
-interface ErrorDiagnosticsContext {
-  path: WritablePath
-  modelTrail: string[]
+/**
+ * @internal
+ */
+export class ErrorDiagnosticsContext {
+  private readonly path: WritablePath = []
+  private readonly modelTrailTypes: string[] = []
+  private readonly modelTrailIds: (string | undefined)[] = []
+
+  pushPath(segment: PathElement): void {
+    this.path.push(segment)
+  }
+
+  popPath(): void {
+    this.path.pop()
+  }
+
+  getPathLength(): number {
+    return this.path.length
+  }
+
+  truncatePath(length: number): void {
+    this.path.length = length
+  }
+
+  pushModelTrail(modelType: string, modelId: string | undefined): void {
+    this.modelTrailTypes.push(modelType)
+    this.modelTrailIds.push(modelId)
+  }
+
+  popModelTrail(): void {
+    this.modelTrailTypes.pop()
+    this.modelTrailIds.pop()
+  }
+
+  getPathSnapshot(): Path {
+    return [...this.path]
+  }
+
+  getModelTrailSnapshot(): readonly string[] | undefined {
+    if (this.modelTrailTypes.length <= 0) {
+      return undefined
+    }
+    return this.modelTrailTypes.map((modelType, index) =>
+      formatErrorModelTrailEntry(modelType, this.modelTrailIds[index])
+    )
+  }
 }
 
 const errorDiagnosticsContextStack: ErrorDiagnosticsContext[] = []
 
-function getCurrentErrorDiagnosticsContext(): ErrorDiagnosticsContext | undefined {
+/**
+ * @internal
+ */
+export function getCurrentErrorDiagnosticsContext(): ErrorDiagnosticsContext | undefined {
   return errorDiagnosticsContextStack.length > 0
     ? errorDiagnosticsContextStack[errorDiagnosticsContextStack.length - 1]
     : undefined
@@ -22,10 +68,7 @@ export function runWithErrorDiagnosticsContext<T>(fn: () => T): T {
     return fn()
   }
 
-  const ctx: ErrorDiagnosticsContext = {
-    path: [],
-    modelTrail: [],
-  }
+  const ctx = new ErrorDiagnosticsContext()
   errorDiagnosticsContextStack.push(ctx)
   try {
     return fn()
@@ -43,11 +86,11 @@ export function withErrorPathSegment<T>(segment: PathElement, fn: () => T): T {
     return fn()
   }
 
-  ctx.path.push(segment)
+  ctx.pushPath(segment)
   try {
     return fn()
   } finally {
-    ctx.path.pop()
+    ctx.popPath()
   }
 }
 
@@ -64,16 +107,16 @@ export function withErrorPathSegments<T>(segments: readonly PathElement[], fn: (
     return fn()
   }
 
-  const initialLen = ctx.path.length
+  const initialLen = ctx.getPathLength()
   const segmentsLen = segments.length
   for (let i = 0; i < segmentsLen; i++) {
-    ctx.path.push(segments[i]!)
+    ctx.pushPath(segments[i]!)
   }
 
   try {
     return fn()
   } finally {
-    ctx.path.length = initialLen
+    ctx.truncatePath(initialLen)
   }
 }
 
@@ -112,12 +155,11 @@ export function withErrorModelTrailEntry<T>(
     return fn()
   }
 
-  const entry = formatErrorModelTrailEntry(modelType, modelId)
-  ctx.modelTrail.push(entry)
+  ctx.pushModelTrail(modelType, modelId)
   try {
     return fn()
   } finally {
-    ctx.modelTrail.pop()
+    ctx.popModelTrail()
   }
 }
 
@@ -126,7 +168,7 @@ export function withErrorModelTrailEntry<T>(
  */
 export function getErrorPathSnapshot(): Path | undefined {
   const ctx = getCurrentErrorDiagnosticsContext()
-  return ctx ? [...ctx.path] : undefined
+  return ctx?.getPathSnapshot()
 }
 
 /**
@@ -134,7 +176,7 @@ export function getErrorPathSnapshot(): Path | undefined {
  */
 export function getErrorModelTrailSnapshot(): readonly string[] | undefined {
   const ctx = getCurrentErrorDiagnosticsContext()
-  return ctx && ctx.modelTrail.length > 0 ? [...ctx.modelTrail] : undefined
+  return ctx?.getModelTrailSnapshot()
 }
 
 /**

package/src/utils/index.ts

@@ -1,5 +1,6 @@
 import * as mobx from "mobx"
 import {
+  type IComputedValue,
   type IObservableArray,
   isObservableArray,
   isObservableMap,
@@ -109,12 +110,7 @@ export let hasOwnProp: (object: object, propName: PropertyKey) => boolean = (
 /**
  * @internal
  */
-export function setOwnProp(target: any, propName: PropertyKey, value: unknown): void {
-  if (propName !== "__proto__") {
-    target[propName] = value
-    return
-  }
-
+export function setProtoProp(target: object, value: unknown): void {
   Object.defineProperty(target, "__proto__", {
     enumerable: true,
     writable: true,
@@ -136,7 +132,12 @@ export function copyOwnEnumerableProps<TTarget extends Record<string, any>>(
   for (let i = 0; i < len; i++) {
     const key = keys[i]
     const value = source[key]
-    setOwnProp(target, key, mapValue ? mapValue(value, key) : value)
+    const mappedValue = mapValue ? mapValue(value, key) : value
+    if (key === "__proto__") {
+      setProtoProp(target, mappedValue)
+    } else {
+      ;(target as Record<PropertyKey, unknown>)[key] = mappedValue
+    }
   }
 
   return target
@@ -419,6 +420,127 @@ export const mobx6 = {
   ],
 }
 
+/**
+ * MobX method action decorator compatible with both legacy decorators and
+ * MobX 7's standard decorator API.
+ *
+ * This is a decorator compatibility helper, not a replacement for other
+ * `action` overloads such as `action(fn)`. Field decorators are not supported.
+ *
+ * @hidden
+ */
+export function mobxAction<This, Args extends unknown[], Return>(
+  value: (this: This, ...args: Args) => Return,
+  context: ClassMethodDecoratorContext<This, (this: This, ...args: Args) => Return>
+): (this: This, ...args: Args) => Return
+export function mobxAction<This, Args extends unknown[], Return>(
+  target: object,
+  propertyKey: string | symbol,
+  descriptor: TypedPropertyDescriptor<(this: This, ...args: Args) => Return>
+): TypedPropertyDescriptor<(this: This, ...args: Args) => Return> | void
+export function mobxAction(...args: any[]): any {
+  if (isStandardDecoratorContext(args[1])) {
+    return (mobx.action as any)(args[0], args[1])
+  }
+
+  if (getMobxVersion() < 7) {
+    return (mobx.action as any)(...args)
+  }
+
+  const descriptor = args[2] as PropertyDescriptor | undefined
+  if (!descriptor?.value) {
+    return descriptor
+  }
+
+  if (mobx.isAction(descriptor.value)) {
+    return descriptor
+  }
+
+  return {
+    ...descriptor,
+    value: mobx.action(String(args[1]), descriptor.value),
+  }
+}
+
+/**
+ * MobX getter computed decorator compatible with both legacy decorators and
+ * MobX 7's standard decorator API.
+ *
+ * This is a decorator compatibility helper, not a replacement for other
+ * `computed` overloads. Field decorators and decorator options are not supported.
+ * Under MobX 7's legacy decorator transform the getter is backed by a computed
+ * value, but is not registered as a computed property for MobX introspection.
+ *
+ * @hidden
+ */
+export function mobxComputed<This, Value>(
+  value: (this: This) => Value,
+  context: ClassGetterDecoratorContext<This, Value>
+): ((this: This) => Value) | void
+export function mobxComputed<Value>(
+  target: object,
+  propertyKey: string | symbol,
+  descriptor: TypedPropertyDescriptor<Value>
+): TypedPropertyDescriptor<Value> | void
+export function mobxComputed(...args: any[]): any {
+  if (isStandardDecoratorContext(args[1])) {
+    return (mobx.computed as any)(args[0], args[1])
+  }
+
+  if (getMobxVersion() < 7) {
+    return (mobx.computed as any)(...args)
+  }
+
+  const descriptor = args[2] as PropertyDescriptor | undefined
+  if (!descriptor?.get) {
+    return descriptor
+  }
+
+  const getter = descriptor.get
+  const computedValues = new WeakMap<object, IComputedValue<unknown>>()
+
+  return {
+    ...descriptor,
+    get(this: object) {
+      let computedValue = computedValues.get(this)
+      if (!computedValue) {
+        const newComputedValue = mobx.computed(() => getter.call(this), {
+          name: String(args[1]),
+        })
+        computedValues.set(this, newComputedValue)
+        computedValue = newComputedValue
+      }
+      return computedValue.get()
+    },
+  }
+}
+
+// Mirrors MobX's standard-decorator call detection. Legacy decorator calls use
+// a string or symbol property key as their second argument, so checking `kind`
+// distinguishes the call shapes without claiming to validate the full context.
+function isStandardDecoratorContext(value: unknown): boolean {
+  return (
+    typeof value === "object" &&
+    value !== null &&
+    typeof (value as { kind?: unknown }).kind === "string"
+  )
+}
+
+/**
+ * Calls `makeObservable` across MobX versions. MobX 7 requires an annotations
+ * object, while MobX 6 and older versions use decorator metadata when no
+ * annotations are passed.
+ *
+ * @internal
+ */
+export function makeObservableCompat(target: object, annotations?: object): void {
+  if (getMobxVersion() >= 7) {
+    mobx6.makeObservable(target, annotations ?? {})
+  } else {
+    mobx6.makeObservable(target)
+  }
+}
+
 /**
  * @internal
  */
@@ -426,15 +548,26 @@ export function propNameToSetterName(propName: string): string {
   return `set${propName[0].toUpperCase()}${propName.slice(1)}`
 }
 
+let cachedMobxVersion: number | undefined
+
 /**
  * @internal
  */
 export function getMobxVersion(): number {
+  if (cachedMobxVersion !== undefined) {
+    return cachedMobxVersion
+  }
+
   if (mobx6.makeObservable!) {
-    return 6
+    const version = (mobx as any)._getGlobalState?.().version
+    cachedMobxVersion = typeof version === "number" && version >= 7 ? version : 6
+  } else if ("extendShallowObservable" in mobx) {
+    cachedMobxVersion = 4
   } else {
-    return 5
+    cachedMobxVersion = 5
   }
+
+  return cachedMobxVersion
 }
 
 /**

package/src/types/createPerEntryCachedCheck.ts

@@ -1,166 +0,0 @@
-import {
-  computed,
-  type IArrayDidChange,
-  type IComputedValue,
-  type IObjectDidChange,
-  observe,
-} from "mobx"
-import type { Path } from "../parent/pathTypes"
-import { isTweakedObject } from "../tweaker/core"
-import type { TypeCheckError } from "./TypeCheckError"
-
-/**
- * @internal
- *
- * Per-entry cache map type used by `createPerEntryCachedCheck`.
- */
-export type PerEntryCache = Map<PropertyKey, IComputedValue<TypeCheckError | null>>
-
-/**
- * @internal
- *
- * Callback that sets up reactive pruning of stale per-entry cache entries.
- * Called once per observable value when the aggregation is first created.
- * Should install an observe listener that removes entries from the cache
- * when the collection structure changes (e.g. key removal, array shrink).
- */
-export type CachePruningSetup = (value: any, capturedEntries: PerEntryCache) => void
-
-/**
- * @internal
- *
- * Pruning strategy for record / plain-object types.
- * Removes a per-entry cached computed when an object key is removed.
- */
-export const recordCachePruning: CachePruningSetup = (value, capturedEntries) => {
-  observe(value, (change: IObjectDidChange) => {
-    if (change.type === "remove") {
-      capturedEntries.delete(change.name)
-    }
-  })
-}
-
-/**
- * @internal
- *
- * Pruning strategy for array types.
- * After a splice that shrinks the array, removes per-entry cached computeds
- * for indices that no longer exist (i.e. index >= newLength).
- */
-export const arrayCachePruning: CachePruningSetup = (value, capturedEntries) => {
-  observe(value, (change: IArrayDidChange) => {
-    if (change.type === "splice") {
-      const newLength = (value as unknown[]).length
-      if (capturedEntries.size > newLength) {
-        for (const key of capturedEntries.keys()) {
-          if ((key as number) >= newLength) {
-            capturedEntries.delete(key)
-          }
-        }
-      }
-    }
-  })
-}
-
-/**
- * @internal
- *
- * Debug registry mapping observable values to their per-entry cache Maps.
- * Used by tests to verify that stale entries are actually pruned.
- */
-const __debugPerEntryCaches = new WeakMap<object, PerEntryCache>()
-
-/**
- * @internal
- *
- * Returns the number of entries in the per-entry cache for the given observable value,
- * or `undefined` if the value has no cached entries. Used by tests to verify pruning.
- */
-export function __getPerEntryCacheSize(value: object): number | undefined {
-  return __debugPerEntryCaches.get(value)?.size
-}
-
-/**
- * @internal
- *
- * Creates a check function that uses per-entry MobX computeds + an aggregation computed
- * for fine-grained reactive type checking.
- *
- * For tweaked (observable) values:
- * 1. Per-entry computeds — each reads only one entry's observable, so changing entry A
- *    only invalidates entry A's computed.
- * 2. Aggregation computed — iterates per-entry computeds. Thanks to MobX's change propagation,
- *    if a per-entry computed re-evaluates but returns the same result (e.g. null → null),
- *    the aggregation body is skipped entirely.
- * 3. Stale entries are pruned reactively via an optional `setupCachePruning` callback
- *    (e.g. MobX `observe` listener) that fires on structural mutations, preventing
- *    memory leaks for dynamic collections.
- *
- * For non-tweaked values (plain snapshots), falls back to imperative checking.
- *
- * @param iterateEntries Called both inside the aggregation computed (cached path) and
- *   for the imperative fallback. Receives a `checkEntry(key)` callback that either
- *   returns a cached computed result or performs a direct check, depending on the path.
- *   Should call `checkEntry(key)` for each entry and return the first error, or null.
- * @param checkEntry Checks a single entry. For tweaked values, the utility wraps this
- *   in a non-keepAlive computed automatically. For non-tweaked values, called directly.
- * @param setupCachePruning Optional callback to install reactive pruning of stale entries.
- *   Called once per observable value. Use `recordCachePruning` for records/objects,
- *   `arrayCachePruning` for arrays, or omit for fixed-schema types (objects, tuples).
- */
-export function createPerEntryCachedCheck<K extends PropertyKey>(
-  iterateEntries: (
-    value: any,
-    checkEntry: (entryKey: K) => TypeCheckError | null
-  ) => TypeCheckError | null,
-  checkEntry: (value: any, entryKey: K, path: Path, typeCheckedValue: any) => TypeCheckError | null,
-  setupCachePruning?: CachePruningSetup
-): (value: any, path: Path, typeCheckedValue: any) => TypeCheckError | null {
-  const perEntryCache = new WeakMap<object, PerEntryCache>()
-  const aggregationCache = new WeakMap<object, IComputedValue<TypeCheckError | null>>()
-
-  // Mutable call context updated before each `.get()` so computed closures
-  // always use the latest path/typeCheckedValue. Safe because MobX computed
-  // evaluation is synchronous and single-threaded.
-  let currentPath: Path
-  let currentTypeCheckedValue: any
-
-  return (value: any, path: Path, typeCheckedValue: any): TypeCheckError | null => {
-    if (!isTweakedObject(value, true)) {
-      return iterateEntries(value, (key) => checkEntry(value, key, path, typeCheckedValue))
-    }
-
-    // Update mutable scope before evaluation.
-    currentPath = path
-    currentTypeCheckedValue = typeCheckedValue
-
-    let aggr = aggregationCache.get(value)
-    if (!aggr) {
-      let entries = perEntryCache.get(value)
-      if (!entries) {
-        entries = new Map()
-        perEntryCache.set(value, entries)
-        __debugPerEntryCaches.set(value, entries)
-      }
-
-      const capturedEntries = entries
-
-      // Install reactive pruning if a strategy was provided.
-      setupCachePruning?.(value, capturedEntries)
-
-      const cachedCheckEntry = (key: K): TypeCheckError | null => {
-        let c = capturedEntries.get(key)
-        if (!c) {
-          c = computed(() => checkEntry(value, key, currentPath, currentTypeCheckedValue))
-          capturedEntries.set(key, c)
-        }
-        return c.get()
-      }
-
-      aggr = computed(() => iterateEntries(value, cachedCheckEntry), { keepAlive: true })
-      aggregationCache.set(value, aggr)
-    }
-
-    return aggr.get()
-  }
-}