@graphcommerce/graphql 10.1.0-canary.43 → 10.1.0-canary.44

package/CHANGELOG.md

@@ -1,5 +1,11 @@
 # Change Log
 
+## 10.1.0-canary.44
+
+### Patch Changes
+
+- [#2662](https://github.com/graphcommerce-org/graphcommerce/pull/2662) [`54e167f`](https://github.com/graphcommerce-org/graphcommerce/commit/54e167f13b883fbe24e954c6c093097c0815263f) - Publishing content now pushes a renew signal through the Next.js incremental cache, so every server invalidates at once instead of each polling `cdn/spaces/me` on a 60 second interval — `storyblok.cacheVersionTtl` therefore defaults to `3600` as a failsafe. ([@paales](https://github.com/paales))
+
 ## 10.1.0-canary.43
 
 ## 10.1.0-canary.42

package/index.ts

@@ -7,6 +7,7 @@ export * from './generated/types'
 export * from './config'
 export * from './utils/getPreviewData'
 export * from './utils/cachePolicy'
+export * from './utils/renewSignal'
 export * from './components/PrivateQueryMask/PrivateQueryMask'
 export * from './hooks/usePrivateQueryContext'
 export * from './hooks/usePrivateQuery'

package/package.json

@@ -2,7 +2,7 @@
   "name": "@graphcommerce/graphql",
   "homepage": "https://www.graphcommerce.org/",
   "repository": "github:graphcommerce-org/graphcommerce",
-  "version": "10.1.0-canary.43",
+  "version": "10.1.0-canary.44",
   "sideEffects": false,
   "main": "index.ts",
   "prettier": "@graphcommerce/prettier-config-pwa",
@@ -28,12 +28,12 @@
     "rxjs": "^7.8.2"
   },
   "peerDependencies": {
-    "@graphcommerce/eslint-config-pwa": "^10.1.0-canary.43",
-    "@graphcommerce/graphql-codegen-near-operation-file": "10.1.0-canary.43",
-    "@graphcommerce/graphql-codegen-relay-optimizer-plugin": "10.1.0-canary.43",
-    "@graphcommerce/next-config": "^10.1.0-canary.43",
-    "@graphcommerce/prettier-config-pwa": "^10.1.0-canary.43",
-    "@graphcommerce/typescript-config-pwa": "^10.1.0-canary.43",
+    "@graphcommerce/eslint-config-pwa": "^10.1.0-canary.44",
+    "@graphcommerce/graphql-codegen-near-operation-file": "10.1.0-canary.44",
+    "@graphcommerce/graphql-codegen-relay-optimizer-plugin": "10.1.0-canary.44",
+    "@graphcommerce/next-config": "^10.1.0-canary.44",
+    "@graphcommerce/prettier-config-pwa": "^10.1.0-canary.44",
+    "@graphcommerce/typescript-config-pwa": "^10.1.0-canary.44",
     "@graphql-mesh/plugin-http-details-extensions": "*",
     "react": "^19.2.0",
     "react-dom": "^19.2.0"

package/utils/renewSignal.ts

@@ -0,0 +1,121 @@
+/**
+ * A deployment-wide "content was published" signal, carried through Next.js' incremental cache so
+ * it reaches every server that shares a `cacheHandler`.
+ *
+ * Caches that are built per process — an SSR Apollo client's `InMemoryCache`, a CMS client's pinned
+ * cache-version — are invalidated by a webhook that only ever reaches one server. This is how the
+ * other servers find out, without any of them polling an upstream API to ask whether anything
+ * changed.
+ *
+ * Two Next.js internals are involved. `globalThis.__incrementalCache` is set per incoming request
+ * before route handling, so it is available inside an API route and inside ISR regeneration, but
+ * *not* in middleware or the edge runtime, which construct their own instance. The entry is written
+ * as `kind: 'FETCH'` with `fetchCache: true`, the one path that stores an arbitrary key verbatim
+ * instead of running it through `normalizePagePath()`.
+ *
+ * Both are unstable API. If either changes shape, reads and writes fail closed: the signal stays at
+ * its last known value and callers fall back to whatever time-based failsafe they have. The call
+ * shape does drift — `revalidate` became `cacheControl` between Next 14 and 15 — so it needs
+ * re-testing per major.
+ *
+ * Deployments on Next's default `FileSystemCache` must set `cacheMaxMemorySize: 0`; its in-memory
+ * LRU sits in front of the shared layer and would answer every read from the writing process' own
+ * memory. Custom cache handlers have no such layer.
+ */
+const RENEW_SIGNAL_KEY = 'gc:signal:content-renew'
+const RENEW_SIGNAL_POLL_MS = 1000
+const RENEW_SIGNAL_REVALIDATE = 60 * 60 * 24 * 30
+
+type IncrementalCacheLike = {
+  get: (key: string, ctx: unknown) => Promise<{ value?: { data?: { body?: string } } } | null>
+  set: (key: string, data: unknown, ctx: unknown) => Promise<void>
+}
+
+/** Undefined outside a Next.js request, in the browser bundle, and on the edge runtime. */
+function incrementalCache(): IncrementalCacheLike | undefined {
+  return (globalThis as { __incrementalCache?: IncrementalCacheLike }).__incrementalCache
+}
+
+/** `undefined` until the first read completes — distinct from "read, and nothing was published". */
+let signalValue: number | undefined
+let signalReadAt = 0
+let inFlight: Promise<number | undefined> | undefined
+
+/**
+ * Publish the signal. Call this from the webhook that learns content changed.
+ *
+ * The value is a millisecond timestamp: only its ordering matters, never its absolute value.
+ */
+export async function publishRenewSignal(): Promise<void> {
+  const cache = incrementalCache()
+  if (!cache) return
+  try {
+    await cache.set(
+      RENEW_SIGNAL_KEY,
+      {
+        kind: 'FETCH',
+        data: { headers: {}, body: String(Date.now()), url: '', status: 200 },
+        tags: [],
+        revalidate: RENEW_SIGNAL_REVALIDATE,
+      },
+      { fetchCache: true, tags: [] },
+    )
+  } catch {
+    // Unsupported or unwritable cache handler.
+  }
+}
+
+async function readRenewSignal(): Promise<number | undefined> {
+  const cache = incrementalCache()
+  if (!cache) return signalValue
+  try {
+    const entry = await cache.get(RENEW_SIGNAL_KEY, {
+      kind: 'FETCH',
+      tags: [],
+      softTags: [],
+      revalidate: RENEW_SIGNAL_REVALIDATE,
+    })
+    const value = Number(entry?.value?.data?.body)
+    // An absent entry means nothing has been published yet, which is a known state, not an unknown
+    // one — record it so cold-start callers stop treating the signal as unreadable.
+    signalValue = Number.isFinite(value) && value > 0 ? value : (signalValue ?? 0)
+  } catch {
+    // A cache handler that cannot serve this entry. Leave the signal as it was.
+  }
+  return signalValue
+}
+
+/**
+ * Read the signal, at most once per {@link RENEW_SIGNAL_POLL_MS}. Never an upstream API request.
+ *
+ * Concurrent callers share one read: on a fresh pod every in-flight `getStaticProps` hits this at
+ * once, and they should not each open their own.
+ */
+export async function refreshRenewSignal(): Promise<number | undefined> {
+  const now = Date.now()
+  if (signalValue !== undefined && now - signalReadAt < RENEW_SIGNAL_POLL_MS) return signalValue
+  if (!inFlight) {
+    signalReadAt = now
+    inFlight = readRenewSignal().finally(() => {
+      inFlight = undefined
+    })
+  }
+  return inFlight
+}
+
+/**
+ * Last known signal value, or `undefined` when it has not been read yet.
+ *
+ * For callers that cannot await one: `graphqlSsrClient()` is synchronous and called as
+ * `const client = graphqlSsrClient(context)` throughout `getStaticProps`, so making the read
+ * awaited would mean making every consumer async. It gets the value from the previous refresh and
+ * schedules the next one, bounding staleness at one poll interval plus one call.
+ *
+ * `undefined` must not be read as "nothing published" — on a fresh pod, which is every pod right
+ * after a deploy, that would silently skip the first invalidation. Callers treat it as unknown and
+ * fall back to their own failsafe.
+ */
+export function renewSignal(): number | undefined {
+  void refreshRenewSignal()
+  return signalValue
+}