mobx-keystone 1.25.0 → 2.1.0

package/src/actionMiddlewares/actionSerialization/applySerializedAction.ts

@@ -1,9 +1,10 @@
 import { runInAction } from "mobx"
 import { applyAction } from "../../action/applyAction"
 import { frozenKey } from "../../frozen/Frozen"
+import type { AnyModel } from "../../model/BaseModel"
 import { getModelIdPropertyName } from "../../model/getModelMetadata"
 import { isModel } from "../../model/utils"
-import { resolvePath } from "../../parent/path"
+import { fastGetParentToChildPath, resolvePath } from "../../parent/path"
 import type { WritablePath } from "../../parent/pathTypes"
 import { applyPatches } from "../../patch/applyPatches"
 import { onPatches } from "../../patch/emitPatch"
@@ -53,16 +54,28 @@ export function applySerializedActionAndTrackNewModelIds<TRet = any>(
 
   const deserializedCall = deserializeActionCall(call, subtreeRoot)
 
-  const modelIdOverrides: Patch[] = []
+  const modelsWithChangedIds = new Map<AnyModel, string>()
 
   // set a patch listener to track changes to model ids
   const patchDisposer = onPatches(subtreeRoot, (patches) => {
-    scanPatchesForModelIdChanges(subtreeRoot, modelIdOverrides, patches)
+    scanPatchesForModelIdChanges(subtreeRoot, modelsWithChangedIds, patches)
   })
 
   try {
     const returnValue = applyAction(subtreeRoot, deserializedCall)
 
+    const modelIdOverrides: Patch[] = []
+    for (const [model, idProperty] of modelsWithChangedIds) {
+      const path = fastGetParentToChildPath(subtreeRoot, model, false)
+      if (path) {
+        modelIdOverrides.push({
+          op: "replace",
+          path: [...path, idProperty],
+          value: model.$[idProperty],
+        })
+      }
+    }
+
     return {
       returnValue,
       serializedActionCall: {
@@ -75,24 +88,23 @@ export function applySerializedActionAndTrackNewModelIds<TRet = any>(
   }
 }
 
-function scanPatchesForModelIdChanges(root: object, modelIdOverrides: Patch[], patches: Patch[]) {
+function scanPatchesForModelIdChanges(
+  root: object,
+  modelsWithChangedIds: Map<AnyModel, string>,
+  patches: Patch[]
+) {
   const len = patches.length
   for (let i = 0; i < len; i++) {
     const patch = patches[i]
     if (patch.op === "replace" || patch.op === "add") {
-      deepScanValueForModelIdChanges(
-        root,
-        modelIdOverrides,
-        patch.value,
-        patch.path as WritablePath
-      )
+      deepScanValueForModelIdChanges(root, modelsWithChangedIds, patch.value, patch.path.slice())
     }
   }
 }
 
 function deepScanValueForModelIdChanges(
   root: object,
-  modelIdOverrides: Patch[],
+  modelsWithChangedIds: Map<AnyModel, string>,
   value: any,
   path: WritablePath
 ) {
@@ -102,20 +114,17 @@ function deepScanValueForModelIdChanges(
 
     if (isModel(parent)) {
       const propertyName = path[path.length - 1]
-      if (propertyName === getModelIdPropertyName(parent.constructor as any)) {
-        // found one
-        modelIdOverrides.push({
-          op: "replace",
-          path: path.slice(),
-          value: value,
-        })
+      const idProperty = getModelIdPropertyName(parent.constructor as any)
+      if (idProperty !== undefined && propertyName === idProperty) {
+        // Resolve the final path and ID after the action, since this model may move or detach.
+        modelsWithChangedIds.set(parent, idProperty)
       }
     }
   } else if (Array.isArray(value)) {
     const len = value.length
     for (let i = 0; i < len; i++) {
       path.push(i)
-      deepScanValueForModelIdChanges(root, modelIdOverrides, value[i], path)
+      deepScanValueForModelIdChanges(root, modelsWithChangedIds, value[i], path)
       path.pop()
     }
   } else if (isObject(value)) {
@@ -128,7 +137,7 @@ function deepScanValueForModelIdChanges(
         const propValue = value[propName]
 
         path.push(propName)
-        deepScanValueForModelIdChanges(root, modelIdOverrides, propValue, path)
+        deepScanValueForModelIdChanges(root, modelsWithChangedIds, propValue, path)
         path.pop()
       }
     }

package/src/actionMiddlewares/actionSerialization/arraySerializer.ts

@@ -11,7 +11,7 @@ export const arraySerializer: ActionCallArgumentSerializer<any[] | IObservableAr
     }
 
     // this will also transform observable arrays into non-observable ones
-    return value.map(serialize)
+    return Array.from(value, serialize)
   },
 
   deserialize(arr, deserialize) {

package/src/actionMiddlewares/actionSerialization/dateSerializer.ts

@@ -1,17 +1,18 @@
 import { namespace } from "../../utils"
 import { type ActionCallArgumentSerializer, cannotSerialize } from "./core"
 
-export const dateSerializer: ActionCallArgumentSerializer<Date, number> = {
+export const dateSerializer: ActionCallArgumentSerializer<Date, number | null> = {
   id: `${namespace}/dateAsTimestamp`,
 
   serialize(date) {
     if (!(date instanceof Date)) {
       return cannotSerialize
     }
-    return +date
+    const timestamp = +date
+    return Number.isNaN(timestamp) ? null : timestamp
   },
 
   deserialize(timestamp) {
-    return new Date(timestamp)
+    return new Date(timestamp === null ? Number.NaN : timestamp)
   },
 }

package/src/actionMiddlewares/actionSerialization/mapSerializer.ts

@@ -15,13 +15,8 @@ export const mapSerializer: ActionCallArgumentSerializer<
 
     const arr: [any, any][] = []
 
-    const iter = map.keys()
-    let cur = iter.next()
-    while (!cur.done) {
-      const k = cur.value
-      const v = map.get(k)
-      arr.push([serialize(k), serialize(v)])
-      cur = iter.next()
+    for (const [key, value] of map.entries()) {
+      arr.push([serialize(key), serialize(value)])
     }
 
     return arr
@@ -30,11 +25,8 @@ export const mapSerializer: ActionCallArgumentSerializer<
   deserialize(arr, deserialize) {
     const map = new Map()
 
-    const len = arr.length
-    for (let i = 0; i < len; i++) {
-      const k = arr[i][0]
-      const v = arr[i][1]
-      map.set(deserialize(k), deserialize(v))
+    for (const [key, value] of arr) {
+      map.set(deserialize(key), deserialize(value))
     }
 
     return map

package/src/actionMiddlewares/actionSerialization/setSerializer.ts

@@ -1,4 +1,4 @@
-import type { ObservableSet } from "mobx"
+import { isObservableSet, type ObservableSet } from "mobx"
 import { namespace } from "../../utils"
 import { type ActionCallArgumentSerializer, cannotSerialize } from "./core"
 
@@ -6,21 +6,12 @@ export const setSerializer: ActionCallArgumentSerializer<Set<any> | ObservableSe
   id: `${namespace}/setAsArray`,
 
   serialize(set, serialize) {
-    if (!(set instanceof Set)) {
+    if (!(set instanceof Set || isObservableSet(set))) {
       return cannotSerialize
     }
 
-    const arr: any[] = []
-
-    const iter = set.keys()
-    let cur = iter.next()
-    while (!cur.done) {
-      const k = cur.value
-      arr.push(serialize(k))
-      cur = iter.next()
-    }
-
-    return arr
+    // Array.from closes the iterator if an element cannot be serialized.
+    return Array.from(set.keys(), serialize)
   },
 
   deserialize(arr, deserialize) {

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

@@ -1,11 +1,13 @@
 import type { ActionMiddlewareDisposer } from "../action/middleware"
+import { runUnprotected } from "../action/runUnprotected"
 import type { AnyModel } from "../model/BaseModel"
 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 { ChangeRollbackRecorder } from "../tweaker/changeRollback"
+import { withoutTypeChecking } from "../tweaker/withoutTypeChecking"
+import { assertIsObject, failure, MobxKeystoneAggregateError } from "../utils"
 import { checkDecoratorContext } from "../utils/decorators"
+import { pushDelayedError } from "../utils/forEachWithDelayedThrow"
 import {
   ActionTrackingResult,
   actionTrackingMiddleware,
@@ -14,7 +16,7 @@ import {
 
 /**
  * Creates a transaction middleware, which reverts changes made by an action / child
- * actions when the root action throws an exception by applying inverse patches.
+ * actions when the root action throws an exception, restoring the values those changes replaced.
  *
  * @template M Model
  * @param target Object with the root target model object (`model`) and root action name (`actionName`).
@@ -34,14 +36,18 @@ export function transactionMiddleware<M extends AnyModel>(target: {
     throw failure("target.actionName must be a string")
   }
 
-  const patchRecorderSymbol = Symbol("patchRecorder")
-  function initPatchRecorder(ctx: SimpleActionContext) {
-    ctx.rootContext.data[patchRecorderSymbol] = internalPatchRecorder(undefined, {
-      recording: false,
-    })
+  const rollbackRecorderSymbol = Symbol("rollbackRecorder")
+  function initRollbackRecorder(ctx: SimpleActionContext) {
+    ctx.rootContext.data[rollbackRecorderSymbol] = {
+      recorder: new ChangeRollbackRecorder(),
+      activeCount: 0,
+    }
   }
-  function getPatchRecorder(ctx: SimpleActionContext): PatchRecorder {
-    return ctx.rootContext.data[patchRecorderSymbol]
+  function getRollbackRecorderData(ctx: SimpleActionContext): {
+    recorder: ChangeRollbackRecorder
+    activeCount: number
+  } {
+    return ctx.rootContext.data[rollbackRecorderSymbol]
   }
 
   return actionTrackingMiddleware(model, {
@@ -52,30 +58,54 @@ export function transactionMiddleware<M extends AnyModel>(target: {
     },
     onStart(ctx) {
       if (ctx === ctx.rootContext) {
-        initPatchRecorder(ctx)
+        initRollbackRecorder(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 = getRollbackRecorderData(ctx)
+      data.activeCount++
+      data.recorder.recording = true
     },
     onSuspend(ctx) {
-      getPatchRecorder(ctx).recording = false
+      const data = getRollbackRecorderData(ctx)
+      data.activeCount--
+      data.recorder.recording = data.activeCount > 0
     },
     onFinish(ctx, ret) {
       if (ctx === ctx.rootContext) {
-        const patchRecorder = getPatchRecorder(ctx)
+        const recorder = getRollbackRecorderData(ctx).recorder
+        // stop recording, so the rollback is not recorded as well
+        recorder.dispose()
 
-        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)
-            }
+        if (ret.result === ActionTrackingResult.Throw) {
+          // revert changes (backwards). Restoring the replaced values themselves
+          // (rather than applying inverse patches) keeps node identities, so
+          // nodes that were detached and then changed are restored too.
+          const { reverts } = recorder
+          const rollbackErrors: unknown[] = []
+          runUnprotected(() => {
+            // it restores the state before the action, which was already checked
+            withoutTypeChecking(() => {
+              for (let i = reverts.length - 1; i >= 0; i--) {
+                // A listener may throw after a change has already been reverted.
+                // Keep going so one failure cannot skip the remaining restoration.
+                try {
+                  reverts[i]()
+                } 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 {
-          patchRecorder.dispose()
         }
       }
     },