houdini-react 2.1.0 → 2.1.2

package/bin/houdini-react

@@ -125,6 +125,8 @@ if (PLATFORM_OVERRIDE === 'wasm') {
 }
 
 // --- Native binary path ---
+const attempted = [];
+
 function getBinaryPath() {
 	if (MANUAL_BINARY_PATH && fs.existsSync(MANUAL_BINARY_PATH)) {
 		return MANUAL_BINARY_PATH;
@@ -138,36 +140,82 @@ function getBinaryPath() {
 			process.stderr.write(`[houdini-react] Unknown platform "${PLATFORM_OVERRIDE}". Valid values: ${Object.keys(BINARY_DISTRIBUTION_PACKAGES).join(', ')}, wasm\n`);
 			process.exit(1);
 		}
-		return path.join(__dirname, binaryName);
+		return path.join(__dirname, '..', binaryName);
 	}
 
+	// module resolution from the shim's own location: real installs, and any
+	// environment that provides NODE_PATH (pnpm scripts do)
 	try {
 		const platformPackagePath = require.resolve(`${platformSpecificPackageName}/package.json`);
 		return path.join(path.dirname(platformPackagePath), 'bin', binaryName);
 	} catch {
-		const siblingPath = path.join(__dirname, '..', platformSpecificPackageName, 'bin', binaryName);
-		if (fs.existsSync(siblingPath)) return siblingPath;
-
-		const pnpmMatch = __dirname.match(/(.+\/node_modules\/)\.pnpm\/[^/]+\/node_modules\//);
-		if (pnpmMatch) {
-			const pnpmDir = path.join(pnpmMatch[1], '.pnpm');
-			try {
-				const packageJSON = require(path.join(__dirname, '..', 'package.json'));
-				const entry = `${platformSpecificPackageName}@${packageJSON.version}`;
-				const found = fs.readdirSync(pnpmDir).find(e => e === entry);
-				if (found) {
-					const p = path.join(pnpmDir, found, 'node_modules', platformSpecificPackageName, 'bin', binaryName);
-					if (fs.existsSync(p)) return p;
-				}
-			} catch {}
-		}
+		attempted.push(`require.resolve('${platformSpecificPackageName}') from ${__dirname}`);
+	}
+
+	// module resolution from the invoking project: a linked development setup puts
+	// the platform package in the project's node_modules, which the walk from the
+	// shim's realpath (inside the linked repo) never visits
+	try {
+		const platformPackagePath = require.resolve(`${platformSpecificPackageName}/package.json`, {
+			paths: [process.cwd()],
+		});
+		return path.join(path.dirname(platformPackagePath), 'bin', binaryName);
+	} catch {
+		attempted.push(`require.resolve('${platformSpecificPackageName}') from ${process.cwd()}`);
+	}
 
-		return path.join(__dirname, binaryName);
+	// flat node_modules: the platform package next to this one
+	const siblingPath = path.join(__dirname, '..', platformSpecificPackageName, 'bin', binaryName);
+	if (fs.existsSync(siblingPath)) return siblingPath;
+	attempted.push(siblingPath);
+
+	// monorepo build layout: the shim lives at <pkg>/build/houdini-react/bin and the
+	// platform package at <pkg>/build/<platform package>
+	const buildSiblingPath = path.join(__dirname, '..', '..', platformSpecificPackageName, 'bin', binaryName);
+	if (fs.existsSync(buildSiblingPath)) return buildSiblingPath;
+	attempted.push(buildSiblingPath);
+
+	const pnpmMatch = __dirname.match(/(.+\/node_modules\/)\.pnpm\/[^/]+\/node_modules\//);
+	if (pnpmMatch) {
+		const pnpmDir = path.join(pnpmMatch[1], '.pnpm');
+		try {
+			const packageJSON = require(path.join(__dirname, '..', 'package.json'));
+			const entry = `${platformSpecificPackageName}@${packageJSON.version}`;
+			const found = fs.readdirSync(pnpmDir).find(e => e === entry);
+			if (found) {
+				const p = path.join(pnpmDir, found, 'node_modules', platformSpecificPackageName, 'bin', binaryName);
+				if (fs.existsSync(p)) return p;
+			}
+			attempted.push(path.join(pnpmDir, entry, 'node_modules', platformSpecificPackageName, 'bin', binaryName));
+		} catch {}
 	}
+
+	// the binary postInstall downloads into the package root when no platform
+	// package could be installed (the shim lives in bin/, one level down)
+	return path.join(__dirname, '..', binaryName);
+}
+
+// Refuse to exec ourselves: when every resolution attempt fails, the final
+// candidate (the postInstall download location) can be this very script — exec'ing
+// it recurses forever, forking a new node per iteration until the machine chokes.
+// A missing binary must be a loud error, never a spawn loop.
+const binaryPath = getBinaryPath();
+let realBinaryPath = null;
+try {
+	realBinaryPath = fs.realpathSync(binaryPath);
+} catch {}
+if (!realBinaryPath || realBinaryPath === fs.realpathSync(__filename)) {
+	attempted.push(binaryPath);
+	process.stderr.write(
+		`[houdini-react] Could not locate the houdini-react binary for ${process.platform}-${process.arch}. Tried:\n` +
+			attempted.map((p) => `  - ${p}\n`).join('') +
+			`Install the platform package for your system or point HOUDINI_REACT_BINARY_PATH at the binary.\n`
+	);
+	process.exit(1);
 }
 
 try {
-	execFileSync(getBinaryPath(), process.argv.slice(2), { stdio: 'inherit' });
+	execFileSync(binaryPath, process.argv.slice(2), { stdio: 'inherit' });
 } catch (error) {
 	process.exit(error.status || 1);
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "houdini-react",
-  "version": "2.1.0",
+  "version": "2.1.2",
   "description": "The React plugin for houdini",
   "keywords": [
     "typescript",
@@ -34,6 +34,7 @@
     "estraverse": "^5.3.0",
     "express": "^5.1.0",
     "graphql-yoga": "^5.21.1",
+    "mrmime": "^2.0.1",
     "react": "^19.2.7",
     "react-dom": "^19.2.7",
     "react-streaming": "^0.4.17",
@@ -81,13 +82,13 @@
     }
   },
   "optionalDependencies": {
-    "houdini-react-darwin-x64": "2.1.0",
-    "houdini-react-darwin-arm64": "2.1.0",
-    "houdini-react-linux-x64": "2.1.0",
-    "houdini-react-linux-arm64": "2.1.0",
-    "houdini-react-win32-x64": "2.1.0",
-    "houdini-react-win32-arm64": "2.1.0",
-    "houdini-react-wasm": "2.1.0"
+    "houdini-react-darwin-x64": "2.1.2",
+    "houdini-react-darwin-arm64": "2.1.2",
+    "houdini-react-linux-x64": "2.1.2",
+    "houdini-react-linux-arm64": "2.1.2",
+    "houdini-react-win32-x64": "2.1.2",
+    "houdini-react-win32-arm64": "2.1.2",
+    "houdini-react-wasm": "2.1.2"
   },
   "scripts": {
     "compile": "scripts build-go",

package/postInstall.js

@@ -5,7 +5,7 @@ const https = require('https')
 const child_process = require('child_process')
 
 // Adjust the version you want to install. You can also make this dynamic.
-const BINARY_DISTRIBUTION_VERSION = '2.1.0'
+const BINARY_DISTRIBUTION_VERSION = '2.1.2'
 
 // Windows binaries end with .exe so we need to special case them.
 const binaryName = process.platform === 'win32' ? 'houdini-react.exe' : 'houdini-react'

package/runtime/Link.tsx

@@ -11,7 +11,7 @@ import type { RouteHrefs, ExternalHref, ParamsForRoute, SearchForRoute } from '.
 import { buildHref, type RouteHrefInfo } from './resolve-href.js'
 
 // re-exported for custom link wrappers that constrain their own `to` prop
-export type { RouteHrefs }
+export type { RouteHrefs, ExternalHref }
 
 export type LinkProps<H extends RouteHrefs | ExternalHref = RouteHrefs | ExternalHref> = Omit<
 	DetailedHTMLProps<AnchorHTMLAttributes<HTMLAnchorElement>, HTMLAnchorElement>,

package/runtime/routing/Router.tsx

@@ -4,8 +4,7 @@ import type { Cache } from 'houdini/runtime/cache'
 import type { DocumentStore, HoudiniClient } from 'houdini/runtime/client'
 import { getCurrentConfig } from '$houdini/runtime'
 import configFile from '$houdini/runtime/imports/config'
-import { deepEquals } from 'houdini/runtime'
-import type { LRUCache } from 'houdini/runtime'
+import { deepEquals, LRUCache } from 'houdini/runtime'
 import { marshalSelection, marshalInputs, getAuthUrl, HOUDINI_SESSION_EVENT } from 'houdini/runtime'
 import type { HoudiniSessionEventDetail } from 'houdini/runtime'
 import { find_match, find_prefix_match } from 'houdini/router/match'
@@ -197,9 +196,9 @@ export function Router({
 		injectToStream,
 	})
 	// if we get this far, it's safe to load the component
-	const { component_cache, data_cache, artifact_cache, ssr_signals } = useRouterContext()
+	const { component_cache, data_cache, artifact_cache, ssr_signals, latestSession } =
+		useRouterContext()
 	const PageComponent = component_cache.get(targetPage.id)!
-	const [session] = useSession()
 
 	// decide whether the entry should render its @loading frame instead of the page.
 	// values come from the router config (bundled client-side; they're UI timing, not
@@ -354,7 +353,7 @@ export function Router({
 		lastRevalidatedURL.current = currentURL
 		for (const name of Object.keys(targetPage.documents)) {
 			if (data_cache.has(name)) {
-				data_cache.get(name).send({ variables, session })
+				data_cache.get(name).send({ variables, session: latestSession.current })
 			}
 		}
 	}, [currentURL])
@@ -544,11 +543,9 @@ function usePageData({
 		artifact_cache,
 		ssr_signals,
 		last_variables,
+		latestSession,
 	} = useRouterContext()
 
-	// grab the current session value
-	const [session] = useSession()
-
 	// the function to load a query using the cache references
 	function load_query({
 		id,
@@ -559,11 +556,12 @@ function usePageData({
 		artifact: QueryArtifact
 		variables: GraphQLVariables
 	}): Promise<void> {
-		// TODO: better tracking - only register the variables that were used
-		// track the new variables
-		for (const artifact of Object.keys(page.documents)) {
-			last_variables.set(artifact, variables)
-		}
+		// record the variables this document is being sent with. only the loaded document:
+		// a preload loads the *destination's* queries while another page is still rendered,
+		// so writing the whole page's documents here (the old behavior) would tag the
+		// current page's documents with the destination's variables — and never tag the
+		// preloaded document at all
+		last_variables.set(id, variables)
 
 		// TODO: AbortController on send()
 		// TODO: we can read from cache here before making an asynchronous network call
@@ -655,7 +653,10 @@ function usePageData({
 			observer
 				.send({
 					variables: variables,
-					session,
+					// read the ref, not the render-scoped session: this send can run during a
+					// render whose committed session predates a just-written one, and it must
+					// not repopulate the invalidated caches with stale-session results
+					session: latestSession.current,
 				})
 				.then(async () => {
 					// a stale-generation result: release the signal so nothing hangs, but
@@ -947,6 +948,15 @@ export function RouterContextProvider({
 	// on the server, we can just use
 	const [session, setSession] = React.useState<App.Session>(ssrSession)
 
+	// the React state above lags behind session writes: a setSession scheduled inside a
+	// transition hasn't committed when another lane renders (e.g. the urgent isPending
+	// flip of a navigation started in the same transition), so a render-phase load_query
+	// in that window would send with the previous session and repopulate the caches the
+	// session change just invalidated — the new-session render then finds everything
+	// "cached" and never refetches. Every session write updates this ref synchronously,
+	// and query sends read it instead of the render-scoped state.
+	const latestSession = React.useRef<App.Session>(ssrSession)
+
 	// if we detect an event that contains a new session value. The detail carries the subtree
 	// and whether to merge it into the current session (an @session(merge:) upsert) or replace
 	// it wholesale; a legacy plain-session detail is treated as a replace.
@@ -966,7 +976,8 @@ export function RouterContextProvider({
 			// old session
 			invalidate_session_caches({ data_cache, ssr_signals, last_variables })
 
-			setSession((prev) => (merge ? { ...prev, ...next } : next))
+			latestSession.current = merge ? { ...latestSession.current, ...next } : next
+			setSession(latestSession.current)
 		},
 		[data_cache, ssr_signals, last_variables]
 	)
@@ -991,9 +1002,19 @@ export function RouterContextProvider({
 				ssr_signals,
 				last_variables,
 				session,
-				setSession: (newSession) => setSession((old) => ({ ...old, ...newSession })),
-				replaceSession: (next) => setSession(next),
-				clearSession: () => setSession({}),
+				latestSession,
+				setSession: (newSession) => {
+					latestSession.current = { ...latestSession.current, ...newSession }
+					setSession(latestSession.current)
+				},
+				replaceSession: (next) => {
+					latestSession.current = next
+					setSession(next)
+				},
+				clearSession: () => {
+					latestSession.current = {}
+					setSession({})
+				},
 				formResult,
 				formToken,
 			}}
@@ -1027,6 +1048,12 @@ export type RouterContext = {
 	// The current session
 	session: App.Session
 
+	// the most recent session value, written synchronously by every session setter. The
+	// `session` state above only updates when React commits, which can lag the write by a
+	// render (e.g. a setSession inside a transition) — anything that fires a request during
+	// render (load_query) must read this instead so it can't send a stale session.
+	latestSession: { current: App.Session }
+
 	// a function to call that sets the client-side session singletone
 	setSession: (newSession: Partial<App.Session>) => void
 
@@ -1406,7 +1433,10 @@ export function router_cache({
 			store.cleanup().catch(() => {})
 		}),
 		ssr_signals: suspense_cache(),
-		last_variables: suspense_cache(),
+		// a plain LRU, NOT a suspense cache: readers look up documents that may have no
+		// entry yet (useQueryResult reads it during render and in its commit effect, where
+		// a suspense cache's thrown promise would land in the nearest error boundary)
+		last_variables: new LRUCache(),
 	}
 
 	// we need to fill each query with an externally resolvable promise

package/vite/index.js

@@ -6,7 +6,8 @@ import {
   client_build_directory
 } from "houdini/router/conventions";
 import { load_manifest } from "houdini/router/manifest";
-import { existsSync, mkdirSync, writeFileSync } from "node:fs";
+import { lookup } from "mrmime";
+import { existsSync, mkdirSync, statSync, writeFileSync } from "node:fs";
 import { createRequire } from "node:module";
 import { build } from "vite";
 import { transform_file } from "./transform.js";
@@ -287,7 +288,7 @@ mount_static_app(App, manifest)
           return;
         }
         const url = req.url.split("?")[0];
-        if (url.startsWith("/@") || url.startsWith("/virtual:") || url.startsWith("/node_modules/") || /\.[a-z]+$/i.test(url)) {
+        if (url.startsWith("/@") || url.startsWith("/virtual:") || url.startsWith("/node_modules/") || /\.[a-z]+$/i.test(url) || lookup(url) !== void 0 || is_public_file(url, server.config.publicDir)) {
           next();
           return;
         }
@@ -304,18 +305,16 @@ mount_static_app(App, manifest)
           adapter_config_path(ctx.config)
         );
         const requestHeaders = new Headers();
-        for (const header of Object.entries(req.headers ?? {})) {
-          requestHeaders.set(header[0], header[1]);
+        for (const [name, value] of Object.entries(req.headers ?? {})) {
+          requestHeaders.set(name, Array.isArray(value) ? value.join(", ") : value ?? "");
         }
         const port = server.config.server.port ?? 5173;
-        const request = new Request(
-          `http://localhost:${port}` + req.url,
-          req.method === "POST" ? {
-            method: req.method,
-            headers: requestHeaders,
-            body: await getBody(req)
-          } : void 0
-        );
+        const hasBody = req.method !== "GET" && req.method !== "HEAD";
+        const request = new Request(`http://localhost:${port}` + req.url, {
+          method: req.method,
+          headers: requestHeaders,
+          ...hasBody ? { body: await getBody(req) } : {}
+        });
         let documentPremable = `<script type="module" src="/@vite/client" async=""></script>`;
         try {
           const transformed = await server.transformIndexHtml(
@@ -353,20 +352,17 @@ mount_static_app(App, manifest)
             if (res.closed) {
               return;
             }
-            for (const header of result.headers ?? []) {
-              res.setHeader(header[0], header[1]);
+            for (const [key, value] of result.headers ?? []) {
+              if (key.toLowerCase() !== "set-cookie") {
+                res.setHeader(key, value);
+              }
+            }
+            const setCookies = result.headers?.getSetCookie() ?? [];
+            if (setCookies.length > 0) {
+              res.setHeader("Set-Cookie", setCookies);
             }
             if (result.status >= 300 && result.status < 400) {
-              res.writeHead(result.status, {
-                Location: result.headers.get("Location") ?? "",
-                ...[...result.headers].reduce(
-                  (headers, [key, value]) => ({
-                    ...headers,
-                    [key]: value
-                  }),
-                  {}
-                )
-              });
+              res.writeHead(result.status);
             } else {
               res.write(await result.text());
             }
@@ -380,6 +376,20 @@ mount_static_app(App, manifest)
     }
   };
 }
+function is_public_file(url, publicDir) {
+  if (!publicDir) {
+    return false;
+  }
+  try {
+    const resolved = path.resolve(publicDir, `.${decodeURIComponent(url)}`);
+    if (!resolved.startsWith(publicDir + path.sep)) {
+      return false;
+    }
+    return statSync(resolved).isFile();
+  } catch {
+    return false;
+  }
+}
 function getBody(request) {
   return new Promise((resolve) => {
     const bodyParts = [];