mobx-keystone 1.25.0 → 2.0.0

package/src/actionMiddlewares/actionTrackingMiddleware.ts

@@ -253,15 +253,13 @@ export function actionTrackingMiddleware(
       state: State.Finished,
     })
 
-    if (hooks.onFinish) {
-      ret = hooks.onFinish(simpleCtx, ret) || ret
-    }
-
-    if (parentResumed) {
-      suspend(parentCtx!)
+    try {
+      return hooks.onFinish?.(simpleCtx, ret) || ret
+    } finally {
+      if (parentResumed) {
+        suspend(parentCtx!)
+      }
     }
-
-    return ret
   }
 
   const resume = (simpleCtx: SimpleActionContext, real: boolean) => {
@@ -323,10 +321,11 @@ export function actionTrackingMiddleware(
         retObj = finish(simpleCtx, retObj)
       } else {
         try {
-          retObj = finish(simpleCtx, { result: ActionTrackingResult.Return, value: next() })
+          retObj = { result: ActionTrackingResult.Return, value: next() }
         } catch (err) {
-          retObj = finish(simpleCtx, { result: ActionTrackingResult.Throw, value: err })
+          retObj = { result: ActionTrackingResult.Throw, value: err }
         }
+        retObj = finish(simpleCtx, retObj)
       }
 
       return returnOrThrowActionTrackingReturn(retObj)
@@ -409,9 +408,8 @@ const simpleDataContextSymbol = Symbol("simpleDataContext")
  * @returns Simplified action context.
  */
 export function simplifyActionContext(ctx: ActionContext): SimpleActionContext {
-  while (ctx.previousAsyncStepContext) {
-    ctx = ctx.previousAsyncStepContext
-  }
+  // every async step points to the step that spawned its flow (the spawn step points to itself)
+  ctx = ctx.spawnAsyncStepContext ?? ctx
 
   let simpleCtx = ctx.data[simpleDataContextSymbol]
   if (!simpleCtx) {

package/src/actionMiddlewares/transactionMiddleware.ts

@@ -4,8 +4,10 @@ import { assertIsModel } from "../model/utils"
 import { addModelClassInitializer } from "../modelShared/modelClassInitializer"
 import { applyPatches } from "../patch"
 import { internalPatchRecorder, type PatchRecorder } from "../patch/patchRecorder"
-import { assertIsObject, failure } from "../utils"
+import { withTypeCheckingBatch } from "../tweaker/typeChecking"
+import { assertIsObject, failure, MobxKeystoneAggregateError } from "../utils"
 import { checkDecoratorContext } from "../utils/decorators"
+import { pushDelayedError } from "../utils/forEachWithDelayedThrow"
 import {
   ActionTrackingResult,
   actionTrackingMiddleware,
@@ -36,11 +38,15 @@ export function transactionMiddleware<M extends AnyModel>(target: {
 
   const patchRecorderSymbol = Symbol("patchRecorder")
   function initPatchRecorder(ctx: SimpleActionContext) {
-    ctx.rootContext.data[patchRecorderSymbol] = internalPatchRecorder(undefined, {
-      recording: false,
-    })
+    ctx.rootContext.data[patchRecorderSymbol] = {
+      recorder: internalPatchRecorder(undefined, { recording: false }),
+      activeCount: 0,
+    }
   }
-  function getPatchRecorder(ctx: SimpleActionContext): PatchRecorder {
+  function getPatchRecorderData(ctx: SimpleActionContext): {
+    recorder: PatchRecorder
+    activeCount: number
+  } {
     return ctx.rootContext.data[patchRecorderSymbol]
   }
 
@@ -55,23 +61,48 @@ export function transactionMiddleware<M extends AnyModel>(target: {
         initPatchRecorder(ctx)
       }
     },
+    // Actions nest, so recording must only stop once every action of the transaction
+    // has been suspended, not as soon as the innermost one returns.
     onResume(ctx) {
-      getPatchRecorder(ctx).recording = true
+      const data = getPatchRecorderData(ctx)
+      data.activeCount++
+      data.recorder.recording = true
     },
     onSuspend(ctx) {
-      getPatchRecorder(ctx).recording = false
+      const data = getPatchRecorderData(ctx)
+      data.activeCount--
+      data.recorder.recording = data.activeCount > 0
     },
     onFinish(ctx, ret) {
       if (ctx === ctx.rootContext) {
-        const patchRecorder = getPatchRecorder(ctx)
+        const patchRecorder = getPatchRecorderData(ctx).recorder
 
         try {
           if (ret.result === ActionTrackingResult.Throw) {
             // undo changes (backwards for inverse patches)
             const { events } = patchRecorder
-            for (let i = events.length - 1; i >= 0; i--) {
-              const event = events[i]
-              applyPatches(event.target, event.inversePatches, true)
+            const rollbackErrors: unknown[] = []
+            withTypeCheckingBatch(() => {
+              for (let i = events.length - 1; i >= 0; i--) {
+                const event = events[i]
+                // A listener may throw after a patch has already been applied.
+                // Continue at patch granularity so one failure cannot skip the
+                // remaining restoration, including patches from the same edit.
+                for (let j = event.inversePatches.length - 1; j >= 0; j--) {
+                  try {
+                    applyPatches(event.target, [event.inversePatches[j]])
+                  } catch (error) {
+                    pushDelayedError(rollbackErrors, error)
+                  }
+                }
+              }
+            })
+            if (rollbackErrors.length > 0) {
+              // Keep the action error first so the reason for the rollback is not lost.
+              throw new MobxKeystoneAggregateError(
+                [ret.value, ...rollbackErrors],
+                "transaction rollback callbacks failed"
+              )
             }
           }
         } finally {

package/src/actionMiddlewares/undoMiddleware.ts

@@ -19,6 +19,16 @@ import {
 } from "../utils"
 import { actionTrackingMiddleware, type SimpleActionContext } from "./actionTrackingMiddleware"
 
+function checkMaxLevels(value: number | undefined, name: string): void {
+  if (
+    value !== undefined &&
+    value !== Number.POSITIVE_INFINITY &&
+    (!Number.isInteger(value) || value < 0)
+  ) {
+    throw failure(`${name} must be a non-negative integer or Infinity`)
+  }
+}
+
 /**
  * An undo/redo event without attached state.
  */
@@ -151,15 +161,13 @@ export class UndoStore extends Model({
     maxUndoLevels?: number
     maxRedoLevels?: number
   }) {
-    if (maxUndoLevels !== undefined) {
-      while (this.undoEvents.length > maxUndoLevels) {
-        this.undoEvents.shift()
-      }
+    checkMaxLevels(maxUndoLevels, "maxUndoLevels")
+    checkMaxLevels(maxRedoLevels, "maxRedoLevels")
+    if (maxUndoLevels !== undefined && this.undoEvents.length > maxUndoLevels) {
+      this.undoEvents.splice(0, this.undoEvents.length - maxUndoLevels)
     }
-    if (maxRedoLevels !== undefined) {
-      while (this.redoEvents.length > maxRedoLevels) {
-        this.redoEvents.shift()
-      }
+    if (maxRedoLevels !== undefined && this.redoEvents.length > maxRedoLevels) {
+      this.redoEvents.splice(0, this.redoEvents.length - maxRedoLevels)
     }
   }
 
@@ -261,10 +269,16 @@ export class UndoStore extends Model({
         running = true
       },
       end: () => {
+        if (ended) {
+          throw failure("cannot end a group when it is already ended")
+        }
         if (running) {
           api.pause()
         }
         ended = true
+        if (group.events.length === 0) {
+          return
+        }
         if (parentGroup) {
           this._addUndoToParentGroup(parentGroup, group)
         } else {
@@ -388,7 +402,7 @@ export class UndoManager {
         })
 
       // restore the attached state before the operation was made
-      if (event.attachedState?.beforeEvent) {
+      if (event.attachedState) {
         this.options?.attachedState?.restore(event.attachedState.beforeEvent)
       }
     })
@@ -413,7 +427,7 @@ export class UndoManager {
       })
 
       // restore the attached state after the operation was made
-      if (event.attachedState?.afterEvent) {
+      if (event.attachedState) {
         this.options?.attachedState?.restore(event.attachedState.afterEvent)
       }
     })
@@ -586,14 +600,14 @@ export class UndoManager {
       function next(ret: any): void {
         if (ret && typeof ret.then === "function") {
           // an async iterator
-          ret.then(next, reject)
+          Promise.resolve(ret).then(next, reject).catch(reject)
         } else if (ret.done) {
           // done
           group.end()
           resolve(ret.value)
         } else {
           // continue
-          Promise.resolve(ret.value).then(onFulfilled, onRejected)
+          Promise.resolve(ret.value).then(onFulfilled, onRejected).catch(reject)
         }
       }
 
@@ -675,6 +689,8 @@ export function undoMiddleware<S>(
   options?: UndoMiddlewareOptions<S>
 ): UndoManager {
   assertTweakedObject(subtreeRoot, "subtreeRoot")
+  checkMaxLevels(options?.maxUndoLevels, "maxUndoLevels")
+  checkMaxLevels(options?.maxRedoLevels, "maxRedoLevels")
 
   let manager: UndoManager
 
@@ -691,6 +707,7 @@ export function undoMiddleware<S>(
   function initPatchRecorder(ctx: SimpleActionContext) {
     const group = manager.store._currentGroup
 
+    const attachedStateBeforeEvent = options?.attachedState?.save()
     const patchRecorderData: PatchRecorderData = {
       recorder: patchRecorder(subtreeRoot, {
         recording: false,
@@ -702,7 +719,7 @@ export function undoMiddleware<S>(
       undoRootContext: ctx,
       group,
 
-      attachedStateBeforeEvent: options?.attachedState?.save(),
+      attachedStateBeforeEvent,
     }
 
     ctx.rootContext.data[patchRecorderSymbol] = patchRecorderData
@@ -733,42 +750,44 @@ export function undoMiddleware<S>(
       if (patchRecorderData && patchRecorderData.undoRootContext === ctx) {
         const patchRecorder = patchRecorderData.recorder
 
-        if (patchRecorder.events.length > 0) {
-          const patches: Patch[] = []
-          const inversePatches: Patch[] = []
-
-          for (const event of patchRecorder.events) {
-            patches.push(...event.patches)
-            inversePatches.push(...event.inversePatches)
-          }
-
-          const event = {
-            type: UndoEventType.Single,
-            targetPath: fastGetRootPath(ctx.target, false).path,
-            actionName: ctx.actionName,
-            patches,
-            inversePatches,
-          } as const
-
-          const parentGroup = patchRecorderData.group
-
-          if (parentGroup) {
-            manager.store._addUndoToParentGroup(parentGroup, event)
-          } else {
-            manager.store._addUndo({
-              event: {
-                ...event,
-                attachedState: {
-                  beforeEvent: patchRecorderData.attachedStateBeforeEvent,
-                  afterEvent: options?.attachedState?.save(),
+        try {
+          if (patchRecorder.events.length > 0) {
+            const patches: Patch[] = []
+            const inversePatches: Patch[] = []
+
+            for (const event of patchRecorder.events) {
+              for (const patch of event.patches) patches.push(patch)
+              for (const patch of event.inversePatches) inversePatches.push(patch)
+            }
+
+            const event = {
+              type: UndoEventType.Single,
+              targetPath: fastGetRootPath(ctx.target, false).path,
+              actionName: ctx.actionName,
+              patches,
+              inversePatches,
+            } as const
+
+            const parentGroup = patchRecorderData.group
+
+            if (parentGroup) {
+              manager.store._addUndoToParentGroup(parentGroup, event)
+            } else {
+              manager.store._addUndo({
+                event: {
+                  ...event,
+                  attachedState: {
+                    beforeEvent: patchRecorderData.attachedStateBeforeEvent,
+                    afterEvent: options?.attachedState?.save(),
+                  },
                 },
-              },
-              maxUndoLevels: options?.maxUndoLevels,
-            })
+                maxUndoLevels: options?.maxUndoLevels,
+              })
+            }
           }
+        } finally {
+          patchRecorder.dispose()
         }
-
-        patchRecorder.dispose()
       }
     },
   })

package/src/actionMiddlewares/utils.ts

@@ -1,5 +1,6 @@
 import { modelIdKey } from "../model/metadata"
 import { isModel } from "../model/utils"
+import { modelToDataNode } from "../parent/core"
 import type { RootPath } from "../parent/path"
 import type { Path } from "../parent/pathTypes"
 
@@ -26,7 +27,7 @@ export function pathToTargetPathIds(root: any, path: Path): (string | null)[] {
   let current = root // we don't care about the root ID
 
   for (let i = 0; i < path.length; i++) {
-    current = current[path[i]]
+    current = modelToDataNode(current)[path[i]]
     const targetObjId = isModel(current) ? (current[modelIdKey] ?? null) : null
     targetPathIds.push(targetObjId)
   }

package/src/computedTree/computedTree.ts

@@ -5,7 +5,12 @@ import { isDataModelClass } from "../dataModel/utils"
 import { isModelClass } from "../model/utils"
 import { isTreeNode } from "../tweaker/core"
 import { tweak } from "../tweaker/tweak"
-import { addLateInitializationFunction, failure, runBeforeOnInitSymbol } from "../utils"
+import {
+  addLateInitializationFunction,
+  failure,
+  isEqualOrBothNaN,
+  runBeforeOnInitSymbol,
+} from "../utils"
 import { checkDecoratorContext, copyFunctionMetadata } from "../utils/decorators"
 import { getOrCreate } from "../utils/mapUtils"
 
@@ -54,14 +59,20 @@ export function computedTree(...args: any[]): any {
       const oldValue = entry.value
       const newValue = entry.computed.get()
 
-      if (oldValue === newValue) {
+      if (isEqualOrBothNaN(oldValue, newValue)) {
         return entry.tweakedValue
       }
 
       const oldTweakedValue = entry.tweakedValue
       tweak(oldTweakedValue, undefined)
 
-      const tweakedValue = tweakComputedTreeNode(newValue, this, propertyKey)
+      let tweakedValue: unknown
+      try {
+        tweakedValue = tweakComputedTreeNode(newValue, this, propertyKey)
+      } catch (error) {
+        entry.tweakedValue = tweakComputedTreeNode(oldTweakedValue, this, propertyKey)
+        throw error
+      }
       entry.value = newValue
       entry.tweakedValue = tweakedValue
       return tweakedValue

package/src/context/context.ts

@@ -120,56 +120,28 @@ class ContextClass<T> implements Context<T> {
     this.nodeAtom.get(node)?.reportChanged()
   }
 
-  private fastGet(node: object, useAtom: boolean): T {
-    if (useAtom) {
-      this.reportNodeAtomObserved(node)
+  get(node: object): T {
+    const provider = this.getProviderNode(node)
+    if (provider) {
+      return resolveContextValue(this.nodeContextValue.get(provider)!)
     }
 
-    const obsForNode = this.nodeContextValue.get(node)
-    if (obsForNode) {
-      return resolveContextValue(obsForNode)
-    }
-
-    const parent = fastGetParent(node, useAtom)
-    if (!parent) {
-      const overrideValue = this.overrideContextValue.get()
-      if (overrideValue) {
-        return resolveContextValue(overrideValue)
-      }
-      return this.getDefault()
-    }
-
-    return this.fastGet(parent, useAtom)
-  }
-
-  get(node: object) {
-    assertTweakedObject(node, "node")
-
-    return this.fastGet(node, true)
-  }
-
-  private fastGetProviderNode(node: object, useAtom: boolean): object | undefined {
-    if (useAtom) {
-      this.reportNodeAtomObserved(node)
-    }
-
-    const obsForNode = this.nodeContextValue.get(node)
-    if (obsForNode) {
-      return node
-    }
-
-    const parent = fastGetParent(node, useAtom)
-    if (!parent) {
-      return undefined
-    }
-
-    return this.fastGetProviderNode(parent, useAtom)
+    const overrideValue = this.overrideContextValue.get()
+    return overrideValue ? resolveContextValue(overrideValue) : this.getDefault()
   }
 
   getProviderNode(node: object): object | undefined {
     assertTweakedObject(node, "node")
 
-    return this.fastGetProviderNode(node, true)
+    let current: object | undefined = node
+    while (current) {
+      this.reportNodeAtomObserved(current)
+      if (this.nodeContextValue.has(current)) {
+        return current
+      }
+      current = fastGetParent(current, true)
+    }
+    return undefined
   }
 
   getDefault(): T {
@@ -227,7 +199,7 @@ class ContextClass<T> implements Context<T> {
 
     try {
       const ret = fn()
-      if (isTweakedObject(ret, true)) {
+      if (isTweakedObject(ret, false)) {
         this.set(ret, value)
       }
       return ret
@@ -247,7 +219,7 @@ class ContextClass<T> implements Context<T> {
 
     try {
       const ret = fn()
-      if (isTweakedObject(ret, true)) {
+      if (isTweakedObject(ret, false)) {
         this._setComputed(ret, computedValueFn)
       }
       return ret

package/src/dataModel/BaseDataModel.ts

@@ -1,4 +1,4 @@
-import { type ModelClass, propsTypeSymbol } from "../modelShared/BaseModelShared"
+import { propsTypeSymbol } from "../modelShared/BaseModelShared"
 import { modelInfoByClass } from "../modelShared/modelInfo"
 import { getInternalModelClassPropsInfo } from "../modelShared/modelPropsInfo"
 import {
@@ -15,14 +15,13 @@ import { toTreeNode } from "../tweaker/tweak"
 import { typesDataModelData } from "../types/objectBased/typesDataModelData"
 import type { TypeCheckError } from "../types/TypeCheckError"
 import { typeCheck } from "../types/typeCheck"
-import { clonePlainObject, failure, isObject } from "../utils"
+import { clonePlainObject, failure, hasOwnProp, isObject, setProtoProp } from "../utils"
 import { getOrCreate } from "../utils/mapUtils"
 import type { DataModelConstructorOptions } from "./DataModelConstructorOptions"
+import { dataModelInstanceCache } from "./dataModelInstanceCache"
 import { getDataModelMetadata } from "./getDataModelMetadata"
 import { internalNewDataModel } from "./newDataModel"
 
-const dataModelInstanceCache = new WeakMap<ModelClass<AnyDataModel>, WeakMap<any, AnyDataModel>>()
-
 /**
  * Base abstract class for data models. Use `DataModel` instead when extending.
  *
@@ -101,7 +100,8 @@ export abstract class BaseDataModel<TProps extends ModelProps> {
         const k = modelPropsKeys[i]
         const propData = modelProps[k]
 
-        let newValue = initialData[k]
+        const hasInitialValue = hasOwnProp(initialData, k)
+        let newValue = hasInitialValue ? initialData[k] : undefined
         let changed = false
 
         // apply untransform (if any)
@@ -117,11 +117,15 @@ export abstract class BaseDataModel<TProps extends ModelProps> {
           if (defaultValue !== noDefaultValue) {
             changed = true
             newValue = defaultValue
+          } else if (!hasInitialValue) {
+            // for mobx4, we need to set up properties even if they are undefined
+            changed = true
           }
         }
 
         if (changed) {
-          initialData[k] = newValue
+          if (k === "__proto__") setProtoProp(initialData, newValue)
+          else initialData[k] = newValue
         }
       }
 
@@ -144,24 +148,24 @@ export abstract class BaseDataModel<TProps extends ModelProps> {
 
     Object.setPrototypeOf(this, modelClass.prototype)
 
-    internalNewDataModel(this, tweakedData as any, {
-      modelClass,
-    })
+    try {
+      internalNewDataModel(this, tweakedData as any, {
+        modelClass,
+      })
+    } catch (error) {
+      instancesForModelClass.delete(tweakedData)
+      throw error
+    }
   }
 
   toString(options?: { withData?: boolean }) {
-    const finalOptions = {
-      withData: true,
-      ...options,
-    }
+    const { withData = true } = options ?? {}
 
     const modelInfo = modelInfoByClass.get(this.constructor as any)
 
     const firstPart = `${this.constructor.name}#${modelInfo!.name}`
 
-    return finalOptions.withData
-      ? `[${firstPart} ${JSON.stringify(getSnapshot(this))}]`
-      : `[${firstPart}]`
+    return withData ? `[${firstPart} ${JSON.stringify(getSnapshot(this.$))}]` : `[${firstPart}]`
   }
 }
 

package/src/dataModel/dataModelInstanceCache.ts

@@ -0,0 +1,8 @@
+import type { ModelClass } from "../modelShared/BaseModelShared"
+import type { AnyDataModel } from "./BaseDataModel"
+
+/** @internal */
+export const dataModelInstanceCache = new WeakMap<
+  ModelClass<AnyDataModel>,
+  WeakMap<object, AnyDataModel>
+>()