fontdue-js 3.0.0-alpha7 → 3.0.0-alpha9

package/dist/next/tenant.js

@@ -0,0 +1,169 @@
+// 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 { notFound } from 'next/navigation';
+import { setFontdueServerConfig, getFontdueServerConfig } 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) {
+    return {
+      domain,
+      origin: requireSingleTenantUrl(),
+      headers: {},
+      tags
+    };
+  }
+  if (internalOrigin) {
+    return {
+      domain,
+      origin: internalOrigin,
+      headers: {
+        'x-forwarded-host': domain,
+        ...(proxySecret ? {
+          'x-fontdue-proxy-secret': proxySecret
+        } : {})
+      },
+      tags
+    };
+  }
+  return {
+    domain,
+    origin: `https://${domain}`,
+    headers: {},
+    tags
+  };
+}
+function requireSingleTenantUrl() {
+  if (!singleTenantUrl) {
+    throw new Error('fontdue-js/next: set NEXT_PUBLIC_FONTDUE_URL (single-tenant) or FONTDUE_MULTI_TENANT=1 (multi-tenant).');
+  }
+  return singleTenantUrl;
+}
+
+// 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}`],
+    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);
+}
+
+// The props every page, layout and generateMetadata receives. Any params
+// object is structurally compatible; only `domain` is read.
+
+// The one line at the top of every page, layout and generateMetadata body
+// in the [domain] route tree:
+//
+//   await prepareFontdueRender(props);
+//
+// Reads the request's site from the [domain] route param, 404s anything
+// that isn't a plain hostname (stray paths can reach the catch-all route
+// with their first segment as the "domain"), and points every Fontdue fetch
+// in the rest of this render pass — the app's fetches via
+// currentFontdueEndpoint and fontdue-js's embedded-component preloads — at
+// that site.
+//
+// It must run per entry point, not only in the layout: a soft navigation
+// re-renders just the page segment, and the per-render store starts empty
+// on every pass. Forgetting it is loud, not subtle: currentFontdueEndpoint
+// throws in multi-tenant mode when no render config was set.
+//
+// Route handlers are not React renders — the render-scoped store doesn't
+// exist there, so use the returned endpoint explicitly instead of relying
+// on currentFontdueEndpoint.
+export async function prepareFontdueRender(props) {
+  const {
+    domain
+  } = await props.params;
+  const endpoint = typeof domain === 'string' ? configureFontdueRender(domain) : null;
+  if (!endpoint) notFound();
+  return endpoint;
+}
+
+// Endpoint for the app's own GraphQL fetches in this render pass: whatever
+// prepareFontdueRender configured, or — in a single-tenant app without the
+// [domain] tree, where prepareFontdueRender is never called — the
+// NEXT_PUBLIC_FONTDUE_URL site. Throwing rather than guessing in
+// multi-tenant mode turns a forgotten prepareFontdueRender into an
+// unmissable error instead of a silent wrong-site fetch on soft
+// navigations.
+export function currentFontdueEndpoint() {
+  var _getFontdueServerConf;
+  const domain = (_getFontdueServerConf = getFontdueServerConfig()) === null || _getFontdueServerConf === void 0 ? void 0 : _getFontdueServerConf.domain;
+  if (domain) return fontdueEndpoint(domain);
+  if (isMultiTenant) {
+    throw new Error('fontdue-js/next: no render config set — call prepareFontdueRender(props) at the top of every page, layout and generateMetadata that fetches.');
+  }
+  return fontdueEndpoint(new URL(requireSingleTenantUrl()).host);
+}
+
+// Re-export from routes in the [domain] tree:
+//
+//   export { generateStaticParams } from 'fontdue-js/next';
+//
+// Domains aren't known at build time, so nothing is prerendered — but
+// providing generateStaticParams is what opts a dynamic route into
+// static-on-demand rendering (generated on first request, then cached until
+// revalidated) instead of fully dynamic rendering.
+export async function generateStaticParams() {
+  return [];
+}

package/dist/relay/environment.js

@@ -4,7 +4,7 @@ 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-alpha7";
+const version = "3.0.0-alpha9";
 const IS_SERVER = typeof window === typeof undefined;
 
 // Read env from either process.env (Node/Next.js) or import.meta.env (Vite/Astro).
@@ -63,6 +63,16 @@ export function createNetworkFetch(options) {
             query: request.text,
             variables
           }),
+          // Server-side fetches are all site content (per-session data is
+          // fetched client-side only), so opt them into Next's data cache —
+          // without this, Next 15 treats them as no-store and silently makes
+          // every page fully dynamic. The tags below let the revalidate
+          // handler purge them when content changes. Inert outside Next:
+          // Node's fetch accepts and ignores this cache mode, and the
+          // browser path doesn't set it.
+          ...(IS_SERVER ? {
+            cache: 'force-cache'
+          } : {}),
           // @ts-ignore
           next: {
             tags: ['graphql', ...((serverConfig === null || serverConfig === void 0 ? void 0 : serverConfig.cacheTags) ?? []), `operation:${request.name}`]

package/dist/relay/serverConfig.d.ts

@@ -5,6 +5,12 @@ export interface FontdueServerConfig {
     headers?: Record<string, string>;
     /** Extra Next.js fetch cache tags applied to every server-side GraphQL fetch. */
     cacheTags?: string[];
+    /**
+     * The site domain this render is for, when known. Set by
+     * fontdue-js/next's prepareFontdueRender so render-scoped helpers
+     * (currentFontdueEndpoint) can recover it.
+     */
+    domain?: string;
 }
 export declare function setFontdueServerConfig(config: FontdueServerConfig): void;
 export declare function getFontdueServerConfig(): FontdueServerConfig | undefined;

package/dist/vite.js

@@ -79,7 +79,9 @@ function getFontdueJsSubpaths() {
   for (const key of Object.keys(pkg.exports ?? {})) {
     if (!key.startsWith('./')) continue;
     if (key.endsWith('.css')) continue;
+    // Build-config and server-only entrypoints never reach a browser bundle.
     if (key === './vite') continue;
+    if (key === './next' || key.startsWith('./next/')) continue;
     out.push(`fontdue-js/${key.slice(2)}`);
   }
   return out;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "fontdue-js",
-  "version": "3.0.0-alpha7",
+  "version": "3.0.0-alpha9",
   "type": "module",
   "scripts": {
     "build": "npm run relay && run-p build-js build-css build-ts",
@@ -82,7 +82,10 @@
   },
   "exports": {
     ".": "./dist/index.js",
-    "./server": "./dist/relay/serverConfig.js",
+    "./next": "./dist/next/index.js",
+    "./next/config": "./dist/next/config.js",
+    "./next/revalidate": "./dist/next/revalidate.js",
+    "./next/image-loader": "./dist/next/image-loader.js",
     "./fontdue.css": "./dist/fontdue.css",
     "./BuyButton": {
       "react-server": "./dist/components/BuyButton/index.server.js",

package/types/next-cache.d.ts

@@ -0,0 +1,6 @@
+// Minimal declaration so src/next/revalidate.ts type-checks without `next`
+// installed (it's the host app's dependency; this package only ever runs the
+// import inside a Next.js server).
+declare module 'next/cache' {
+  export function revalidateTag(tag: string): void;
+}

package/types/next-navigation.d.ts

@@ -0,0 +1,6 @@
+// Minimal declaration so src/next/tenant.ts type-checks without `next`
+// installed (it's the host app's dependency; this package only ever runs the
+// import inside a Next.js server).
+declare module 'next/navigation' {
+  export function notFound(): never;
+}

package/vitest.config.ts

@@ -2,6 +2,10 @@ import { defineConfig } from 'vitest/config';
 import path from 'path';
 
 export default defineConfig({
+  // Stand-in for the babel define plugin that inlines the package version.
+  define: {
+    __FONTDUE_JS_VERSION__: JSON.stringify('0.0.0-test'),
+  },
   test: {
     alias: {
       '__generated__': path.resolve(__dirname, 'src/__generated__'),