@lewebsimple/nuxt-graphql 0.6.18 → 0.6.20

package/dist/module.json

@@ -1,7 +1,7 @@
 {
   "name": "@lewebsimple/nuxt-graphql",
   "configKey": "graphql",
-  "version": "0.6.18",
+  "version": "0.6.20",
   "builder": {
     "@nuxt/module-builder": "1.0.2",
     "unbuild": "3.6.1"

package/dist/module.mjs

@@ -203,7 +203,7 @@ function addUniversalTemplate({ filename, getContents, emitTs }) {
   return modulePath;
 }
 
-const version = "0.6.18";
+const version = "0.6.20";
 
 async function getDocuments(documentsGlob) {
   try {

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

@@ -3,9 +3,10 @@ import type { QueryName, ResultOf, VariablesOf } from "#graphql/registry";
 import { type MaybeRefOrGetter } from "#imports";
 import type { NormalizedError } from "../../shared/lib/error.js";
 import type { CacheConfig, IsEmptyObject } from "../../shared/lib/types.js";
-type UseAsyncGraphQLQueryOptions<TName extends QueryName, TTransformed = ResultOf<TName>> = Omit<AsyncDataOptions<ResultOf<TName>>, "transform" | "pick"> & {
+type UseAsyncGraphQLQueryOptions<TName extends QueryName, TTransformed = ResultOf<TName>> = Omit<AsyncDataOptions<ResultOf<TName>, TTransformed, never>, "transform" | "pick"> & {
     transform?: (input: ResultOf<TName>) => TTransformed;
     cache?: Partial<CacheConfig>;
+    scope?: string;
 };
 /**
  * Async GraphQL query composable with caching support.

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

@@ -1,5 +1,5 @@
 import { useAsyncData, useNuxtApp, useNuxtData, useRuntimeConfig } from "#app";
-import { computed, toValue } from "#imports";
+import { computed, toValue, watchEffect } from "#imports";
 import { normalizeError } from "../../shared/lib/error.js";
 import { getOperationDocument } from "../../shared/lib/registry.js";
 import { getCacheKeyParts, markCacheKeyRefreshed, registerCacheKey, resolveCacheConfig, shouldBypassCache } from "../lib/cache.js";
@@ -11,10 +11,13 @@ export function useAsyncGraphQLQuery(operationName, ...args) {
   const document = getOperationDocument(operationName);
   const isClient = import.meta.client;
   const { public: { graphql } } = useRuntimeConfig();
-  const { cache, transform, ...asyncDataOptions } = options ?? {};
+  const { cache, transform, scope: scopeOpt, ...asyncDataOptions } = options ?? {};
   const cacheConfig = resolveCacheConfig(graphql.cacheConfig, cache);
-  const cacheKey = computed(() => getCacheKeyParts(cacheConfig, operationName, toValue(variables)).key);
-  registerCacheKey(cacheKey.value);
+  const scope = scopeOpt ?? "global";
+  const cacheKey = computed(() => getCacheKeyParts(cacheConfig, scope, operationName, toValue(variables)).key);
+  watchEffect(() => {
+    registerCacheKey(cacheKey.value);
+  });
   const inFlight = getInFlightRequests();
   async function fetchAndPersist() {
     const key = cacheKey.value;

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

@@ -8,11 +8,12 @@ type CacheWriteOptions = {
  *
  * @returns Cache manipulation helpers.
  */
-export declare function useGraphQLCache(): {
+export declare function useGraphQLCache(scope?: string): {
     readonly cacheConfig: import("../../shared/lib/types.js").CacheConfig;
     readonly read: <TName extends QueryName>(operation: TName, ...args: IsEmptyObject<VariablesOf<TName>> extends true ? [variables?: VariablesOf<TName>] : [variables: VariablesOf<TName>]) => ResultOf<TName> | undefined;
     readonly write: <TName extends QueryName>(operation: TName, variables: VariablesOf<TName>, value: ResultOf<TName> | ((current: ResultOf<TName> | undefined) => ResultOf<TName>), options?: CacheWriteOptions) => void;
     readonly update: <TName extends QueryName>(operation: TName, variables: VariablesOf<TName>, value: ResultOf<TName> | ((current: ResultOf<TName> | undefined) => ResultOf<TName>), options?: CacheWriteOptions) => Promise<void>;
     readonly invalidate: <TName extends QueryName>(operation?: TName | undefined, variables?: VariablesOf<TName> | undefined) => Promise<void>;
+    readonly invalidateAllScopes: () => Promise<void>;
 };
 export {};

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

@@ -1,65 +1,89 @@
 import { refreshNuxtData, useNuxtData, useRuntimeConfig } from "#imports";
-import { getCacheKeyParts, getCacheKeysByPrefix, invalidateAllCacheKeys, invalidateCacheKey, invalidateCachePrefix, markCacheKeyRefreshed, registerCacheKey } from "../lib/cache.js";
+import {
+  forgetCacheAll,
+  forgetCacheByPrefix,
+  forgetCacheKey,
+  getCacheKeyParts,
+  getCacheKeysByPrefix,
+  invalidateAllCacheKeys,
+  invalidateCacheKey,
+  invalidateCachePrefix,
+  markCacheKeyRefreshed,
+  registerCacheKey
+} from "../lib/cache.js";
 import { deletePersistedByPrefix, deletePersistedEntry, getPersistedEntry, setPersistedEntry } from "../lib/persisted.js";
-export function useGraphQLCache() {
+export function useGraphQLCache(scope = "global") {
   const { public: { graphql: { cacheConfig } } } = useRuntimeConfig();
+  function resolveKeyParts(operation, variables) {
+    return getCacheKeyParts(cacheConfig, scope, operation, variables ?? {});
+  }
   function read(operation, ...args) {
     const [variables] = args;
-    const { key } = getCacheKeyParts(cacheConfig, operation, variables ?? {});
+    const { key } = resolveKeyParts(operation, variables);
     const nuxtData = useNuxtData(key);
     return nuxtData.data.value;
   }
-  function write(operation, variables, value, options) {
-    const { key } = getCacheKeyParts(cacheConfig, operation, variables);
+  function applyWrite(key, value, current, options) {
     const nuxtData = useNuxtData(key);
-    nuxtData.data.value = typeof value === "function" ? value(nuxtData.data.value) : value;
+    const next = typeof value === "function" ? value(current) : value;
+    nuxtData.data.value = next;
     registerCacheKey(key);
     if (options?.markFresh) {
       markCacheKeyRefreshed(key);
     }
+    return next;
+  }
+  function write(operation, variables, value, options) {
+    const { key } = resolveKeyParts(operation, variables);
+    const nuxtData = useNuxtData(key);
+    applyWrite(key, value, nuxtData.data.value, options);
   }
   async function update(operation, variables, value, options) {
-    const { key } = getCacheKeyParts(cacheConfig, operation, variables);
+    const { key } = resolveKeyParts(operation, variables);
     const nuxtData = useNuxtData(key);
     let current = nuxtData.data.value;
     if (current === void 0 && cacheConfig.ttl !== void 0) {
       current = await getPersistedEntry(key);
     }
-    const updated = typeof value === "function" ? value(current) : value;
-    nuxtData.data.value = updated;
+    const next = applyWrite(key, value, current, options);
     if (cacheConfig.ttl !== void 0) {
-      await setPersistedEntry(key, updated, cacheConfig.ttl);
-    }
-    registerCacheKey(key);
-    if (options?.markFresh) {
-      markCacheKeyRefreshed(key);
+      await setPersistedEntry(key, next, cacheConfig.ttl);
     }
   }
   async function invalidate(operation, variables) {
+    const { scopePrefix, opPrefix, key } = resolveKeyParts(operation, variables);
     if (operation === void 0) {
-      const { keyPrefix, keyVersion } = cacheConfig;
-      const prefix = `${keyPrefix}:${keyVersion}:`;
-      invalidateAllCacheKeys();
-      await deletePersistedByPrefix(prefix);
-      await refreshNuxtData();
+      invalidateCachePrefix(scopePrefix);
+      await deletePersistedByPrefix(scopePrefix);
+      const keys = getCacheKeysByPrefix(scopePrefix);
+      if (keys.length > 0) {
+        await refreshNuxtData(keys);
+      }
+      forgetCacheByPrefix(scopePrefix);
       return;
     }
     if (variables === void 0) {
-      const { opPrefix } = getCacheKeyParts(cacheConfig, operation, {});
       invalidateCachePrefix(opPrefix);
       await deletePersistedByPrefix(opPrefix);
       const keys = getCacheKeysByPrefix(opPrefix);
       if (keys.length > 0) {
         await refreshNuxtData(keys);
-      } else {
-        console.warn(`[nuxt-graphql][cache] No cache keys found for operation "${operation}" with prefix "${opPrefix}"`);
       }
+      forgetCacheByPrefix(opPrefix);
       return;
     }
-    const { key } = getCacheKeyParts(cacheConfig, operation, variables);
     invalidateCacheKey(key);
     await deletePersistedEntry(key);
     await refreshNuxtData(key);
+    forgetCacheKey(key);
+  }
+  async function invalidateAllScopes() {
+    const { keyPrefix, keyVersion } = cacheConfig;
+    const rootPrefix = `${keyPrefix}:${keyVersion}:`;
+    invalidateAllCacheKeys();
+    await deletePersistedByPrefix(rootPrefix);
+    await refreshNuxtData();
+    forgetCacheAll();
   }
-  return { cacheConfig, read, write, update, invalidate };
+  return { cacheConfig, read, write, update, invalidate, invalidateAllScopes };
 }

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

@@ -7,21 +7,23 @@ import type { CacheConfig } from "../../shared/lib/types.js";
  */
 export declare function resolveCacheConfig(...overrides: Array<Partial<CacheConfig> | undefined>): CacheConfig;
 type CacheKeyParts = {
-    key: string;
+    rootPrefix: string;
+    scopePrefix: string;
     opPrefix: string;
+    key: string;
 };
 /**
  * Build cache key parts from config, operation name, and variables.
  *
- * @param {GraphQLCacheConfig} options Cache configuration.
- * @param options.keyPrefix Cache key prefix.
- * @param options.keyVersion Cache key version.
+ * @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.
- * @param scope Optional cache scope segment.
  * @returns Key parts including full key and operation prefix.
  */
-export declare function getCacheKeyParts({ keyPrefix, keyVersion }: CacheConfig, operationName: string, variables: unknown, scope?: string): CacheKeyParts;
+export declare function getCacheKeyParts({ keyPrefix, keyVersion }: CacheConfig, scope: string, operationName: string, variables: unknown): CacheKeyParts;
 /**
  * Register a cache key seen by async GraphQL queries.
  *
@@ -64,4 +66,17 @@ export declare function markCacheKeyRefreshed(key: string): void;
  * @returns True when invalidation is newer than the last successful network refresh.
  */
 export declare function shouldBypassCache(key: string): boolean;
+/**
+ * Remove a single cache key from all internal registries.
+ */
+export declare function forgetCacheKey(key: string): void;
+/**
+ * Remove all cache keys and related metadata matching a prefix.
+ */
+export declare function forgetCacheByPrefix(prefix: string): void;
+/**
+ * Clear all in-memory cache tracking metadata.
+ * Does NOT delete persisted storage.
+ */
+export declare function forgetCacheAll(): void;
 export {};

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

@@ -8,13 +8,12 @@ const defaultCacheConfig = {
 export function resolveCacheConfig(...overrides) {
   return Object.assign({}, defaultCacheConfig, ...overrides);
 }
-export function getCacheKeyParts({ keyPrefix, keyVersion }, operationName, variables, scope) {
-  const parts = [keyPrefix, keyVersion];
-  if (scope) parts.push(scope);
-  parts.push(operationName);
-  const opPrefix = parts.join(":") + ":";
-  const key = opPrefix + hash(variables || {});
-  return { key, opPrefix };
+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 };
 }
 const knownCacheKeys = /* @__PURE__ */ new Set();
 export function registerCacheKey(key) {
@@ -51,3 +50,25 @@ export function shouldBypassCache(key) {
   const latestInvalidationAt = Math.max(invalidatedAllAt, exactInvalidatedAt, prefixInvalidatedAt);
   return latestInvalidationAt > lastRefreshAt;
 }
+export function forgetCacheKey(key) {
+  knownCacheKeys.delete(key);
+  invalidatedExactAt.delete(key);
+  refreshedAt.delete(key);
+}
+export function forgetCacheByPrefix(prefix) {
+  for (const key of knownCacheKeys) {
+    if (key.startsWith(prefix)) {
+      knownCacheKeys.delete(key);
+      invalidatedExactAt.delete(key);
+      refreshedAt.delete(key);
+    }
+  }
+  invalidatedPrefixAt.delete(prefix);
+}
+export function forgetCacheAll() {
+  knownCacheKeys.clear();
+  invalidatedExactAt.clear();
+  invalidatedPrefixAt.clear();
+  refreshedAt.clear();
+  invalidatedAllAt = 0;
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@lewebsimple/nuxt-graphql",
-  "version": "0.6.18",
+  "version": "0.6.20",
   "description": "Opinionated Nuxt module for using GraphQL",
   "repository": "lewebsimple/nuxt-graphql",
   "license": "AGPL-3.0-only",
@@ -33,10 +33,10 @@
     "@graphql-tools/graphql-file-loader": "^8.1.9",
     "@graphql-tools/load": "^8.1.8",
     "@graphql-tools/schema": "^10.0.31",
-    "@graphql-tools/stitch": "^10.1.11",
+    "@graphql-tools/stitch": "^10.1.12",
     "@nuxt/kit": "^4.3.1",
     "defu": "^6.1.4",
-    "graphql": "^16.12.0",
+    "graphql": "^16.13.0",
     "graphql-sse": "^2.6.0",
     "graphql-yoga": "^5.18.0",
     "jiti": "^2.6.1",
@@ -44,18 +44,18 @@
     "unstorage": "^1.17.4"
   },
   "devDependencies": {
-    "@nuxt/devtools": "^3.2.1",
-    "@nuxt/eslint-config": "^1.15.1",
+    "@nuxt/devtools": "^3.2.2",
+    "@nuxt/eslint-config": "^1.15.2",
     "@nuxt/module-builder": "^1.0.2",
     "@nuxt/schema": "^4.3.1",
     "@nuxt/test-utils": "^3.23.0",
     "@types/node": "latest",
     "changelogen": "^0.6.2",
-    "eslint": "^9.39.2",
+    "eslint": "^9.39.3",
     "nuxt": "^4.3.1",
     "typescript": "~5.9.3",
     "vitest": "^4.0.18",
-    "vue-tsc": "^3.2.4"
+    "vue-tsc": "^3.2.5"
   },
   "scripts": {
     "dev": "pnpm run dev:prepare && nuxt dev playground",