fontdue-js 3.0.0-alpha8 → 3.0.0

package/dist/__tests__/networkFetch.test.js

@@ -0,0 +1,188 @@
+import { describe, it, expect, beforeEach, vi } from 'vitest';
+// environment.ts reads env at module load, so stub env and re-import fresh.
+beforeEach(() => {
+  vi.resetModules();
+  vi.unstubAllEnvs();
+  vi.unstubAllGlobals();
+});
+const request = {
+  name: 'TestQuery',
+  text: 'query TestQuery { viewer { id } }'
+};
+describe('createNetworkFetch (server)', () => {
+  it('opts fetches into the Next data cache, tagged for revalidation (production)', async () => {
+    vi.stubEnv('FONTDUE_URL', 'https://acme.fontdue.com');
+    vi.stubEnv('NODE_ENV', 'production');
+    const fetchMock = vi.fn(async () => ({
+      json: async () => ({
+        data: {}
+      })
+    }));
+    vi.stubGlobal('fetch', fetchMock);
+    const {
+      createNetworkFetch
+    } = await import("../relay/environment.js");
+    await createNetworkFetch()(request, {});
+    expect(fetchMock).toHaveBeenCalledTimes(1);
+    const [url, options] = fetchMock.mock.calls[0];
+    expect(url).toBe('https://acme.fontdue.com/graphql?queryName=TestQuery');
+    // Without an explicit cache option Next 15 treats the fetch as no-store
+    // and silently makes every page fully dynamic — the static + revalidate
+    // pattern depends on this.
+    expect(options.cache).toBe('force-cache');
+    expect(options.next.tags).toContain('graphql');
+    expect(options.next.tags).toContain('operation:TestQuery');
+  });
+  it('skips the data cache in development so local dev is always fresh', async () => {
+    vi.stubEnv('FONTDUE_URL', 'https://acme.fontdue.com');
+    vi.stubEnv('NODE_ENV', 'development');
+    const fetchMock = vi.fn(async () => ({
+      json: async () => ({
+        data: {}
+      })
+    }));
+    vi.stubGlobal('fetch', fetchMock);
+    const {
+      createNetworkFetch
+    } = await import("../relay/environment.js");
+    await createNetworkFetch()(request, {});
+    const [, options] = fetchMock.mock.calls[0];
+    // `next dev`'s data cache + revalidateTag don't reliably refresh, so dev
+    // fetches stay out of it (no-store) and every render fetches fresh.
+    expect(options.cache).toBe('no-store');
+    expect(options.next).toBeUndefined();
+  });
+  it('applies the per-render server config tags and headers', async () => {
+    vi.stubEnv('FONTDUE_URL', 'https://acme.fontdue.com');
+    vi.stubEnv('NODE_ENV', 'production');
+    const fetchMock = vi.fn(async () => ({
+      json: async () => ({
+        data: {}
+      })
+    }));
+    vi.stubGlobal('fetch', fetchMock);
+
+    // React.cache doesn't memoize outside a React render, so the store is
+    // mocked rather than set through setFontdueServerConfig. The network layer
+    // reads it through resolveFontdueServerConfig (awaited per fetch).
+    vi.doMock('../relay/serverConfig', async importActual => ({
+      ...(await importActual()),
+      resolveFontdueServerConfig: async () => ({
+        url: 'http://app:4000',
+        headers: {
+          'x-forwarded-host': 'acme.fontdue.com'
+        },
+        cacheTags: ['graphql:acme.fontdue.com']
+      })
+    }));
+    const {
+      createNetworkFetch
+    } = await import("../relay/environment.js");
+    await createNetworkFetch()(request, {});
+    vi.doUnmock('../relay/serverConfig');
+    const [url, options] = fetchMock.mock.calls[0];
+    expect(url).toBe('http://app:4000/graphql?queryName=TestQuery');
+    expect(options.headers['x-forwarded-host']).toBe('acme.fontdue.com');
+    expect(options.next.tags).toContain('graphql:acme.fontdue.com');
+  });
+  it('forwards per-call options.headers (e.g. a preview Bearer token)', async () => {
+    vi.stubEnv('FONTDUE_URL', 'https://acme.fontdue.com');
+    const fetchMock = vi.fn(async () => ({
+      json: async () => ({
+        data: {}
+      })
+    }));
+    vi.stubGlobal('fetch', fetchMock);
+
+    // This is the non-RSC path: the render-scoped serverConfig store is a
+    // no-op outside an RSC render, so apps forward the token per call instead.
+    const {
+      createNetworkFetch
+    } = await import("../relay/environment.js");
+    await createNetworkFetch({
+      headers: {
+        authorization: 'Bearer preview-tok'
+      }
+    })(request, {});
+    const [, options] = fetchMock.mock.calls[0];
+    expect(options.headers.authorization).toBe('Bearer preview-tok');
+  });
+});
+function headersOf(fetchMock) {
+  return fetchMock.mock.calls[0][1].headers;
+}
+describe('createNetworkFetch (fontdue-preview header)', () => {
+  it('sends fontdue-preview: false on a public server fetch (no token)', async () => {
+    vi.stubEnv('FONTDUE_URL', 'https://acme.fontdue.com');
+    const fetchMock = vi.fn(async () => ({
+      json: async () => ({
+        data: {}
+      })
+    }));
+    vi.stubGlobal('fetch', fetchMock);
+    const {
+      createNetworkFetch
+    } = await import("../relay/environment.js");
+    await createNetworkFetch()(request, {});
+    expect(headersOf(fetchMock)['fontdue-preview']).toBe('false');
+  });
+  it('sends fontdue-preview: true when a preview Bearer token is forwarded (server)', async () => {
+    vi.stubEnv('FONTDUE_URL', 'https://acme.fontdue.com');
+    const fetchMock = vi.fn(async () => ({
+      json: async () => ({
+        data: {}
+      })
+    }));
+    vi.stubGlobal('fetch', fetchMock);
+    const {
+      createNetworkFetch
+    } = await import("../relay/environment.js");
+    await createNetworkFetch({
+      headers: {
+        authorization: 'Bearer tok'
+      }
+    })(request, {});
+    expect(headersOf(fetchMock)['fontdue-preview']).toBe('true');
+  });
+  it('on the client, sends true only when the preview marker cookie is set', async () => {
+    // typeof window must be defined at module load for IS_SERVER to be false.
+    vi.stubGlobal('window', {
+      addEventListener: () => {}
+    });
+    vi.stubGlobal('document', {
+      cookie: 'fontdue_preview=1'
+    });
+    vi.stubEnv('NEXT_PUBLIC_FONTDUE_URL', 'https://acme.fontdue.com');
+    const fetchMock = vi.fn(async () => ({
+      json: async () => ({
+        data: {}
+      })
+    }));
+    vi.stubGlobal('fetch', fetchMock);
+    const {
+      createNetworkFetch
+    } = await import("../relay/environment.js");
+    await createNetworkFetch()(request, {});
+    expect(headersOf(fetchMock)['fontdue-preview']).toBe('true');
+  });
+  it('on the client, sends false when the marker cookie is absent (logged-in admin browsing normally)', async () => {
+    vi.stubGlobal('window', {
+      addEventListener: () => {}
+    });
+    vi.stubGlobal('document', {
+      cookie: 'other=1'
+    });
+    vi.stubEnv('NEXT_PUBLIC_FONTDUE_URL', 'https://acme.fontdue.com');
+    const fetchMock = vi.fn(async () => ({
+      json: async () => ({
+        data: {}
+      })
+    }));
+    vi.stubGlobal('fetch', fetchMock);
+    const {
+      createNetworkFetch
+    } = await import("../relay/environment.js");
+    await createNetworkFetch()(request, {});
+    expect(headersOf(fetchMock)['fontdue-preview']).toBe('false');
+  });
+});

package/dist/__tests__/nextAdapter.test.js

@@ -1,10 +1,18 @@
 import { describe, it, expect, beforeEach, vi } from 'vitest';
+import fs from 'node:fs';
+import os from 'node:os';
+import path from 'node:path';
 
 // The next adapter modules read process.env at module load, so each test
 // group stubs the env and re-imports them fresh.
 async function importTenant() {
   return await import("../next/tenant.js");
 }
+// Importing this module registers the single-tenant ambient resolver as a side
+// effect, the same way the FontdueProvider react-server entrypoint does.
+async function importRegister() {
+  return await import("../next/registerSingleTenantResolver.js");
+}
 async function importConfig() {
   return await import("../next/config.js");
 }
@@ -15,10 +23,58 @@ const revalidateTag = vi.fn();
 vi.mock('next/cache', () => ({
   revalidateTag: tag => revalidateTag(tag)
 }));
+
+// Next's notFound() throws a sentinel the framework catches; the mock does
+// the same so tests can assert on it. unstable_rethrow re-throws Next's
+// internal control-flow errors (dynamic bailout, notFound, redirect) and is a
+// no-op for anything else — the mock keys off the `digest` convention Next
+// uses to tag those errors.
+vi.mock('next/navigation', () => ({
+  notFound: () => {
+    throw new Error('NEXT_NOT_FOUND');
+  },
+  unstable_rethrow: error => {
+    const digest = error === null || error === void 0 ? void 0 : error.digest;
+    if (typeof digest === 'string' && (digest.startsWith('DYNAMIC_SERVER_USAGE') || digest.startsWith('NEXT_') || digest.startsWith('BAILOUT_TO_CLIENT_SIDE_RENDERING'))) {
+      throw error;
+    }
+  }
+}));
+
+// Draft mode + the preview token cookie, controllable per test. Default: not
+// previewing, so __prepareFontdueRender takes the public (cached) path. Set
+// cookiesError to make cookies() throw (e.g. simulate Next's dynamic bailout
+// during a prerender pass).
+const draft = vi.hoisted(() => ({
+  enabled: false,
+  token: undefined,
+  cookiesError: undefined
+}));
+vi.mock('next/headers', () => ({
+  draftMode: async () => ({
+    isEnabled: draft.enabled
+  }),
+  cookies: async () => {
+    if (draft.cookiesError) throw draft.cookiesError;
+    return {
+      get: name => name === 'fontdue_preview_token' && draft.token ? {
+        value: draft.token
+      } : undefined
+    };
+  }
+}));
 beforeEach(() => {
   vi.resetModules();
+  // The server-config store (incl. the ambient resolver) is anchored on
+  // globalThis, so it survives resetModules; clear it so a resolver registered
+  // by one test can't leak into the next.
+  delete globalThis.__fontdueServerConfigStore__;
   revalidateTag.mockClear();
   vi.unstubAllEnvs();
+  vi.restoreAllMocks();
+  draft.enabled = false;
+  draft.token = undefined;
+  draft.cookiesError = undefined;
 });
 function stubSingleTenant() {
   let url = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : 'https://acme.fontdue.com';
@@ -52,13 +108,14 @@ describe('isValidDomain', () => {
     expect(isValidDomain('a'.repeat(254) + '.example')).toBe(false);
   });
 });
-describe('fontdueEndpoint', () => {
+describe('endpointForDomain', () => {
   it('single-tenant: targets NEXT_PUBLIC_FONTDUE_URL with no headers', async () => {
     stubSingleTenant('https://acme.fontdue.com');
     const {
-      fontdueEndpoint
+      endpointForDomain
     } = await importTenant();
-    expect(fontdueEndpoint('acme.fontdue.com')).toEqual({
+    expect(endpointForDomain('acme.fontdue.com')).toEqual({
+      domain: 'acme.fontdue.com',
       origin: 'https://acme.fontdue.com',
       headers: {},
       tags: ['graphql', 'graphql:acme.fontdue.com']
@@ -68,9 +125,9 @@ describe('fontdueEndpoint', () => {
     vi.stubEnv('NEXT_PUBLIC_FONTDUE_URL', '');
     vi.stubEnv('FONTDUE_MULTI_TENANT', '');
     const {
-      fontdueEndpoint
+      endpointForDomain
     } = await importTenant();
-    expect(() => fontdueEndpoint('acme.fontdue.com')).toThrow(/NEXT_PUBLIC_FONTDUE_URL/);
+    expect(() => endpointForDomain('acme.fontdue.com')).toThrow(/NEXT_PUBLIC_FONTDUE_URL/);
   });
   it('multi-tenant: forwards the host to FONTDUE_ORIGIN with the proxy secret', async () => {
     stubMultiTenant({
@@ -78,9 +135,10 @@ describe('fontdueEndpoint', () => {
       secret: 's3cret'
     });
     const {
-      fontdueEndpoint
+      endpointForDomain
     } = await importTenant();
-    expect(fontdueEndpoint('acme.fontdue.com')).toEqual({
+    expect(endpointForDomain('acme.fontdue.com')).toEqual({
+      domain: 'acme.fontdue.com',
       origin: 'http://app:4000',
       headers: {
         'x-forwarded-host': 'acme.fontdue.com',
@@ -94,18 +152,18 @@ describe('fontdueEndpoint', () => {
       origin: 'http://app:4000'
     });
     const {
-      fontdueEndpoint
+      endpointForDomain
     } = await importTenant();
-    expect(fontdueEndpoint('acme.fontdue.com').headers).toEqual({
+    expect(endpointForDomain('acme.fontdue.com').headers).toEqual({
       'x-forwarded-host': 'acme.fontdue.com'
     });
   });
   it('multi-tenant: falls back to the tenant public URL without FONTDUE_ORIGIN', async () => {
     stubMultiTenant();
     const {
-      fontdueEndpoint
+      endpointForDomain
     } = await importTenant();
-    expect(fontdueEndpoint('acme.fontdue.com').origin).toBe('https://acme.fontdue.com');
+    expect(endpointForDomain('acme.fontdue.com').origin).toBe('https://acme.fontdue.com');
   });
 });
 describe('configureFontdueRender', () => {
@@ -116,11 +174,8 @@ describe('configureFontdueRender', () => {
     const {
       configureFontdueRender
     } = await importTenant();
-    const {
-      getFontdueServerConfig
-    } = await import("../relay/serverConfig.js");
+    // Invalid domain returns null before any setFontdueServerConfig call.
     expect(configureFontdueRender('not a domain')).toBeNull();
-    expect(getFontdueServerConfig()).toBeUndefined();
   });
   it('sets the per-render server config and returns the endpoint', async () => {
     stubMultiTenant({
@@ -130,9 +185,6 @@ describe('configureFontdueRender', () => {
     const {
       configureFontdueRender
     } = await importTenant();
-    const {
-      getFontdueServerConfig
-    } = await import("../relay/serverConfig.js");
     const endpoint = configureFontdueRender('acme.fontdue.com');
     expect(endpoint === null || endpoint === void 0 ? void 0 : endpoint.origin).toBe('http://app:4000');
     // Outside an RSC render React.cache doesn't memoize, so the write is a
@@ -151,7 +203,180 @@ describe('configureFontdueRender', () => {
     });
   });
 });
+describe('__prepareFontdueRender', () => {
+  const props = params => ({
+    params: Promise.resolve(params)
+  });
+  it('configures the render and returns the endpoint', async () => {
+    stubMultiTenant({
+      origin: 'http://app:4000'
+    });
+    const {
+      __prepareFontdueRender
+    } = await importTenant();
+    const endpoint = await __prepareFontdueRender(props({
+      domain: 'acme.fontdue.com',
+      slug: 'sans'
+    }));
+    expect(endpoint.origin).toBe('http://app:4000');
+    expect(endpoint.tags).toContain('graphql:acme.fontdue.com');
+  });
+  it('404s invalid or missing domains', async () => {
+    stubMultiTenant();
+    const {
+      __prepareFontdueRender
+    } = await importTenant();
+    await expect(__prepareFontdueRender(props({
+      domain: 'not a domain'
+    }))).rejects.toThrow('NEXT_NOT_FOUND');
+    await expect(__prepareFontdueRender(props({
+      slug: 'sans'
+    }))).rejects.toThrow('NEXT_NOT_FOUND');
+  });
+
+  // React.cache doesn't memoize outside an RSC render (see configureFontdueRender
+  // above), so the slot write is a no-op here — capture what __prepareFontdueRender
+  // passes to setFontdueServerConfig instead.
+  async function captureRenderConfig(params) {
+    let captured;
+    vi.doMock('../relay/serverConfig', async importActual => ({
+      ...(await importActual()),
+      setFontdueServerConfig: c => {
+        captured = c;
+      }
+    }));
+    const {
+      __prepareFontdueRender
+    } = await importTenant();
+    await __prepareFontdueRender(props(params));
+    vi.doUnmock('../relay/serverConfig');
+    return captured;
+  }
+  it('public render: sets the tenant config with cache tags and no token', async () => {
+    var _config$headers;
+    stubMultiTenant({
+      origin: 'http://app:4000'
+    });
+    const config = await captureRenderConfig({
+      domain: 'acme.fontdue.com'
+    });
+    expect(config.cacheTags).toEqual(['graphql:acme.fontdue.com']);
+    expect((_config$headers = config.headers) === null || _config$headers === void 0 ? void 0 : _config$headers.authorization).toBeUndefined();
+  });
+  it('preview render: folds the token into headers and drops cache tags', async () => {
+    var _config$headers2;
+    stubMultiTenant({
+      origin: 'http://app:4000'
+    });
+    draft.enabled = true;
+    draft.token = 'admin-tok';
+    const config = await captureRenderConfig({
+      domain: 'acme.fontdue.com'
+    });
+    // Embeds (createNetworkFetch) and the app's fetch (createFontdueFetch) both
+    // read this, so both reveal hidden fonts; no tags keeps the render live.
+    expect((_config$headers2 = config.headers) === null || _config$headers2 === void 0 ? void 0 : _config$headers2.authorization).toBe('Bearer admin-tok');
+    expect(config.cacheTags).toBeUndefined();
+  });
+});
+describe('single-tenant ambient resolver (no per-render call)', () => {
+  // Importing registerSingleTenantResolver registers the resolver as a module
+  // side effect — the FontdueProvider RSC entrypoint does this import, so
+  // merely mounting the provider wires it up. No per-render setup call is made
+  // in any of these tests; the config is pulled at fetch time.
+  it('public render: feeds the env URL + cache tags, no token', async () => {
+    var _config$headers3;
+    stubSingleTenant('https://acme.fontdue.com');
+    await importRegister();
+    const {
+      resolveFontdueServerConfig
+    } = await import("../relay/serverConfig.js");
+    const config = await resolveFontdueServerConfig();
+    expect(config === null || config === void 0 ? void 0 : config.url).toBe('https://acme.fontdue.com');
+    expect(config === null || config === void 0 ? void 0 : config.cacheTags).toEqual(['graphql:acme.fontdue.com']);
+    expect(config === null || config === void 0 ? void 0 : (_config$headers3 = config.headers) === null || _config$headers3 === void 0 ? void 0 : _config$headers3.authorization).toBeUndefined();
+  });
+  it('preview render: folds in the admin token and drops cache tags', async () => {
+    var _config$headers4;
+    stubSingleTenant('https://acme.fontdue.com');
+    draft.enabled = true;
+    draft.token = 'admin-tok';
+    await importRegister();
+    const {
+      resolveFontdueServerConfig
+    } = await import("../relay/serverConfig.js");
+    const config = await resolveFontdueServerConfig();
+    // This is what reveals hidden fonts in an embedded component's own preload
+    // on a page that never calls the app's GraphQL fetcher.
+    expect(config === null || config === void 0 ? void 0 : (_config$headers4 = config.headers) === null || _config$headers4 === void 0 ? void 0 : _config$headers4.authorization).toBe('Bearer admin-tok');
+    expect(config === null || config === void 0 ? void 0 : config.cacheTags).toBeUndefined();
+  });
+  it('multi-tenant: resolver stays out of the way so the slot drives config', async () => {
+    stubMultiTenant({
+      origin: 'http://app:4000'
+    });
+    await importRegister();
+    const {
+      resolveFontdueServerConfig
+    } = await import("../relay/serverConfig.js");
+    expect(await resolveFontdueServerConfig()).toBeUndefined();
+  });
+
+  // Regression for FD-712: a preview render that begins as a static/prerender
+  // pass must NOT swallow Next's dynamic bailout — re-throwing it is what takes
+  // the route off the full-route cache so the embeds' preloads re-run with the
+  // token. If this were swallowed, every server fetch (including a <BuyButton>
+  // node(id) @required(THROW) preload) would silently get the public view.
+  it('preview render: propagates Next’s dynamic bailout instead of dropping the token', async () => {
+    stubSingleTenant('https://acme.fontdue.com');
+    draft.enabled = true;
+    draft.token = 'admin-tok';
+    draft.cookiesError = Object.assign(new Error('Dynamic server usage'), {
+      digest: 'DYNAMIC_SERVER_USAGE'
+    });
+    await importRegister();
+    const {
+      resolveFontdueServerConfig
+    } = await import("../relay/serverConfig.js");
+    await expect(resolveFontdueServerConfig()).rejects.toBe(draft.cookiesError);
+  });
+
+  // A non-control-flow throw (e.g. no request scope at all) is not a bailout,
+  // so it's swallowed and the render degrades to the public (token-less) config
+  // rather than crashing.
+  it('preview render: swallows a non-control-flow throw and falls back to public', async () => {
+    var _config$headers5;
+    stubSingleTenant('https://acme.fontdue.com');
+    draft.enabled = true;
+    draft.token = 'admin-tok';
+    draft.cookiesError = new Error('no request scope');
+    await importRegister();
+    const {
+      resolveFontdueServerConfig
+    } = await import("../relay/serverConfig.js");
+    const config = await resolveFontdueServerConfig();
+    expect(config === null || config === void 0 ? void 0 : config.url).toBe('https://acme.fontdue.com');
+    expect(config === null || config === void 0 ? void 0 : config.cacheTags).toEqual(['graphql:acme.fontdue.com']);
+    expect(config === null || config === void 0 ? void 0 : (_config$headers5 = config.headers) === null || _config$headers5 === void 0 ? void 0 : _config$headers5.authorization).toBeUndefined();
+  });
+});
+
+// withFontdue detects the route-tree shape from the working directory; give
+// it one with or without src/app/[domain].
+function mockAppDir(_ref) {
+  let {
+    domainTree
+  } = _ref;
+  const dir = fs.mkdtempSync(path.join(os.tmpdir(), 'fontdue-app-'));
+  fs.mkdirSync(path.join(dir, domainTree ? 'src/app/[domain]' : 'src/app'), {
+    recursive: true
+  });
+  vi.spyOn(process, 'cwd').mockReturnValue(dir);
+}
 describe('withFontdue', () => {
+  beforeEach(() => mockAppDir({
+    domainTree: true
+  }));
   it('throws when neither mode is configured', async () => {
     vi.stubEnv('NEXT_PUBLIC_FONTDUE_URL', '');
     vi.stubEnv('FONTDUE_MULTI_TENANT', '');
@@ -267,6 +492,36 @@ describe('withFontdue', () => {
       htmlLimitedBots: /Googlebot/
     }).htmlLimitedBots).toEqual(/Googlebot/);
   });
+  it('single-tenant flat tree: installs no tenant rewrites', async () => {
+    mockAppDir({
+      domainTree: false
+    });
+    stubSingleTenant('https://acme.fontdue.com');
+    const {
+      withFontdue
+    } = await importConfig();
+    const userRule = {
+      source: '/old',
+      destination: '/new'
+    };
+    const rewrites = await withFontdue({
+      rewrites: async () => ({
+        beforeFiles: [userRule]
+      })
+    }).rewrites();
+    expect(rewrites.beforeFiles).toEqual([userRule]);
+    expect(rewrites.afterFiles).toEqual([]);
+  });
+  it('multi-tenant flat tree: refuses to start', async () => {
+    mockAppDir({
+      domainTree: false
+    });
+    stubMultiTenant();
+    const {
+      withFontdue
+    } = await importConfig();
+    expect(() => withFontdue({})).toThrow(/\[domain\]/);
+  });
 });
 describe('revalidate POST', () => {
   it('multi-tenant: purges only the tenant tag', async () => {