@lewebsimple/nuxt-graphql 0.6.17 → 0.6.19

package/dist/module.json

@@ -1,7 +1,7 @@
 {
   "name": "@lewebsimple/nuxt-graphql",
   "configKey": "graphql",
-  "version": "0.6.17",
+  "version": "0.6.19",
   "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.17";
+const version = "0.6.19";
 
 async function getDocuments(documentsGlob) {
   try {

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

@@ -6,6 +6,7 @@ import type { CacheConfig, IsEmptyObject } from "../../shared/lib/types.js";
 type UseAsyncGraphQLQueryOptions<TName extends QueryName, TTransformed = ResultOf<TName>> = Omit<AsyncDataOptions<ResultOf<TName>>, "transform" | "pick"> & {
     transform?: (input: ResultOf<TName>) => TTransformed;
     cache?: Partial<CacheConfig>;
+    scope?: string;
 };
 /**
  * Async GraphQL query composable with caching support.
@@ -14,5 +15,5 @@ type UseAsyncGraphQLQueryOptions<TName extends QueryName, TTransformed = ResultO
  * @param args Operation variables (if any) and optional HTTP headers.
  * @returns Nuxt AsyncData wrapper for the query result.
  */
-export declare function useAsyncGraphQLQuery<TName extends QueryName, TTransformed = ResultOf<TName>>(operationName: TName, ...args: IsEmptyObject<VariablesOf<TName>> extends true ? [variables?: MaybeRefOrGetter<VariablesOf<TName>>, options?: UseAsyncGraphQLQueryOptions<TName, TTransformed>] : [variables: MaybeRefOrGetter<VariablesOf<TName>>, options?: UseAsyncGraphQLQueryOptions<TName, TTransformed>]): AsyncData<TTransformed | undefined, NormalizedError | undefined>;
+export declare function useAsyncGraphQLQuery<TName extends QueryName, TTransformed extends ResultOf<TName> | Promise<ResultOf<TName>> = ResultOf<TName>>(operationName: TName, ...args: IsEmptyObject<VariablesOf<TName>> extends true ? [variables?: MaybeRefOrGetter<VariablesOf<TName>>, options?: UseAsyncGraphQLQueryOptions<TName, TTransformed>] : [variables: MaybeRefOrGetter<VariablesOf<TName>>, options?: UseAsyncGraphQLQueryOptions<TName, TTransformed>]): AsyncData<TTransformed | undefined, NormalizedError | undefined>;
 export {};

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

@@ -1,8 +1,8 @@
 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, resolveCacheConfig } from "../lib/cache.js";
+import { getCacheKeyParts, markCacheKeyRefreshed, registerCacheKey, resolveCacheConfig, shouldBypassCache } from "../lib/cache.js";
 import { getInFlightRequests } from "../lib/in-flight.js";
 import { getPersistedEntry, setPersistedEntry } from "../lib/persisted.js";
 export function useAsyncGraphQLQuery(operationName, ...args) {
@@ -11,23 +11,27 @@ 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);
+  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;
     if (inFlight.has(key)) {
       return inFlight.get(key);
     }
-    const promise = $executeGraphQL({ query: document, variables: toValue(variables), operationName }).then((result) => {
-      if (result.error) {
-        throw result.error;
+    const promise = $executeGraphQL({ query: document, variables: toValue(variables), operationName }).then(({ data, error }) => {
+      if (error) {
+        throw error;
       }
-      const data = result.data;
       if (isClient && cacheConfig.ttl !== void 0) {
         setPersistedEntry(key, data, cacheConfig.ttl);
       }
+      markCacheKeyRefreshed(key);
       return data;
     });
     inFlight.set(key, promise);
@@ -35,7 +39,8 @@ export function useAsyncGraphQLQuery(operationName, ...args) {
     return promise;
   }
   async function asyncDataHandler() {
-    if (cacheConfig.policy === "no-cache") {
+    registerCacheKey(cacheKey.value);
+    if (cacheConfig.policy === "no-cache" || shouldBypassCache(cacheKey.value)) {
       return await fetchAndPersist();
     }
     const nuxtData = useNuxtData(cacheKey.value);

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

@@ -1,14 +1,19 @@
 import type { QueryName, ResultOf, VariablesOf } from "#graphql/registry";
 import type { IsEmptyObject } from "../../shared/lib/types.js";
+type CacheWriteOptions = {
+    markFresh?: boolean;
+};
 /**
  * GraphQL cache helper composable.
  *
  * @returns Cache manipulation helpers.
  */
-export declare function useGraphQLCache(): {
-    readonly cacheConfig: any;
+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>)) => void;
-    readonly update: <TName extends QueryName>(operation: TName, variables: VariablesOf<TName>, value: ResultOf<TName> | ((current: ResultOf<TName> | undefined) => ResultOf<TName>)) => Promise<void>;
+    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,49 +1,89 @@
-import { clearNuxtData, useNuxtData, useRuntimeConfig } from "#imports";
-import { getCacheKeyParts } from "../lib/cache.js";
+import { refreshNuxtData, useNuxtData, useRuntimeConfig } from "#imports";
+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) {
-    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;
   }
-  async function update(operation, variables, value) {
-    const { key } = getCacheKeyParts(cacheConfig, operation, variables);
+  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 } = 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);
+      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}:`;
-      clearNuxtData((k) => k.startsWith(prefix));
-      await deletePersistedByPrefix(prefix);
+      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, {});
-      clearNuxtData((k) => k.startsWith(opPrefix));
+      invalidateCachePrefix(opPrefix);
       await deletePersistedByPrefix(opPrefix);
+      const keys = getCacheKeysByPrefix(opPrefix);
+      if (keys.length > 0) {
+        await refreshNuxtData(keys);
+      }
+      forgetCacheByPrefix(opPrefix);
       return;
     }
-    const { key } = getCacheKeyParts(cacheConfig, operation, variables);
-    clearNuxtData(key);
+    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/composables/useGraphQLLoadMore.d.ts

@@ -10,8 +10,8 @@ type Connection<TItem> = {
 };
 export declare function useGraphQLLoadMore<TQueryName extends QueryName, TConnection extends Connection<unknown>>(queryName: TQueryName, inputVars: MaybeRef<Omit<VariablesOf<TQueryName>, "after">>, getConnection: (data?: ResultOf<TQueryName>) => TConnection | null | undefined): Promise<{
     items: Ref<TConnection["nodes"][number][], TConnection["nodes"][number][]>;
-    pending: any;
-    error: any;
+    pending: Ref<boolean, boolean>;
+    error: Ref<import("../../shared/lib/error.js").NormalizedError | undefined, import("../../shared/lib/error.js").NormalizedError | undefined>;
     reset: (clearProducts?: boolean) => void;
     hasNextPage: ComputedRef<boolean>;
     isLoadingMore: Ref<boolean, boolean>;

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

@@ -52,6 +52,6 @@ export type MutationOptions<TName extends MutationName, TContext = unknown> = {
  * @returns Mutation state and mutate function.
  */
 export declare function useGraphQLMutation<TName extends MutationName, TContext = unknown>(operationName: TName, options?: MutationOptions<TName, TContext>): {
-    pending: import("@vue/reactivity").Ref<boolean, boolean>;
+    pending: import("vue").Ref<boolean, boolean>;
     mutate: (...args: IsEmptyObject<VariablesOf<TName>> extends true ? [variables?: VariablesOf<TName>] : [variables: VariablesOf<TName>]) => Promise<ExecuteGraphQLResult<ResultOf<TName>>>;
 };

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

@@ -7,19 +7,76 @@ 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.
+ *
+ * @param key Cache key.
+ */
+export declare function registerCacheKey(key: string): void;
+/**
+ * Get known cache keys by prefix.
+ *
+ * @param prefix Cache key prefix.
+ * @returns Matching cache keys.
+ */
+export declare function getCacheKeysByPrefix(prefix: string): string[];
+/**
+ * Mark a single cache key as invalidated.
+ *
+ * @param key Cache key.
+ */
+export declare function invalidateCacheKey(key: string): void;
+/**
+ * Mark all cache keys matching a prefix as invalidated.
+ *
+ * @param prefix Cache key prefix.
+ */
+export declare function invalidateCachePrefix(prefix: string): void;
+/**
+ * Mark all cache keys as invalidated.
+ */
+export declare function invalidateAllCacheKeys(): void;
+/**
+ * Mark a cache key as refreshed from network.
+ *
+ * @param key Cache key.
+ */
+export declare function markCacheKeyRefreshed(key: string): void;
+/**
+ * Determine whether cache should be bypassed for this key.
+ *
+ * @param key Cache key.
+ * @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,11 +8,67 @@ 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) {
+  knownCacheKeys.add(key);
+}
+export function getCacheKeysByPrefix(prefix) {
+  return [...knownCacheKeys].filter((key) => key.startsWith(prefix));
+}
+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() {
+  invalidatedAllAt = Date.now();
+}
+export function markCacheKeyRefreshed(key) {
+  refreshedAt.set(key, Date.now());
+}
+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;
+    }
+  }
+  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/dist/runtime/app/plugins/execute-graphql.d.ts

@@ -1,5 +1,9 @@
 import type { ExecuteGraphQLInput, ExecuteGraphQLResult, GraphQLVariables } from "../../shared/lib/types.js";
-declare const _default: any;
+declare const _default: import("#app").Plugin<{
+    executeGraphQL: <TResult = unknown, TVariables extends GraphQLVariables = GraphQLVariables>({ query, variables, operationName }: ExecuteGraphQLInput<TVariables>) => Promise<ExecuteGraphQLResult<TResult>>;
+}> & import("#app").ObjectPlugin<{
+    executeGraphQL: <TResult = unknown, TVariables extends GraphQLVariables = GraphQLVariables>({ query, variables, operationName }: ExecuteGraphQLInput<TVariables>) => Promise<ExecuteGraphQLResult<TResult>>;
+}>;
 export default _default;
 type ExecuteGraphQL = <TResult = unknown, TVariables extends GraphQLVariables = GraphQLVariables>(input: ExecuteGraphQLInput<TVariables>) => Promise<ExecuteGraphQLResult<TResult>>;
 declare module "#app/nuxt" {

package/dist/runtime/app/plugins/graphql-sse.client.d.ts

@@ -4,7 +4,11 @@ import { type Client as SSEClient } from "graphql-sse";
  *
  * @returns Nuxt plugin with SSE client provider.
  */
-declare const _default: any;
+declare const _default: import("#app").Plugin<{
+    getGraphQLSSEClient: () => SSEClient;
+}> & import("#app").ObjectPlugin<{
+    getGraphQLSSEClient: () => SSEClient;
+}>;
 export default _default;
 declare module "#app/nuxt" {
     interface NuxtApp {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@lewebsimple/nuxt-graphql",
-  "version": "0.6.17",
+  "version": "0.6.19",
   "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",