@povio/openapi-codegen-cli 2.0.7 → 2.0.8-rc.1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@povio/openapi-codegen-cli",
-  "version": "2.0.7",
+  "version": "2.0.8-rc.1",
   "keywords": [
     "codegen",
     "openapi",

package/src/assets/useCrossTabQueryInvalidation.ts

@@ -0,0 +1,40 @@
+import type { QueryClient, QueryKey } from "@tanstack/react-query";
+
+const CROSS_TAB_INVALIDATE_KEY = "__rq_invalidate__";
+
+/**
+ * Broadcasts a query invalidation event to all other open tabs via localStorage.
+ *
+ * @param queryKeys - An array of query keys to invalidate (array of arrays).
+ *
+ * NOTE: The `storage` event only fires in *other* tabs — the calling tab
+ * must invalidate its own queryClient separately if needed.
+ */
+export const broadcastQueryInvalidation = (queryKeys: QueryKey[]) => {
+  localStorage.setItem(CROSS_TAB_INVALIDATE_KEY, JSON.stringify({ keys: queryKeys, timestamp: Date.now() }));
+};
+
+/**
+ * Registers a one-time global `storage` event listener that reacts to
+ * cross-tab invalidation broadcasts. Safe to call from multiple hooks —
+ * only the first call sets up the listener.
+ */
+let isListenerSetUp = false;
+
+export const setupCrossTabListener = (queryClient: QueryClient) => {
+  if (isListenerSetUp) return;
+  isListenerSetUp = true;
+
+  window.addEventListener("storage", (e: StorageEvent) => {
+    if (e.key !== CROSS_TAB_INVALIDATE_KEY || !e.newValue) return;
+
+    try {
+      const { keys } = JSON.parse(e.newValue) as { keys: QueryKey[] };
+      for (const queryKey of keys) {
+        queryClient.invalidateQueries({ queryKey });
+      }
+    } catch {
+      // Ignore malformed payloads
+    }
+  });
+};

package/src/assets/useMutationEffects.ts

@@ -1,12 +1,15 @@
-import { useCallback } from "react";
+import { useCallback, useEffect } from "react";
 
 import { OpenApiQueryConfig } from "@povio/openapi-codegen-cli";
 import { QueryKey, useQueryClient } from "@tanstack/react-query";
 
 import { QueryModule } from "./queryModules";
+import { broadcastQueryInvalidation, setupCrossTabListener } from "./useCrossTabQueryInvalidation";
 
 export interface MutationEffectsOptions {
   invalidateCurrentModule?: boolean;
+  crossTabInvalidation?: boolean;
+  invalidationMap?: Record<string, (context: Record<string, string>) => QueryKey[]>;
   invalidateModules?: QueryModule[];
   invalidateKeys?: QueryKey[];
   preferUpdate?: boolean;
@@ -20,6 +23,11 @@ export function useMutationEffects({ currentModule }: UseMutationEffectsProps) {
   const queryClient = useQueryClient();
   const config = OpenApiQueryConfig.useConfig();
 
+  useEffect(() => {
+    if (!config.crossTabInvalidation) return;
+    setupCrossTabListener(queryClient);
+  }, [queryClient, config.crossTabInvalidation]);
+
   const runMutationEffects = useCallback(
     async <TData>(data: TData, options: MutationEffectsOptions = {}, updateKeys?: QueryKey[]) => {
       const { invalidateCurrentModule = true, invalidateModules, invalidateKeys, preferUpdate } = options;
@@ -30,6 +38,8 @@ export function useMutationEffects({ currentModule }: UseMutationEffectsProps) {
       const isQueryKeyEqual = (keyA: QueryKey, keyB: QueryKey) =>
         keyA.length === keyB.length && keyA.every((item, index) => item === keyB[index]);
 
+      const invalidatedQueryKeys: QueryKey[] = [];
+
       queryClient.invalidateQueries({
         predicate: ({ queryKey }) => {
           const isUpdateKey = updateKeys?.some((key) => isQueryKeyEqual(queryKey, key));
@@ -40,15 +50,29 @@ export function useMutationEffects({ currentModule }: UseMutationEffectsProps) {
           const isCurrentModule = shouldInvalidateCurrentModule && queryKey[0] === currentModule;
           const isInvalidateModule = !!invalidateModules && invalidateModules.some((module) => queryKey[0] === module);
           const isInvalidateKey = !!invalidateKeys && invalidateKeys.some((key) => isQueryKeyEqual(queryKey, key));
-          return isCurrentModule || isInvalidateModule || isInvalidateKey;
+
+          const map = config.invalidationMap?.[currentModule]?.(data);
+          const isMappedKey = !!map && map.some((key) => isQueryKeyEqual(queryKey, key));
+
+          const shouldInvalidate = isCurrentModule || isInvalidateModule || isInvalidateKey || isMappedKey;
+
+          if (shouldInvalidate && config.crossTabInvalidation) {
+            invalidatedQueryKeys.push([...queryKey]);
+          }
+
+          return shouldInvalidate;
         },
       });
 
+      if (config.crossTabInvalidation && invalidatedQueryKeys.length > 0) {
+        broadcastQueryInvalidation(invalidatedQueryKeys);
+      }
+
       if (shouldUpdate && updateKeys) {
         updateKeys.map((queryKey) => queryClient.setQueryData(queryKey, data));
       }
     },
-    [queryClient, currentModule, config.preferUpdate],
+    [queryClient, currentModule, config.preferUpdate, config.invalidationMap, config.crossTabInvalidation],
   );
 
   return { runMutationEffects };