mobx-keystone 1.22.0 → 1.24.0

package/src/modelShared/modelDecorator.ts

@@ -15,10 +15,11 @@ import {
 } from "../modelShared/modelSymbols"
 import { refreshInternalSnapshot } from "../snapshot/internal"
 import {
+  addLateInitializationFunction,
   failure,
   getMobxVersion,
   logWarning,
-  mobx6,
+  makeObservableCompat,
   runAfterNewSymbol,
   runBeforeOnInitSymbol,
   runLateInitializationFunctions,
@@ -34,11 +35,11 @@ import type { AnyFunction } from "../utils/AnyFunction"
  */
 export const model =
   (name: string) =>
-  <MC extends ModelClass<AnyModel | AnyDataModel>>(clazz: MC, ...args: any[]): MC => {
-    const ctx = typeof args[1] === "object" ? (args[1] as ClassDecoratorContext) : undefined
-
-    return internalModel(name, clazz, ctx?.addInitializer) as any
-  }
+  <MC extends ModelClass<AnyModel | AnyDataModel>>(
+    clazz: MC,
+    _context?: ClassDecoratorContext<MC>
+  ): MC =>
+    internalModel(name, clazz) as any
 
 const afterClassInitializationData = new WeakMap<
   ModelClass<AnyModel | AnyDataModel>,
@@ -56,14 +57,14 @@ const runAfterClassInitialization = (
 
   const tag = afterClassInitializationData.get(target)!
 
-  // compatibility with mobx 6
+  // compatibility with mobx 6 and 7
   if (tag.needsMakeObservable) {
     // we know it can be done and shouldn't fail
-    mobx6.makeObservable(instance)
+    makeObservableCompat(instance)
   } else if (tag.needsMakeObservable === undefined) {
     if (getMobxVersion() >= 6) {
       try {
-        mobx6.makeObservable(instance)
+        makeObservableCompat(instance)
         tag.needsMakeObservable = true
       } catch (e) {
         const err = e as Error
@@ -121,8 +122,7 @@ const proxyClassHandler: ProxyHandler<ModelClass<AnyModel | AnyDataModel>> = {
 
 const internalModel = <MC extends ModelClass<AnyModel | AnyDataModel>>(
   name: string,
-  clazz: MC,
-  addInitializer: ((initializer: (this: any) => void) => void) | undefined
+  clazz: MC
 ): MC | void => {
   const type = isModelClass(clazz) ? "class" : isDataModelClass(clazz) ? "data" : undefined
   if (!type) {
@@ -151,48 +151,24 @@ const internalModel = <MC extends ModelClass<AnyModel | AnyDataModel>>(
   // track if we fail so we only try it once per class
   afterClassInitializationData.set(clazz, { needsMakeObservable: undefined, type })
 
-  if (addInitializer) {
-    // standard decorator API, avoid proxies
-    addInitializer(function (this: any) {
-      runAfterClassInitialization(clazz, this)
-    })
-
-    const modelInfo = {
-      name,
-      class: clazz,
-    }
-
-    modelInfoByName[name] = modelInfo
+  const decoratedClass = new Proxy<MC>(clazz, proxyClassHandler)
+  ;(decoratedClass as any)[modelUnwrappedClassSymbol] = clazz
 
-    modelInfoByClass.set(clazz, modelInfo)
+  decoratedClass.prototype.constructor = decoratedClass
 
-    runLateInitializationFunctions(clazz, runAfterModelDecoratorSymbol)
-
-    return undefined // use same class
-  } else {
-    // non-standard decorator API, use proxies
-
-    // trick so plain new works
-    const proxyClass = new Proxy<MC>(clazz, proxyClassHandler)
-
-    // set or else it points to the undecorated class
-    proxyClass.prototype.constructor = proxyClass
-    ;(proxyClass as any)[modelUnwrappedClassSymbol] = clazz
-
-    const modelInfo = {
-      name,
-      class: proxyClass,
-    }
+  const modelInfo = {
+    name,
+    class: decoratedClass,
+  }
 
-    modelInfoByName[name] = modelInfo
+  modelInfoByName[name] = modelInfo
 
-    modelInfoByClass.set(proxyClass, modelInfo)
-    modelInfoByClass.set(clazz, modelInfo)
+  modelInfoByClass.set(decoratedClass, modelInfo)
+  modelInfoByClass.set(clazz, modelInfo)
 
-    runLateInitializationFunctions(clazz, runAfterModelDecoratorSymbol)
+  runLateInitializationFunctions(clazz, runAfterModelDecoratorSymbol)
 
-    return proxyClass
-  }
+  return decoratedClass
 }
 
 // basically taken from TS
@@ -243,18 +219,53 @@ export function decoratedModel<M, MC extends abstract new (...ags: any) => M>(
     [k in keyof M]?: AnyFunction | ReadonlyArray<AnyFunction>
   }
 ): MC {
+  const mobx7Annotations: Record<string, unknown> = {}
+
   // decorate class members
   for (const [k, decorator] of Object.entries(decorators)) {
+    const decoratorList = Array.isArray(decorator) ? decorator : [decorator]
+    const mobx7Annotation = decoratorList.find(isMobxAnnotation)
+    if (getMobxVersion() >= 7 && mobx7Annotation) {
+      if (decoratorList.length !== 1) {
+        throw failure("MobX 7 decorators cannot be combined in decoratedModel")
+      }
+      mobx7Annotations[k] = mobx7Annotation
+      continue
+    }
+
     const prototypeValueDesc = Object.getOwnPropertyDescriptor(clazz.prototype, k)
     // TS seems to send null for methods in the prototype
     // (which we substitute for the descriptor to avoid a double look-up) and void 0 (undefined) for props
-    tsDecorate(
-      Array.isArray(decorator) ? decorator : [decorator],
-      clazz.prototype,
-      k,
-      prototypeValueDesc ? prototypeValueDesc : void 0
-    )
+    tsDecorate(decoratorList, clazz.prototype, k, prototypeValueDesc ? prototypeValueDesc : void 0)
+  }
+
+  if (getMobxVersion() >= 7 && Object.keys(mobx7Annotations).length > 0) {
+    addLateInitializationFunction(clazz.prototype, runAfterNewSymbol, (instance) => {
+      makeObservableCompat(instance, mobx7Annotations)
+    })
   }
 
   return (name ? model(name)(clazz as unknown as ModelClass<AnyModel>) : clazz) as MC
 }
+
+type MobxAnnotation = {
+  annotationType_: string
+  make_: AnyFunction
+  extend_: AnyFunction
+}
+
+// MobX uses this same structural check in its internal `isAnnotation` helper.
+// That helper is not part of MobX's public root API, so mirror it here instead
+// of depending on a private deep import that may not exist in every supported version.
+function isMobxAnnotation(value: unknown): value is MobxAnnotation {
+  if ((typeof value !== "object" || value === null) && typeof value !== "function") {
+    return false
+  }
+
+  const annotation = value as Partial<MobxAnnotation>
+  return (
+    typeof annotation.annotationType_ === "string" &&
+    typeof annotation.make_ === "function" &&
+    typeof annotation.extend_ === "function"
+  )
+}

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
   }