fontdue-js 3.0.0-alpha6 → 3.0.0-alpha8

package/dist/components/FontdueProvider/index.server.js

@@ -2,6 +2,7 @@ function _extends() { return _extends = Object.assign ? Object.assign.bind() : f
 import React from 'react';
 import FontdueProvider from './index.js';
 import loadFontdueProviderQueryImpl from '../../loadFontdueProviderQuery.js';
+import { setFontdueServerConfig } from '../../relay/serverConfig.js';
 // Stub for the RSC export condition. The default `<FontdueProvider>` server
 // entrypoint (this file) awaits the query for consumers, so RSC users should
 // never call it manually. Re-exporting a throwing stub makes the mistake
@@ -14,11 +15,26 @@ export function loadFontdueProviderQuery() {
 
 // RSC entry. When no preloadedQuery is passed, fetch one server-side so the
 // Next.js App Router path stays "drop the provider in your layout, done."
+//
+// `serverConfig` (and, as a shorthand, the `url` prop) is written to the
+// per-render server config store before anything fetches, so every Fontdue
+// server component below the provider — and the provider's own query —
+// fetches against it. It is intentionally NOT forwarded to the client
+// component: it can carry internal headers (e.g. proxy auth) that must not
+// be serialized into the RSC payload. Note a soft navigation re-renders only
+// the page segment, not a layout-hosted provider — pages that contain
+// Fontdue components should call setFontdueServerConfig themselves.
 export default async function FontdueProviderServer(_ref) {
   let {
     preloadedQuery,
+    serverConfig,
     ...rest
   } = _ref;
+  if (serverConfig || rest.url) {
+    setFontdueServerConfig(serverConfig ?? {
+      url: rest.url
+    });
+  }
   const resolved = preloadedQuery ?? (await loadFontdueProviderQueryImpl());
   return /*#__PURE__*/React.createElement(FontdueProvider, _extends({}, rest, {
     preloadedQuery: resolved

package/dist/components/NewsletterSignup/index.js

@@ -182,7 +182,10 @@ export function NewsletterSignupPreloadedQueryRenderer(_ref3) {
     preloadedQuery,
     ...props
   } = _ref3;
-  const queryRef = useSerializablePreloadedQuery(preloadedQuery);
+  // The query node lets the hook commit the payload into the store, so
+  // usePreloadedQuery resolves synchronously during SSR instead of
+  // refetching (the response cache only exists in the browser).
+  const queryRef = useSerializablePreloadedQuery(preloadedQuery, 'store-or-network', query);
   const data = usePreloadedQuery(query, queryRef);
   return /*#__PURE__*/React.createElement(NewsletterSignupComponent, _extends({
     data: data

package/dist/components/TestFontsForm/index.js

@@ -202,7 +202,10 @@ export function TestFontsFormPreloadedQueryRenderer(_ref4) {
     preloadedQuery,
     ...rest
   } = _ref4;
-  const queryRef = useSerializablePreloadedQuery(preloadedQuery);
+  // The query node lets the hook commit the payload into the store, so
+  // usePreloadedQuery resolves synchronously during SSR instead of
+  // refetching (the response cache only exists in the browser).
+  const queryRef = useSerializablePreloadedQuery(preloadedQuery, 'store-or-network', query);
   const data = usePreloadedQuery(query, queryRef);
   return /*#__PURE__*/React.createElement(TestFontsFormComponent, _extends({
     data: data

package/dist/components/TypeTesters/index.js

@@ -191,7 +191,10 @@ export function TypeTestersPreloadedIDQueryRenderer(_ref3) {
     preloadedQuery,
     ...rest
   } = _ref3;
-  const queryRef = useSerializablePreloadedQuery(preloadedQuery);
+  // The query node lets the hook commit the payload into the store, so
+  // usePreloadedQuery resolves synchronously during SSR instead of
+  // refetching (the response cache only exists in the browser).
+  const queryRef = useSerializablePreloadedQuery(preloadedQuery, 'store-or-network', idQuery);
   const data = usePreloadedQuery(idQuery, queryRef);
   return /*#__PURE__*/React.createElement(TypeTestersComponent, _extends({}, data, rest));
 }
@@ -219,7 +222,10 @@ export function TypeTestersPreloadedSlugQueryRenderer(_ref5) {
     preloadedQuery,
     ...rest
   } = _ref5;
-  const queryRef = useSerializablePreloadedQuery(preloadedQuery);
+  // The query node lets the hook commit the payload into the store, so
+  // usePreloadedQuery resolves synchronously during SSR instead of
+  // refetching (the response cache only exists in the browser).
+  const queryRef = useSerializablePreloadedQuery(preloadedQuery, 'store-or-network', slugQuery);
   const data = usePreloadedQuery(slugQuery, queryRef);
   return /*#__PURE__*/React.createElement(TypeTestersComponent, _extends({
     collection: ((_data$viewer$slug = data.viewer.slug) === null || _data$viewer$slug === void 0 ? void 0 : _data$viewer$slug.collection) ?? null

package/dist/next/config.d.ts

@@ -0,0 +1,45 @@
+interface RouteHas {
+    type: 'header' | 'query' | 'cookie' | 'host';
+    key?: string;
+    value?: string;
+}
+interface Rewrite {
+    source: string;
+    destination: string;
+    has?: RouteHas[];
+    missing?: RouteHas[];
+}
+interface RewriteGroups {
+    beforeFiles: Rewrite[];
+    afterFiles: Rewrite[];
+    fallback: Rewrite[];
+}
+type RewritesResult = Rewrite[] | Partial<RewriteGroups>;
+interface NextConfigLike {
+    rewrites?: () => Promise<RewritesResult> | RewritesResult;
+    images?: {
+        remotePatterns?: unknown[];
+        [key: string]: unknown;
+    };
+    [key: string]: unknown;
+}
+export declare function tenantRewrites(): Rewrite[];
+export declare function withFontdue<C extends NextConfigLike>(nextConfig?: C): C & {
+    rewrites(): Promise<{
+        beforeFiles: Rewrite[];
+        afterFiles: Rewrite[];
+        fallback: Rewrite[];
+    }>;
+    images: {
+        remotePatterns: unknown[];
+        dangerouslyAllowSVG: boolean;
+        loader: "custom";
+        loaderFile: string;
+    } | {
+        remotePatterns: unknown[];
+        dangerouslyAllowSVG: boolean;
+        unoptimized: boolean;
+    };
+    htmlLimitedBots: RegExp;
+};
+export {};

package/dist/next/config.js

@@ -0,0 +1,180 @@
+// withFontdue(nextConfig): next.config wrapper that installs everything a
+// Fontdue storefront needs — host→path tenant rewrites, image settings, and
+// workarounds for Next behaviors that would otherwise break Fontdue pages.
+// Import it from next.config.mjs (this package is ESM):
+//
+//   import { withFontdue } from 'fontdue-js/next/config';
+//   export default withFontdue({ /* your config */ });
+//
+// This module is evaluated at config-load time, so it must not import React,
+// Relay, or anything else from the component tree.
+
+import { relative } from 'node:path';
+import { fileURLToPath } from 'node:url';
+
+// Minimal structural types so this module doesn't need `next` installed to
+// type-check; the shapes match next/dist/lib/load-custom-routes.
+
+// Every page lives under the /[domain]/... route tree so Next renders and
+// caches each tenant's pages independently. These rewrites turn the request's
+// host into that leading path segment:
+//
+//   acme.fontdue.com/fonts/foo  →  /acme.fontdue.com/fonts/foo (internal)
+//
+// In single-tenant mode the domain is constant (from NEXT_PUBLIC_FONTDUE_URL)
+// so the app behaves exactly like a plain single-site Next app.
+//
+// This is done with config rewrites rather than middleware on purpose:
+// middleware rewrites bypass the ISR page cache on self-hosted next start,
+// turning every request into a full render. beforeFiles rewrites go through
+// the normal routing layer and keep per-tenant ISR working. (beforeFiles also
+// runs before app routes are matched, so the internal /[domain] paths can't
+// be reached directly with a mismatching Host — /evil.com on acme's domain
+// becomes /acme.fontdue.com/evil.com, which 404s.)
+//
+// X-Forwarded-Host (set by the Fontdue proxy in front of this service) wins
+// over Host. The hostname charset is constrained in the patterns; anything
+// else falls through to a 404.
+//
+// beforeFiles rules CHAIN: each rule is evaluated in order against the
+// already-rewritten path, so a rewrite must produce a path no later rule can
+// match. Tenant domains always contain a dot, so the catch-all path rule
+// refuses any path whose first segment contains a dot — that makes the
+// rewritten /acme.fontdue.com/... inert. robots.txt and sitemap.xml (dotted
+// first segments we DO want to serve) get their own explicit rules, which run
+// first. Side effect: a page slug containing a dot can't be routed at the
+// top level.
+const TENANT_HOST = '(?<tenant>[a-zA-Z0-9][a-zA-Z0-9.-]*)';
+const DOTLESS_PATH = '/:path((?!api/|_next/|favicon\\.ico)(?![^/]*\\.[^/]*(?:/|$)).*)';
+
+// One rule set rewriting onto `dest` (either a fixed /domain or the /:tenant
+// capture from `has`). `conditions` is {has?, missing?}.
+function rewriteRules(dest) {
+  let conditions = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
+  return [{
+    source: '/',
+    destination: dest,
+    ...conditions
+  }, {
+    source: '/robots.txt',
+    destination: `${dest}/robots.txt`,
+    ...conditions
+  }, {
+    source: '/sitemap.xml',
+    destination: `${dest}/sitemap.xml`,
+    ...conditions
+  }, {
+    source: DOTLESS_PATH,
+    destination: `${dest}/:path`,
+    ...conditions
+  }];
+}
+export function tenantRewrites() {
+  const fontdueUrl = process.env.NEXT_PUBLIC_FONTDUE_URL;
+  const isMultiTenant = process.env.FONTDUE_MULTI_TENANT === '1';
+  if (!isMultiTenant) {
+    return rewriteRules(`/${new URL(fontdueUrl).host}`);
+  }
+  const forwardedHost = {
+    type: 'header',
+    key: 'x-forwarded-host',
+    value: `${TENANT_HOST}(:.*)?`
+  };
+  const noForwardedHost = {
+    type: 'header',
+    key: 'x-forwarded-host'
+  };
+  const host = {
+    type: 'host',
+    value: TENANT_HOST
+  };
+  return [...rewriteRules('/:tenant', {
+    has: [forwardedHost]
+  }),
+  // Host-based rules only apply when X-Forwarded-Host is absent, so the
+  // two sets can't both rewrite one request.
+  ...rewriteRules('/:tenant', {
+    has: [host],
+    missing: [noForwardedHost]
+  })];
+}
+async function resolveRewrites(rewrites) {
+  const result = (await (rewrites === null || rewrites === void 0 ? void 0 : rewrites())) ?? [];
+  // A plain array from rewrites() is afterFiles, per Next's contract.
+  if (Array.isArray(result)) {
+    return {
+      beforeFiles: [],
+      afterFiles: result,
+      fallback: []
+    };
+  }
+  return {
+    beforeFiles: result.beforeFiles ?? [],
+    afterFiles: result.afterFiles ?? [],
+    fallback: result.fallback ?? []
+  };
+}
+export function withFontdue() {
+  let nextConfig = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
+  const fontdueUrl = process.env.NEXT_PUBLIC_FONTDUE_URL;
+  const isMultiTenant = process.env.FONTDUE_MULTI_TENANT === '1';
+  if (!isMultiTenant && !fontdueUrl) {
+    throw new Error('Set NEXT_PUBLIC_FONTDUE_URL (single-tenant) or FONTDUE_MULTI_TENANT=1 (multi-tenant).');
+  }
+  const userImages = nextConfig.images ?? {};
+  return {
+    ...nextConfig,
+    async rewrites() {
+      const user = await resolveRewrites(nextConfig.rewrites);
+      return {
+        // App rules run first, against the public (pre-tenant) path; because
+        // beforeFiles rules chain, a dotless path they produce is then
+        // prefixed by the tenant rules like any direct request. afterFiles
+        // and fallback rules run after the tenant prefix is applied, so
+        // their sources must match the internal /[domain]/... form.
+        beforeFiles: [...user.beforeFiles, ...tenantRewrites()],
+        afterFiles: user.afterFiles,
+        fallback: user.fallback
+      };
+    },
+    images: {
+      // With a Cloudflare image transformation host configured, optimization
+      // moves to its edge (image-loader.ts) and the in-process optimizer —
+      // and sharp — stay out of the deployment entirely. The host must be in
+      // the env at build time (the loader is inlined into the client bundle)
+      // as well as at serve time (this config runs again under next start).
+      //
+      // Without one, in multi-tenant dev the GraphQL origin is typically a
+      // container or tunnel from which tenant hostnames don't resolve
+      // publicly, so the optimizer can't fetch the originals — serve them
+      // unoptimized there.
+      ...(process.env.NEXT_PUBLIC_FONTDUE_IMAGE_HOST ? {
+        loader: 'custom',
+        // Next resolves loaderFile against the project root and rejects
+        // absolute paths, so point into this package relative to cwd.
+        loaderFile: relative(process.cwd(), fileURLToPath(new URL('./image-loader.js', import.meta.url)))
+      } : {
+        unoptimized: isMultiTenant && process.env.NODE_ENV !== 'production'
+      }),
+      dangerouslyAllowSVG: true,
+      ...userImages,
+      remotePatterns: [...(fontdueUrl ? [{
+        protocol: 'https',
+        hostname: new URL(fontdueUrl).hostname
+      }] : []), {
+        protocol: 'https',
+        hostname: '*.fontdue.com'
+      },
+      // Multi-tenant: logos and images can live on any tenant custom
+      // domain. The URLs all come from the Fontdue CMS, not user input.
+      ...(isMultiTenant ? [{
+        protocol: 'https',
+        hostname: '**'
+      }] : []), ...(userImages.remotePatterns ?? [])]
+    },
+    // Treat every user agent as HTML-limited so metadata rendering blocks
+    // the response. Streamed metadata locks in a 200 status before
+    // generateMetadata's notFound() can produce a real 404.
+    htmlLimitedBots: nextConfig.htmlLimitedBots ?? /.*/
+  };
+}

package/dist/next/image-loader.d.ts

@@ -0,0 +1,7 @@
+interface ImageLoaderProps {
+    src: string;
+    width: number;
+    quality?: number;
+}
+export default function fontdueImageLoader({ src, width, quality, }: ImageLoaderProps): string;
+export {};

package/dist/next/image-loader.js

@@ -0,0 +1,39 @@
+// Custom next/image loader that serves images through a Cloudflare image
+// transformation host (developers.cloudflare.com/images/transform-images)
+// instead of the in-process Next optimizer, so the deployment needs neither
+// the /_next/image endpoint nor sharp. withFontdue activates it when
+// NEXT_PUBLIC_FONTDUE_IMAGE_HOST is set; see config.ts.
+//
+// NEXT_PUBLIC_FONTDUE_IMAGE_ORIGINS (comma-separated hostnames) should
+// mirror the transformation host's allowed-origins list. Sources on other
+// hosts — e.g. the /logo endpoint a site serves from its own (possibly
+// customer-owned) domain, which can't be allowlisted — are served as-is
+// rather than as transform URLs Cloudflare would refuse (ERROR 9401).
+//
+// Next bundles this file into the client build and inlines the NEXT_PUBLIC_
+// reads at build time, so it must stay dependency-free, and the variables
+// have to be present when `next build` runs (not just at serve time).
+
+function transformable(src) {
+  const origins = process.env.NEXT_PUBLIC_FONTDUE_IMAGE_ORIGINS;
+  if (!origins) return true;
+  let hostname;
+  try {
+    hostname = new URL(src).hostname;
+  } catch {
+    return false;
+  }
+  return origins.split(',').some(origin => origin.trim() === hostname);
+}
+export default function fontdueImageLoader(_ref) {
+  let {
+    src,
+    width,
+    quality
+  } = _ref;
+  const host = process.env.NEXT_PUBLIC_FONTDUE_IMAGE_HOST;
+  // No transform host, a local asset it couldn't fetch, or a source outside
+  // its allowed origins: serve the original, like `unoptimized`.
+  if (!host || src.startsWith('/') || !transformable(src)) return src;
+  return `https://${host}/cdn-cgi/image/width=${width},quality=${quality ?? 75},format=auto/${src}`;
+}

package/dist/next/index.d.ts

@@ -0,0 +1,2 @@
+export { isMultiTenant, isValidDomain, fontdueEndpoint, fallbackSiteUrl, fontdueServerConfig, configureFontdueRender, type FontdueEndpoint, } from './tenant.js';
+export { setFontdueServerConfig, getFontdueServerConfig, type FontdueServerConfig, } from '../relay/serverConfig.js';

package/dist/next/index.js

@@ -0,0 +1,10 @@
+// Server-side entrypoint for Next.js apps (the App Router / RSC adapter).
+// The config-time wrapper lives in 'fontdue-js/next/config' and the deploy
+// hook route handler in 'fontdue-js/next/revalidate'.
+
+export { isMultiTenant, isValidDomain, fontdueEndpoint, fallbackSiteUrl, fontdueServerConfig, configureFontdueRender } from './tenant.js';
+
+// The per-render config store consumed by fontdue-js's own server-side
+// fetches. configureFontdueRender covers the common case; these are exported
+// for apps that need to set or inspect the config directly.
+export { setFontdueServerConfig, getFontdueServerConfig } from '../relay/serverConfig.js';

package/dist/next/revalidate.d.ts

@@ -0,0 +1 @@
+export declare function POST(request: Request): Promise<Response>;

package/dist/next/revalidate.js

@@ -0,0 +1,37 @@
+// Route handler for Fontdue's deploy hook: re-export it from
+// app/api/revalidate/route.ts:
+//
+//   export { POST } from 'fontdue-js/next/revalidate';
+//
+// Fontdue calls it when a site's content changes. Multi-tenant deployments
+// receive the tenant in the URL, e.g.
+//   POST /api/revalidate?domain=acme.fontdue.com
+// and only that tenant's cache is purged (pages and embed data share the
+// per-domain tag — see fontdueEndpoint/fontdueServerConfig in ./tenant).
+// Single-tenant deployments use the parameterless form and purge everything
+// carrying the 'graphql' tag.
+
+import { revalidateTag } from 'next/cache';
+import { isMultiTenant, isValidDomain } from './tenant.js';
+export async function POST(request) {
+  var _URL$searchParams$get;
+  const domain = (_URL$searchParams$get = new URL(request.url).searchParams.get('domain')) === null || _URL$searchParams$get === void 0 ? void 0 : _URL$searchParams$get.toLowerCase();
+  if (isMultiTenant) {
+    if (!domain || !isValidDomain(domain)) {
+      return Response.json({
+        revalidated: false,
+        error: 'Missing or invalid ?domain='
+      }, {
+        status: 400
+      });
+    }
+    revalidateTag(`graphql:${domain}`);
+  } else {
+    revalidateTag('graphql');
+  }
+  return Response.json({
+    revalidated: true,
+    domain,
+    now: Date.now()
+  });
+}

package/dist/next/tenant.d.ts

@@ -0,0 +1,18 @@
+import { type FontdueServerConfig } from '../relay/serverConfig.js';
+export declare const isMultiTenant: boolean;
+export declare function isValidDomain(domain: string): boolean;
+export interface FontdueEndpoint {
+    /** Base URL the app's own GraphQL fetches should target. */
+    origin: string;
+    /** Headers the Fontdue server needs to resolve the tenant. */
+    headers: Record<string, string>;
+    /**
+     * Cache tags for the app's own fetch calls (pass as `next: { tags }`), so
+     * the revalidate handler (see ./revalidate) can purge one site at a time.
+     */
+    tags: string[];
+}
+export declare function fontdueEndpoint(domain: string): FontdueEndpoint;
+export declare function fallbackSiteUrl(domain: string): string;
+export declare function fontdueServerConfig(domain: string): FontdueServerConfig;
+export declare function configureFontdueRender(domain: string): FontdueEndpoint | null;

package/dist/next/tenant.js

@@ -0,0 +1,105 @@
+// Tenant/mode resolution for Next.js apps. An app using this adapter runs in
+// one of two modes:
+//
+// - Single-tenant (default): NEXT_PUBLIC_FONTDUE_URL points at one Fontdue
+//   site and every request renders that site.
+//
+// - Multi-tenant (FONTDUE_MULTI_TENANT=1): the tenant is derived per request
+//   from the (forwarded) Host header, and one deployment serves every
+//   tenant. The rewrites installed by withFontdue (see ./config) turn each
+//   request into the /[domain]/... route tree so pages are rendered and
+//   cached per domain.
+//
+// In multi-tenant mode, GraphQL is fetched from FONTDUE_ORIGIN (the internal
+// Fontdue server, e.g. http://localhost:4000 when running next to it) with
+// the tenant's domain forwarded via X-Forwarded-Host, authenticated by the
+// FONTDUE_PROXY_SECRET shared secret (the Fontdue server refuses to trust
+// X-Forwarded-Host without it). Without FONTDUE_ORIGIN it falls back to
+// fetching the tenant's public URL directly, which is useful for local
+// development against live sites.
+//
+// The fontdue-js components embedded in pages fetch the same way: their
+// server-side preloads read the per-render config set by
+// configureFontdueRender, and in the browser they fetch the relative
+// /graphql on the page's own origin — so multi-tenant mode needs no
+// NEXT_PUBLIC_FONTDUE_URL at all.
+
+import { setFontdueServerConfig } from '../relay/serverConfig.js';
+export const isMultiTenant = process.env.FONTDUE_MULTI_TENANT === '1';
+const singleTenantUrl = process.env.NEXT_PUBLIC_FONTDUE_URL;
+const internalOrigin = process.env.FONTDUE_ORIGIN;
+const proxySecret = process.env.FONTDUE_PROXY_SECRET;
+
+// Hostnames only: letters/digits/hyphens/dots, no path or port. Anything else
+// is rejected before it can reach the GraphQL fetch or the filesystem cache.
+const DOMAIN_RE = /^[a-z0-9]([a-z0-9-]*[a-z0-9])?(\.[a-z0-9]([a-z0-9-]*[a-z0-9])?)+$/;
+export function isValidDomain(domain) {
+  return domain.length <= 253 && DOMAIN_RE.test(domain);
+}
+// Where to fetch GraphQL for a given tenant domain, plus any headers needed
+// for the Fontdue server to resolve that tenant.
+export function fontdueEndpoint(domain) {
+  const tags = ['graphql', `graphql:${domain}`];
+  if (!isMultiTenant) {
+    if (!singleTenantUrl) {
+      throw new Error('fontdue-js/next: set NEXT_PUBLIC_FONTDUE_URL (single-tenant) or FONTDUE_MULTI_TENANT=1 (multi-tenant).');
+    }
+    return {
+      origin: singleTenantUrl,
+      headers: {},
+      tags
+    };
+  }
+  if (internalOrigin) {
+    return {
+      origin: internalOrigin,
+      headers: {
+        'x-forwarded-host': domain,
+        ...(proxySecret ? {
+          'x-fontdue-proxy-secret': proxySecret
+        } : {})
+      },
+      tags
+    };
+  }
+  return {
+    origin: `https://${domain}`,
+    headers: {},
+    tags
+  };
+}
+
+// metadataBase / sitemap fallback when the site URL setting is empty.
+export function fallbackSiteUrl(domain) {
+  return isMultiTenant ? `https://${domain}` : 'http://localhost:3000';
+}
+
+// Per-render config for fontdue-js's own server-side fetches: same endpoint
+// and headers as the app's fetches, plus the per-domain cache tag so the
+// revalidate handler purges embed data (theme config, type testers, store)
+// along with the pages. ('graphql' itself is added by the network layer.)
+export function fontdueServerConfig(domain) {
+  const {
+    origin,
+    headers
+  } = fontdueEndpoint(domain);
+  return {
+    url: origin,
+    headers,
+    cacheTags: [`graphql:${domain}`]
+  };
+}
+
+// The one call a data helper needs at the top of every page render:
+// validates the request-derived domain (null means "treat as 404"), then
+// points fontdue-js's server-side fetches at the tenant's endpoint for the
+// rest of this render pass.
+//
+// Call it in a data helper every page goes through, not only in the root
+// layout: an App Router soft navigation re-renders just the page segment,
+// and the per-render config store starts empty on every pass.
+export function configureFontdueRender(domain) {
+  if (!isValidDomain(domain)) return null;
+  setFontdueServerConfig(fontdueServerConfig(domain));
+  return fontdueEndpoint(domain);
+}

package/dist/relay/environment.js

@@ -1,9 +1,10 @@
 import { Environment, Network, RecordSource, Store, QueryResponseCache } from 'relay-runtime';
 import { handlePossibleCorsError } from '../corsError.js';
+import { getFontdueServerConfig } from './serverConfig.js';
 
 // `__FONTDUE_JS_VERSION__` is replaced by an inline babel plugin
 // (defineVersionPlugin in .babelrc.cjs) with the literal package.json#version.
-const version = "3.0.0-alpha6";
+const version = "3.0.0-alpha8";
 const IS_SERVER = typeof window === typeof undefined;
 
 // Read env from either process.env (Node/Next.js) or import.meta.env (Vite/Astro).
@@ -37,9 +38,13 @@ const CACHE_TTL = 10 * 1000; // 10 seconds, to resolve preloaded results
 
 export function createNetworkFetch(options) {
   return async function networkFetch(request, variables) {
-    const base = (options === null || options === void 0 ? void 0 : options.url) ?? FONTDUE_URL;
+    // Per-render server config (set via setFontdueServerConfig or the
+    // FontdueProvider server entrypoint). Resolved per call, not per
+    // createNetworkFetch, because module-level fetchers outlive renders.
+    const serverConfig = IS_SERVER ? getFontdueServerConfig() : undefined;
+    const base = (options === null || options === void 0 ? void 0 : options.url) ?? (serverConfig === null || serverConfig === void 0 ? void 0 : serverConfig.url) ?? FONTDUE_URL;
     if (IS_SERVER && (base == null || base === '')) {
-      throw new Error('fontdue-js: no Fontdue URL configured for server-side fetch. ' + 'Set FONTDUE_URL / PUBLIC_FONTDUE_URL / VITE_FONTDUE_URL in your environment, ' + 'or pass `url` explicitly to loadSerializableQuery (or its component-level wrappers).');
+      throw new Error('fontdue-js: no Fontdue URL configured for server-side fetch. ' + 'Set FONTDUE_URL / PUBLIC_FONTDUE_URL / VITE_FONTDUE_URL in your environment, ' + 'pass `url` to loadSerializableQuery, or call setFontdueServerConfig ' + '(or render <FontdueProvider url=…>) earlier in the server render.');
     }
     const url = `${base ?? ''}/graphql`;
     for (let attempt = 0; attempt <= 2; attempt++) {
@@ -48,6 +53,7 @@ export function createNetworkFetch(options) {
           method: 'POST',
           credentials: 'include',
           headers: {
+            ...(serverConfig === null || serverConfig === void 0 ? void 0 : serverConfig.headers),
             Accept: 'application/json',
             'Content-Type': 'application/json',
             'fontdue-stripe-integration': (options === null || options === void 0 ? void 0 : options.stripeIntegration) ?? STRIPE_INTEGRATION ?? 'dynamic',
@@ -59,7 +65,7 @@ export function createNetworkFetch(options) {
           }),
           // @ts-ignore
           next: {
-            tags: ['graphql', `operation:${request.name}`]
+            tags: ['graphql', ...((serverConfig === null || serverConfig === void 0 ? void 0 : serverConfig.cacheTags) ?? []), `operation:${request.name}`]
           }
         });
         const json = await resp.json();

package/dist/relay/loadSerializableQuery.d.ts

@@ -43,5 +43,7 @@ export interface SerializablePreloadedQuery<TQuery extends OperationType> {
 type RequireAllWithNull<T> = {
     [K in keyof T]-?: T[K] | null;
 };
-export default function loadSerializableQuery<TQuery extends OperationType>(query: GraphQLTaggedNode, variables: RequireAllWithNull<VariablesOf<TQuery>>): Promise<SerializablePreloadedQuery<TQuery>>;
+export default function loadSerializableQuery<TQuery extends OperationType>(query: GraphQLTaggedNode, variables: RequireAllWithNull<VariablesOf<TQuery>>, options?: {
+    url?: string;
+}): Promise<SerializablePreloadedQuery<TQuery>>;
 export {};

package/dist/relay/loadSerializableQuery.js

@@ -40,9 +40,9 @@ import { createNetworkFetch } from './environment.js';
 // Call into raw network fetch to get serializable GraphQL query response
 // This response will be sent to the client to "warm" the QueryResponseCache
 // to avoid the client fetches.
-export default async function loadSerializableQuery(query, variables) {
+export default async function loadSerializableQuery(query, variables, options) {
   if (!('params' in query)) throw new Error('Params not found in query, is it a fragment instead of a query?');
-  const fetcher = createNetworkFetch();
+  const fetcher = createNetworkFetch(options);
   const response = await fetcher(query.params, variables);
   return {
     params: query.params,

package/dist/relay/serverConfig.d.ts

@@ -0,0 +1,10 @@
+export interface FontdueServerConfig {
+    /** Base URL for server-side GraphQL fetches, e.g. https://acme.fontdue.com */
+    url?: string;
+    /** Extra headers sent with every server-side GraphQL fetch. */
+    headers?: Record<string, string>;
+    /** Extra Next.js fetch cache tags applied to every server-side GraphQL fetch. */
+    cacheTags?: string[];
+}
+export declare function setFontdueServerConfig(config: FontdueServerConfig): void;
+export declare function getFontdueServerConfig(): FontdueServerConfig | undefined;