mobx-keystone 1.22.0 → 1.23.0

package/src/modelShared/prop.ts

@@ -1,5 +1,6 @@
 import type { SnapshotInOf, SnapshotOutOf } from "../snapshot/SnapshotOf"
 import type { AnyStandardType } from "../types/schemas"
+import { lazy } from "../utils"
 import { runWithErrorDiagnosticsContext, withErrorPathSegment } from "../utils/errorDiagnostics"
 import { getOrCreate } from "../utils/mapUtils"
 import type { Flatten, IsNeverType, IsOptionalValue } from "../utils/types"
@@ -13,6 +14,17 @@ type SetterMode = boolean | "assign"
 
 export type ModelPropSetterValueTransform<T> = (value: T) => T
 
+/** @internal */
+export interface FullModelPropTransform {
+  transform: (
+    original: unknown,
+    model: object,
+    propName: PropertyKey,
+    setOriginalValue: (newOriginalValue: unknown) => void
+  ) => unknown
+  untransform: (transformed: unknown, model: object, propName: PropertyKey) => unknown
+}
+
 /**
  * A model property.
  */
@@ -42,24 +54,18 @@ export interface ModelProp<
   // True when the declared default is a runtime/transformed value and must be
   // converted before it can be stored in `$`.
   _defaultValueIsTransformed: boolean
+  _getDefaultValueIsTransformed?: () => boolean
   _typeChecker: AnyStandardType | undefined
   _setter: SetterMode
   _setterValueTransform: ((value: unknown) => unknown) | undefined
   _isId: boolean
   _idGenerator?: (() => string) | undefined
-  _transform:
-    | {
-        transform: (
-          original: unknown,
-          model: object,
-          propName: PropertyKey,
-          setOriginalValue: (newOriginalValue: unknown) => void
-        ) => unknown
-        untransform: (transformed: unknown, model: object, propName: PropertyKey) => unknown
-      }
-    | undefined
+  _transform: FullModelPropTransform | undefined
+  _getTransform?: () => FullModelPropTransform | undefined
   _fromSnapshotProcessor?: (sn: unknown) => unknown
   _toSnapshotProcessor?: (sn: unknown) => unknown
+  _getFromSnapshotProcessor?: () => ((sn: unknown) => unknown) | undefined
+  _getToSnapshotProcessor?: () => ((sn: unknown) => unknown) | undefined
 
   /**
    * Adds a setter to the property. The setter will be named `set${CapitalizedPropName}`
@@ -141,6 +147,9 @@ export interface ModelProp<
    *
    * `fromSnapshot` runs before assigning snapshot data into the model prop.
    * `toSnapshot` runs when exporting model data back to snapshot form.
+   * Both processors must be pure and deterministic, and their canonical output
+   * must round-trip to the same stored value. Reconciliation and snapshot
+   * generation may skip calls when that canonical snapshot is already current.
    */
   withSnapshotProcessor<
     FS = TFromSnapshotOverride,
@@ -400,13 +409,17 @@ const baseProp: AnyModelProp = {
   _defaultFn: noDefaultValue,
   _defaultValue: noDefaultValue,
   _defaultValueIsTransformed: false,
+  _getDefaultValueIsTransformed: undefined,
   _typeChecker: undefined,
   _setter: false,
   _setterValueTransform: undefined,
   _isId: false,
   _transform: undefined,
+  _getTransform: undefined,
   _fromSnapshotProcessor: undefined,
   _toSnapshotProcessor: undefined,
+  _getFromSnapshotProcessor: undefined,
+  _getToSnapshotProcessor: undefined,
 
   withSetter(modeOrValueTransform?: SetterMode | ModelPropSetterValueTransform<unknown>) {
     const obj: AnyModelProp = Object.create(this)
@@ -418,43 +431,88 @@ const baseProp: AnyModelProp = {
 
   withTransform(transform: ModelPropTransform<unknown, unknown>) {
     const obj: AnyModelProp = Object.create(this)
-    obj._transform = composeFullTransforms(this._transform, toFullTransform(transform))
+    const innerTransform = toFullModelPropTransform(transform)
+    if (this._getTransform) {
+      const oldGet = this._getTransform
+      obj._getTransform = lazy(() => composeFullTransforms(oldGet(), innerTransform))
+      obj._transform = undefined
+    } else {
+      obj._transform = composeFullTransforms(this._transform, innerTransform)
+    }
     return obj
   },
 
   withSnapshotProcessor({ fromSnapshot, toSnapshot }) {
-    let newFromSnapshot: ((sn: any) => any) | undefined
-
-    if (this._fromSnapshotProcessor && fromSnapshot) {
-      const oldFn = this._fromSnapshotProcessor
-      const newFn = fromSnapshot
-      newFromSnapshot = (sn: any) => oldFn(newFn(sn))
-    } else if (fromSnapshot) {
-      newFromSnapshot = fromSnapshot
-    } else {
-      newFromSnapshot = this._fromSnapshotProcessor
-    }
-
-    let newToSnapshot: ((sn: any) => any) | undefined
+    const obj: AnyModelProp = Object.create(this)
 
-    if (this._toSnapshotProcessor && toSnapshot) {
-      const oldFn: (sn: unknown) => any = this._toSnapshotProcessor
-      const newFn = toSnapshot
-      newToSnapshot = (sn: unknown) => newFn(oldFn(sn))
-    } else if (toSnapshot) {
-      newToSnapshot = toSnapshot
-    } else {
-      newToSnapshot = this._toSnapshotProcessor
+    if (fromSnapshot) {
+      const newProcessor = fromSnapshot as (sn: unknown) => unknown
+      if (this._getFromSnapshotProcessor) {
+        const oldGet = this._getFromSnapshotProcessor
+        obj._getFromSnapshotProcessor = lazy(() => {
+          const oldProcessor = oldGet()
+          return oldProcessor ? (sn: unknown) => oldProcessor(newProcessor(sn)) : newProcessor
+        })
+        obj._fromSnapshotProcessor = undefined
+      } else {
+        const oldProcessor = this._fromSnapshotProcessor
+        obj._fromSnapshotProcessor = oldProcessor
+          ? (sn: unknown) => oldProcessor(newProcessor(sn))
+          : newProcessor
+      }
     }
 
-    const obj: AnyModelProp = Object.create(this)
-    obj._fromSnapshotProcessor = newFromSnapshot
-    obj._toSnapshotProcessor = newToSnapshot
+    if (toSnapshot) {
+      const newProcessor = toSnapshot as (sn: unknown) => unknown
+      if (this._getToSnapshotProcessor) {
+        const oldGet = this._getToSnapshotProcessor
+        obj._getToSnapshotProcessor = lazy(() => {
+          const oldProcessor = oldGet()
+          return oldProcessor ? (sn: unknown) => newProcessor(oldProcessor(sn)) : newProcessor
+        })
+        obj._toSnapshotProcessor = undefined
+      } else {
+        const oldProcessor = this._toSnapshotProcessor
+        obj._toSnapshotProcessor = oldProcessor
+          ? (sn: unknown) => newProcessor(oldProcessor(sn))
+          : newProcessor
+      }
+    }
 
     return obj
   },
 }
 
+/** @internal */
+export function getModelPropFromSnapshotProcessor(
+  modelProp: AnyModelProp
+): ((sn: unknown) => unknown) | undefined {
+  return modelProp._getFromSnapshotProcessor
+    ? modelProp._getFromSnapshotProcessor()
+    : modelProp._fromSnapshotProcessor
+}
+
+/** @internal */
+export function getModelPropToSnapshotProcessor(
+  modelProp: AnyModelProp
+): ((sn: unknown) => unknown) | undefined {
+  return modelProp._getToSnapshotProcessor
+    ? modelProp._getToSnapshotProcessor()
+    : modelProp._toSnapshotProcessor
+}
+
+/** @internal */
+export function getModelPropTransform(modelProp: AnyModelProp): FullModelPropTransform | undefined {
+  return modelProp._getTransform ? modelProp._getTransform() : modelProp._transform
+}
+
+/** @internal */
+export function getModelPropDefaultValueIsTransformed(modelProp: AnyModelProp): boolean {
+  return modelProp._getDefaultValueIsTransformed
+    ? modelProp._getDefaultValueIsTransformed()
+    : modelProp._defaultValueIsTransformed
+}
+
 /**
  * Defines a model property, with an optional function to generate a default value
  * if the input snapshot / model creation data is `null` or `undefined`.
@@ -565,7 +623,10 @@ const cacheTransformedValueFn = () => {
   cacheTransformResult = true
 }
 
-function toFullTransform(transformObject: ModelPropTransform<unknown, unknown>) {
+/** @internal */
+export function toFullModelPropTransform(
+  transformObject: ModelPropTransform<unknown, unknown>
+): FullModelPropTransform {
   const cache = new WeakMap<
     object,
     Map<PropertyKey, { originalValue: unknown; transformedValue: unknown }>
@@ -630,27 +691,9 @@ function toFullTransform(transformObject: ModelPropTransform<unknown, unknown>)
 }
 
 function composeFullTransforms(
-  outerTransform:
-    | {
-        transform(
-          originalValue: unknown,
-          model: object,
-          propName: PropertyKey,
-          setOriginalValue: (newOriginalValue: unknown) => void
-        ): unknown
-        untransform(transformedValue: unknown, model: object, propName: PropertyKey): unknown
-      }
-    | undefined,
-  innerTransform: {
-    transform(
-      originalValue: unknown,
-      model: object,
-      propName: PropertyKey,
-      setOriginalValue: (newOriginalValue: unknown) => void
-    ): unknown
-    untransform(transformedValue: unknown, model: object, propName: PropertyKey): unknown
-  }
-) {
+  outerTransform: FullModelPropTransform | undefined,
+  innerTransform: FullModelPropTransform
+): FullModelPropTransform {
   if (!outerTransform) {
     return innerTransform
   }
@@ -699,15 +742,14 @@ export function getModelPropStoredDefaultValue(
   propName: string
 ): unknown | typeof noDefaultValue {
   const defaultValue = getModelPropDefaultValue(propData)
-  if (defaultValue === noDefaultValue || !propData._defaultValueIsTransformed) {
+  if (defaultValue === noDefaultValue || !getModelPropDefaultValueIsTransformed(propData)) {
     return defaultValue
   }
 
-  return propData._transform
+  const transform = getModelPropTransform(propData)
+  return transform
     ? runWithErrorDiagnosticsContext(() =>
-        withErrorPathSegment(propName, () =>
-          propData._transform!.untransform(defaultValue, model, propName)
-        )
+        withErrorPathSegment(propName, () => transform.untransform(defaultValue, model, propName))
       )
     : defaultValue
 }

package/src/modelShared/sharedInternalModel.ts

@@ -28,7 +28,10 @@ import { getInternalModelClassPropsInfo, setInternalModelClassPropsInfo } from "
 import { modelMetadataSymbol, modelUnwrappedClassSymbol } from "./modelSymbols"
 import {
   type AnyModelProp,
+  getModelPropFromSnapshotProcessor,
   getModelPropStoredDefaultValue,
+  getModelPropToSnapshotProcessor,
+  getModelPropTransform,
   type ModelProps,
   noDefaultValue,
   prop,
@@ -39,21 +42,36 @@ function createGetModelInstanceDataField<M extends AnyModel | AnyDataModel>(
   modelProp: AnyModelProp,
   modelPropName: string
 ): (this: M) => unknown {
-  const transformFn = modelProp._transform?.transform
+  const fixedTransform = modelProp._getTransform ? undefined : modelProp._transform
 
-  if (!transformFn) {
+  if (!modelProp._getTransform && !fixedTransform) {
     // no need to use get since these vars always get on the initial $
     return function (this) {
       return this.$[modelPropName]
     }
   }
 
-  const transformValue = (model: M, value: unknown) =>
-    transformFn(value, model, modelPropName, (newValue) => {
-      // use apply set instead to wrap it in an action
-      // set the $ object to set the original value directly
-      applySet(model.$, modelPropName, newValue)
-    })
+  type TransformValue = (model: M, value: unknown) => unknown
+  const createTransformValue =
+    (transform: NonNullable<ReturnType<typeof getModelPropTransform>>): TransformValue =>
+    (model, value) =>
+      transform.transform(value, model, modelPropName, (newValue) => {
+        // use apply set instead to wrap it in an action
+        // set the $ object to set the original value directly
+        applySet(model.$, modelPropName, newValue)
+      })
+  let transformValue: TransformValue
+  if (fixedTransform) {
+    transformValue = createTransformValue(fixedTransform)
+  } else {
+    transformValue = (model, value) => {
+      const transform = getModelPropTransform(modelProp)
+      transformValue = transform
+        ? createTransformValue(transform)
+        : (_model, storedValue) => storedValue
+      return transformValue(model, value)
+    }
+  }
 
   return function (this) {
     // no need to use get since these vars always get on the initial $
@@ -85,10 +103,9 @@ const setModelInstanceDataField: SetModelInstanceDataFieldFn = (
     value = modelProp._setterValueTransform(value)
   }
 
-  let untransformedValue = modelProp._transform
-    ? withErrorPathSegment(modelPropName, () =>
-        modelProp._transform!.untransform(value, model, modelPropName)
-      )
+  const transform = modelProp._getTransform ? modelProp._getTransform() : modelProp._transform
+  let untransformedValue = transform
+    ? withErrorPathSegment(modelPropName, () => transform.untransform(value, model, modelPropName))
     : value
 
   // apply default value if applicable
@@ -128,6 +145,27 @@ propForDefaultId._isId = true
 type FromSnapshotProcessorFn = (sn: any) => any
 type ToSnapshotProcessorFn = (sn: any, instance: any) => any
 
+function defineLazySnapshotProcessor(
+  modelClass: object,
+  property: "fromSnapshotProcessor" | "toSnapshotProcessor",
+  compile: () => FromSnapshotProcessorFn | ToSnapshotProcessorFn | undefined
+): void {
+  Object.defineProperty(modelClass, property, {
+    configurable: true,
+    enumerable: true,
+    get() {
+      const processor = compile()
+      Object.defineProperty(modelClass, property, {
+        configurable: true,
+        enumerable: true,
+        writable: true,
+        value: processor,
+      })
+      return processor
+    },
+  })
+}
+
 export function sharedInternalModel<
   TProps extends ModelProps,
   TBaseModel extends AnyModel | AnyDataModel,
@@ -234,13 +272,13 @@ export function sharedInternalModel<
   // create type checker if needed
   let dataTypeChecker: AnyType | undefined
   if (needsTypeChecker) {
-    const typeCheckerObj: {
-      [k: string]: any
-    } = {}
-    for (const [k, mp] of Object.entries(composedModelProps)) {
-      typeCheckerObj[k] = mp._typeChecker ? resolveStoredType(mp._typeChecker) : typesUnchecked()
-    }
-    dataTypeChecker = typesObject(() => typeCheckerObj)
+    dataTypeChecker = typesObject(() => {
+      const typeCheckerObj: Record<string, AnyType> = {}
+      for (const [k, mp] of Object.entries(composedModelProps)) {
+        typeCheckerObj[k] = mp._typeChecker ? resolveStoredType(mp._typeChecker) : typesUnchecked()
+      }
+      return typeCheckerObj
+    })
   }
 
   const base: any = baseModel ?? (type === "class" ? BaseModel : BaseDataModel)
@@ -279,8 +317,17 @@ export function sharedInternalModel<
     return baseModel
   }
 
-  // copy static props from base
-  Object.assign(ThisModel, base)
+  // Copy static props from the base without reading its lazy snapshot processor
+  // accessors. This keeps subclass declaration from compiling the parent model's
+  // processor graph before snapshot processing is actually needed.
+  for (const key of Reflect.ownKeys(base)) {
+    if (key === "fromSnapshotProcessor" || key === "toSnapshotProcessor") {
+      continue
+    }
+    if (Object.prototype.propertyIsEnumerable.call(base, key)) {
+      ;(ThisModel as any)[key] = (base as any)[key]
+    }
+  }
   delete (ThisModel as any)[modelUnwrappedClassSymbol]
 
   const initializers: ModelClassInitializer[] = base[modelInitializersSymbol]
@@ -345,10 +392,6 @@ export function sharedInternalModel<
     }
   }
 
-  const modelPropsFromSnapshotProcessor = getModelPropsFromSnapshotProcessor(composedModelProps)
-
-  const modelPropsToSnapshotProcessor = getModelPropsToSnapshotProcessor(composedModelProps)
-
   if (fromSnapshotProcessor) {
     const fn = fromSnapshotProcessor
     fromSnapshotProcessor = (sn) => {
@@ -373,54 +416,42 @@ export function sharedInternalModel<
     }
   }
 
-  ThisModel.fromSnapshotProcessor = chainFns(fromSnapshotProcessor, modelPropsFromSnapshotProcessor)
-  ThisModel.toSnapshotProcessor = chainFns(modelPropsToSnapshotProcessor, toSnapshotProcessor)
+  defineLazySnapshotProcessor(ThisModel, "fromSnapshotProcessor", () =>
+    chainFns(
+      fromSnapshotProcessor,
+      getModelPropsSnapshotProcessor(composedModelProps, getModelPropFromSnapshotProcessor)
+    )
+  )
+  defineLazySnapshotProcessor(ThisModel, "toSnapshotProcessor", () =>
+    chainFns(
+      getModelPropsSnapshotProcessor(composedModelProps, getModelPropToSnapshotProcessor),
+      toSnapshotProcessor
+    )
+  )
 
   return ThisModel
 }
 
-function getModelPropsFromSnapshotProcessor(
-  composedModelProps: ModelProps
+function getModelPropsSnapshotProcessor(
+  composedModelProps: ModelProps,
+  getProcessor: (prop: AnyModelProp) => ((sn: unknown) => unknown) | undefined
 ): FromSnapshotProcessorFn | undefined {
-  const propsWithFromSnapshotProcessor = Object.entries(composedModelProps).filter(
-    ([_propName, propData]) => propData._fromSnapshotProcessor
-  )
-  if (propsWithFromSnapshotProcessor.length <= 0) {
-    return undefined
-  }
-
-  return (sn) => {
-    const newSn = { ...sn }
-    for (const [propName, propData] of propsWithFromSnapshotProcessor) {
-      if (propData._fromSnapshotProcessor) {
-        newSn[propName] = withErrorPathSegment(propName, () =>
-          propData._fromSnapshotProcessor!(sn[propName])
-        )
-      }
+  const propsWithProcessor: Array<readonly [string, (sn: unknown) => unknown]> = []
+  for (const [propName, propData] of Object.entries(composedModelProps)) {
+    const processor = getProcessor(propData)
+    if (processor) {
+      propsWithProcessor.push([propName, processor])
     }
-    return newSn
   }
-}
-
-function getModelPropsToSnapshotProcessor(
-  composedModelProps: ModelProps
-): ToSnapshotProcessorFn | undefined {
-  const propsWithToSnapshotProcessor = Object.entries(composedModelProps).filter(
-    ([_propName, propData]) => propData._toSnapshotProcessor
-  )
 
-  if (propsWithToSnapshotProcessor.length <= 0) {
+  if (propsWithProcessor.length === 0) {
     return undefined
   }
 
   return (sn) => {
     const newSn = { ...sn }
-    for (const [propName, propData] of propsWithToSnapshotProcessor) {
-      if (propData._toSnapshotProcessor) {
-        newSn[propName] = withErrorPathSegment(propName, () =>
-          propData._toSnapshotProcessor!(sn[propName])
-        )
-      }
+    for (const [propName, processor] of propsWithProcessor) {
+      newSn[propName] = withErrorPathSegment(propName, () => processor(sn[propName]))
     }
     return newSn
   }

package/src/parent/core.ts

@@ -1,13 +1,9 @@
 import { createAtom, type IAtom } from "mobx"
 import { isModel } from "../model/utils"
+import { treeNodeMetadata } from "../tweaker/treeNodeMetadata"
 import { getOrCreate } from "../utils/mapUtils"
 import type { ParentPath } from "./path"
 
-/**
- * @internal
- */
-export const objectParents = new WeakMap<object, ParentPath<object> | undefined>()
-
 const objectParentsAtoms = new WeakMap<object, IAtom>()
 
 /**
@@ -44,16 +40,26 @@ export function reportParentPathChanged(node: object) {
   objectParentsAtoms.get(node)?.reportChanged()
 }
 
-/**
- * @internal
- */
-export const dataObjectParent = new WeakMap<object, object>()
+/** @internal */
+export function getDataObjectParent(node: object): object | undefined {
+  return treeNodeMetadata.get(node)?.dataObjectParent
+}
+
+/** @internal */
+export function hasDataObjectParent(node: object): boolean {
+  return treeNodeMetadata.get(node)?.dataObjectParent !== undefined
+}
+
+/** @internal */
+export function setDataObjectParent(node: object, parent: object): void {
+  treeNodeMetadata.get(node)!.dataObjectParent = parent
+}
 
 /**
  * @internal
  */
 export function dataToModelNode<T extends object>(node: T): T {
-  const modelNode = dataObjectParent.get(node)
+  const modelNode = getDataObjectParent(node)
   return (modelNode as T | undefined) ?? node
 }