mobx-keystone 0.67.4 → 0.68.1-alpha

package/dist/src/actionMiddlewares/actionTrackingMiddleware.mjs

@@ -0,0 +1,239 @@
+import { ActionContextActionType, ActionContextAsyncStepType } from "../action/context.mjs";
+import { addActionMiddleware } from "../action/middleware.mjs";
+import { assertTweakedObject } from "../tweaker/core.mjs";
+import { failure } from "../utils/index.mjs";
+var ActionTrackingResult;
+(function(ActionTrackingResult2) {
+  ActionTrackingResult2["Return"] = "return";
+  ActionTrackingResult2["Throw"] = "throw";
+})(ActionTrackingResult || (ActionTrackingResult = {}));
+function actionTrackingMiddleware(subtreeRoot, hooks) {
+  assertTweakedObject(subtreeRoot, "subtreeRoot");
+  const dataSymbol = Symbol("actionTrackingMiddlewareData");
+  let State;
+  (function(State2) {
+    State2["Idle"] = "idle";
+    State2["Started"] = "started";
+    State2["RealResumed"] = "realResumed";
+    State2["FakeResumed"] = "fakeResumed";
+    State2["Suspended"] = "suspended";
+    State2["Finished"] = "finished";
+  })(State || (State = {}));
+  function getCtxData(ctx) {
+    return ctx.data[dataSymbol];
+  }
+  function setCtxData(ctx, partialData) {
+    let currentData = ctx.data[dataSymbol];
+    if (!currentData) {
+      ctx.data[dataSymbol] = partialData;
+    } else {
+      Object.assign(currentData, partialData);
+    }
+  }
+  const userFilter = (ctx) => {
+    if (hooks.filter) {
+      return hooks.filter(simplifyActionContext(ctx));
+    }
+    return true;
+  };
+  const resumeSuspendSupport = !!hooks.onResume || !!hooks.onSuspend;
+  const filter = (ctx) => {
+    if (ctx.type === ActionContextActionType.Sync) {
+      const accepted = userFilter(ctx);
+      if (accepted) {
+        setCtxData(ctx, {
+          startAccepted: true,
+          state: State.Idle
+        });
+      }
+      return accepted;
+    } else {
+      switch (ctx.asyncStepType) {
+        case ActionContextAsyncStepType.Spawn:
+          const accepted = userFilter(ctx);
+          if (accepted) {
+            setCtxData(ctx, {
+              startAccepted: true,
+              state: State.Idle
+            });
+          }
+          return accepted;
+        case ActionContextAsyncStepType.Return:
+        case ActionContextAsyncStepType.Throw:
+          const data = getCtxData(ctx.spawnAsyncStepContext);
+          return data ? data.startAccepted : false;
+        case ActionContextAsyncStepType.Resume:
+        case ActionContextAsyncStepType.ResumeError:
+          if (!resumeSuspendSupport) {
+            return false;
+          } else {
+            const data2 = getCtxData(ctx.spawnAsyncStepContext);
+            return data2 ? data2.startAccepted : false;
+          }
+        default:
+          return false;
+      }
+    }
+  };
+  const start = (simpleCtx) => {
+    setCtxData(simpleCtx, {
+      state: State.Started
+    });
+    if (hooks.onStart) {
+      return hooks.onStart(simpleCtx) || void 0;
+    }
+    return void 0;
+  };
+  const finish = (simpleCtx, ret) => {
+    const parentCtx = simpleCtx.parentContext;
+    let parentResumed = false;
+    if (parentCtx) {
+      const parentData = getCtxData(parentCtx);
+      if (parentData && parentData.startAccepted && parentData.state === State.Suspended) {
+        parentResumed = true;
+        resume(parentCtx, false);
+      }
+    }
+    setCtxData(simpleCtx, {
+      state: State.Finished
+    });
+    if (hooks.onFinish) {
+      ret = hooks.onFinish(simpleCtx, ret) || ret;
+    }
+    if (parentResumed) {
+      suspend(parentCtx);
+    }
+    return ret;
+  };
+  const resume = (simpleCtx, real) => {
+    const parentCtx = simpleCtx.parentContext;
+    if (parentCtx) {
+      const parentData = getCtxData(parentCtx);
+      if (parentData && parentData.startAccepted && parentData.state === State.Suspended) {
+        resume(parentCtx, false);
+      }
+    }
+    setCtxData(simpleCtx, {
+      state: real ? State.RealResumed : State.FakeResumed
+    });
+    if (hooks.onResume) {
+      hooks.onResume(simpleCtx);
+    }
+  };
+  const suspend = (simpleCtx) => {
+    setCtxData(simpleCtx, {
+      state: State.Suspended
+    });
+    if (hooks.onSuspend) {
+      hooks.onSuspend(simpleCtx);
+    }
+    const parentCtx = simpleCtx.parentContext;
+    if (parentCtx) {
+      const parentData = getCtxData(parentCtx);
+      if (parentData && parentData.startAccepted && parentData.state === State.FakeResumed) {
+        suspend(parentCtx);
+      }
+    }
+  };
+  const mware = (ctx, next) => {
+    const simpleCtx = simplifyActionContext(ctx);
+    const origNext = next;
+    next = () => {
+      resume(simpleCtx, true);
+      try {
+        return origNext();
+      } finally {
+        suspend(simpleCtx);
+      }
+    };
+    if (ctx.type === ActionContextActionType.Sync) {
+      let retObj = start(simpleCtx);
+      if (retObj) {
+        resume(simpleCtx, true);
+        suspend(simpleCtx);
+        retObj = finish(simpleCtx, retObj);
+      } else {
+        try {
+          retObj = finish(simpleCtx, { result: ActionTrackingResult.Return, value: next() });
+        } catch (err) {
+          retObj = finish(simpleCtx, { result: ActionTrackingResult.Throw, value: err });
+        }
+      }
+      return returnOrThrowActionTrackingReturn(retObj);
+    } else {
+      switch (ctx.asyncStepType) {
+        case ActionContextAsyncStepType.Spawn: {
+          let retObj = start(simpleCtx);
+          if (retObj) {
+            resume(simpleCtx, true);
+            suspend(simpleCtx);
+            retObj = finish(simpleCtx, retObj);
+            return returnOrThrowActionTrackingReturn(retObj);
+          } else {
+            return next();
+          }
+        }
+        case ActionContextAsyncStepType.Return: {
+          const flowFinisher = next();
+          const retObj = finish(simpleCtx, {
+            result: ActionTrackingResult.Return,
+            value: flowFinisher.value
+          });
+          flowFinisher.resolution = retObj.result === ActionTrackingResult.Return ? "accept" : "reject";
+          flowFinisher.value = retObj.value;
+          return flowFinisher;
+        }
+        case ActionContextAsyncStepType.Throw: {
+          const flowFinisher = next();
+          const retObj = finish(simpleCtx, {
+            result: ActionTrackingResult.Throw,
+            value: flowFinisher.value
+          });
+          flowFinisher.resolution = retObj.result === ActionTrackingResult.Return ? "accept" : "reject";
+          flowFinisher.value = retObj.value;
+          return flowFinisher;
+        }
+        case ActionContextAsyncStepType.Resume:
+        case ActionContextAsyncStepType.ResumeError:
+          if (resumeSuspendSupport) {
+            return next();
+          } else {
+            throw failure(`assertion error: async step should have been filtered out - ${ctx.asyncStepType}`);
+          }
+        default:
+          throw failure(`assertion error: async step should have been filtered out - ${ctx.asyncStepType}`);
+      }
+    }
+  };
+  return addActionMiddleware({ middleware: mware, filter, subtreeRoot });
+}
+function returnOrThrowActionTrackingReturn(retObj) {
+  if (retObj.result === ActionTrackingResult.Return) {
+    return retObj.value;
+  } else {
+    throw retObj.value;
+  }
+}
+const simpleDataContextSymbol = Symbol("simpleDataContext");
+function simplifyActionContext(ctx) {
+  while (ctx.previousAsyncStepContext) {
+    ctx = ctx.previousAsyncStepContext;
+  }
+  let simpleCtx = ctx.data[simpleDataContextSymbol];
+  if (!simpleCtx) {
+    const parentContext = ctx.parentContext ? simplifyActionContext(ctx.parentContext) : void 0;
+    simpleCtx = {
+      actionName: ctx.actionName,
+      type: ctx.type,
+      target: ctx.target,
+      args: ctx.args,
+      data: ctx.data,
+      parentContext
+    };
+    simpleCtx.rootContext = parentContext ? parentContext.rootContext : simpleCtx;
+    ctx.data[simpleDataContextSymbol] = simpleCtx;
+  }
+  return simpleCtx;
+}
+export { ActionTrackingResult, actionTrackingMiddleware, simplifyActionContext };
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"file":"actionTrackingMiddleware.mjs","sources":["../../../src/actionMiddlewares/actionTrackingMiddleware.ts"],"sourcesContent":["import {\n  ActionContext,\n  ActionContextActionType,\n  ActionContextAsyncStepType,\n} from \"../action/context\"\nimport {\n  ActionMiddleware,\n  ActionMiddlewareDisposer,\n  addActionMiddleware,\n} from \"../action/middleware\"\nimport type { FlowFinisher } from \"../action/modelFlow\"\nimport type { AnyModel } from \"../model/BaseModel\"\nimport { assertTweakedObject } from \"../tweaker/core\"\nimport { failure } from \"../utils\"\n\n/**\n * Simplified version of action context.\n */\nexport interface SimpleActionContext {\n  /**\n   * Action name\n   */\n  readonly actionName: string\n  /**\n   * Action type, sync or async.\n   */\n  readonly type: ActionContextActionType\n  /**\n   * Action target model instance.\n   */\n  readonly target: AnyModel\n  /**\n   * Array of action arguments.\n   */\n  readonly args: ReadonlyArray<any>\n  /**\n   * Parent action context, if any.\n   */\n  readonly parentContext?: SimpleActionContext\n  /**\n   * Root action context, or itself if the root.\n   */\n  readonly rootContext: SimpleActionContext\n  /**\n   * Custom data for the action context to be set by middlewares, an object.\n   * Symbols must be used as keys to avoid name clashing between middlewares.\n   */\n  readonly data: Record<symbol, any>\n}\n\n/**\n * Action tracking middleware finish result.\n */\nexport enum ActionTrackingResult {\n  /**\n   * The action returned normally (without throwing).\n   */\n  Return = \"return\",\n  /**\n   * The action threw an error.\n   */\n  Throw = \"throw\",\n}\n\n/**\n * Action tracking middleware hooks.\n */\nexport interface ActionTrackingMiddleware {\n  /**\n   * Filter function called whenever each action starts, and only then.\n   *\n   * If the action is accepted then `onStart`, `onResume`, `onSuspend` and `onFinish`\n   * for that particular action will be called.\n   *\n   * All actions are accepted by default if no filter function is present.\n   *\n   * @param ctx Simplified action context.\n   * @returns true to accept the action, false to skip it.\n   */\n  filter?(ctx: SimpleActionContext): boolean\n\n  /**\n   * Called when an action just started.\n   *\n   * @param ctx Simplified action context.\n   * @returns Can optionally return a result that will cancel the original action and finish it\n   * with the returned value / error to be thrown. In either case case resume / suspend / finish will\n   * still be called normally.\n   */\n  onStart?(ctx: SimpleActionContext): void | ActionTrackingReturn\n\n  /**\n   * Called when an action just resumed a synchronous piece of code execution.\n   * Gets called once for sync actions and multiple times for flows.\n   *\n   * @param ctx Simplified action context.\n   */\n  onResume?(ctx: SimpleActionContext): void\n\n  /**\n   * Called when an action just finished a synchronous pice of code execution.\n   * Note that this doesn't necessarily mean the action is finished.\n   * Gets called once for sync actions and multiple times for flows.\n   *\n   * @param ctx Simplified action context.\n   */\n  onSuspend?(ctx: SimpleActionContext): void\n\n  /**\n   * Called when an action just finished, either by returning normally or by throwing an error.\n   *\n   * @param ctx Simplified action context.\n   * @param ret Action return result.\n   * @returns Can optionally return a new result that will override the original one.\n   */\n  onFinish?(ctx: SimpleActionContext, ret: ActionTrackingReturn): void | ActionTrackingReturn\n}\n\n/**\n * Return result of an action.\n */\nexport interface ActionTrackingReturn {\n  result: ActionTrackingResult\n  value: any\n}\n\n/**\n * Creates an action tracking middleware, which is a simplified version\n * of the standard action middleware.\n *\n * @param subtreeRoot Subtree root target object.\n * @param hooks Middleware hooks.\n * @returns The middleware disposer.\n */\nexport function actionTrackingMiddleware(\n  subtreeRoot: object,\n  hooks: ActionTrackingMiddleware\n): ActionMiddlewareDisposer {\n  assertTweakedObject(subtreeRoot, \"subtreeRoot\")\n\n  const dataSymbol = Symbol(\"actionTrackingMiddlewareData\")\n\n  enum State {\n    Idle = \"idle\",\n    Started = \"started\",\n    RealResumed = \"realResumed\",\n    FakeResumed = \"fakeResumed\",\n    Suspended = \"suspended\",\n    Finished = \"finished\",\n  }\n\n  interface Data {\n    startAccepted: boolean\n    state: State\n  }\n\n  function getCtxData(ctx: ActionContext | SimpleActionContext): Data | undefined {\n    return ctx.data[dataSymbol]\n  }\n\n  function setCtxData(ctx: ActionContext | SimpleActionContext, partialData: Partial<Data>) {\n    let currentData = ctx.data[dataSymbol]\n    if (!currentData) {\n      ctx.data[dataSymbol] = partialData\n    } else {\n      Object.assign(currentData, partialData)\n    }\n  }\n\n  const userFilter: ActionMiddleware[\"filter\"] = (ctx) => {\n    if (hooks.filter) {\n      return hooks.filter(simplifyActionContext(ctx))\n    }\n\n    return true\n  }\n\n  const resumeSuspendSupport = !!hooks.onResume || !!hooks.onSuspend\n\n  const filter: ActionMiddleware[\"filter\"] = (ctx) => {\n    if (ctx.type === ActionContextActionType.Sync) {\n      // start and finish is on the same context\n      const accepted = userFilter(ctx)\n      if (accepted) {\n        setCtxData(ctx, {\n          startAccepted: true,\n          state: State.Idle,\n        })\n      }\n      return accepted\n    } else {\n      switch (ctx.asyncStepType) {\n        case ActionContextAsyncStepType.Spawn:\n          const accepted = userFilter(ctx)\n          if (accepted) {\n            setCtxData(ctx, {\n              startAccepted: true,\n              state: State.Idle,\n            })\n          }\n          return accepted\n\n        case ActionContextAsyncStepType.Return:\n        case ActionContextAsyncStepType.Throw:\n          // depends if the spawn one was accepted or not\n          const data = getCtxData(ctx.spawnAsyncStepContext!)\n          return data ? data.startAccepted : false\n\n        case ActionContextAsyncStepType.Resume:\n        case ActionContextAsyncStepType.ResumeError:\n          if (!resumeSuspendSupport) {\n            return false\n          } else {\n            // depends if the spawn one was accepted or not\n            const data = getCtxData(ctx.spawnAsyncStepContext!)\n            return data ? data.startAccepted : false\n          }\n\n        default:\n          return false\n      }\n    }\n  }\n\n  const start = (simpleCtx: SimpleActionContext): ActionTrackingReturn | undefined => {\n    setCtxData(simpleCtx, {\n      state: State.Started,\n    })\n    if (hooks.onStart) {\n      return hooks.onStart(simpleCtx) || undefined\n    }\n    return undefined\n  }\n\n  const finish = (\n    simpleCtx: SimpleActionContext,\n    ret: ActionTrackingReturn\n  ): ActionTrackingReturn => {\n    // fakely resume and suspend the parent if needed\n    const parentCtx = simpleCtx.parentContext\n    let parentResumed = false\n    if (parentCtx) {\n      const parentData = getCtxData(parentCtx)\n      if (parentData && parentData.startAccepted && parentData.state === State.Suspended) {\n        parentResumed = true\n        resume(parentCtx, false)\n      }\n    }\n\n    setCtxData(simpleCtx, {\n      state: State.Finished,\n    })\n\n    if (hooks.onFinish) {\n      ret = hooks.onFinish(simpleCtx, ret) || ret\n    }\n\n    if (parentResumed) {\n      suspend(parentCtx!)\n    }\n\n    return ret\n  }\n\n  const resume = (simpleCtx: SimpleActionContext, real: boolean) => {\n    // ensure parents are resumed\n    const parentCtx = simpleCtx.parentContext\n    if (parentCtx) {\n      const parentData = getCtxData(parentCtx)\n      if (parentData && parentData.startAccepted && parentData.state === State.Suspended) {\n        resume(parentCtx, false)\n      }\n    }\n\n    setCtxData(simpleCtx, {\n      state: real ? State.RealResumed : State.FakeResumed,\n    })\n    if (hooks.onResume) {\n      hooks.onResume(simpleCtx)\n    }\n  }\n\n  const suspend = (simpleCtx: SimpleActionContext) => {\n    setCtxData(simpleCtx, {\n      state: State.Suspended,\n    })\n    if (hooks.onSuspend) {\n      hooks.onSuspend(simpleCtx)\n    }\n\n    // ensure parents are suspended if they were fakely resumed\n    const parentCtx = simpleCtx.parentContext\n    if (parentCtx) {\n      const parentData = getCtxData(parentCtx)\n      if (parentData && parentData.startAccepted && parentData.state === State.FakeResumed) {\n        suspend(parentCtx)\n      }\n    }\n  }\n\n  const mware: ActionMiddleware[\"middleware\"] = (ctx, next) => {\n    const simpleCtx = simplifyActionContext(ctx)\n\n    const origNext = next\n    next = () => {\n      resume(simpleCtx, true)\n      try {\n        return origNext()\n      } finally {\n        suspend(simpleCtx)\n      }\n    }\n\n    if (ctx.type === ActionContextActionType.Sync) {\n      let retObj = start(simpleCtx)\n\n      if (retObj) {\n        // action canceled / overridden by onStart\n        resume(simpleCtx, true)\n        suspend(simpleCtx)\n        retObj = finish(simpleCtx, retObj)\n      } else {\n        try {\n          retObj = finish(simpleCtx, { result: ActionTrackingResult.Return, value: next() })\n        } catch (err) {\n          retObj = finish(simpleCtx, { result: ActionTrackingResult.Throw, value: err })\n        }\n      }\n\n      return returnOrThrowActionTrackingReturn(retObj)\n    } else {\n      // async\n\n      switch (ctx.asyncStepType) {\n        case ActionContextAsyncStepType.Spawn: {\n          let retObj = start(simpleCtx)\n          if (retObj) {\n            // action canceled / overridden by onStart\n            resume(simpleCtx, true)\n            suspend(simpleCtx)\n            retObj = finish(simpleCtx, retObj)\n            return returnOrThrowActionTrackingReturn(retObj)\n          } else {\n            return next()\n          }\n        }\n\n        case ActionContextAsyncStepType.Return: {\n          const flowFinisher: FlowFinisher = next()\n          const retObj = finish(simpleCtx, {\n            result: ActionTrackingResult.Return,\n            value: flowFinisher.value,\n          })\n          flowFinisher.resolution =\n            retObj.result === ActionTrackingResult.Return ? \"accept\" : \"reject\"\n          flowFinisher.value = retObj.value\n          return flowFinisher\n        }\n\n        case ActionContextAsyncStepType.Throw: {\n          const flowFinisher: FlowFinisher = next()\n          const retObj = finish(simpleCtx, {\n            result: ActionTrackingResult.Throw,\n            value: flowFinisher.value,\n          })\n          flowFinisher.resolution =\n            retObj.result === ActionTrackingResult.Return ? \"accept\" : \"reject\"\n          flowFinisher.value = retObj.value\n          return flowFinisher\n        }\n\n        case ActionContextAsyncStepType.Resume:\n        case ActionContextAsyncStepType.ResumeError:\n          if (resumeSuspendSupport) {\n            return next()\n          } else {\n            throw failure(\n              `assertion error: async step should have been filtered out - ${ctx.asyncStepType}`\n            )\n          }\n\n        default:\n          throw failure(\n            `assertion error: async step should have been filtered out - ${ctx.asyncStepType}`\n          )\n      }\n    }\n  }\n\n  return addActionMiddleware({ middleware: mware, filter, subtreeRoot: subtreeRoot })\n}\n\nfunction returnOrThrowActionTrackingReturn(retObj: ActionTrackingReturn) {\n  if (retObj.result === ActionTrackingResult.Return) {\n    return retObj.value\n  } else {\n    throw retObj.value\n  }\n}\n\nconst simpleDataContextSymbol = Symbol(\"simpleDataContext\")\n\n/**\n * Simplifies an action context by converting an async call hierarchy into a simpler one.\n *\n * @param ctx Action context to convert.\n * @returns Simplified action context.\n */\nexport function simplifyActionContext(ctx: ActionContext): SimpleActionContext {\n  while (ctx.previousAsyncStepContext) {\n    ctx = ctx.previousAsyncStepContext\n  }\n\n  let simpleCtx = ctx.data[simpleDataContextSymbol]\n  if (!simpleCtx) {\n    const parentContext = ctx.parentContext ? simplifyActionContext(ctx.parentContext) : undefined\n\n    simpleCtx = {\n      actionName: ctx.actionName,\n      type: ctx.type,\n      target: ctx.target,\n      args: ctx.args,\n      data: ctx.data,\n      parentContext,\n    }\n    simpleCtx.rootContext = parentContext ? parentContext.rootContext : simpleCtx\n\n    ctx.data[simpleDataContextSymbol] = simpleCtx\n  }\n  return simpleCtx\n}\n"],"names":[],"mappings":"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"}

package/dist/src/actionMiddlewares/onActionMiddleware.mjs

@@ -0,0 +1,44 @@
+import { isHookAction } from "../action/hookActions.mjs";
+import { fastGetRootPath } from "../parent/path.mjs";
+import { assertTweakedObject } from "../tweaker/core.mjs";
+import { assertIsObject } from "../utils/index.mjs";
+import { actionTrackingMiddleware } from "./actionTrackingMiddleware.mjs";
+import { rootPathToTargetPathIds } from "./utils.mjs";
+function onActionMiddleware(subtreeRoot, listeners) {
+  assertTweakedObject(subtreeRoot, "subtreeRoot");
+  assertIsObject(listeners, "listeners");
+  return actionTrackingMiddleware(subtreeRoot, {
+    filter(ctx) {
+      if (ctx.parentContext) {
+        return false;
+      }
+      if (isHookAction(ctx.actionName)) {
+        return false;
+      }
+      return true;
+    },
+    onStart(ctx) {
+      if (listeners.onStart) {
+        const actionCall = actionContextToActionCall(ctx);
+        return listeners.onStart(actionCall, ctx);
+      }
+    },
+    onFinish(ctx, ret) {
+      if (listeners.onFinish) {
+        const actionCall = actionContextToActionCall(ctx);
+        return listeners.onFinish(actionCall, ctx, ret);
+      }
+    }
+  });
+}
+function actionContextToActionCall(ctx) {
+  const rootPath = fastGetRootPath(ctx.target);
+  return {
+    actionName: ctx.actionName,
+    args: ctx.args,
+    targetPath: rootPath.path,
+    targetPathIds: rootPathToTargetPathIds(rootPath)
+  };
+}
+export { onActionMiddleware };
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,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

package/dist/src/actionMiddlewares/readonlyMiddleware.mjs

@@ -0,0 +1,49 @@
+import { isHookAction } from "../action/hookActions.mjs";
+import { assertTweakedObject } from "../tweaker/core.mjs";
+import { failure } from "../utils/index.mjs";
+import { actionTrackingMiddleware, ActionTrackingResult } from "./actionTrackingMiddleware.mjs";
+function readonlyMiddleware(subtreeRoot) {
+  assertTweakedObject(subtreeRoot, "subtreeRoot");
+  let writable = false;
+  const writableSymbol = Symbol("writable");
+  const disposer = actionTrackingMiddleware(subtreeRoot, {
+    filter(ctx) {
+      if (isHookAction(ctx.actionName)) {
+        return false;
+      }
+      let currentlyWritable = writable;
+      if (!currentlyWritable) {
+        let currentCtx = ctx;
+        while (currentCtx && !currentlyWritable) {
+          currentlyWritable = !!currentCtx.data[writableSymbol];
+          currentCtx = currentCtx.parentContext;
+        }
+      }
+      if (currentlyWritable) {
+        ctx.data[writableSymbol] = true;
+        return false;
+      }
+      return true;
+    },
+    onStart(ctx) {
+      return {
+        result: ActionTrackingResult.Throw,
+        value: failure(`tried to invoke action '${ctx.actionName}' over a readonly node`)
+      };
+    }
+  });
+  return {
+    dispose: disposer,
+    allowWrite(fn) {
+      const oldWritable = writable;
+      writable = true;
+      try {
+        return fn();
+      } finally {
+        writable = oldWritable;
+      }
+    }
+  };
+}
+export { readonlyMiddleware };
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,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

package/dist/src/actionMiddlewares/transactionMiddleware.mjs

@@ -0,0 +1,69 @@
+import { assertIsModel } from "../model/utils.mjs";
+import { checkModelDecoratorArgs } from "../modelShared/checkModelDecoratorArgs.mjs";
+import { addModelClassInitializer } from "../modelShared/modelClassInitializer.mjs";
+import { applyPatches } from "../patch/applyPatches.mjs";
+import "mobx";
+import { assertIsObject, failure } from "../utils/index.mjs";
+import { internalPatchRecorder } from "../patch/patchRecorder.mjs";
+import { actionTrackingMiddleware, ActionTrackingResult } from "./actionTrackingMiddleware.mjs";
+function transactionMiddleware(target) {
+  assertIsObject(target, "target");
+  const { model, actionName } = target;
+  assertIsModel(model, "target.model");
+  if (typeof actionName !== "string") {
+    throw failure("target.actionName must be a string");
+  }
+  const patchRecorderSymbol = Symbol("patchRecorder");
+  function initPatchRecorder(ctx) {
+    ctx.rootContext.data[patchRecorderSymbol] = internalPatchRecorder(void 0, {
+      recording: false
+    });
+  }
+  function getPatchRecorder(ctx) {
+    return ctx.rootContext.data[patchRecorderSymbol];
+  }
+  return actionTrackingMiddleware(model, {
+    filter(ctx) {
+      const rootContext = ctx.rootContext;
+      return rootContext.target === model && rootContext.actionName === actionName;
+    },
+    onStart(ctx) {
+      if (ctx === ctx.rootContext) {
+        initPatchRecorder(ctx);
+      }
+    },
+    onResume(ctx) {
+      getPatchRecorder(ctx).recording = true;
+    },
+    onSuspend(ctx) {
+      getPatchRecorder(ctx).recording = false;
+    },
+    onFinish(ctx, ret) {
+      if (ctx === ctx.rootContext) {
+        const patchRecorder = getPatchRecorder(ctx);
+        try {
+          if (ret.result === ActionTrackingResult.Throw) {
+            const { events } = patchRecorder;
+            for (let i = events.length - 1; i >= 0; i--) {
+              const event = events[i];
+              applyPatches(event.target, event.inversePatches, true);
+            }
+          }
+        } finally {
+          patchRecorder.dispose();
+        }
+      }
+    }
+  });
+}
+function transaction(target, propertyKey) {
+  checkModelDecoratorArgs("transaction", target, propertyKey);
+  addModelClassInitializer(target.constructor, (modelInstance) => {
+    transactionMiddleware({
+      model: modelInstance,
+      actionName: propertyKey
+    });
+  });
+}
+export { transaction, transactionMiddleware };
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,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