@pylonsync/functions 0.7.0 → 0.8.0

package/dist/ssr-runtime.d.ts

@@ -39,7 +39,11 @@ export interface RenderRouteMessage {
     layouts?: string[];
     /** The matched route pattern (e.g. `/blog/:slug`). */
     route_path: string;
-    /** The incoming URL path (e.g. `/blog/hello-world`). */
+    /**
+     * The incoming request PATH, query already stripped by the router (it
+     * passes `path_only_owned`). Reaches userland as BOTH `pathname` (use
+     * this) and `url` (deprecated); the query is `search_params`.
+     */
     url: string;
     /** Dynamic-segment matches keyed by name (e.g. `{slug: "hello-world"}`). */
     params: Record<string, string>;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pylonsync/functions",
-  "version": "0.7.0",
+  "version": "0.8.0",
   "description": "TypeScript function runtime for pylon — defines server-side queries, mutations, and actions.",
   "type": "module",
   "main": "src/index.ts",

package/src/ssr-pathname-prop.test.ts

@@ -0,0 +1,60 @@
+// The `url` page prop carries the request PATH, never the query — the router
+// hands over `path_only_owned` and the query arrives separately as
+// `search_params`. The name does not say that, and the gap has a cost: a
+// login page did `new URL(props.url).searchParams.get("next")`, which
+// compiles, looks right, and returns null on every request. It silently
+// dropped the pending OIDC authorize request, so signing in to one app in the
+// fleet landed on the identity provider's dashboard with no error.
+//
+// `pathname` is the honest name. These pin that both exist, agree, and reach
+// a bucketed page's hydrated tail together — a page that got one but not the
+// other would be the same trap in a new place.
+
+import { expect, test } from "bun:test";
+import { readFileSync } from "node:fs";
+
+const runtime = readFileSync(new URL("./ssr-runtime.ts", import.meta.url), "utf8");
+const publicTypes = readFileSync(
+  new URL("../../react/src/ssr.ts", import.meta.url),
+  "utf8",
+);
+
+function block(src: string, start: string, end: string): string {
+  const a = src.indexOf(start);
+  expect(a).toBeGreaterThan(-1);
+  const b = src.indexOf(end, a);
+  return src.slice(a, b > a ? b : undefined);
+}
+
+test("page props carry pathname and url, both from the same value", () => {
+  const props = block(runtime, "props = {", "params: msg.params");
+  expect(props).toContain("pathname: msg.url");
+  expect(props).toContain("url: msg.url");
+});
+
+test("a bucketed page's serialized tail carries both", () => {
+  const tail = block(runtime, "serializableProps = {", "auth: {");
+  expect(tail).toContain("pathname:");
+  expect(tail).toContain("url: restProps.url");
+});
+
+test("the PPR snapshot carries both", () => {
+  const snap = block(runtime, "bucketTailBase = bucketOptIn", "searchParams: jsonClone");
+  expect(snap).toContain("pathname: msg.url");
+  expect(snap).toContain("url: msg.url");
+});
+
+test("PageProps declares pathname and marks url deprecated", () => {
+  expect(publicTypes).toContain("pathname: string;");
+  const urlDoc = block(publicTypes, "The request path. Same value as `pathname`", "url: string;");
+  expect(urlDoc).toContain("@deprecated");
+  // The doc has to name the replacement, or it just says "don't" without
+  // saying what instead.
+  expect(urlDoc).toContain("searchParams");
+});
+
+test("the deprecation explains the failure, not just the preference", () => {
+  const urlDoc = block(publicTypes, "The request path. Same value as `pathname`", "url: string;");
+  expect(urlDoc.toLowerCase()).toContain("query");
+  expect(urlDoc).toMatch(/null|silently/);
+});

package/src/ssr-runtime.ts

@@ -58,7 +58,11 @@ export interface RenderRouteMessage {
   layouts?: string[];
   /** The matched route pattern (e.g. `/blog/:slug`). */
   route_path: string;
-  /** The incoming URL path (e.g. `/blog/hello-world`). */
+  /**
+   * The incoming request PATH, query already stripped by the router (it
+   * passes `path_only_owned`). Reaches userland as BOTH `pathname` (use
+   * this) and `url` (deprecated); the query is `search_params`.
+   */
   url: string;
   /** Dynamic-segment matches keyed by name (e.g. `{slug: "hello-world"}`). */
   params: Record<string, string>;
@@ -2071,6 +2075,10 @@ export function buildHydrationTail(args: {
     // collapsed binary auth bit. (params/searchParams are keyed by pathname; a
     // bucket request has no query, so searchParams is empty.)
     serializableProps = {
+      // Both, and for the same reason they are both on props: a bucketed page
+      // that got `url` but not `pathname` would hydrate with one of the two
+      // undefined, which is the same trap in a new place.
+      pathname: restProps.pathname ?? restProps.url,
       url: restProps.url,
       params: restProps.params,
       searchParams: restProps.searchParams,
@@ -3245,6 +3253,13 @@ export async function handleRenderRoute(
     );
 
     props = {
+      // Both name the same value: the request PATH, with no query string.
+      // `pathname` is the name to use; `url` is kept for compatibility and
+      // is deprecated — see the doc comments on PageProps. The old name is a
+      // trap, because a prop called `url` reads as if it carries the query,
+      // and code that does `new URL(props.url).searchParams.get(x)` silently
+      // finds nothing forever instead of failing.
+      pathname: msg.url,
       url: msg.url,
       params: msg.params,
       searchParams: msg.search_params,
@@ -3270,6 +3285,7 @@ export async function handleRenderRoute(
     const bucketOptIn = (mod as any).cache === "auth-bucketed";
     const bucketTailBase = bucketOptIn
       ? {
+          pathname: msg.url,
           url: msg.url,
           params: jsonClone(msg.params),
           searchParams: jsonClone(msg.search_params),