@solidjs/router 2.0.0-next.25 → 2.0.0-next.26

package/README.md

@@ -519,6 +519,8 @@ getUser.keyFor(5); // "users[5]"
 
 Revalidate with the `revalidate` export or by setting `revalidate` keys on action responses — the whole key invalidates every entry for the query, `keyFor` invalidates one.
 
+A query may also redirect — a guard read that throws or returns `redirect()` (from `@solidjs/web`) navigates instead of resolving: same-origin targets navigate softly with `replace`, other origins leave the document, any `revalidate` keys on the response invalidate first, and the read itself stays pending so nothing renders the redirect as data. This holds for `"use server"` queries too, where the transport carries the redirect to the client rather than letting `fetch` follow it.
+
 ### `liveQuery` (experimental)
 
 `query`'s live sibling: a keyed query over a value-shaped stream. The function is an async iterable (typically an async generator server function) whose yields are successive **values of one logical query** — each yield is the current state, not an event — with the contract that it re-yields current state on every invocation:

package/dist/data/query.js

@@ -1,15 +1,20 @@
 import { createSignal, getObserver, getOwner, onCleanup, sharedConfig, untrack } from "solid-js";
 // Everything server-function-shaped comes off the CORE entry: detection
 // (isServerFunction/getServerFunctionMetadata, registered-symbol reads) and
-// the late-bound RPC seam (getServerFunctionRPC). The server-functions
-// entry itself — the fetch transport + the seroval codec behind it — is
-// deliberately NOT imported here: query() is in every router app's eager
-// graph, and a static import made every zero-server-function app ship
+// the late-bound RPC seam (getServerFunctionRPC). The transport itself —
+// the fetch RPC client + the seroval codec behind it — is deliberately NOT
+// imported here: query() is in every router app's eager graph, and a static
+// import of `decodeResponse` made every zero-server-function app ship
 // ~9 KB gz of codec it could never invoke. The transport registers itself
 // into the seam when a `'use server'` reference is created (compiled
 // output, module scope), so by the time a server function can reach
 // query() the seam is filled; plain-fetch apps read undefined forever.
 import { getRequestEvent, getServerFunctionMetadata, getServerFunctionRPC, isResponseEnvelope, isServer, isServerFunction, REVALIDATE_HEADER } from "@solidjs/web";
+// The redirect carrier's name and decoder are the exception: two pure,
+// dependency-free bindings off a `sideEffects: false` entry, so they
+// tree-shake to a few hundred bytes without dragging the codec in (the same
+// bindings action.ts already imports statically).
+import { decodeRedirectHeaderValue, REDIRECT_HEADER } from "@solidjs/web/server-functions";
 import { useRouter, getIntent, getInPreloadFn } from "../routing.js";
 const LocationHeader = "Location";
 const PRELOAD_TIMEOUT = 5000;
@@ -62,7 +67,12 @@ export function revalidate(key, force = true) {
     const now = Date.now();
     cacheKeyOp(key, entry => {
         force && (entry[0] = 0); //force cache miss
-        entry[4][1](now); // retrigger live signals
+        // retrigger live signals. The version is the entry's fetch stamp, and
+        // a signal write of an equal value is a no-op — an entry fetched within
+        // this same millisecond (a mount whose redirect lands before the clock
+        // ticks) would otherwise never be told to refetch, and the surviving
+        // consumer paints stale. A sweep must notify unconditionally.
+        entry[4][1](v => (v === now ? now + 1 : now));
     });
     const keys = key === undefined ? undefined : Array.isArray(key) ? key : [key];
     for (const hook of revalidateHooks)
@@ -251,7 +261,27 @@ export function query(fn, name) {
                                 e.response.headers.set(key, value);
                         }
                     }
-                    const url = v.headers.get(LocationHeader);
+                    let url = v.headers.get(LocationHeader);
+                    // A `"use server"` redirect reaches a client-side read masked: the
+                    // transport answers scripted callers with a 200, drops `Location`
+                    // and carries "<status> <absolute-url>" in REDIRECT_HEADER instead.
+                    // Decode it with the runtime's own reader, as action() does. The
+                    // carrier arrives RESOLVED to an absolute url, so same-origin vs
+                    // cross-origin is a real origin comparison: same-origin folds to
+                    // a path the soft branch below navigates under the router, any
+                    // other origin keeps its href and the document goes with it. This
+                    // stays synchronous on purpose — navigate runs in the same tick as
+                    // the `Location` branch would, so the transition semantics match.
+                    if (url === null && !isServer && v.headers.has(REDIRECT_HEADER)) {
+                        const carried = decodeRedirectHeaderValue(v.headers.get(REDIRECT_HEADER));
+                        if (carried) {
+                            const target = new URL(carried.url);
+                            url =
+                                target.origin === window.location.origin
+                                    ? target.pathname + target.search + target.hash
+                                    : target.href;
+                        }
+                    }
                     if (url !== null) {
                         // invalidate the redirect's revalidation keys before navigating so
                         // the destination's preloads see the miss and fetch fresh (#580 thread).

package/dist/index.js

@@ -1,6 +1,6 @@
 import { getOwner, runWithOwner, createMemo, createRenderEffect, onCleanup, untrack, createContext, createSignal, useContext, NotReadyError, isPending, DEV, latest, createComponent, createRoot, Show, createEffect, sharedConfig, OBSERVE, onSettled, getObserver, $TRACK, action as action$1 } from 'solid-js';
 import { registerElementClaim, delegateEvents, isServer, getRequestEvent, hasFlashCookie, clearFlashCookie, createComponent as createComponent$1, memo, isServerFunction, getServerFunctionMetadata, getServerFunctionRPC, isResponseEnvelope, REVALIDATE_HEADER } from '@solidjs/web';
-import { subscribeFlightData, decodeRedirectHeaderValue, REDIRECT_HEADER, decodeResponsePayload, parseServerFunctionActionUrl, createServerReference } from '@solidjs/web/server-functions';
+import { REDIRECT_HEADER, decodeRedirectHeaderValue, subscribeFlightData, decodeResponsePayload, parseServerFunctionActionUrl, createServerReference } from '@solidjs/web/server-functions';
 import { decodeFlashCookie } from '@solidjs/web/server-functions/server';
 
 const hasSchemeRegex = /^(?:[a-z0-9]+:)?\/\//i;
@@ -2457,7 +2457,12 @@ function revalidate(key, force = true) {
   const now = Date.now();
   cacheKeyOp(key, entry => {
     force && (entry[0] = 0); //force cache miss
-    entry[4][1](now); // retrigger live signals
+    // retrigger live signals. The version is the entry's fetch stamp, and
+    // a signal write of an equal value is a no-op — an entry fetched within
+    // this same millisecond (a mount whose redirect lands before the clock
+    // ticks) would otherwise never be told to refetch, and the surviving
+    // consumer paints stale. A sweep must notify unconditionally.
+    entry[4][1](v => v === now ? now + 1 : now);
   });
   const keys = key === undefined ? undefined : Array.isArray(key) ? key : [key];
   for (const hook of revalidateHooks) hook(keys, force);
@@ -2619,7 +2624,25 @@ function query(fn, name) {
               if (key == "set-cookie") e.response.headers.append("set-cookie", value);else e.response.headers.set(key, value);
             }
           }
-          const url = v.headers.get(LocationHeader);
+          let url = v.headers.get(LocationHeader);
+
+          // A `"use server"` redirect reaches a client-side read masked: the
+          // transport answers scripted callers with a 200, drops `Location`
+          // and carries "<status> <absolute-url>" in REDIRECT_HEADER instead.
+          // Decode it with the runtime's own reader, as action() does. The
+          // carrier arrives RESOLVED to an absolute url, so same-origin vs
+          // cross-origin is a real origin comparison: same-origin folds to
+          // a path the soft branch below navigates under the router, any
+          // other origin keeps its href and the document goes with it. This
+          // stays synchronous on purpose — navigate runs in the same tick as
+          // the `Location` branch would, so the transition semantics match.
+          if (url === null && !isServer && v.headers.has(REDIRECT_HEADER)) {
+            const carried = decodeRedirectHeaderValue(v.headers.get(REDIRECT_HEADER));
+            if (carried) {
+              const target = new URL(carried.url);
+              url = target.origin === window.location.origin ? target.pathname + target.search + target.hash : target.href;
+            }
+          }
           if (url !== null) {
             // invalidate the redirect's revalidation keys before navigating so
             // the destination's preloads see the miss and fetch fresh (#580 thread).

package/package.json

@@ -6,7 +6,7 @@
     "Ryan Turnquist"
   ],
   "license": "MIT",
-  "version": "2.0.0-next.25",
+  "version": "2.0.0-next.26",
   "homepage": "https://github.com/solidjs/solid-router#readme",
   "repository": {
     "type": "git",