mobx-keystone 2.0.0 → 2.1.0

package/dist/types/actionMiddlewares/transactionMiddleware.d.ts

@@ -2,7 +2,7 @@ import { ActionMiddlewareDisposer } from '../action/middleware';
 import { AnyModel } from '../model/BaseModel';
 /**
  * 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`).

package/dist/types/actionMiddlewares/undoMiddleware.d.ts

@@ -1,6 +1,8 @@
 import { ActionMiddlewareDisposer } from '../action/middleware';
+import { Frozen } from '../frozen';
 import { Path } from '../parent/pathTypes';
 import { Patch } from '../patch';
+import { FrozenData } from '../snapshot';
 /**
  * An undo/redo event without attached state.
  */
@@ -75,20 +77,25 @@ export interface UndoEventGroup {
     readonly events: ReadonlyArray<UndoEventWithoutAttachedState>;
 }
 declare const UndoStore_base: import('..')._Model<unknown, {
-    undoEvents: import('..').OptionalModelProp<UndoEvent[]> & {
-        $storedValueType: UndoEvent[];
-        $storedCreationValueType: UndoEvent[] | null | undefined;
-        $typedFromSnapshotOverride: UndoEvent[] | null | undefined;
+    undoEvents: import('..').OptionalModelProp<Frozen<UndoEvent>[]> & {
+        $storedValueType: Frozen<UndoEvent>[];
+        $storedCreationValueType: Frozen<UndoEvent>[] | null | undefined;
+        $typedFromSnapshotOverride: import('..').SnapshotInOfFrozen<Frozen<UndoEvent>>[] | null | undefined;
     };
-    redoEvents: import('..').OptionalModelProp<UndoEvent[]> & {
-        $storedValueType: UndoEvent[];
-        $storedCreationValueType: UndoEvent[] | null | undefined;
-        $typedFromSnapshotOverride: UndoEvent[] | null | undefined;
+    redoEvents: import('..').OptionalModelProp<Frozen<UndoEvent>[]> & {
+        $storedValueType: Frozen<UndoEvent>[];
+        $storedCreationValueType: Frozen<UndoEvent>[] | null | undefined;
+        $typedFromSnapshotOverride: import('..').SnapshotInOfFrozen<Frozen<UndoEvent>>[] | null | undefined;
     };
-}, never, never>;
+}, {
+    undoEvents?: ReadonlyArray<UndoEvent | FrozenData<UndoEvent>>;
+    redoEvents?: ReadonlyArray<UndoEvent | FrozenData<UndoEvent>>;
+}, never>;
 /**
  * Store model instance for undo/redo actions.
- * Do not manipulate directly, other that creating it.
+ * Do not manipulate directly, other than creating it.
+ *
+ * Events are stored as frozen data, since they never change once recorded.
  */
 export declare class UndoStore extends UndoStore_base {
     /**

package/dist/types/parent/arrayPaths.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/types/parent/treeOrder.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/types/patch/applyPatches.d.ts

@@ -2,7 +2,8 @@ import { Patch } from '../patch/Patch';
 /**
  * Applies the given patches to the given target object.
  * Automatic type checking validates the completed batch, including nested lists.
- * A rejected batch is rolled back with compensating patches.
+ * A batch that throws or is rejected is rolled back with compensating patches.
+ * Errors thrown by listeners do not roll it back.
  *
  * @param node Target object.
  * @param patches List of patches to apply.

package/dist/types/ref/modelRefIdIndex.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/types/ref/nodesById.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/types/ref/refIdIndex.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/types/snapshot/applySnapshot.d.ts

@@ -1,6 +1,7 @@
 import { SnapshotInOf, SnapshotOutOf } from './SnapshotOf';
 /**
  * Applies a full snapshot over an object, reconciling it with the current contents of the object.
+ * If it throws, the changes it made are rolled back (errors thrown by listeners do not roll them back).
  *
  * @template T Object type.
  * @param node Target object (model object, object or array).

package/dist/types/snapshot/fromSnapshot.d.ts

@@ -28,6 +28,3 @@ export declare function fromSnapshot<TType extends AnyType>(type: TType, snapsho
  * @returns The deserialized object.
  */
 export declare function fromSnapshot<T>(snapshot: SnapshotInOf<T> | SnapshotOutOf<T>, options?: Partial<FromSnapshotOptions>): T;
-export declare const observableOptions: {
-    deep: boolean;
-};

package/dist/types/tweaker/changeRollback.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/types/tweaker/tweakedChangeListeners.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/types/utils/ModelPool.d.ts

@@ -1,7 +1,13 @@
 import { AnyModel } from '../model/BaseModel';
+/**
+ * A view of the models under a node, as they were when the pool was created.
+ * Must be released once no longer used.
+ */
 export declare class ModelPool {
-    private pool;
+    private readonly pool;
+    private readonly pinned;
     constructor(root: object);
+    release(): void;
     findModelByTypeAndId(modelType: string, modelId: string | undefined): AnyModel | undefined;
     findModelForSnapshot(sn: any): AnyModel | undefined;
 }

package/dist/types/utils/chunks.d.ts

@@ -0,0 +1 @@
+export {};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "mobx-keystone",
-  "version": "2.0.0",
+  "version": "2.1.0",
   "description": "A MobX powered state management solution based on data trees with first class support for TypeScript, snapshots, patches and much more",
   "keywords": [
     "mobx",
@@ -78,12 +78,12 @@
     "@types/node": "^26.4.1",
     "@typescript/typescript6": "^6.0.2",
     "@vitest/coverage-v8": "^5.0.0",
+    "expect-type": "^1.4.0",
     "mobx-v4": "npm:mobx@^4.15.7",
     "mobx-v5": "npm:mobx@^5.15.7",
     "mobx-v6": "npm:mobx@^6.0.0",
     "mobx-v7": "npm:mobx@^7.0.0",
     "shx": "^0.4.0",
-    "spec.ts": "^1.1.3",
     "ts-node": "^10.9.2",
     "typedoc": "^0.28.20",
     "typescript": "^7.0.2",

package/src/actionMiddlewares/transactionMiddleware.ts

@@ -1,10 +1,10 @@
 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 { withTypeCheckingBatch } from "../tweaker/typeChecking"
+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"
@@ -16,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`).
@@ -36,18 +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] = {
-      recorder: internalPatchRecorder(undefined, { recording: false }),
+  const rollbackRecorderSymbol = Symbol("rollbackRecorder")
+  function initRollbackRecorder(ctx: SimpleActionContext) {
+    ctx.rootContext.data[rollbackRecorderSymbol] = {
+      recorder: new ChangeRollbackRecorder(),
       activeCount: 0,
     }
   }
-  function getPatchRecorderData(ctx: SimpleActionContext): {
-    recorder: PatchRecorder
+  function getRollbackRecorderData(ctx: SimpleActionContext): {
+    recorder: ChangeRollbackRecorder
     activeCount: number
   } {
-    return ctx.rootContext.data[patchRecorderSymbol]
+    return ctx.rootContext.data[rollbackRecorderSymbol]
   }
 
   return actionTrackingMiddleware(model, {
@@ -58,55 +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) {
-      const data = getPatchRecorderData(ctx)
+      const data = getRollbackRecorderData(ctx)
       data.activeCount++
       data.recorder.recording = true
     },
     onSuspend(ctx) {
-      const data = getPatchRecorderData(ctx)
+      const data = getRollbackRecorderData(ctx)
       data.activeCount--
       data.recorder.recording = data.activeCount > 0
     },
     onFinish(ctx, ret) {
       if (ctx === ctx.rootContext) {
-        const patchRecorder = getPatchRecorderData(ctx).recorder
+        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
-            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 (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"
-              )
-            }
+          })
+          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()
         }
       }
     },

package/src/actionMiddlewares/undoMiddleware.ts

@@ -1,12 +1,15 @@
 import type { ActionMiddlewareDisposer } from "../action/middleware"
 import { modelAction } from "../action/modelAction"
+import { type Frozen, FrozenCheckMode, frozen, isFrozenSnapshot, toFrozenSnapshot } from "../frozen"
 import { Model } from "../model/Model"
 import { model } from "../modelShared/modelDecorator"
 import { fastGetRootPath } from "../parent/path"
 import type { Path } from "../parent/pathTypes"
 import { applyPatches, type Patch, type PatchRecorder, patchRecorder } from "../patch"
+import type { FrozenData } from "../snapshot"
 import { assertTweakedObject } from "../tweaker/core"
 import { typesArray } from "../types/arrayBased/typesArray"
+import { typesFrozen } from "../types/objectBased/typesObject"
 import { tProp } from "../types/tProp"
 import { typesUnchecked } from "../types/utility/typesUnchecked"
 import {
@@ -121,16 +124,45 @@ function toSingleEvents(
   return array
 }
 
+// snapshots from before events were frozen have them as plain objects
+function toFrozenEventSnapshots(
+  events: ReadonlyArray<UndoEvent | FrozenData<UndoEvent>> | undefined
+): FrozenData<UndoEvent>[] | undefined {
+  return events?.map((e) => (isFrozenSnapshot<UndoEvent>(e) ? e : toFrozenSnapshot(e)))
+}
+
+function freezeEvent(event: UndoEvent): Frozen<UndoEvent> {
+  // events are only read once recorded, so they are not checked or deeply
+  // frozen (that would also freeze the attached states given by the user)
+  return frozen(event, FrozenCheckMode.Off)
+}
+
 /**
  * Store model instance for undo/redo actions.
- * Do not manipulate directly, other that creating it.
+ * Do not manipulate directly, other than creating it.
+ *
+ * Events are stored as frozen data, since they never change once recorded.
  */
 @model(`${namespace}/UndoStore`)
-export class UndoStore extends Model({
-  // TODO: add proper type checking to undo store
-  undoEvents: tProp(typesArray(typesUnchecked<UndoEvent>()), () => []),
-  redoEvents: tProp(typesArray(typesUnchecked<UndoEvent>()), () => []),
-}) {
+export class UndoStore extends Model(
+  {
+    // TODO: add proper type checking to undo store
+    undoEvents: tProp(typesArray(typesFrozen(typesUnchecked<UndoEvent>())), () => []),
+    redoEvents: tProp(typesArray(typesFrozen(typesUnchecked<UndoEvent>())), () => []),
+  },
+  {
+    fromSnapshotProcessor(sn: {
+      undoEvents?: ReadonlyArray<UndoEvent | FrozenData<UndoEvent>>
+      redoEvents?: ReadonlyArray<UndoEvent | FrozenData<UndoEvent>>
+    }) {
+      return {
+        ...sn,
+        undoEvents: toFrozenEventSnapshots(sn.undoEvents),
+        redoEvents: toFrozenEventSnapshots(sn.redoEvents),
+      }
+    },
+  }
+) {
   /**
    * @ignore
    */
@@ -201,7 +233,7 @@ export class UndoStore extends Model({
   @modelAction
   _addUndo({ event, maxUndoLevels }: { event: UndoEvent; maxUndoLevels: number | undefined }) {
     withoutUndo(() => {
-      this.undoEvents.push(event)
+      this.undoEvents.push(freezeEvent(event))
       // once an undo event is added redo queue is no longer valid
       this.redoEvents.length = 0
       this.enforceMaxLevels({ maxUndoLevels })
@@ -323,7 +355,7 @@ export class UndoManager {
    */
   @mobxComputed
   get undoQueue(): ReadonlyArray<UndoEvent> {
-    return this.store.undoEvents
+    return this.store.undoEvents.map((e) => e.data)
   }
 
   /**
@@ -332,7 +364,7 @@ export class UndoManager {
    */
   @mobxComputed
   get redoQueue(): ReadonlyArray<UndoEvent> {
-    return this.store.redoEvents
+    return this.store.redoEvents.map((e) => e.data)
   }
 
   /**
@@ -340,7 +372,7 @@ export class UndoManager {
    */
   @mobxComputed
   get undoLevels() {
-    return this.undoQueue.length
+    return this.store.undoEvents.length
   }
 
   /**
@@ -364,7 +396,7 @@ export class UndoManager {
    */
   @mobxComputed
   get redoLevels() {
-    return this.redoQueue.length
+    return this.store.redoEvents.length
   }
 
   /**
@@ -392,7 +424,8 @@ export class UndoManager {
     if (!this.canUndo) {
       throw failure("nothing to undo")
     }
-    const event = this.undoQueue[this.undoQueue.length - 1]
+    const events = this.store.undoEvents
+    const event = events[events.length - 1].data
 
     withoutUndo(() => {
       toSingleEvents(event)
@@ -419,7 +452,8 @@ export class UndoManager {
     if (!this.canRedo) {
       throw failure("nothing to redo")
     }
-    const event = this.redoQueue[this.redoQueue.length - 1]
+    const events = this.store.redoEvents
+    const event = events[events.length - 1].data
 
     withoutUndo(() => {
       toSingleEvents(event).forEach((e) => {

package/src/model/BaseModel.ts

@@ -17,7 +17,7 @@ import type { SnapshotInOfModel, SnapshotOutOfModel } from "../snapshot/Snapshot
 import { typesModel } from "../types/objectBased/typesModel"
 import type { TypeCheckError } from "../types/TypeCheckError"
 import { typeCheck } from "../types/typeCheck"
-import { assertIsObject, failure } from "../utils"
+import { assertIsObject, failure, nodeObservableOptions } from "../utils"
 import { getModelIdPropertyName } from "./getModelMetadata"
 import type { ModelConstructorOptions } from "./ModelConstructorOptions"
 import { modelIdKey, modelTypeKey } from "./metadata"
@@ -150,9 +150,11 @@ export abstract class BaseModel<
       // Empty input is filled by the constructor below. Track its primitive
       // defaults directly instead of rereading observable fields for the snapshot.
       const useInitialDataSnapshot = Reflect.ownKeys(initialData).length === 0
-      const observableInitialData = observable.object(initialData as any, undefined, {
-        deep: false,
-      })
+      const observableInitialData = observable.object(
+        initialData as any,
+        undefined,
+        nodeObservableOptions
+      )
       if (useInitialDataSnapshot) {
         setModelInitialDataSnapshot(observableInitialData, {})
       }

package/src/modelShared/modelDecorator.ts

@@ -19,6 +19,7 @@ import {
   addLateInitializationFunction,
   failure,
   getMobxVersion,
+  hasStoredMobxAnnotations,
   logWarning,
   makeObservableCompat,
   runAfterNewSymbol,
@@ -55,33 +56,12 @@ const afterClassInitializationData = new WeakMap<
 const runAfterClassInitialization = (tag: AfterClassInitializationData, instance: any) => {
   runLateInitializationFunctions(instance, runAfterNewSymbol)
 
-  // compatibility with mobx 6 and 7
+  // MobX 6 legacy decorators need makeObservable, while MobX 7 annotations (see
+  // decoratedModel) and 2022.3 decorators initialize themselves. Otherwise it
+  // would only add an empty observable administration to every instance.
+  tag.needsMakeObservable ??= getMobxVersion() === 6 && hasStoredMobxAnnotations(instance)
   if (tag.needsMakeObservable) {
-    // we know it can be done and shouldn't fail
     makeObservableCompat(instance)
-  } else if (tag.needsMakeObservable === undefined) {
-    if (getMobxVersion() >= 6) {
-      try {
-        makeObservableCompat(instance)
-        tag.needsMakeObservable = true
-      } catch (e) {
-        const err = e as Error
-        if (
-          err.message !==
-            "[MobX] No annotations were passed to makeObservable, but no decorator members have been found either" &&
-          err.message !==
-            "[MobX] No annotations were passed to makeObservable, but no decorated members have been found either"
-        ) {
-          throw err
-        }
-
-        // sadly we need to use this hack since the PR to do this the proper way
-        // was rejected on the mobx side
-        tag.needsMakeObservable = false
-      }
-    } else {
-      tag.needsMakeObservable = false
-    }
   }
 
   // the object is ready