@lewebsimple/nuxt-graphql 0.6.16 → 0.6.18

package/dist/module.json

@@ -1,7 +1,7 @@
 {
   "name": "@lewebsimple/nuxt-graphql",
   "configKey": "graphql",
-  "version": "0.6.16",
+  "version": "0.6.18",
   "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.16";
+const version = "0.6.18";
 
 async function getDocuments(documentsGlob) {
   try {
@@ -238,7 +238,7 @@ async function getOperationsTemplate({ loadSchema, loadDocuments, documentGlob }
             defaultValue: false
           },
           defaultScalarType: "never",
-          enumsAsTypes: true,
+          enumsAsConst: true,
           preResolveTypes: false,
           strictScalars: true,
           useTypeImports: true
@@ -253,7 +253,7 @@ async function getOperationsTemplate({ loadSchema, loadDocuments, documentGlob }
             defaultValue: false
           },
           defaultScalarType: "never",
-          enumsAsTypes: true,
+          enumsAsConst: true,
           exportFragmentSpreadSubTypes: true,
           inlineFragmentTypes: "combine",
           operationResultSuffix: "Result",

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

@@ -2,7 +2,7 @@ import { useAsyncData, useNuxtApp, useNuxtData, useRuntimeConfig } from "#app";
 import { computed, toValue } 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) {
@@ -14,20 +14,21 @@ export function useAsyncGraphQLQuery(operationName, ...args) {
   const { cache, transform, ...asyncDataOptions } = options ?? {};
   const cacheConfig = resolveCacheConfig(graphql.cacheConfig, cache);
   const cacheKey = computed(() => getCacheKeyParts(cacheConfig, operationName, toValue(variables)).key);
+  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 +36,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,5 +1,8 @@
 import type { QueryName, ResultOf, VariablesOf } from "#graphql/registry";
 import type { IsEmptyObject } from "../../shared/lib/types.js";
+type CacheWriteOptions = {
+    markFresh?: boolean;
+};
 /**
  * GraphQL cache helper composable.
  *
@@ -8,7 +11,8 @@ import type { IsEmptyObject } from "../../shared/lib/types.js";
 export declare function useGraphQLCache(): {
     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>;
 };
+export {};

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

@@ -1,5 +1,5 @@
-import { clearNuxtData, useNuxtData, useRuntimeConfig } from "#imports";
-import { getCacheKeyParts } from "../lib/cache.js";
+import { refreshNuxtData, useNuxtData, useRuntimeConfig } from "#imports";
+import { getCacheKeyParts, getCacheKeysByPrefix, invalidateAllCacheKeys, invalidateCacheKey, invalidateCachePrefix, markCacheKeyRefreshed, registerCacheKey } from "../lib/cache.js";
 import { deletePersistedByPrefix, deletePersistedEntry, getPersistedEntry, setPersistedEntry } from "../lib/persisted.js";
 export function useGraphQLCache() {
   const { public: { graphql: { cacheConfig } } } = useRuntimeConfig();
@@ -9,12 +9,16 @@ export function useGraphQLCache() {
     const nuxtData = useNuxtData(key);
     return nuxtData.data.value;
   }
-  function write(operation, variables, value) {
+  function write(operation, variables, value, options) {
     const { key } = getCacheKeyParts(cacheConfig, operation, variables);
     const nuxtData = useNuxtData(key);
     nuxtData.data.value = typeof value === "function" ? value(nuxtData.data.value) : value;
+    registerCacheKey(key);
+    if (options?.markFresh) {
+      markCacheKeyRefreshed(key);
+    }
   }
-  async function update(operation, variables, value) {
+  async function update(operation, variables, value, options) {
     const { key } = getCacheKeyParts(cacheConfig, operation, variables);
     const nuxtData = useNuxtData(key);
     let current = nuxtData.data.value;
@@ -26,24 +30,36 @@ export function useGraphQLCache() {
     if (cacheConfig.ttl !== void 0) {
       await setPersistedEntry(key, updated, cacheConfig.ttl);
     }
+    registerCacheKey(key);
+    if (options?.markFresh) {
+      markCacheKeyRefreshed(key);
+    }
   }
   async function invalidate(operation, variables) {
     if (operation === void 0) {
       const { keyPrefix, keyVersion } = cacheConfig;
       const prefix = `${keyPrefix}:${keyVersion}:`;
-      clearNuxtData((k) => k.startsWith(prefix));
+      invalidateAllCacheKeys();
       await deletePersistedByPrefix(prefix);
+      await refreshNuxtData();
       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);
+      } else {
+        console.warn(`[nuxt-graphql][cache] No cache keys found for operation "${operation}" with prefix "${opPrefix}"`);
+      }
       return;
     }
     const { key } = getCacheKeyParts(cacheConfig, operation, variables);
-    clearNuxtData(key);
+    invalidateCacheKey(key);
     await deletePersistedEntry(key);
+    await refreshNuxtData(key);
   }
   return { cacheConfig, read, write, update, invalidate };
 }

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

@@ -22,4 +22,46 @@ type CacheKeyParts = {
  * @returns Key parts including full key and operation prefix.
  */
 export declare function getCacheKeyParts({ keyPrefix, keyVersion }: CacheConfig, operationName: string, variables: unknown, scope?: string): 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;
 export {};

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

@@ -16,3 +16,38 @@ export function getCacheKeyParts({ keyPrefix, keyVersion }, operationName, varia
   const key = opPrefix + hash(variables || {});
   return { key, opPrefix };
 }
+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;
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@lewebsimple/nuxt-graphql",
-  "version": "0.6.16",
+  "version": "0.6.18",
   "description": "Opinionated Nuxt module for using GraphQL",
   "repository": "lewebsimple/nuxt-graphql",
   "license": "AGPL-3.0-only",
@@ -27,9 +27,9 @@
   ],
   "dependencies": {
     "@graphql-codegen/core": "^5.0.0",
-    "@graphql-codegen/typed-document-node": "^6.1.5",
-    "@graphql-codegen/typescript": "^5.0.7",
-    "@graphql-codegen/typescript-operations": "^5.0.7",
+    "@graphql-codegen/typed-document-node": "^6.1.6",
+    "@graphql-codegen/typescript": "^5.0.8",
+    "@graphql-codegen/typescript-operations": "^5.0.8",
     "@graphql-tools/graphql-file-loader": "^8.1.9",
     "@graphql-tools/load": "^8.1.8",
     "@graphql-tools/schema": "^10.0.31",