pinia-plugin-subscription 0.1.8 → 0.2.0-beta.0

package/CHANGELOG.md

@@ -5,6 +5,17 @@ All notable changes to this project will be documented in this file.
 The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/),
 and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
+## [Unreleased]
+
+### Added
+- Added automatic state rollback on action failure via the `rollbackAfterFailure` store option: the declared state keys are snapshotted before the action runs and restored through `$patch` when the action throws (sync or async).
+- Added `$rollbackAfterFailure(params, ...args)` to `PiniaCustomProperties`, available on every store registered by the plugin, to run an action with an explicit snapshot/rollback wrapper.
+- Added `RollbackActionParams` and `RollbackAfterFailureParams` types to the public API.
+
+### Changed
+- Action names starting with `_` or `$` are rejected by the rollback wrapper to protect internal store methods.
+- Rollback tracking data (`rollbackAfterFailure` params and pending snapshots) is now cleaned up when a store is disposed, preventing memory leaks with dynamically created stores.
+
 ## [0.1.8]
 
 ### Added 

package/README.md

@@ -6,7 +6,8 @@
  - a lightweight mechanism to declare "subscribers" that are invoked when stores are registered or updated by Pinia;
  - a `Store` base class (helper wrapper) to ease interacting with Pinia stores from subscribers or other plugin code;
  - an API to create a Pinia plugin from a list of subscribers;
- - the $reset method to all stores modified by the plugin.
+ - the $reset method to all stores modified by the plugin;
+ - automatic state rollback on action failure via the `rollbackAfterFailure` store option and the `$rollbackAfterFailure` method.
 
  The main goal is to offer a clear API for writing reusable Pinia plugins and to make it easy to extend stores from plugin code.
 
@@ -205,6 +206,57 @@ const mySubscriber: PluginSubscriberInterface = {
 
 This keeps the server render deterministic and prevents browser-only initialization from crashing Nuxt or SSR builds.
 
+### State rollback on action failure
+
+The plugin can automatically restore the previous state when an action throws. Declare the state keys to snapshot per action via the `rollbackAfterFailure` store option:
+
+```typescript
+import { defineAStore } from 'pinia-plugin-subscription'
+
+export const useMyStore = defineAStore('myStore', () => {
+  const count = ref(0)
+
+  function riskyAction() {
+    count.value += 1
+    throw new Error('Something went wrong')
+  }
+
+  return { count, riskyAction }
+}, {
+  rollbackAfterFailure: {
+    // only the listed keys are snapshotted / restored (deep-cloned)
+    riskyAction: ['count']
+  }
+})
+```
+
+Before a configured action runs, the declared state keys are snapshotted. If the action throws (synchronously or by rejecting its returned promise), the snapshot is restored through `$patch`, so partial mutations are rolled back. The snapshot is always discarded once the action completes or fails.
+
+Only the actions listed in `rollbackAfterFailure` are snapshotted, so unrelated actions pay no cloning cost. Use `'all'` instead of a key list to snapshot the full state — prefer explicit keys for large states.
+
+Action names starting with `_` or `$` are rejected to protect internal store methods.
+
+#### Manual rollback with `$rollbackAfterFailure`
+
+Every store registered by the plugin also exposes a `$rollbackAfterFailure` method to run any action with an explicit snapshot/rollback wrapper, without declaring it in the store options:
+
+```typescript
+const store = useMyStore()
+
+try {
+  await store.$rollbackAfterFailure(
+    { action: 'riskyAction', stateKeys: ['count'] },
+    // ...args forwarded to the action
+  )
+} catch (error) {
+  // the action failed and the state was restored
+}
+```
+
+- `params.action` — the name of the action to execute.
+- `params.stateKeys` — optional; the state keys to snapshot, or `'all'` (default when omitted or empty).
+- The original error is rethrown after the state is restored.
+
 ### `defineAStoreCtx(id, setup, options?)`
 
 Use actions or access the state, added by one or more plugins, when defining the store.

package/dist/chunks/{index-B-zO0yrr.js → index-D-rnwSJk.js}

@@ -49,10 +49,10 @@ class L {
   set subscriptions(t) {
     this._subscriptions = t;
   }
-  hydrate(t, e) {
-  }
   afterHydration(t, e) {
   }
+  hydrate(t, e) {
+  }
   invoke({ store: t, options: e }, r) {
     return this._storeInstance = this._createInstance(t, { ...e, ...this.pluginOptions }, r, this.console), this._storeInstance ? (this._subscriptions = this._storeInstance.getSubscriptions(), this._storeMutationSubscription = this._storeInstance.storeSubscribe, this._storeOnActionSubscription = this._storeInstance.onAction, this.pluginCreated && this.pluginCreated(t), !0) : !1;
   }
@@ -104,7 +104,7 @@ function N(s, t, e) {
     s,
     t,
     r
-  ) : m(
+  ) : $(
     s,
     t,
     r
@@ -129,12 +129,12 @@ function d(s, t, e) {
     return o && (p.set(a, r), c.delete(s), h(s, e, "moved context to weak map"), x(a, s, e)), a;
   }), i);
 }
-function m(s, t, e) {
+function $(s, t, e) {
   return e && (t = { ...t, ...e ?? {} }), g(s, t);
 }
-const $ = /* @__PURE__ */ new Set(["_", "$"]);
+const m = /* @__PURE__ */ new Set(["_", "$"]);
 function I(s) {
-  return $.has(s[0]);
+  return m.has(s[0]);
 }
 function w(s) {
   return p.get(s) ?? (typeof s?.$id == "string" ? c.get(s.$id) : void 0);
@@ -151,6 +151,9 @@ function M(s, t) {
 function T(s) {
   return k(s);
 }
+function W(s, t) {
+  return `${s}-${t.$id}`;
+}
 function E(s) {
   return s ? Array.isArray(s) ? s.length === 0 : typeof s == "object" ? Object.keys(s).length === 0 : typeof s == "string" ? s.trim() === "" : !1 : !(typeof s == "boolean" || typeof s == "number");
 }
@@ -190,10 +193,6 @@ class P extends C {
   get store() {
     return this._store;
   }
-  hydrate() {
-  }
-  afterHydration() {
-  }
   get storeSubscribe() {
     if (this._storeSubscribe)
       return () => ({
@@ -215,6 +214,8 @@ class P extends C {
   addSubscription(e, r, o) {
     this._subscriptions[e] = { subscription: r, ...o ?? {} };
   }
+  afterHydration() {
+  }
   /**
    * Create and return a class instance
    * @param store 
@@ -226,12 +227,6 @@ class P extends C {
     if (r.storeOptions && this.hasRequiredKeys(r.storeOptions))
       return new this(e, r, o, i);
   }
-  hasDeniedFirstChar(e) {
-    return I(e);
-  }
-  static hasRequiredKeys(e) {
-    return this._requiredKeys !== void 0 && this._requiredKeys?.every((r) => !!e[r]);
-  }
   getOption(e) {
     return this.options && this.options[e];
   }
@@ -245,6 +240,14 @@ class P extends C {
   getValue(e) {
     return e?.__v_isRef ? e.value : e;
   }
+  hasDeniedFirstChar(e) {
+    return I(e);
+  }
+  static hasRequiredKeys(e) {
+    return this._requiredKeys !== void 0 && this._requiredKeys?.every((r) => !!e[r]);
+  }
+  hydrate() {
+  }
   isOptionApi() {
     return this.store._isOptionsAPI;
   }
@@ -314,24 +317,26 @@ class D {
     );
   }
 }
-class j extends D {
+class K extends D {
   constructor() {
     super(...arguments);
     n(this, "_pluginName", _);
   }
 }
-const W = new j();
+const F = new K();
 export {
   D as C,
   C as D,
-  W as P,
+  F as P,
   P as S,
   L as a,
   R as b,
-  k as c,
+  w as c,
   N as d,
-  T as e,
-  w as g,
+  k as e,
+  T as f,
+  W as g,
+  I as h,
   E as i,
   _ as p,
   M as s

package/dist/core/PluginSubscriber.d.ts

@@ -28,8 +28,8 @@ export default abstract class PluginSubscriber<Instance extends Store> implement
     get subscriptions(): PluginSubscriptions | undefined;
     set subscriptions(subscriptions: PluginSubscriptions);
     constructor(pluginName: string, createInstanceFunction: CreateInstance, pluginConsole?: Console);
-    hydrate(context: PiniaPluginContext, debug: boolean): void | Promise<void>;
     afterHydration(context: PiniaPluginContext, debug: boolean): void | Promise<void>;
+    hydrate(context: PiniaPluginContext, debug: boolean): void | Promise<void>;
     invoke({ store, options }: PiniaPluginContext, debug: boolean): boolean;
 }
 export {};

package/dist/core/PluginSubscription.d.ts

@@ -4,9 +4,13 @@ import type { PluginSubscriber, PluginSubscriptionOptions, PluginSubscriptions }
 export default class PluginSubscription extends Debug {
     protected _className: string;
     private _hydrationScheduler;
+    private _onActionSubscriptions;
+    private _onActionAfterSubscriptions;
+    private _onActionOnErrorSubscriptions;
     private _options?;
     private _pluginDebug?;
     private _resetStoreCallback;
+    private _storeRollbackSnapshotsHandler;
     private _subscribers;
     private _subscribersDelivered;
     private _subscribersScheduled;
@@ -16,7 +20,32 @@ export default class PluginSubscription extends Debug {
     set subscribers(subscribers: PluginSubscriber[]);
     get subscriptions(): PluginSubscriptions[] | undefined;
     constructor(subscribers: PluginSubscriber[], debugOrOptions?: PluginSubscriptionOptions | string[], pluginOptions?: PluginSubscriptionOptions);
+    private addOnActionAfterCallback;
+    private addOnActionOnErrorCallback;
     private addResetStoreCallback;
+    private clearOnActionCallbacksSubscriptions;
+    private clearStoreTracking;
+    /**
+     * Creates a callback collector for the specified action and store.
+     * @param actionName The name of the action to collect callbacks for.
+     * @param store The store instance associated with the action.
+     * @returns A function that collects callbacks for the specified action and store.
+     */
+    private createOnActionAfterCallbackCollector;
+    /**
+     * Creates a callback collector for the specified action and store that handles errors.
+     * @param actionName The name of the action to collect error callbacks for.
+     * @param store The store instance associated with the action.
+     * @returns A function that collects error callbacks for the specified action and store.
+     */
+    private createOnActionOnErrorCallbackCollector;
+    /**
+     * Rolls back the state snapshot for a given action if an error occurs, and removes the snapshot after the action completes or fails.
+     * @param actionName The name of the action being executed.
+     * @param store The Pinia store instance.
+     * @returns void
+     */
+    private createRollbackSnapshot;
     private defineCurrentEnvironment;
     private definePluginDebug;
     private definePluginExecution;
@@ -24,15 +53,21 @@ export default class PluginSubscription extends Debug {
     private defineSubscriberKey;
     private defineSubscriptionKey;
     private executeResetStoreCallbacks;
+    /**
+     * Executes the store's onAction subscription for the given plugin subscriber.
+     * @param store The Pinia store instance.
+     * @param subscriber The plugin subscriber.
+     * @returns void
+     */
+    private executeStoreOnActionSubscription;
     private executeSubscriber;
     private executeSubscriberSafely;
+    plugin({ store, options }: PiniaPluginContext): void;
     private queueSubscriberExecution;
+    private registerStoreCleanup;
+    private rewriteResetStore;
     private shouldInvokePlugin;
     private shouldScheduleAfterHydration;
-    plugin({ store, options }: PiniaPluginContext): void;
-    private rewriteResetStore;
-    private registerStoreCleanup;
-    private clearStoreTracking;
     private storeOnActionSubscription;
     private storeMutationSubscription;
     private subscriptionDelivery;

package/dist/core/RollbackStateSnapshotsHandler.d.ts

@@ -0,0 +1,64 @@
+import type { PiniaPluginContext, Store } from 'pinia';
+/**
+ * Handles rollback state snapshots for Pinia stores.
+ * This class provides methods to add rollback actions to stores,
+ * create rollback snapshots, and manage the state snapshots internally.
+ */
+export default class RollbackStateSnapshotsHandler {
+    private _stateSnapshots;
+    private _storeHasRollbackSnapshots;
+    private _storeRollbackSnapshotsParams;
+    /**
+     * Adds a rollback action to the given store.
+     * This method extends the store with a $rollbackAfterFailure function that handles rollback logic for actions.
+     * @param {Store} store The store to which the rollback action will be added.
+     * @returns void
+     */
+    addRollbackAction(store: Store): void;
+    /**
+     * Creates a rollback snapshot for the specified action and store.
+     * This snapshot can be used to restore the store's state in case of an error during the action execution.
+     * @param {string} actionName The name of the action for which the rollback snapshot is created.
+     * @param {Store} store The Pinia store instance.
+     * @returns An object containing `after` and `onError` callbacks for handling the rollback, or `undefined` if no snapshot is created.
+     */
+    createOnActionCallbacks(actionName: string, store: Store): {
+        after: () => void;
+        onError: () => void;
+    } | undefined;
+    /**
+     * Initializes the rollback state snapshots handler from the given Pinia plugin context.
+     * This method extracts the rollback snapshot parameters from the store options and stores them internally.
+     * @param {PiniaPluginContext} param0 The Pinia plugin context containing the store and its options.
+     * @returns void
+     */
+    initFromPluginContext({ options, store }: PiniaPluginContext): void;
+    /**
+     * Clears all rollback tracking data for the given store.
+     * Must be called when the store is disposed to avoid memory leaks with dynamically created stores.
+     * @param {Store} store The disposed Pinia store instance.
+     * @returns void
+     */
+    clearStoreTracking(store: Store): void;
+    private patchStore;
+    /**
+     * Removes a state snapshot identified by the given snapshot key from the internal state snapshot tracking.
+     * @param snapshotKey The key of the state snapshot to be removed.
+     * @returns void
+     */
+    private removeStateSnapshot;
+    /**
+     * Saves the current state snapshot for a given store and action.
+     * @param store The Pinia store instance.
+     * @param actionName The name of the action being executed.
+     * @param stateKeys The state keys to include in the snapshot, or 'all' for the full state.
+     * @returns A unique symbol key representing the saved snapshot.
+     */
+    private saveStateSnapshot;
+    /**
+     * Checks if the given store has rollback snapshots.
+     * @param store The Pinia store instance.
+     * @returns True if the store has rollback snapshots, false otherwise.
+     */
+    storeHasRollbackSnapshots(store: Store): boolean;
+}

package/dist/core/Store.d.ts

@@ -18,8 +18,6 @@ export default class Store extends Debug {
     get state(): StateTree;
     set state(state: StateTree);
     get store(): AnyObject;
-    hydrate(): void | Promise<void>;
-    afterHydration(): void | Promise<void>;
     get storeSubscribe(): StoreMutationSubscription | undefined;
     set storeSubscribe(storeSubscribe: StoreMutationSubscriptionCallback);
     constructor(store: PiniaStore, options: AnyObject, debug?: boolean, customConsole?: Console);
@@ -33,6 +31,7 @@ export default class Store extends Debug {
         subscriptionOptions?: StoreOptions;
         stores?: PiniaStore[];
     }): void;
+    afterHydration(): void | Promise<void>;
     /**
      * Create and return a class instance
      * @param store
@@ -41,12 +40,13 @@ export default class Store extends Debug {
      * @returns
      */
     static customizeStore<Instance extends Store>(store: PiniaStore, options: AnyObject, debug?: boolean, customConsole?: Console): Instance | undefined;
-    hasDeniedFirstChar(property: string): boolean;
-    protected static hasRequiredKeys(options: AnyObject): boolean;
     getOption(optionName: keyof StoreOptions): import("../types").StoreOptionsPropertyValue;
     getStatePropertyValue(propertyName: string): any;
     getSubscriptions(): PluginSubscriptions | undefined;
     getValue(value: any): any;
+    protected hasDeniedFirstChar(property: string): boolean;
+    protected static hasRequiredKeys(options: AnyObject): boolean;
+    hydrate(): void | Promise<void>;
     isOptionApi(): boolean;
     stateHas(property: string): boolean;
     storeHas(property: string): boolean;

package/dist/factories/state-snapshot.d.ts

@@ -0,0 +1,3 @@
+import type { StateTree } from 'pinia';
+import type { CreateStateSnapshotKeys } from '../types/plugin';
+export declare function createStateSnapshot(state: StateTree, keys?: CreateStateSnapshotKeys): StateTree;

package/dist/helpers.js

@@ -1,4 +1,4 @@
-import { C as a, a as r, S as e, i } from "./chunks/index-B-zO0yrr.js";
+import { C as a, a as r, S as e, i } from "./chunks/index-D-rnwSJk.js";
 export {
   a as CustomConsole,
   r as PluginSubscriber,

package/dist/lib/main.d.ts

@@ -5,6 +5,7 @@ export { createPlugin } from "../plugins/createPlugin";
 export { createHydrationPlugin } from "../plugins/createHydrationPlugin";
 export type { AnyObject, Console, CustomStore, DefineAStoreSetupContext, DefineAStoreSetupExtensions, EmptyExtensions, PluginExecutionEnvironment, PluginExecutionOptions, PluginHydrationScheduler, PluginHydrationTiming, PluginRuntimeEnvironment, PluginStoreOptions, PluginSubscriptionOptions, PluginSubscriberInterface, PluginSubscriptionDefinition, PluginSubscriptions, StatePropertyValue, StoreOptions, StoreOptionsPropertyValue, StoreMutationSubscription, StoreMutationSubscriptionCallback, StoreOnActionCallbackParameters, StoreOnActionSubscription, StoreOnActionSubscriptionCallback, NativePiniaSubscription, NativePiniaSubscriptionReturn, SearchCollectionCriteria, LogType, StyleDefinition, StyleDefinitionKeys, StyleDefinitions, ConsoleStyleDefinition, ConsoleStyleDefinitionKeys, ConsoleStyleDefinitions, PartialList, ListTypes, ListTypesMap, List } from "../types";
 export type { StoreMutationSubscriptionReturn, StoreOnActionSubscriptionReturn } from "../types/plugin";
+export type { RollbackActionParams, RollbackAfterFailureParams } from "../types/store";
 export { defineAStore, defineAStoreCtx, getDefineAStoreSetupContext, getEnhancedStore, getExtendingStore, setEnhancedStore } from "../utils/store";
 export { CustomConsole } from "../system/log";
 export { isEmpty } from "../utils/validation";

package/dist/pinia-plugin-subscription.js

@@ -1,288 +1,498 @@
-var S = Object.defineProperty;
-var y = (r, o, e) => o in r ? S(r, o, { enumerable: !0, configurable: !0, writable: !0, value: e }) : r[o] = e;
-var c = (r, o, e) => y(r, typeof o != "symbol" ? o + "" : o, e);
-import { D as g, i as l, P as _ } from "./chunks/index-B-zO0yrr.js";
-import { C as w, p as O, a as j, S as x, d as H, b as K, g as R, c as M, e as L, s as T } from "./chunks/index-B-zO0yrr.js";
-const f = "PluginSubscription", m = {
-  environment: "both",
-  hydration: "immediate"
-};
-function E(r) {
-  if (typeof window < "u" && typeof window.requestAnimationFrame == "function") {
-    window.requestAnimationFrame(() => globalThis.setTimeout(r, 0));
-    return;
-  }
-  globalThis.setTimeout(r, 0);
-}
-function h(r) {
+var g = Object.defineProperty;
+var E = (n, s, t) => s in n ? g(n, s, { enumerable: !0, configurable: !0, writable: !0, value: t }) : n[s] = t;
+var a = (n, s, t) => E(n, typeof s != "symbol" ? s + "" : s, t);
+import { h as O, g as f, D as m, i as y, P as C } from "./chunks/index-D-rnwSJk.js";
+import { C as T, p as W, a as L, S as I, d as q, b as G, c as U, e as z, f as B, s as J } from "./chunks/index-D-rnwSJk.js";
+import { toRaw as _ } from "vue";
+function u(n) {
   if (typeof structuredClone == "function")
     try {
-      return structuredClone(r);
+      return structuredClone(n);
     } catch {
     }
-  if (r === null || typeof r != "object")
-    return r;
-  if (r instanceof Map)
+  if (n === null || typeof n != "object")
+    return n;
+  if (n instanceof Map)
     return new Map(
-      Array.from(r.entries(), ([e, i]) => [h(e), h(i)])
+      Array.from(n.entries(), ([t, e]) => [u(t), u(e)])
     );
-  if (r instanceof Set)
-    return new Set(Array.from(r.values(), (e) => h(e)));
-  if (Array.isArray(r))
-    return r.map((e) => h(e));
-  if (Object.getPrototypeOf(r) === Object.prototype || Object.getPrototypeOf(r) === null)
+  if (n instanceof Set)
+    return new Set(Array.from(n.values(), (t) => u(t)));
+  if (Array.isArray(n))
+    return n.map((t) => u(t));
+  if (Object.getPrototypeOf(n) === Object.prototype || Object.getPrototypeOf(n) === null)
     return Object.fromEntries(
-      Object.entries(r).map(([e, i]) => [e, h(i)])
+      Object.entries(n).map(([t, e]) => [t, u(e)])
+    );
+  const s = Object.create(Object.getPrototypeOf(n));
+  for (const [t, e] of Object.entries(n))
+    s[t] = u(e);
+  return s;
+}
+function $(n, s = "all") {
+  if (Array.isArray(s)) {
+    const t = {};
+    for (const e of s)
+      e in n && (t[e] = u(_(n[e])));
+    return t;
+  }
+  if (s !== "all")
+    throw new Error(`Invalid keys parameter: ${s}`);
+  return u(_(n));
+}
+class v {
+  constructor() {
+    a(this, "_stateSnapshots", /* @__PURE__ */ new Map());
+    a(this, "_storeHasRollbackSnapshots", /* @__PURE__ */ new Set());
+    a(this, "_storeRollbackSnapshotsParams", /* @__PURE__ */ new Map());
+  }
+  /**
+   * Adds a rollback action to the given store.
+   * This method extends the store with a $rollbackAfterFailure function that handles rollback logic for actions.
+   * @param {Store} store The store to which the rollback action will be added.
+   * @returns void
+   */
+  addRollbackAction(s) {
+    typeof s.$rollbackAfterFailure != "function" && (s.$rollbackAfterFailure = async ({ action: t, stateKeys: e }, ...i) => {
+      const r = s[t];
+      if (typeof r != "function" || O(t))
+        return;
+      const o = !e || e.length === 0 ? "all" : e, h = this.saveStateSnapshot(s, t, o);
+      try {
+        await r.apply(s, i);
+      } catch (c) {
+        throw this.patchStore(h, s), c;
+      } finally {
+        this.removeStateSnapshot(h);
+      }
+    });
+  }
+  /**
+   * Creates a rollback snapshot for the specified action and store.
+   * This snapshot can be used to restore the store's state in case of an error during the action execution.
+   * @param {string} actionName The name of the action for which the rollback snapshot is created.
+   * @param {Store} store The Pinia store instance.
+   * @returns An object containing `after` and `onError` callbacks for handling the rollback, or `undefined` if no snapshot is created.
+   */
+  createOnActionCallbacks(s, t) {
+    const e = this._storeRollbackSnapshotsParams.get(
+      f(s, t)
     );
-  const o = Object.create(Object.getPrototypeOf(r));
-  for (const [e, i] of Object.entries(r))
-    o[e] = h(i);
-  return o;
+    if (!e || e.length === 0)
+      return;
+    const i = this.saveStateSnapshot(t, s, e);
+    return {
+      after: () => {
+        this.removeStateSnapshot(i);
+      },
+      onError: () => {
+        this.patchStore(i, t), this.removeStateSnapshot(i);
+      }
+    };
+  }
+  /**
+   * Initializes the rollback state snapshots handler from the given Pinia plugin context.
+   * This method extracts the rollback snapshot parameters from the store options and stores them internally.
+   * @param {PiniaPluginContext} param0 The Pinia plugin context containing the store and its options.
+   * @returns void
+   */
+  initFromPluginContext({ options: s, store: t }) {
+    const e = s?.storeOptions?.rollbackAfterFailure;
+    e && !this._storeHasRollbackSnapshots.has(t.$id) && (Object.keys(e).forEach((i) => {
+      this._storeRollbackSnapshotsParams.set(
+        f(i, t),
+        e[i]
+      );
+    }), this._storeHasRollbackSnapshots.add(t.$id)), this.addRollbackAction(t);
+  }
+  /**
+   * Clears all rollback tracking data for the given store.
+   * Must be called when the store is disposed to avoid memory leaks with dynamically created stores.
+   * @param {Store} store The disposed Pinia store instance.
+   * @returns void
+   */
+  clearStoreTracking(s) {
+    const t = `-${s.$id}`;
+    for (const e of Array.from(this._storeRollbackSnapshotsParams.keys()))
+      e.endsWith(t) && this._storeRollbackSnapshotsParams.delete(e);
+    this._storeHasRollbackSnapshots.delete(s.$id);
+    for (const e of Array.from(this._stateSnapshots.keys()))
+      e.description?.startsWith(`${s.$id}:`) && this._stateSnapshots.delete(e);
+  }
+  patchStore(s, t) {
+    const e = this._stateSnapshots.get(s);
+    if (e)
+      try {
+        t.$patch(e);
+      } catch (i) {
+        console.error(`Failed to patch store with snapshot ${String(s)}`, i);
+      }
+  }
+  /**
+   * Removes a state snapshot identified by the given snapshot key from the internal state snapshot tracking.
+   * @param snapshotKey The key of the state snapshot to be removed.
+   * @returns void
+   */
+  removeStateSnapshot(s) {
+    s && this._stateSnapshots.delete(s);
+  }
+  /**
+   * Saves the current state snapshot for a given store and action.
+   * @param store The Pinia store instance.
+   * @param actionName The name of the action being executed.
+   * @param stateKeys The state keys to include in the snapshot, or 'all' for the full state.
+   * @returns A unique symbol key representing the saved snapshot.
+   */
+  saveStateSnapshot(s, t, e) {
+    const i = $(
+      s.$state,
+      e
+    ), r = /* @__PURE__ */ Symbol(`${s.$id}:${t}`);
+    return this._stateSnapshots.set(r, i), r;
+  }
+  /**
+   * Checks if the given store has rollback snapshots.
+   * @param store The Pinia store instance.
+   * @returns True if the store has rollback snapshots, false otherwise.
+   */
+  storeHasRollbackSnapshots(s) {
+    return this._storeHasRollbackSnapshots.has(s.$id);
+  }
+}
+const A = "PluginSubscription", P = {
+  environment: "both",
+  hydration: "immediate"
+};
+function R(n) {
+  if (typeof window < "u" && typeof window.requestAnimationFrame == "function") {
+    window.requestAnimationFrame(() => globalThis.setTimeout(n, 0));
+    return;
+  }
+  globalThis.setTimeout(n, 0);
 }
-function A(r) {
-  return r !== void 0 && !Array.isArray(r);
+function D(n) {
+  return n !== void 0 && !Array.isArray(n);
 }
-class p extends g {
-  constructor(e, i, t) {
-    const s = Array.isArray(i) ? i : void 0, n = A(i) ? i : t;
-    super(Array.isArray(s) && !!s?.includes(f), _);
-    c(this, "_className", f);
-    c(this, "_hydrationScheduler");
-    c(this, "_options");
-    c(this, "_pluginDebug");
-    c(this, "_resetStoreCallback", []);
-    c(this, "_subscribers", []);
-    c(this, "_subscribersDelivered", /* @__PURE__ */ new Set());
-    c(this, "_subscribersScheduled", /* @__PURE__ */ new Set());
-    c(this, "_subscriptions", []);
-    c(this, "_subscriptionsDelivered", /* @__PURE__ */ new Set());
-    c(this, "_subscriptionsScheduled", /* @__PURE__ */ new Set());
-    this._hydrationScheduler = n?.hydrationScheduler ?? E, this._options = n, this._pluginDebug = Array.isArray(s) ? s : void 0, this._subscribers = e;
-  }
-  set subscribers(e) {
-    this._subscribers = e;
+class k extends m {
+  constructor(t, e, i) {
+    const r = Array.isArray(e) ? e : void 0, o = D(e) ? e : i;
+    super(Array.isArray(r) && !!r?.includes(A), C);
+    a(this, "_className", A);
+    a(this, "_hydrationScheduler");
+    a(this, "_onActionSubscriptions", []);
+    a(this, "_onActionAfterSubscriptions", {});
+    a(this, "_onActionOnErrorSubscriptions", {});
+    a(this, "_options");
+    a(this, "_pluginDebug");
+    a(this, "_resetStoreCallback", []);
+    a(this, "_storeRollbackSnapshotsHandler", new v());
+    a(this, "_subscribers", []);
+    a(this, "_subscribersDelivered", /* @__PURE__ */ new Set());
+    a(this, "_subscribersScheduled", /* @__PURE__ */ new Set());
+    a(this, "_subscriptions", []);
+    a(this, "_subscriptionsDelivered", /* @__PURE__ */ new Set());
+    a(this, "_subscriptionsScheduled", /* @__PURE__ */ new Set());
+    this._hydrationScheduler = o?.hydrationScheduler ?? R, this._options = o, this._pluginDebug = Array.isArray(r) ? r : void 0, this._subscribers = t;
+  }
+  set subscribers(t) {
+    this._subscribers = t;
   }
   get subscriptions() {
-    if (!l(this._subscriptions))
+    if (!y(this._subscriptions))
       return this._subscriptions;
   }
-  addResetStoreCallback(e) {
-    this._resetStoreCallback.push(e);
+  addOnActionAfterCallback(t, e, i) {
+    const r = f(t, e);
+    this._onActionAfterSubscriptions[r] || (this._onActionAfterSubscriptions[r] = []), this._onActionAfterSubscriptions[r]?.push(i);
+  }
+  addOnActionOnErrorCallback(t, e, i) {
+    const r = f(t, e);
+    this._onActionOnErrorSubscriptions[r] || (this._onActionOnErrorSubscriptions[r] = []), this._onActionOnErrorSubscriptions[r]?.push(i);
+  }
+  addResetStoreCallback(t) {
+    this._resetStoreCallback.push(t);
+  }
+  clearOnActionCallbacksSubscriptions(t) {
+    delete this._onActionAfterSubscriptions[t], delete this._onActionOnErrorSubscriptions[t];
+  }
+  clearStoreTracking(t) {
+    const e = `-${t.$id}`;
+    for (const i of Array.from(this._subscribersDelivered))
+      i.endsWith(e) && this._subscribersDelivered.delete(i);
+    for (const i of Array.from(this._subscribersScheduled))
+      i.endsWith(e) && this._subscribersScheduled.delete(i);
+    for (const i of Array.from(this._subscriptionsDelivered))
+      i.endsWith(e) && this._subscriptionsDelivered.delete(i);
+    for (const i of Array.from(this._subscriptionsScheduled))
+      i.endsWith(e) && this._subscriptionsScheduled.delete(i);
+    for (const i of Object.keys(this._onActionAfterSubscriptions))
+      i.endsWith(e) && delete this._onActionAfterSubscriptions[i];
+    for (const i of Object.keys(this._onActionOnErrorSubscriptions))
+      i.endsWith(e) && delete this._onActionOnErrorSubscriptions[i];
+  }
+  /**
+   * Creates a callback collector for the specified action and store.
+   * @param actionName The name of the action to collect callbacks for.
+   * @param store The store instance associated with the action.
+   * @returns A function that collects callbacks for the specified action and store.
+   */
+  createOnActionAfterCallbackCollector(t, e) {
+    return (i) => {
+      this.addOnActionAfterCallback(t, e, i);
+    };
+  }
+  /**
+   * Creates a callback collector for the specified action and store that handles errors.
+   * @param actionName The name of the action to collect error callbacks for.
+   * @param store The store instance associated with the action.
+   * @returns A function that collects error callbacks for the specified action and store.
+   */
+  createOnActionOnErrorCallbackCollector(t, e) {
+    return (i) => {
+      this.addOnActionOnErrorCallback(t, e, i);
+    };
+  }
+  /**
+   * Rolls back the state snapshot for a given action if an error occurs, and removes the snapshot after the action completes or fails.
+   * @param actionName The name of the action being executed.
+   * @param store The Pinia store instance.
+   * @returns void
+   */
+  createRollbackSnapshot(t, e) {
+    const {
+      after: i,
+      onError: r
+    } = this._storeRollbackSnapshotsHandler.createOnActionCallbacks(
+      t,
+      e
+    ) ?? {};
+    !i || !r || (this.addOnActionAfterCallback(t, e, i), this.addOnActionOnErrorCallback(t, e, r));
   }
   defineCurrentEnvironment() {
     return this._options?.runtimeEnvironment ?? (typeof window > "u" ? "server" : "client");
   }
-  definePluginDebug(e) {
-    return !!this._pluginDebug?.includes(e.name);
+  definePluginDebug(t) {
+    return !!this._pluginDebug?.includes(t.name);
   }
-  definePluginExecution(e) {
+  definePluginExecution(t) {
     return {
-      ...m,
+      ...P,
       ...this._options?.execution ?? {},
-      ...e.execution ?? {},
-      ...this._options?.subscriberExecution?.[e.name] ?? {}
+      ...t.execution ?? {},
+      ...this._options?.subscriberExecution?.[t.name] ?? {}
     };
   }
-  defineHydrationScheduler(e) {
-    return e.hydrationScheduler ?? this._hydrationScheduler;
+  defineHydrationScheduler(t) {
+    return t.hydrationScheduler ?? this._hydrationScheduler;
   }
-  defineSubscriberKey(e, i) {
-    return `${e.name}-${i.$id}`;
+  defineSubscriberKey(t, e) {
+    return `${t.name}-${e.$id}`;
   }
-  defineSubscriptionKey(e, i) {
-    return `${e}-${i.$id}`;
+  defineSubscriptionKey(t, e) {
+    return `${t}-${e.$id}`;
   }
-  executeResetStoreCallbacks(e) {
-    this._resetStoreCallback.forEach((i) => i(e));
+  executeResetStoreCallbacks(t) {
+    this._resetStoreCallback.forEach((e) => e(t));
   }
-  executeSubscriber(e, i) {
-    const t = this.defineSubscriberKey(i, e.store), s = this.definePluginDebug(i);
-    if (this._subscribersDelivered.has(t) || !i.invoke(
-      e,
-      s
+  /**
+   * Executes the store's onAction subscription for the given plugin subscriber.
+   * @param store The Pinia store instance.
+   * @param subscriber The plugin subscriber.
+   * @returns void
+   */
+  executeStoreOnActionSubscription(t) {
+    const e = this._onActionSubscriptions, i = this._storeRollbackSnapshotsHandler.storeHasRollbackSnapshots(t);
+    !e?.length && !i || t.$onAction(({ after: r, args: o, name: h, onError: c }) => {
+      const l = f(h, t);
+      this.debugLog(`storeOnActionSubscription ${l}`, { args: o, name: h, store: t }), i && this.createRollbackSnapshot(h, t), e?.length && e.forEach((b) => b({
+        after: this.createOnActionAfterCallbackCollector(h, t),
+        args: o,
+        name: h,
+        onError: this.createOnActionOnErrorCallbackCollector(h, t)
+      }));
+      const d = this._onActionAfterSubscriptions[l], S = this._onActionOnErrorSubscriptions[l];
+      this.clearOnActionCallbacksSubscriptions(l), d?.length && r((b) => {
+        d.forEach((p) => p(b));
+      }), S?.length && c((b) => {
+        S.forEach((p) => p(b));
+      });
+    });
+  }
+  executeSubscriber(t, e) {
+    const i = this.defineSubscriberKey(e, t.store), r = this.definePluginDebug(e);
+    if (this._subscribersDelivered.has(i) || !e.invoke(
+      t,
+      r
     ))
       return;
-    this._subscribersDelivered.add(t);
-    let n;
+    this._subscribersDelivered.add(i);
+    let o;
     try {
-      n = i.hydrate?.(e, s);
-    } catch (u) {
-      this.logError(u, e.store, e.options);
+      o = e.hydrate?.(t, r);
+    } catch (c) {
+      this.logError(c, t.store, t.options);
       return;
     }
-    const d = () => {
+    const h = () => {
       try {
-        const u = i.afterHydration?.(e, s);
-        u && typeof u.then == "function" && u.catch((a) => this.logError(a, e.store, e.options));
-      } catch (u) {
-        this.logError(u, e.store, e.options);
+        const c = e.afterHydration?.(t, r);
+        c && typeof c.then == "function" && c.catch((l) => this.logError(l, t.store, t.options));
+      } catch (c) {
+        this.logError(c, t.store, t.options);
       }
     };
-    n && typeof n.then == "function" ? n.then(() => d()).catch((u) => this.logError(u, e.store, e.options)) : d(), i.subscriptions && this.subscriptionDelivery(e, i.subscriptions), i.storeMutationSubscription && this.storeMutationSubscription(i.storeMutationSubscription), i.storeOnActionSubscription && this.storeOnActionSubscription(i.storeOnActionSubscription), i.resetStoreCallback && this.addResetStoreCallback(i.resetStoreCallback);
+    o && typeof o.then == "function" ? o.then(() => h()).catch((c) => this.logError(c, t.store, t.options)) : h(), e.subscriptions && this.subscriptionDelivery(t, e.subscriptions), e.storeMutationSubscription && this.storeMutationSubscription(e.storeMutationSubscription), this.storeOnActionSubscription(e), e.resetStoreCallback && this.addResetStoreCallback(e.resetStoreCallback);
   }
-  executeSubscriberSafely(e, i) {
+  executeSubscriberSafely(t, e) {
     try {
-      this.executeSubscriber(e, i);
-    } catch (t) {
-      this.logError(t, e.store, e.options);
+      this.executeSubscriber(t, e);
+    } catch (i) {
+      this.logError(i, t.store, t.options);
     }
   }
-  queueSubscriberExecution(e, i, t) {
-    const s = this.defineHydrationScheduler(i);
-    this._subscribersScheduled.add(t), s(() => {
-      this._subscribersScheduled.delete(t), this.executeSubscriberSafely(e, i);
-    });
-  }
-  shouldInvokePlugin(e) {
-    const i = this.defineCurrentEnvironment();
-    return e.environment === "both" || e.environment === i;
-  }
-  shouldScheduleAfterHydration(e) {
-    return this.defineCurrentEnvironment() === "client" && e.hydration === "defer";
-  }
-  plugin({ store: e, options: i }) {
+  plugin({ store: t, options: e }) {
     if (this._subscribers.length) {
-      this.debugLog(`plugin() - ${e.$id}`, [
+      this.debugLog(`plugin() - ${t.$id}`, [
         "subscriber:",
         this._subscribers,
         "store:",
-        e,
+        t,
         "options:",
-        i
+        e
       ]);
       try {
         this._subscribers.forEach(
-          (t) => {
-            const s = this.defineSubscriberKey(t, e), n = this.definePluginExecution(t);
-            if (!(this._subscribersDelivered.has(s) || this._subscribersScheduled.has(s)) && this.shouldInvokePlugin(n)) {
-              if (this.shouldScheduleAfterHydration(n)) {
-                this.queueSubscriberExecution({ store: e, options: i }, t, s);
+          (i) => {
+            const r = this.defineSubscriberKey(i, t), o = this.definePluginExecution(i);
+            if (!(this._subscribersDelivered.has(r) || this._subscribersScheduled.has(r)) && this.shouldInvokePlugin(o)) {
+              if (this.shouldScheduleAfterHydration(o)) {
+                this.queueSubscriberExecution({ store: t, options: e }, i, r);
                 return;
               }
-              this.executeSubscriber({ store: e, options: i }, t);
+              this.executeSubscriber({ store: t, options: e }, i);
             }
           }
-        ), this.rewriteResetStore({ store: e }, h(e.$state), Object.assign({}, e)), this.registerStoreCleanup(e);
-      } catch (t) {
-        this.logError(t, e, i);
+        ), this.rewriteResetStore({ store: t }, t.$state), this._storeRollbackSnapshotsHandler.initFromPluginContext({ store: t, options: e }), this.executeStoreOnActionSubscription(t), this.registerStoreCleanup(t);
+      } catch (i) {
+        this.logError(i, t, e);
       }
     }
   }
-  rewriteResetStore({ store: e }, i, t) {
-    const s = h(i);
-    e.$reset = () => {
-      this.debugLog("rewriteResetStore()", { initState: s, store: e, customStore: t }), this.executeResetStoreCallbacks(e), e.$patch(h(s));
-    };
+  queueSubscriberExecution(t, e, i) {
+    const r = this.defineHydrationScheduler(e);
+    this._subscribersScheduled.add(i), r(() => {
+      this._subscribersScheduled.delete(i), this.executeSubscriberSafely(t, e);
+    });
   }
-  registerStoreCleanup(e) {
-    if (typeof e.$dispose != "function")
+  registerStoreCleanup(t) {
+    if (this._onActionSubscriptions = [], typeof t.$dispose != "function")
       return;
-    const i = e.$dispose.bind(e), t = e;
-    t.__piniaPluginSubscriptionDisposed || (t.__piniaPluginSubscriptionDisposed = !0, e.$dispose = () => (this.clearStoreTracking(e), i()));
-  }
-  clearStoreTracking(e) {
-    const i = `-${e.$id}`;
-    for (const t of Array.from(this._subscribersDelivered))
-      t.endsWith(i) && this._subscribersDelivered.delete(t);
-    for (const t of Array.from(this._subscribersScheduled))
-      t.endsWith(i) && this._subscribersScheduled.delete(t);
-    for (const t of Array.from(this._subscriptionsDelivered))
-      t.endsWith(i) && this._subscriptionsDelivered.delete(t);
-    for (const t of Array.from(this._subscriptionsScheduled))
-      t.endsWith(i) && this._subscriptionsScheduled.delete(t);
-  }
-  storeOnActionSubscription(e) {
-    const { store: i, callback: t } = e();
-    i.$onAction(({ after: s, args: n, name: d, onError: u }) => {
-      this.debugLog(`storeOnActionSubscription ${i.$id}`, { after: s, args: n, name: d, store: i }), t({ after: s, args: n, name: d, onError: u });
-    });
+    const e = t.$dispose.bind(t), i = t;
+    i.__piniaPluginSubscriptionDisposed || (i.__piniaPluginSubscriptionDisposed = !0, t.$dispose = () => (this.clearStoreTracking(t), this._storeRollbackSnapshotsHandler.clearStoreTracking(t), e()));
+  }
+  rewriteResetStore({ store: t }, e) {
+    const i = u(e);
+    t.$reset = () => {
+      this.debugLog("rewriteResetStore()", { initState: i, store: t }), this.executeResetStoreCallbacks(t), t.$patch(u(i));
+    };
   }
-  storeMutationSubscription(e) {
-    const { store: i, callback: t } = e();
-    i.$subscribe((s) => {
-      this.debugLog(`$subscribe ${i.$id}`, { mutation: s, store: i }), t(s);
+  shouldInvokePlugin(t) {
+    const e = this.defineCurrentEnvironment();
+    return t.environment === "both" || t.environment === e;
+  }
+  shouldScheduleAfterHydration(t) {
+    return this.defineCurrentEnvironment() === "client" && t.hydration === "defer";
+  }
+  storeOnActionSubscription(t) {
+    const { store: e, callback: i } = t?.storeOnActionSubscription?.() ?? {};
+    !e || !i || this._onActionSubscriptions.push(i);
+  }
+  storeMutationSubscription(t) {
+    const { store: e, callback: i } = t();
+    e.$subscribe((r) => {
+      this.debugLog(`$subscribe ${e.$id}`, { mutation: r, store: e }), i(r);
     });
   }
-  subscriptionDelivery(e, i) {
-    Object.entries(i).forEach(([t, s]) => {
-      const n = this.defineSubscriptionKey(t, e.store), d = this.definePluginExecution(s.subscription);
-      if (!(this._subscriptionsDelivered.has(n) || this._subscriptionsScheduled.has(n)) && this.shouldInvokePlugin(d)) {
-        if (this.shouldScheduleAfterHydration(d)) {
-          const u = this.defineHydrationScheduler(s.subscription);
-          this._subscriptionsScheduled.add(n), u(() => {
-            this._subscriptionsScheduled.delete(n), this.subscriptionDeliverySafely(e, t, s);
+  subscriptionDelivery(t, e) {
+    Object.entries(e).forEach(([i, r]) => {
+      const o = this.defineSubscriptionKey(i, t.store), h = this.definePluginExecution(r.subscription);
+      if (!(this._subscriptionsDelivered.has(o) || this._subscriptionsScheduled.has(o)) && this.shouldInvokePlugin(h)) {
+        if (this.shouldScheduleAfterHydration(h)) {
+          const c = this.defineHydrationScheduler(r.subscription);
+          this._subscriptionsScheduled.add(o), c(() => {
+            this._subscriptionsScheduled.delete(o), this.subscriptionDeliverySafely(t, i, r);
           });
           return;
         }
-        this.subscriptionDeliverySafely(e, t, s);
+        this.subscriptionDeliverySafely(t, i, r);
       }
     });
   }
-  subscriptionDeliverySafely({ store: e, options: i }, t, s) {
+  subscriptionDeliverySafely({ store: t, options: e }, i, r) {
     try {
-      if (this._subscriptionsDelivered.has(this.defineSubscriptionKey(t, e)))
+      if (this._subscriptionsDelivered.has(this.defineSubscriptionKey(i, t)))
         return;
-      const { subscription: n, subscriptionOptions: d, stores: u } = s;
-      this.debugLog(`subscriptionDelivery() - store: ${e.$id}`, [
+      const { subscription: o, subscriptionOptions: h, stores: c } = r;
+      this.debugLog(`subscriptionDelivery() - store: ${t.$id}`, [
         "pluginName:",
-        t,
+        i,
         "subscription:",
-        n,
+        o,
         "options:",
-        s,
+        r,
         "stores:",
-        u
+        c
       ]);
-      const a = {
-        storeOptions: { ...i?.storeOptions ?? {}, ...d }
+      const l = {
+        storeOptions: { ...e?.storeOptions ?? {}, ...h }
       };
-      n.invoke(
-        { store: e, options: { ...i, ...a } },
+      o.invoke(
+        { store: t, options: { ...e, ...l } },
         this.debug
-      ), this._subscriptionsDelivered.add(this.defineSubscriptionKey(t, e)), l(u) || u?.forEach(
-        (b) => n.invoke(
+      ), this._subscriptionsDelivered.add(this.defineSubscriptionKey(i, t)), y(c) || c?.forEach(
+        (d) => o.invoke(
           {
-            store: b,
+            store: d,
             options: {
-              ...i,
-              ...a,
-              ...b?.storeOptions ?? {}
+              ...e,
+              ...l,
+              ...d?.storeOptions ?? {}
             }
           },
           this.debug
         )
       );
-    } catch (n) {
-      this.logError("subscriptionDelivery()", n, e, i);
+    } catch (o) {
+      this.logError("subscriptionDelivery()", o, t, e);
     }
   }
 }
-function $(r, o) {
-  const e = new p(r, o);
-  return e.plugin.bind(e);
+function j(n, s) {
+  const t = new k(n, s);
+  return t.plugin.bind(t);
 }
-function P(r, o) {
-  const e = new p(r, o?.debug, {
-    execution: o?.execution,
-    hydrationScheduler: o?.hydrationScheduler,
-    runtimeEnvironment: o?.runtimeEnvironment,
-    subscriberExecution: o?.subscriberExecution
+function K(n, s) {
+  const t = new k(n, s?.debug, {
+    execution: s?.execution,
+    hydrationScheduler: s?.hydrationScheduler,
+    runtimeEnvironment: s?.runtimeEnvironment,
+    subscriberExecution: s?.subscriberExecution
   });
-  return e.plugin.bind(e);
+  return t.plugin.bind(t);
 }
 export {
-  w as CustomConsole,
-  O as PLUGIN_NAME,
-  j as PluginSubscriber,
-  p as PluginSubscription,
-  x as Store,
-  P as createHydrationPlugin,
-  $ as createPlugin,
-  H as defineAStore,
-  K as defineAStoreCtx,
-  R as getDefineAStoreSetupContext,
-  M as getEnhancedStore,
-  L as getExtendingStore,
-  l as isEmpty,
-  T as setEnhancedStore
+  T as CustomConsole,
+  W as PLUGIN_NAME,
+  L as PluginSubscriber,
+  k as PluginSubscription,
+  I as Store,
+  K as createHydrationPlugin,
+  j as createPlugin,
+  q as defineAStore,
+  G as defineAStoreCtx,
+  U as getDefineAStoreSetupContext,
+  z as getEnhancedStore,
+  B as getExtendingStore,
+  y as isEmpty,
+  J as setEnhancedStore
 };

package/dist/plugins/createPlugin.d.ts

@@ -1,9 +1,14 @@
 import type { PiniaPlugin } from "pinia";
 import type { PluginSubscriber } from "../types/plugin";
-import type { StoreOptions } from "../types/store";
+import type { RollbackActionParams, StoreOptions } from "../types/store";
 export declare function createPlugin(subscribers: PluginSubscriber[], debug?: string[]): PiniaPlugin;
 declare module 'pinia' {
     interface PiniaCustomProperties {
+        /**
+         * Executes an action and restores the previous state snapshot if it fails.
+         * Added to every store when the plugin is active.
+         */
+        $rollbackAfterFailure: (params: RollbackActionParams, ...args: any[]) => Promise<void>;
     }
     interface DefineStoreOptionsBase<S, Store> {
         storeOptions?: StoreOptions;

package/dist/types/plugin.d.ts

@@ -1,6 +1,7 @@
 import type { PiniaPluginContext, StateTree, Store, SubscriptionCallbackMutation } from "pinia";
 import type { StoreOptions } from "./store";
 import type { Console, PluginSubscriberInterface } from ".";
+export type CreateStateSnapshotKeys = (keyof StateTree)[] | 'all';
 export type PluginHydrationScheduler = (callback: () => void) => void;
 export type PluginHydrationTiming = 'defer' | 'immediate';
 export type PluginRuntimeEnvironment = 'client' | 'server';
@@ -33,11 +34,13 @@ export interface NativePiniaSubscriptionReturn<Callback> {
     store: Store;
     callback: Callback;
 }
+export type StoreOnActionAfterCallbackParameter = (callback: (result?: unknown) => void) => void;
+export type StoreOnActionOnErrorCallbackParameter = (callback: (error: unknown) => void) => void;
 export interface StoreOnActionCallbackParameters {
-    after: Function;
+    after: StoreOnActionAfterCallbackParameter;
     args: any[] | object;
     name: string;
-    onError?: Error | unknown;
+    onError?: StoreOnActionOnErrorCallbackParameter;
 }
 export interface PluginSubscription {
     stores?: Store[];

package/dist/types/store.d.ts

@@ -1,4 +1,5 @@
 import type { AnyObject } from ".";
+import type { CreateStateSnapshotKeys } from "./plugin";
 import type { PiniaCustomProperties, Store, StoreDefinition } from "pinia";
 import type { Ref } from "vue";
 export type CustomStore<TStore, TState> = Store & TStore & TState & PiniaCustomProperties & StoreDefinition;
@@ -20,8 +21,18 @@ export type OptionBaseProperty = string | number | boolean | null | undefined |
 export interface PluginStoreOptions {
     storeOptions: StoreOptions;
 }
+export interface RollbackActionParams {
+    action: string;
+    stateKeys?: CreateStateSnapshotKeys;
+}
+export type RollbackAfterFailureParams = {
+    [key: string]: CreateStateSnapshotKeys;
+};
 export type StatePropertyValue = StdStatePropertyValue | Ref<StdStatePropertyValue> | StdStatePropertyValue[] | Ref<StdStatePropertyValue[]> | Ref<StdStatePropertyValue>[];
 type StdStatePropertyValue = AnyObject | boolean | null | number | string | undefined;
-export type StoreOptions = Record<string, StoreOptionsPropertyValue>;
+export interface StoreOptions {
+    [key: string]: StoreOptionsPropertyValue;
+    rollbackAfterFailure?: RollbackAfterFailureParams;
+}
 export type StoreOptionsPropertyValue = OptionBaseProperty | OptionBaseProperty[] | ObjectBaseProperty | ObjectBaseProperty[];
 export {};

package/dist/utils/deep-clone.d.ts

@@ -0,0 +1 @@
+export declare function deepClone<T>(value: T): T;

package/dist/utils/store.d.ts

@@ -1,4 +1,4 @@
-import type { DefineStoreOptions, StateTree, StoreDefinition } from "pinia";
+import type { DefineStoreOptions, StateTree, Store, StoreDefinition } from "pinia";
 import type { AnyObject } from "../types";
 import type { DefineAStoreSetupContext, EmptyExtensions, PluginStoreOptions, StoreOptions } from "../types/store";
 export declare const itemState: {
@@ -28,4 +28,11 @@ export declare function setEnhancedStore<TEnhancedStore>(ctx: DefineAStoreSetupC
  * @deprecated Use getEnhancedStore instead.
  */
 export declare function getExtendingStore<TEnhancedStore>(ctx: DefineAStoreSetupContext<TEnhancedStore>): TEnhancedStore;
+/**
+ * Get the storage key for a given action and store combination.
+ * @param actionName The name of the action.
+ * @param store The Pinia store instance.
+ * @returns The storage key for the action and store combination.
+ */
+export declare function getActionStoreKey(actionName: string, store: Store): string;
 export {};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pinia-plugin-subscription",
-  "version": "0.1.8",
+  "version": "0.2.0-beta.0",
   "description": "Pinia plugin for Vue.js that helps building Pinia plugins by centralizing subscriber registration and providing a Store base class for store helpers.",
   "type": "module",
   "sideEffects": false,