@lewebsimple/nuxt-graphql 0.6.19 → 0.7.0

package/dist/runtime/app/composables/useGraphQLMutation.js

@@ -1,41 +1,26 @@
 import { useNuxtApp } from "#app";
-import { ref } from "vue";
-import { getOperationDocument } from "../../shared/lib/registry.js";
-import { normalizeError } from "../../shared/lib/error.js";
-export function useGraphQLMutation(operationName, options) {
-  const { $executeGraphQL } = useNuxtApp();
-  const document = getOperationDocument(operationName);
-  const pending = ref(false);
-  async function mutate(...args) {
-    const [variables] = args;
-    let context;
-    if (options?.onMutate) {
-      try {
-        context = await options.onMutate(variables);
-      } catch (error) {
-        const normalizedError = normalizeError(error);
-        options?.onError?.(normalizedError, variables, context);
-        return { data: null, error: normalizedError };
-      }
-    }
-    pending.value = true;
+import { computed, ref } from "vue";
+export function useGraphQLMutation(operationName, hooks) {
+  const { $executeOperation } = useNuxtApp();
+  const inFlightCount = ref(0);
+  const pending = computed(() => inFlightCount.value > 0);
+  async function mutate(variables) {
+    let context = void 0;
+    inFlightCount.value += 1;
     try {
-      const result = await $executeGraphQL({ query: document, variables, operationName });
+      if (hooks?.onMutate) {
+        context = await hooks.onMutate(variables);
+      }
+      const result = await $executeOperation({ operationName, variables });
       if (result.error) {
-        options?.onError?.(result.error, variables, context);
-      } else if (result.data) {
-        options?.onSuccess?.(result.data, variables, context);
+        hooks?.onError?.(result.error, variables, context);
+      } else {
+        hooks?.onSuccess?.(result.data, variables, context);
       }
-      options?.onSettled?.(result, variables, context);
+      hooks?.onSettled?.(result, variables, context);
       return result;
-    } catch (error) {
-      const normalizedError = normalizeError(error);
-      const errorResult = { data: null, error: normalizedError };
-      options?.onError?.(normalizedError, variables, context);
-      options?.onSettled?.(errorResult, variables, context);
-      return errorResult;
     } finally {
-      pending.value = false;
+      inFlightCount.value = Math.max(0, inFlightCount.value - 1);
     }
   }
   return { pending, mutate };

package/dist/runtime/app/composables/useGraphQLQuery.d.ts

@@ -1,3 +1,10 @@
-import type { QueryName, ResultOf, VariablesOf } from "#graphql/registry";
-import type { ExecuteGraphQLResult, IsEmptyObject } from "../../shared/lib/types.js";
-export declare function useGraphQLQuery<TName extends QueryName>(operationName: TName, ...args: IsEmptyObject<VariablesOf<TName>> extends true ? [variables?: VariablesOf<TName>] : [variables: VariablesOf<TName>]): Promise<ExecuteGraphQLResult<ResultOf<TName>>>;
+import type { ExecuteGraphQLResult } from "../../shared/utils/execute.js";
+import type { QueryName, VariablesInputOf } from "../../shared/utils/registry.js";
+/**
+ * Execute a GraphQL query operation once.
+ *
+ * @param operationName Query operation name.
+ * @param variables Query variables.
+ * @returns Query execution result.
+ */
+export declare function useGraphQLQuery<TName extends QueryName>(operationName: TName, variables: VariablesInputOf<TName>): Promise<ExecuteGraphQLResult<TName>>;

package/dist/runtime/app/composables/useGraphQLQuery.js

@@ -1,15 +1,5 @@
-import { useNuxtApp } from "#imports";
-import { normalizeError } from "../../shared/lib/error.js";
-import { getOperationDocument } from "../../shared/lib/registry.js";
-export async function useGraphQLQuery(operationName, ...args) {
-  const { $executeGraphQL } = useNuxtApp();
-  const [variables] = args;
-  const document = getOperationDocument(operationName);
-  try {
-    return await $executeGraphQL(
-      { query: document, variables, operationName }
-    );
-  } catch (error) {
-    return { data: null, error: normalizeError(error) };
-  }
+import { useNuxtApp } from "#app";
+export async function useGraphQLQuery(operationName, variables) {
+  const { $executeOperation } = useNuxtApp();
+  return $executeOperation({ operationName, variables });
 }

package/dist/runtime/app/composables/useGraphQLSubscription.client.d.ts

@@ -1,7 +1,6 @@
-import { type Ref } from "#imports";
-import type { ResultOf, SubscriptionName, VariablesOf } from "#graphql/registry";
-import { type NormalizedError } from "../../shared/lib/error.js";
-import type { IsEmptyObject } from "../../shared/lib/types.js";
+import { type Ref } from "vue";
+import { type NormalizedError } from "../../shared/utils/error.js";
+import { type ResultOf, type SubscriptionName, type VariablesInputOf } from "../../shared/utils/registry.js";
 type UseGraphQLSubscriptionReturn<TName extends SubscriptionName> = {
     data: Readonly<Ref<ResultOf<TName> | null>>;
     error: Readonly<Ref<NormalizedError | null>>;
@@ -15,5 +14,5 @@ type UseGraphQLSubscriptionReturn<TName extends SubscriptionName> = {
  * @param args Operation variables (if any).
  * @returns Object with reactive data, error, and start/stop helpers.
  */
-export declare function useGraphQLSubscription<TName extends SubscriptionName>(operationName: TName, ...args: IsEmptyObject<VariablesOf<TName>> extends true ? [variables?: VariablesOf<TName>] : [variables: VariablesOf<TName>]): UseGraphQLSubscriptionReturn<TName>;
+export declare function useGraphQLSubscription<TName extends SubscriptionName>(operationName: TName, variables: VariablesInputOf<TName>): UseGraphQLSubscriptionReturn<TName>;
 export {};

package/dist/runtime/app/composables/useGraphQLSubscription.client.js

@@ -1,10 +1,12 @@
+import { useNuxtApp } from "#app";
 import { print } from "graphql";
-import { onScopeDispose, shallowRef, useNuxtApp } from "#imports";
-import { normalizeError } from "../../shared/lib/error.js";
-import { getOperationDocument } from "../../shared/lib/registry.js";
-export function useGraphQLSubscription(operationName, ...args) {
+import { onScopeDispose, shallowRef } from "vue";
+import { normalizeError } from "../../shared/utils/error.js";
+import {
+  getOperationDocument
+} from "../../shared/utils/registry.js";
+export function useGraphQLSubscription(operationName, variables) {
   const { $getGraphQLSSEClient } = useNuxtApp();
-  const [variables] = args;
   const document = getOperationDocument(operationName);
   const query = print(document);
   const data = shallowRef(null);

package/dist/runtime/app/lib/cache-config.d.ts

@@ -0,0 +1,18 @@
+/** Cache configuration. */
+export type CacheConfig = {
+    /** Cache strategy. */
+    policy: "no-cache" | "cache-first" | "network-first" | "swr";
+    /** Optional cache time-to-live in seconds. */
+    ttl?: number;
+    /** Cache key prefix. */
+    keyPrefix: string;
+    /** Cache key version. */
+    keyVersion: string | number;
+};
+/**
+ * Merge cache configuration overrides with defaults.
+ *
+ * @param overrides Partial cache config overrides.
+ * @returns Resolved cache configuration.
+ */
+export declare function resolveCacheConfig(...overrides: Array<Partial<CacheConfig> | undefined>): CacheConfig;

package/dist/runtime/app/lib/cache-config.js

@@ -0,0 +1,9 @@
+const DEFAULT_CACHE_CONFIG = {
+  policy: "no-cache",
+  ttl: void 0,
+  keyPrefix: "gql",
+  keyVersion: "1"
+};
+export function resolveCacheConfig(...overrides) {
+  return Object.assign({}, DEFAULT_CACHE_CONFIG, ...overrides);
+}

package/dist/runtime/app/lib/cache.d.ts

@@ -1,82 +1,114 @@
-import type { CacheConfig } from "../../shared/lib/types.js";
+import type { CacheConfig } from "./cache-config.js";
 /**
- * Resolve cache config from default value with user overrides.
+ * Build the root cache key prefix shared by all entries.
  *
- * @param overrides Partial cache config overrides.
- * @returns Resolved cache configuration.
+ * @param config Cache configuration.
+ * @returns Root cache prefix.
  */
-export declare function resolveCacheConfig(...overrides: Array<Partial<CacheConfig> | undefined>): CacheConfig;
-type CacheKeyParts = {
-    rootPrefix: string;
-    scopePrefix: string;
-    opPrefix: string;
-    key: string;
-};
+export declare function getCacheRootPrefix({ keyPrefix, keyVersion }: CacheConfig): string;
 /**
- * Build cache key parts from config, operation name, and variables.
+ * Build the cache key prefix for a specific scope.
  *
- * @param {GraphQLCacheConfig} config Cache configuration.
- * @param config.keyPrefix Cache key prefix.
- * @param config.keyVersion Cache key version.
- * @param scope Cache scope segment.
- * @param operationName Operation name.
- * @param variables Operation variables.
- * @returns Key parts including full key and operation prefix.
+ * @param config Cache configuration.
+ * @param scope Cache scope.
+ * @returns Scope cache prefix.
  */
-export declare function getCacheKeyParts({ keyPrefix, keyVersion }: CacheConfig, scope: string, operationName: string, variables: unknown): CacheKeyParts;
+export declare function getCacheScopePrefix(config: CacheConfig, scope: string): string;
 /**
- * Register a cache key seen by async GraphQL queries.
+ * Build the cache key prefix for a specific operation in a scope.
  *
- * @param key Cache key.
+ * @param config Cache configuration.
+ * @param scope Cache scope.
+ * @param operationName GraphQL operation name.
+ * @returns Operation cache prefix.
  */
-export declare function registerCacheKey(key: string): void;
+export declare function getCacheOperationPrefix(config: CacheConfig, scope: string, operationName: string): string;
 /**
- * Get known cache keys by prefix.
+ * Build the full cache key for a scoped operation and variables.
  *
- * @param prefix Cache key prefix.
- * @returns Matching cache keys.
+ * @param config Cache configuration.
+ * @param scope Cache scope.
+ * @param operationName GraphQL operation name.
+ * @param variables Operation variables.
+ * @returns Full cache key.
  */
-export declare function getCacheKeysByPrefix(prefix: string): string[];
+export declare function getCacheKey(config: CacheConfig, scope: string, operationName: string, variables: unknown): string;
 /**
- * Mark a single cache key as invalidated.
+ * Invalidate cache entries matching a specific key prefix.
  *
- * @param key Cache key.
+ * @param prefix Cache key prefix to invalidate.
  */
-export declare function invalidateCacheKey(key: string): void;
+export declare function invalidateCachePrefix(prefix: string): void;
+/** Invalidate all cache entries regardless of prefix. */
+export declare function invalidateAllCache(): void;
 /**
- * Mark all cache keys matching a prefix as invalidated.
+ * Determine whether a cache entry should be bypassed due to invalidation.
  *
- * @param prefix Cache key prefix.
+ * @param key Full cache key.
+ * @param createdAt Entry creation timestamp in milliseconds.
+ * @returns `true` when the entry was invalidated by global or prefix invalidation.
  */
-export declare function invalidateCachePrefix(prefix: string): void;
+export declare function shouldBypassCache(key: string, createdAt?: number): boolean;
+/** Metadata stored for a cache entry. */
+export type CacheMeta<T> = {
+    /** In-flight promise for the current cache request. */
+    promise?: Promise<T>;
+    /** Timestamp when this metadata entry was created. */
+    createdAt: number;
+    /** Expiration timestamp in milliseconds, or `null` when it does not expire. */
+    expiresAt: number | null;
+};
 /**
- * Mark all cache keys as invalidated.
+ * Returns metadata for a cache key.
+ *
+ * @param key Cache key used to look up metadata.
+ * @returns Metadata for the key when present, otherwise `undefined`.
  */
-export declare function invalidateAllCacheKeys(): void;
+export declare function getCacheMeta<T>(key: string): CacheMeta<T> | undefined;
 /**
- * Mark a cache key as refreshed from network.
+ * Resolves a cache entry and updates both metadata and Nuxt data state.
  *
- * @param key Cache key.
+ * @param key Cache key to resolve.
+ * @param value Resolved data to store in Nuxt state.
+ * @param ttl Optional time-to-live in milliseconds. When omitted or `null`, the entry does not expire.
+ * @returns The resolved value.
  */
-export declare function markCacheKeyRefreshed(key: string): void;
+export declare function resolveCacheEntry<T>(key: string, value: T, ttl?: number | null): T;
 /**
- * Determine whether cache should be bypassed for this key.
+ * Returns whether the provided cache metadata is expired.
  *
- * @param key Cache key.
- * @returns True when invalidation is newer than the last successful network refresh.
+ * @param meta Metadata object to evaluate.
+ * @returns `true` when metadata exists and is past its expiration time; otherwise `false`.
  */
-export declare function shouldBypassCache(key: string): boolean;
+export declare function isExpired(meta?: CacheMeta<unknown>): boolean;
 /**
- * Remove a single cache key from all internal registries.
+ * Returns a promise for a cache key, creating it if it doesn't exist.
+ *
+ * @param key Cache key to resolve.
+ * @param create Function to create a new promise if none exists.
+ * @param ttl Optional time-to-live in milliseconds. When omitted or `null`, the entry does not expire.
+ * @returns A promise for the cache key.
  */
-export declare function forgetCacheKey(key: string): void;
+export declare function getOrCreatePromise<T>(key: string, create: () => Promise<T>, ttl?: number | null): Promise<T>;
 /**
- * Remove all cache keys and related metadata matching a prefix.
+ * Determines whether a cache entry should be used based on its presence, invalidation status, and expiration.
+ *
+ * @param key Cache key to evaluate.
+ * @param cached Cached value to check.
+ * @param meta Metadata associated with the cache entry.
+ * @returns `true` if the cache entry should be used; otherwise `false`.
  */
-export declare function forgetCacheByPrefix(prefix: string): void;
+export declare function shouldUseCached<T>(key: string, cached: T | undefined, meta?: CacheMeta<unknown>): cached is T;
+type SWRParams<T> = {
+    cached: T | undefined;
+    fetch: () => Promise<T>;
+    inFlight?: Promise<T>;
+};
 /**
- * Clear all in-memory cache tracking metadata.
- * Does NOT delete persisted storage.
+ * Return cached data immediately and refresh in background when possible.
+ *
+ * @param params SWR inputs including cached value, fetcher, and optional in-flight promise.
+ * @returns Cached value when available, otherwise a promise resolving fresh data.
  */
-export declare function forgetCacheAll(): void;
+export declare function staleWhileRevalidate<T>({ cached, fetch, inFlight }: SWRParams<T>): Promise<T> | T;
 export {};

package/dist/runtime/app/lib/cache.js

@@ -1,74 +1,84 @@
 import { hash } from "ohash";
-const defaultCacheConfig = {
-  policy: "no-cache",
-  ttl: void 0,
-  keyPrefix: "gql",
-  keyVersion: "1"
-};
-export function resolveCacheConfig(...overrides) {
-  return Object.assign({}, defaultCacheConfig, ...overrides);
+export function getCacheRootPrefix({ keyPrefix, keyVersion }) {
+  return `${keyPrefix}:${keyVersion}:`;
 }
-export function getCacheKeyParts({ keyPrefix, keyVersion }, scope, operationName, variables) {
-  const rootPrefix = `${keyPrefix}:${keyVersion}:`;
-  const scopePrefix = `${rootPrefix}${scope}:`;
-  const opPrefix = `${scopePrefix}${operationName}:`;
-  const key = `${opPrefix}${hash(variables || {})}`;
-  return { rootPrefix, scopePrefix, opPrefix, key };
+export function getCacheScopePrefix(config, scope) {
+  return `${getCacheRootPrefix(config)}${scope}:`;
 }
-const knownCacheKeys = /* @__PURE__ */ new Set();
-export function registerCacheKey(key) {
-  knownCacheKeys.add(key);
+export function getCacheOperationPrefix(config, scope, operationName) {
+  return `${getCacheScopePrefix(config, scope)}${operationName}:`;
 }
-export function getCacheKeysByPrefix(prefix) {
-  return [...knownCacheKeys].filter((key) => key.startsWith(prefix));
+export function getCacheKey(config, scope, operationName, variables) {
+  return `${getCacheOperationPrefix(config, scope, operationName)}${hash(variables ?? {})}`;
 }
-const invalidatedExactAt = /* @__PURE__ */ new Map();
 const invalidatedPrefixAt = /* @__PURE__ */ new Map();
-const refreshedAt = /* @__PURE__ */ new Map();
 let invalidatedAllAt = 0;
-export function invalidateCacheKey(key) {
-  invalidatedExactAt.set(key, Date.now());
-}
 export function invalidateCachePrefix(prefix) {
   invalidatedPrefixAt.set(prefix, Date.now());
 }
-export function invalidateAllCacheKeys() {
+export function invalidateAllCache() {
   invalidatedAllAt = Date.now();
 }
-export function markCacheKeyRefreshed(key) {
-  refreshedAt.set(key, Date.now());
+export function shouldBypassCache(key, createdAt) {
+  if (!createdAt) return false;
+  if (createdAt < invalidatedAllAt) return true;
+  let newest = 0;
+  let idx = key.indexOf(":");
+  while (idx !== -1) {
+    const prefix = key.slice(0, idx + 1);
+    const ts = invalidatedPrefixAt.get(prefix);
+    if (ts && ts > newest) newest = ts;
+    idx = key.indexOf(":", idx + 1);
+  }
+  return createdAt < newest;
+}
+const metaCache = /* @__PURE__ */ new Map();
+export function getCacheMeta(key) {
+  return metaCache.get(key);
 }
-export function shouldBypassCache(key) {
-  const lastRefreshAt = refreshedAt.get(key) ?? 0;
-  const exactInvalidatedAt = invalidatedExactAt.get(key) ?? 0;
-  let prefixInvalidatedAt = 0;
-  for (const [prefix, timestamp] of invalidatedPrefixAt) {
-    if (key.startsWith(prefix) && timestamp > prefixInvalidatedAt) {
-      prefixInvalidatedAt = timestamp;
-    }
+export function resolveCacheEntry(key, value, ttl) {
+  const now = Date.now();
+  const meta = metaCache.get(key);
+  const next = meta ?? { createdAt: now, expiresAt: null };
+  next.createdAt = now;
+  next.expiresAt = ttl ? now + ttl : null;
+  next.promise = void 0;
+  metaCache.set(key, next);
+  return value;
+}
+export function isExpired(meta) {
+  if (!meta) return false;
+  if (meta.expiresAt === null) return false;
+  return Date.now() > meta.expiresAt;
+}
+export function getOrCreatePromise(key, create, ttl) {
+  let meta = metaCache.get(key);
+  if (meta?.promise) return meta.promise;
+  const promise = (async () => {
+    const value = await create();
+    resolveCacheEntry(key, value, ttl);
+    return value;
+  })();
+  if (!meta) {
+    meta = { createdAt: Date.now(), expiresAt: null };
+    metaCache.set(key, meta);
   }
-  const latestInvalidationAt = Math.max(invalidatedAllAt, exactInvalidatedAt, prefixInvalidatedAt);
-  return latestInvalidationAt > lastRefreshAt;
+  meta.promise = promise;
+  return promise;
 }
-export function forgetCacheKey(key) {
-  knownCacheKeys.delete(key);
-  invalidatedExactAt.delete(key);
-  refreshedAt.delete(key);
+export function shouldUseCached(key, cached, meta) {
+  if (cached === void 0) return false;
+  if (shouldBypassCache(key, meta?.createdAt)) return false;
+  if (isExpired(meta)) return false;
+  return true;
 }
-export function forgetCacheByPrefix(prefix) {
-  for (const key of knownCacheKeys) {
-    if (key.startsWith(prefix)) {
-      knownCacheKeys.delete(key);
-      invalidatedExactAt.delete(key);
-      refreshedAt.delete(key);
+export function staleWhileRevalidate({ cached, fetch, inFlight }) {
+  if (cached !== void 0) {
+    if (!inFlight) {
+      fetch().catch(() => {
+      });
     }
+    return cached;
   }
-  invalidatedPrefixAt.delete(prefix);
-}
-export function forgetCacheAll() {
-  knownCacheKeys.clear();
-  invalidatedExactAt.clear();
-  invalidatedPrefixAt.clear();
-  refreshedAt.clear();
-  invalidatedAllAt = 0;
+  return inFlight ?? fetch();
 }

package/dist/runtime/app/lib/persisted.d.ts

@@ -1,30 +1,36 @@
+type PersistedEntry<T> = {
+    value: T;
+    createdAt: number;
+    expiresAt: number | null;
+};
 /**
- * Retrieve a persisted cache entry.
+ * Read a persisted cache entry from local storage.
  *
  * @param key Cache key.
- * @returns Cached value or undefined when missing/expired.
+ * @returns Persisted entry when present and not expired.
  */
-export declare function getPersistedEntry<T>(key: string): Promise<T | undefined>;
+export declare function getPersistedEntry<T>(key: string): Promise<PersistedEntry<T> | undefined>;
 /**
- * Persist a cache entry with TTL.
+ * Persist a cache entry to local storage.
  *
  * @param key Cache key.
- * @param value Value to store.
- * @param ttl Time to live in seconds (0 = never expires).
- * @returns Resolves when the entry is stored.
+ * @param value Value to persist.
+ * @param ttl Optional time-to-live in milliseconds.
+ * @returns Nothing.
  */
-export declare function setPersistedEntry<T>(key: string, value: T, ttl: number): Promise<void>;
+export declare function setPersistedEntry<T>(key: string, value: T, ttl?: number | null): Promise<void>;
 /**
- * Delete a persisted cache entry by key.
+ * Remove a single persisted cache entry.
  *
  * @param key Cache key.
- * @returns Resolves when the entry is removed.
+ * @returns Nothing.
  */
 export declare function deletePersistedEntry(key: string): Promise<void>;
 /**
- * Delete all persisted cache entries by key prefix.
+ * Remove persisted cache entries matching a key prefix.
  *
  * @param prefix Cache key prefix.
- * @returns Resolves when matching entries are removed.
+ * @returns Nothing.
  */
 export declare function deletePersistedByPrefix(prefix: string): Promise<void>;
+export {};

package/dist/runtime/app/lib/persisted.js

@@ -1,70 +1,67 @@
-import { createStorage } from "unstorage";
-import localStorageDriver from "unstorage/drivers/localstorage";
-function isPersistedStorageAvailable() {
-  return import.meta.client && typeof window.localStorage !== "undefined";
-}
-let storage = null;
-function getPersistedStorage() {
-  if (!storage && isPersistedStorageAvailable()) {
-    try {
-      storage = createStorage({
-        driver: localStorageDriver({ base: "nuxt-graphql:" })
-      });
-    } catch {
-      storage = null;
-    }
+function getStorage() {
+  if (import.meta.server) {
+    return null;
   }
-  return storage;
+  try {
+    return window.localStorage;
+  } catch {
+    return null;
+  }
+}
+function buildKey(key) {
+  return `cache:${key}`;
 }
 export async function getPersistedEntry(key) {
-  const ps = getPersistedStorage();
-  if (!ps) {
-    return void 0;
-  }
+  const storage = getStorage();
+  if (!storage) return void 0;
   try {
-    const payload = await ps.getItem(key);
-    if (!payload) {
-      return void 0;
-    }
-    if (payload.expiresAt && payload.expiresAt < Date.now()) {
-      await ps.removeItem(key);
+    const storageKey = buildKey(key);
+    const raw = storage.getItem(storageKey);
+    if (!raw) return void 0;
+    const entry = JSON.parse(raw);
+    if (entry.expiresAt !== null && Date.now() > entry.expiresAt) {
+      storage.removeItem(storageKey);
       return void 0;
     }
-    return payload.value;
+    return entry;
   } catch {
     return void 0;
   }
 }
 export async function setPersistedEntry(key, value, ttl) {
-  const ps = getPersistedStorage();
-  if (!ps) {
-    return;
-  }
-  const expiresAt = ttl > 0 ? Date.now() + ttl * 1e3 : null;
+  const storage = getStorage();
+  if (!storage) return;
   try {
-    const payload = { value, expiresAt };
-    await ps.setItem(key, payload);
+    const now = Date.now();
+    const entry = {
+      value,
+      createdAt: now,
+      expiresAt: ttl ? now + ttl : null
+    };
+    storage.setItem(buildKey(key), JSON.stringify(entry));
   } catch {
   }
 }
 export async function deletePersistedEntry(key) {
-  const ps = getPersistedStorage();
-  if (!ps) {
-    return;
-  }
+  const storage = getStorage();
+  if (!storage) return;
   try {
-    await ps.removeItem(key);
+    storage.removeItem(buildKey(key));
   } catch {
   }
 }
 export async function deletePersistedByPrefix(prefix) {
-  const ps = getPersistedStorage();
-  if (!ps) {
-    return;
-  }
+  const storage = getStorage();
+  if (!storage) return;
   try {
-    const keys = await ps.getKeys(prefix);
-    await Promise.all(keys.map((key) => ps.removeItem(key)));
+    const fullPrefix = buildKey(prefix);
+    for (let i = storage.length - 1; i >= 0; i--) {
+      const k = storage.key(i);
+      if (!k) continue;
+      if (k.startsWith(fullPrefix)) {
+        storage.removeItem(k);
+      }
+    }
   } catch {
   }
 }

package/dist/runtime/app/plugins/graphql-sse.client.js

@@ -1,6 +1,6 @@
 import { defineNuxtPlugin, useRequestURL } from "#app";
 import { createClient } from "graphql-sse";
-export default defineNuxtPlugin((_nuxtApp) => {
+export default defineNuxtPlugin(() => {
   const { origin } = useRequestURL();
   let sseClient;
   function getGraphQLSSEClient() {
@@ -10,6 +10,5 @@ export default defineNuxtPlugin((_nuxtApp) => {
     if (sseClient) return sseClient;
     return sseClient = createClient({ url: `${origin}/api/graphql` });
   }
-  ;
   return { provide: { getGraphQLSSEClient } };
 });