@decocms/tanstack 7.78.1 → 7.78.2

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@decocms/tanstack",
-  "version": "7.78.1",
+  "version": "7.78.2",
   "type": "module",
   "description": "Deco framework binding for TanStack Start + Cloudflare Workers",
   "repository": {
@@ -27,9 +27,9 @@
     "lint:unused": "knip"
   },
   "dependencies": {
-    "@decocms/blocks": "7.78.1",
-    "@decocms/blocks-admin": "7.78.1",
-    "@decocms/blocks-cli": "7.78.1",
+    "@decocms/blocks": "7.78.2",
+    "@decocms/blocks-admin": "7.78.2",
+    "@decocms/blocks-cli": "7.78.2",
     "@deco-cx/warp-node": "^0.3.16",
     "fast-json-patch": "^3.1.0",
     "ws": "^8.18.0"

package/src/routes/cmsRoute.ts

@@ -69,6 +69,7 @@ import {
 } from "@tanstack/react-start/server";
 import { createElement } from "react";
 import { derivePageUrl, isClientNavigation } from "./pageUrl";
+import { createRequestSingleFlight } from "./requestSingleFlight";
 import { dedupeGlobals, resolveSiteGlobals } from "./withSiteGlobals";
 import type { SiteGlobalRef } from "./withSiteGlobals";
 
@@ -92,7 +93,7 @@ export function setSectionChunkMap(map: Record<string, string>): void {
 // ---------------------------------------------------------------------------
 
 type PageResult = Awaited<ReturnType<typeof loadCmsPageInternal>>;
-const pageInflight = new Map<string, Promise<PageResult>>();
+const loadPageForRequest = createRequestSingleFlight<PageResult>();
 
 /** Same shape as `resolveSiteGlobals()`'s empty result — used when `resolveGlobals: false`. */
 const EMPTY_GLOBALS: { resolvedSections: ResolvedSection[]; rawRefs: SiteGlobalRef[] } = {
@@ -337,33 +338,15 @@ export const loadCmsPage = createServerFn({ method: "GET" })
   .handler(async (ctx) => {
     const { path: fullPath, resolveGlobals } = parseLoadCmsPageInput(ctx.data);
 
-    // Use the full path (including query string) as the dedup key.
-    // Using basePath only caused /s?q=a and /s?q=b to share one promise,
-    // returning wrong/empty results for search and filtered PLPs.
-    //
-    // SSR and client-nav produce the same eager/deferred split now, so the
-    // original reason for the `__nav:` bucket — a client-nav request must never
-    // inherit an SSR response's deferredSections (#277) — no longer applies. It
-    // is kept anyway, because this map is module-global and the payload it
-    // shares carries `pageUrl`, `flags`, and `device` derived from whichever
-    // request won the race. That cross-request bleed is pre-existing and wider
-    // than this bucket (two concurrent same-path requests already collide on
-    // cookies/UA/geo), but SSR and client-nav are exactly the pair whose
-    // `derivePageUrl` inputs differ most, so collapsing them would widen a
-    // known hole for no gain. `resolveGlobals` is part of the key for the same
-    // reason: a `resolveGlobals: false` request must not share a promise with a
-    // `resolveGlobals: true` one.
+    // Whole-page results contain request-specific cookies, flags, device and URL.
+    // A module-global URL key also lets one stalled request block later visitors.
+    // Dedup only within this request; keep query and globals options distinct.
     const clientNav = isClientNavigation(fullPath, getRequestUrl());
     const inflightKey =
       (clientNav ? `__nav:${fullPath}` : fullPath) + (resolveGlobals ? "" : "|noGlobals");
-    const existing = pageInflight.get(inflightKey);
-    if (existing) return existing;
-
-    const promise = loadCmsPageInternal(fullPath, resolveGlobals).finally(() =>
-      pageInflight.delete(inflightKey),
+    return loadPageForRequest(getRequest(), inflightKey, () =>
+      loadCmsPageInternal(fullPath, resolveGlobals),
     );
-    pageInflight.set(inflightKey, promise);
-    return promise;
   });
 
 /** Accepted by `loadCmsHomePage` — optional so existing no-arg callers keep working. */

package/src/routes/requestSingleFlight.test.ts

@@ -0,0 +1,62 @@
+import { describe, expect, it, vi } from "vitest";
+import { createRequestSingleFlight } from "./requestSingleFlight";
+
+describe("request-scoped page single-flight", () => {
+  it("lets a healthy visitor complete while an earlier visitor's page is stuck", async () => {
+    const load = createRequestSingleFlight<string>();
+    const path = "/granado/sabonetes/sabonete-barra";
+    let release!: (value: string) => void;
+    const first = load(
+      new Request(`https://shop.test${path}`),
+      path,
+      () =>
+        new Promise<string>((resolve) => {
+          release = resolve;
+        }),
+    );
+    const healthy = load(
+      new Request(`https://shop.test${path}`),
+      path,
+      async () => "healthy visitor",
+    );
+    try {
+      expect(
+        await Promise.race([
+          healthy,
+          new Promise((resolve) => setTimeout(() => resolve("blocked"), 100)),
+        ]),
+      ).toBe("healthy visitor");
+    } finally {
+      release("earlier visitor");
+      await first;
+    }
+  });
+
+  it("deduplicates concurrent callers within one request and removes completed work", async () => {
+    const load = createRequestSingleFlight<string>();
+    const request = new Request("https://shop.test/category");
+    const run = vi.fn(async () => "page");
+    const first = load(request, "/category", run);
+    expect(load(request, "/category", run)).toBe(first);
+    await first;
+    await load(request, "/category", run);
+    expect(run).toHaveBeenCalledTimes(2);
+  });
+
+  it("keeps page options separate and allows retry after a failure", async () => {
+    const load = createRequestSingleFlight<string>();
+    const request = new Request("https://shop.test/category");
+    await expect(
+      load(request, "/category", async () => {
+        throw new Error("failed");
+      }),
+    ).rejects.toThrow("failed");
+    expect(await load(request, "/category", async () => "retry")).toBe("retry");
+    const results = await Promise.all([
+      load(request, "/category?p=1", async () => "first page"),
+      load(request, "/category?p=2", async () => "second page"),
+      load(request, "/category?p=1|noGlobals", async () => "without globals"),
+    ]);
+    expect(results).toEqual(["first page", "second page", "without globals"]);
+  });
+});

package/src/routes/requestSingleFlight.ts

@@ -0,0 +1,17 @@
+/** Share pending work only among callers belonging to the same HTTP request. */
+export function createRequestSingleFlight<T>() {
+  const requests = new WeakMap<Request, Map<string, Promise<T>>>();
+
+  return (request: Request, key: string, run: () => Promise<T>): Promise<T> => {
+    const pending = requests.get(request) ?? new Map<string, Promise<T>>();
+    requests.set(request, pending);
+    const existing = pending.get(key);
+    if (existing) return existing;
+
+    const promise = Promise.resolve()
+      .then(run)
+      .finally(() => pending.delete(key));
+    pending.set(key, promise);
+    return promise;
+  };
+}