@graphcommerce/graphql 10.1.0-canary.9 → 11.0.0-canary.46

package/CHANGELOG.md

@@ -1,5 +1,93 @@
 # Change Log
 
+## 11.0.0-canary.46
+
+## 11.0.0-canary.45
+
+## 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
+
+## 10.1.0-canary.41
+
+## 10.1.0-canary.40
+
+## 10.1.0-canary.39
+
+## 10.1.0-canary.38
+
+## 10.1.0-canary.37
+
+## 10.1.0-canary.36
+
+## 10.1.0-canary.35
+
+## 10.1.0-canary.34
+
+### Minor Changes
+
+- [#2646](https://github.com/graphcommerce-org/graphcommerce/pull/2646) [`35707a1`](https://github.com/graphcommerce-org/graphcommerce/commit/35707a1f68a6b8c97de5d22221a7c9229961cd7a) - Add a `terminatingLink` prop to `GraphQLProvider` to override the terminating link at the tail of the Apollo link chain (by default the `HttpLink` to the Mesh backend).
+
+  Because the terminating link runs after every context-setting link (customer auth token, store, cache-id, header links), this lets you route specific operations to a different transport while still inheriting all request headers. The motivating case is file uploads: `File`/`Blob` variables must be sent as a `multipart/form-data` request (e.g. via `apollo-upload-client`'s `UploadHttpLink`), which the default `HttpLink` cannot serialize. Previously such an upload link had to be prepended via `links`, where it terminated _before_ the auth/header links could run — dropping the customer token from multipart requests, so a logged-in customer's cart mutations were rejected. Supplying the upload-aware split as `terminatingLink` keeps it at the tail, so uploads inherit the token like any other operation. ([@paales](https://github.com/paales))
+
+## 10.1.0-canary.33
+
+## 10.1.0-canary.32
+
+## 10.1.0-canary.31
+
+## 10.1.0-canary.30
+
+## 10.1.0-canary.29
+
+## 10.1.0-canary.28
+
+## 10.1.0-canary.27
+
+## 10.1.0-canary.26
+
+## 10.1.0-canary.25
+
+## 10.1.0-canary.24
+
+## 10.1.0-canary.23
+
+### Patch Changes
+
+- [#2634](https://github.com/graphcommerce-org/graphcommerce/pull/2634) [`06082ad`](https://github.com/graphcommerce-org/graphcommerce/commit/06082ad47a59217fbdfb24f1a60411e4d0eecd9b) - Make GraphCommerce compatible with Apollo Client 4.2+ by augmenting Apollo's `DefaultOptions` type with the `preview` extension and the SSR clients' `errorPolicy: 'all'` default. ([@bramvanderholst](https://github.com/bramvanderholst))
+
+## 10.1.0-canary.22
+
+## 10.1.0-canary.21
+
+## 10.1.0-canary.20
+
+## 10.1.0-canary.19
+
+## 10.1.0-canary.18
+
+## 10.1.0-canary.17
+
+## 10.1.0-canary.16
+
+## 10.1.0-canary.15
+
+## 10.1.0-canary.14
+
+## 10.1.0-canary.13
+
+## 10.1.0-canary.12
+
+## 10.1.0-canary.11
+
+## 10.1.0-canary.10
+
 ## 10.1.0-canary.9
 
 ## 10.1.0-canary.8

package/apolloTypeOverrides.d.ts

@@ -0,0 +1,34 @@
+/**
+ * Apollo Client 4.2+ type augmentations for the GraphCommerce setup.
+ *
+ * - `DefaultOptions.Input.preview` declares the `preview` extension GraphCommerce stuffs into
+ *   defaultOptions so it's part of the type instead of needing an `as unknown` cast at every
+ *   client-construction site.
+ * - `DeclareDefaultOptions.Query.errorPolicy: 'all'` opts the SSR clients into errorPolicy 'all'
+ *   so partial GraphQL responses are returned alongside errors instead of throwing on every
+ *   field-level error during SSG.
+ * - `signatureStyle: 'classic'` keeps the pre-4.2 query result typing (`T` instead of
+ *   `DeepPartial<T> | undefined`) so the codebase doesn't need an app-wide migration to handle
+ *   the now-correctly-modelled partial data. This is a deliberate trade-off — TS doesn't model
+ *   the runtime reality of errorPolicy 'all', but it keeps consumer code ergonomic.
+ */
+import '@apollo/client'
+
+declare module '@apollo/client' {
+  namespace ApolloClient {
+    namespace DefaultOptions {
+      interface Input {
+        preview: unknown
+      }
+    }
+    namespace DeclareDefaultOptions {
+      interface Query {
+        errorPolicy?: 'all'
+      }
+    }
+  }
+
+  interface TypeOverrides {
+    signatureStyle: 'classic'
+  }
+}

package/components/GraphQLProvider/GraphQLProvider.tsx

@@ -20,7 +20,27 @@ export const globalApolloClient: { current: ApolloClient | null } = {
 }
 
 export type GraphQLProviderProps = AppProps &
-  Omit<ApolloClientConfigInput, 'storefront'> & { children: React.ReactNode }
+  Omit<ApolloClientConfigInput, 'storefront'> & {
+    children: React.ReactNode
+    /**
+     * Overrides the terminating link at the tail of the Apollo link chain (by default the `HttpLink`
+     * connection to the Mesh backend). Because it sits *after* every context-setting link (customer
+     * auth token, store, cache-id, header links), use it to route specific operations to a different
+     * transport while still inheriting all request headers.
+     *
+     * The motivating case is file uploads: `File`/`Blob` variables must be sent as a
+     * `multipart/form-data` request (e.g. via `apollo-upload-client`'s `UploadHttpLink`), which the
+     * default `HttpLink` cannot serialize. Providing the upload-aware split here keeps it at the tail
+     * of the chain, so uploads still pick up the customer token instead of going out unauthenticated.
+     *
+     * @example
+     *   ```tsx
+     *   const terminatingLink = ApolloLink.split(hasUploadFiles, uploadHttpLink, httpLink)
+     *   <GraphQLProvider {...props} terminatingLink={terminatingLink} />
+     *   ```
+     */
+    terminatingLink?: ApolloLink
+  }
 
 /**
  * The GraphQLProvider allows us to configure the ApolloClient and provide it to the rest of the
@@ -29,7 +49,7 @@ export type GraphQLProviderProps = AppProps &
  * Take a look at the props to see possible customization options.
  */
 export function GraphQLProvider(props: GraphQLProviderProps) {
-  const { children, links, migrations, policies, pageProps, router } = props
+  const { children, links, migrations, policies, pageProps, router, terminatingLink } = props
   const state = (pageProps as { apolloState?: unknown }).apolloState
 
   const stateRef = useRef(state)
@@ -58,8 +78,10 @@ export function GraphQLProvider(props: GraphQLProviderProps) {
     const link = ApolloLink.from([
       ...(typeof window === 'undefined' ? [errorLink, measurePerformanceLink] : []),
       ...config.current.links,
-      // The actual Http connection to the Mesh backend.
-      new HttpLink({ uri: '/api/graphql', credentials: 'same-origin' }),
+      // The actual Http connection to the Mesh backend. Overridable via `terminatingLink` so
+      // e.g. multipart file uploads can be routed to a different transport while still inheriting
+      // every header set by the links above.
+      terminatingLink ?? new HttpLink({ uri: '/api/graphql', credentials: 'same-origin' }),
     ])
 
     const cache = createCache()
@@ -76,7 +98,7 @@ export function GraphQLProvider(props: GraphQLProviderProps) {
         preview: {
           preview: router.isPreview,
         } as PreviewConfig,
-      } as ApolloClient.DefaultOptions,
+      },
       localState: new LocalState({}),
     })
   })

package/index.ts

@@ -1,3 +1,5 @@
+/// <reference path="./apolloTypeOverrides.d.ts" />
+
 export * from './apollo'
 export * from './components/GraphQLProvider'
 export { default as fragments } from './generated/fragments.json'
@@ -5,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.9",
+  "version": "11.0.0-canary.46",
   "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.9",
-    "@graphcommerce/graphql-codegen-near-operation-file": "10.1.0-canary.9",
-    "@graphcommerce/graphql-codegen-relay-optimizer-plugin": "10.1.0-canary.9",
-    "@graphcommerce/next-config": "^10.1.0-canary.9",
-    "@graphcommerce/prettier-config-pwa": "^10.1.0-canary.9",
-    "@graphcommerce/typescript-config-pwa": "^10.1.0-canary.9",
+    "@graphcommerce/eslint-config-pwa": "^11.0.0-canary.46",
+    "@graphcommerce/graphql-codegen-near-operation-file": "11.0.0-canary.46",
+    "@graphcommerce/graphql-codegen-relay-optimizer-plugin": "11.0.0-canary.46",
+    "@graphcommerce/next-config": "^11.0.0-canary.46",
+    "@graphcommerce/prettier-config-pwa": "^11.0.0-canary.46",
+    "@graphcommerce/typescript-config-pwa": "^11.0.0-canary.46",
     "@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
+}