@spoosh/plugin-invalidation 0.5.1 → 0.5.3

package/README.md

@@ -2,7 +2,7 @@
 
 Cache invalidation plugin for Spoosh - auto-invalidates related queries after mutations.
 
-**[Documentation](https://spoosh.dev/docs/plugins/invalidation)** · **Requirements:** TypeScript >= 5.0 · **Peer Dependencies:** `@spoosh/core`
+**[Documentation](https://spoosh.dev/react/docs/plugins/invalidation)** · **Requirements:** TypeScript >= 5.0 · **Peer Dependencies:** `@spoosh/core`
 
 ## Installation
 
@@ -81,7 +81,13 @@ await trigger({
   invalidate: "none", // No invalidation
 });
 
-// Tags only (array without mode keyword)
+// Single tag (string)
+await trigger({
+  body: { title: "New Post" },
+  invalidate: "posts", // Invalidate only "posts" tag
+});
+
+// Multiple tags (array without mode keyword)
 await trigger({
   body: { title: "New Post" },
   invalidate: ["posts", "users", "custom-tag"],
@@ -106,6 +112,18 @@ await trigger({
   invalidate: ["dashboard", "stats", "all"],
   // → 'all' mode + explicit tags (mode can be anywhere)
 });
+
+// Wildcard - global refetch
+await trigger({
+  body: { title: "New Post" },
+  invalidate: "*", // Triggers ALL queries to refetch
+});
+
+// Combined with clearCache (from @spoosh/plugin-cache)
+await trigger({
+  clearCache: true,     // Clear all cached data
+  invalidate: "*",      // Then refetch all queries
+});
 ```
 
 ## Options
@@ -118,9 +136,9 @@ await trigger({
 
 ### Per-Request Options
 
-| Option       | Type                                    | Description                                                                                             |
-| ------------ | --------------------------------------- | ------------------------------------------------------------------------------------------------------- |
-| `invalidate` | `"all" \| "self" \| "none" \| string[]` | Mode only (string), tags only (array), or mode + tags (array with 'all'/'self' keyword at any position) |
+| Option       | Type                                                     | Description                                                                                                                      |
+| ------------ | -------------------------------------------------------- | -------------------------------------------------------------------------------------------------------------------------------- |
+| `invalidate` | `"all" \| "self" \| "none" \| "*" \| string \| string[]` | Mode (`"all"`, `"self"`, `"none"`), wildcard (`"*"` for global refetch), single tag, or array of tags with optional mode keyword |
 
 ### Invalidation Modes
 
@@ -129,6 +147,25 @@ await trigger({
 | `"all"`  | Invalidate all tags from path hierarchy | `users/123/posts` → `users`, `users/123`, `users/123/posts` |
 | `"self"` | Only invalidate the exact endpoint tag  | `users/123/posts` → `users/123/posts`                       |
 | `"none"` | Disable auto-invalidation (manual only) | No automatic invalidation                                   |
+| `"*"`    | Global refetch - triggers all queries   | All active queries refetch                                  |
+
+### Understanding `"all"` vs `"*"`
+
+These two options serve different purposes:
+
+- **`"all"`** - Invalidates all tags **from the current endpoint's path hierarchy**. If you're mutating `users/123/posts`, it invalidates `["users", "users/123", "users/123/posts"]`. It's scoped to the mutation's path.
+
+- **`"*"`** - Triggers a **global refetch of every active query** in your app, regardless of tags. Use this sparingly for scenarios like "user logged out" or "full data sync from server".
+
+```typescript
+// "all" - scoped to this mutation's path hierarchy
+await trigger({ invalidate: "all" });
+// If path is users/123/posts → invalidates: users, users/123, users/123/posts
+
+// "*" - refetches ALL queries in the entire app
+await trigger({ invalidate: "*" });
+// Every active useRead/injectRead will refetch
+```
 
 ## Instance API
 
@@ -145,12 +182,38 @@ invalidate(["users", "posts"]);
 // Invalidate with single string
 invalidate("users");
 
+// Global refetch - triggers ALL queries to refetch
+invalidate("*");
+
 // Useful for external events like WebSocket messages
 socket.on("data-changed", (tags) => {
   invalidate(tags);
 });
+
+// WebSocket: trigger global refetch
+socket.on("full-sync", () => {
+  invalidate("*");
+});
+```
+
+| Method       | Description                                                            |
+| ------------ | ---------------------------------------------------------------------- |
+| `invalidate` | Manually invalidate cache entries by tags, or use `"*"` to refetch all |
+
+## Combining with Cache Plugin
+
+For scenarios like logout or user switching, combine `invalidate: "*"` with `clearCache` from `@spoosh/plugin-cache`:
+
+```typescript
+const { trigger } = useWrite((api) => api("auth/logout").POST);
+
+// Clear cache + trigger all queries to refetch
+await trigger({
+  clearCache: true,    // From cache plugin: clear all cached data
+  invalidate: "*",     // From invalidation plugin: trigger all queries to refetch
+});
 ```
 
-| Method       | Description                               |
-| ------------ | ----------------------------------------- |
-| `invalidate` | Manually invalidate cache entries by tags |
+This ensures both:
+1. All cached data is cleared (no stale data from previous session)
+2. All active queries refetch with fresh data

package/dist/index.d.mts

@@ -15,7 +15,7 @@ type ReadPaths<TSchema> = {
  *   - Otherwise, it's tags only with mode defaulting to 'none'
  *   - 'none' keyword should NOT be used in arrays (use string 'none' instead)
  */
-type InvalidateOption<TSchema = unknown> = InvalidationMode | (ReadPaths<TSchema> | "all" | "self" | (string & {}))[];
+type InvalidateOption<TSchema = unknown> = InvalidationMode | "*" | ReadPaths<TSchema> | (ReadPaths<TSchema> | "all" | "self" | (string & {}))[];
 interface InvalidationPluginConfig {
     /**
      * Default invalidation mode when invalidate option is not specified
@@ -32,13 +32,12 @@ type InvalidationInfiniteReadOptions = object;
 type InvalidationReadResult = object;
 type InvalidationWriteResult = object;
 /**
- * Manual invalidation - tags only
+ * Manual invalidation - tags only, or "*" for global refetch
  */
 type InvalidateFn<TSchema> = {
-    (tag: ReadPaths<TSchema>): void;
-    (tags: ReadPaths<TSchema>[]): void;
-    (tag: string): void;
-    (tags: string[]): void;
+    (tag: "*"): void;
+    (tag: ReadPaths<TSchema> | (string & {})): void;
+    (tags: (ReadPaths<TSchema> | (string & {}))[]): void;
 };
 interface InvalidationInstanceApi {
     /** Manually invalidate cache entries by tags. Useful for external events like WebSocket messages. */
@@ -85,12 +84,20 @@ declare module "@spoosh/core" {
  * });
  *
  * trigger({
- *   invalidate: ["posts", "users"], // Tags only
+ *   invalidate: "posts", // Single tag
+ * });
+ *
+ * trigger({
+ *   invalidate: ["posts", "users"], // Multiple tags
  * });
  *
  * trigger({
  *   invalidate: ["all", "posts", "custom-tag"], // Mode + tags
  * });
+ *
+ * trigger({
+ *   invalidate: "*", // Global refetch - triggers all queries to refetch
+ * });
  * ```
  */
 declare function invalidationPlugin(config?: InvalidationPluginConfig): SpooshPlugin<{

package/dist/index.d.ts

@@ -15,7 +15,7 @@ type ReadPaths<TSchema> = {
  *   - Otherwise, it's tags only with mode defaulting to 'none'
  *   - 'none' keyword should NOT be used in arrays (use string 'none' instead)
  */
-type InvalidateOption<TSchema = unknown> = InvalidationMode | (ReadPaths<TSchema> | "all" | "self" | (string & {}))[];
+type InvalidateOption<TSchema = unknown> = InvalidationMode | "*" | ReadPaths<TSchema> | (ReadPaths<TSchema> | "all" | "self" | (string & {}))[];
 interface InvalidationPluginConfig {
     /**
      * Default invalidation mode when invalidate option is not specified
@@ -32,13 +32,12 @@ type InvalidationInfiniteReadOptions = object;
 type InvalidationReadResult = object;
 type InvalidationWriteResult = object;
 /**
- * Manual invalidation - tags only
+ * Manual invalidation - tags only, or "*" for global refetch
  */
 type InvalidateFn<TSchema> = {
-    (tag: ReadPaths<TSchema>): void;
-    (tags: ReadPaths<TSchema>[]): void;
-    (tag: string): void;
-    (tags: string[]): void;
+    (tag: "*"): void;
+    (tag: ReadPaths<TSchema> | (string & {})): void;
+    (tags: (ReadPaths<TSchema> | (string & {}))[]): void;
 };
 interface InvalidationInstanceApi {
     /** Manually invalidate cache entries by tags. Useful for external events like WebSocket messages. */
@@ -85,12 +84,20 @@ declare module "@spoosh/core" {
  * });
  *
  * trigger({
- *   invalidate: ["posts", "users"], // Tags only
+ *   invalidate: "posts", // Single tag
+ * });
+ *
+ * trigger({
+ *   invalidate: ["posts", "users"], // Multiple tags
  * });
  *
  * trigger({
  *   invalidate: ["all", "posts", "custom-tag"], // Mode + tags
  * });
+ *
+ * trigger({
+ *   invalidate: "*", // Global refetch - triggers all queries to refetch
+ * });
  * ```
  */
 declare function invalidationPlugin(config?: InvalidationPluginConfig): SpooshPlugin<{

package/dist/index.js

@@ -25,39 +25,30 @@ __export(src_exports, {
 module.exports = __toCommonJS(src_exports);
 
 // src/plugin.ts
-var import_core = require("@spoosh/core");
 var INVALIDATION_DEFAULT_KEY = "invalidation:defaultMode";
-function resolveModeTags(context, mode, stripTagPrefix) {
+function resolveModeTags(context, mode) {
   switch (mode) {
     case "all":
-      if (stripTagPrefix) {
-        return context.tags.map((tag) => {
-          const segments = tag.split("/").filter(Boolean);
-          return (0, import_core.stripPrefixFromPath)(segments, stripTagPrefix).join("/");
-        });
-      }
       return context.tags;
-    case "self": {
-      const selfPath = context.path.join("/");
-      if (stripTagPrefix) {
-        return [(0, import_core.stripPrefixFromPath)(context.path, stripTagPrefix).join("/")];
-      }
-      return [selfPath];
-    }
+    case "self":
+      return [context.path.join("/")];
     case "none":
       return [];
   }
 }
-function resolveInvalidateTags(context, defaultMode, stripTagPrefix) {
+function resolveInvalidateTags(context, defaultMode) {
   const pluginOptions = context.pluginOptions;
   const invalidateOption = pluginOptions?.invalidate;
   if (!invalidateOption) {
     const overrideDefault = context.metadata.get(INVALIDATION_DEFAULT_KEY);
     const effectiveDefault = overrideDefault ?? defaultMode;
-    return resolveModeTags(context, effectiveDefault, stripTagPrefix);
+    return resolveModeTags(context, effectiveDefault);
   }
   if (typeof invalidateOption === "string") {
-    return resolveModeTags(context, invalidateOption, stripTagPrefix);
+    if (invalidateOption === "all" || invalidateOption === "self" || invalidateOption === "none") {
+      return resolveModeTags(context, invalidateOption);
+    }
+    return [invalidateOption];
   }
   if (Array.isArray(invalidateOption)) {
     const tags = [];
@@ -66,15 +57,10 @@ function resolveInvalidateTags(context, defaultMode, stripTagPrefix) {
       if (item === "all" || item === "self") {
         mode = item;
       } else if (typeof item === "string") {
-        if (stripTagPrefix) {
-          const segments = item.split("/").filter(Boolean);
-          tags.push((0, import_core.stripPrefixFromPath)(segments, stripTagPrefix).join("/"));
-        } else {
-          tags.push(item);
-        }
+        tags.push(item);
       }
     }
-    tags.push(...resolveModeTags(context, mode, stripTagPrefix));
+    tags.push(...resolveModeTags(context, mode));
     return [...new Set(tags)];
   }
   return [];
@@ -93,11 +79,11 @@ function invalidationPlugin(config = {}) {
     },
     afterResponse(context, response) {
       if (!response.error) {
-        const tags = resolveInvalidateTags(
-          context,
-          defaultMode,
-          context.stripTagPrefix
-        );
+        const tags = resolveInvalidateTags(context, defaultMode);
+        if (tags.includes("*")) {
+          context.eventEmitter.emit("refetchAll", void 0);
+          return;
+        }
         if (tags.length > 0) {
           context.stateManager.markStale(tags);
           context.eventEmitter.emit("invalidate", tags);
@@ -108,6 +94,10 @@ function invalidationPlugin(config = {}) {
       const { stateManager, eventEmitter } = context;
       const invalidate = (input) => {
         const tags = Array.isArray(input) ? input : [input];
+        if (tags.includes("*")) {
+          eventEmitter.emit("refetchAll", void 0);
+          return;
+        }
         if (tags.length > 0) {
           stateManager.markStale(tags);
           eventEmitter.emit("invalidate", tags);

package/dist/index.mjs

@@ -1,39 +1,28 @@
 // src/plugin.ts
-import {
-  stripPrefixFromPath
-} from "@spoosh/core";
 var INVALIDATION_DEFAULT_KEY = "invalidation:defaultMode";
-function resolveModeTags(context, mode, stripTagPrefix) {
+function resolveModeTags(context, mode) {
   switch (mode) {
     case "all":
-      if (stripTagPrefix) {
-        return context.tags.map((tag) => {
-          const segments = tag.split("/").filter(Boolean);
-          return stripPrefixFromPath(segments, stripTagPrefix).join("/");
-        });
-      }
       return context.tags;
-    case "self": {
-      const selfPath = context.path.join("/");
-      if (stripTagPrefix) {
-        return [stripPrefixFromPath(context.path, stripTagPrefix).join("/")];
-      }
-      return [selfPath];
-    }
+    case "self":
+      return [context.path.join("/")];
     case "none":
       return [];
   }
 }
-function resolveInvalidateTags(context, defaultMode, stripTagPrefix) {
+function resolveInvalidateTags(context, defaultMode) {
   const pluginOptions = context.pluginOptions;
   const invalidateOption = pluginOptions?.invalidate;
   if (!invalidateOption) {
     const overrideDefault = context.metadata.get(INVALIDATION_DEFAULT_KEY);
     const effectiveDefault = overrideDefault ?? defaultMode;
-    return resolveModeTags(context, effectiveDefault, stripTagPrefix);
+    return resolveModeTags(context, effectiveDefault);
   }
   if (typeof invalidateOption === "string") {
-    return resolveModeTags(context, invalidateOption, stripTagPrefix);
+    if (invalidateOption === "all" || invalidateOption === "self" || invalidateOption === "none") {
+      return resolveModeTags(context, invalidateOption);
+    }
+    return [invalidateOption];
   }
   if (Array.isArray(invalidateOption)) {
     const tags = [];
@@ -42,15 +31,10 @@ function resolveInvalidateTags(context, defaultMode, stripTagPrefix) {
       if (item === "all" || item === "self") {
         mode = item;
       } else if (typeof item === "string") {
-        if (stripTagPrefix) {
-          const segments = item.split("/").filter(Boolean);
-          tags.push(stripPrefixFromPath(segments, stripTagPrefix).join("/"));
-        } else {
-          tags.push(item);
-        }
+        tags.push(item);
       }
     }
-    tags.push(...resolveModeTags(context, mode, stripTagPrefix));
+    tags.push(...resolveModeTags(context, mode));
     return [...new Set(tags)];
   }
   return [];
@@ -69,11 +53,11 @@ function invalidationPlugin(config = {}) {
     },
     afterResponse(context, response) {
       if (!response.error) {
-        const tags = resolveInvalidateTags(
-          context,
-          defaultMode,
-          context.stripTagPrefix
-        );
+        const tags = resolveInvalidateTags(context, defaultMode);
+        if (tags.includes("*")) {
+          context.eventEmitter.emit("refetchAll", void 0);
+          return;
+        }
         if (tags.length > 0) {
           context.stateManager.markStale(tags);
           context.eventEmitter.emit("invalidate", tags);
@@ -84,6 +68,10 @@ function invalidationPlugin(config = {}) {
       const { stateManager, eventEmitter } = context;
       const invalidate = (input) => {
         const tags = Array.isArray(input) ? input : [input];
+        if (tags.includes("*")) {
+          eventEmitter.emit("refetchAll", void 0);
+          return;
+        }
         if (tags.length > 0) {
           stateManager.markStale(tags);
           eventEmitter.emit("invalidate", tags);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@spoosh/plugin-invalidation",
-  "version": "0.5.1",
+  "version": "0.5.3",
   "description": "Cache invalidation plugin for Spoosh - auto-invalidates after mutations",
   "license": "MIT",
   "repository": {
@@ -33,10 +33,10 @@
     }
   },
   "peerDependencies": {
-    "@spoosh/core": ">=0.9.1"
+    "@spoosh/core": ">=0.8.0"
   },
   "devDependencies": {
-    "@spoosh/core": "0.9.1",
+    "@spoosh/core": "0.9.3",
     "@spoosh/test-utils": "0.1.5"
   },
   "scripts": {