@solidjs/start 2.0.0-rc.5 → 2.0.0-rc.6

package/CHANGELOG.md

@@ -1,5 +1,18 @@
 # @solidjs/start
 
+## 2.0.0-rc.6
+
+### Minor Changes
+
+- bac24b2: Add a `serverFunctions.onError` option naming a module that observes and replaces what a server function threw, before it is serialized into the response
+
+### Patch Changes
+
+- 27c2877: Remove leftover debug `console.log` calls from the server functions inspector, which logged on every server function request in dev.
+- f15724b: Declare `@solidjs/router` as an optional peer dependency constrained to `>=0.16.0 <2.0.0-0`. Router v2 is expected to target Solid v2, so installing it alongside `@solidjs/start` v2 now surfaces a peer warning instead of silently producing an incompatible pairing. The peer is marked optional, so apps that do not use the router are unaffected.
+- 5c8612f: Apply cookies set on a returned or thrown response during single flight mutations. `redirect(to, { headers: { "Set-Cookie": ... } })` previously only reached the browser: the single flight re-render of the redirect target still ran with the old request cookies, so queries reading that cookie saw stale values. Those cookies are now merged into the request the re-render sees, matching what a browser round trip would have sent.
+- 83122ed: Reject server function calls when the response is a 5xx without an X-Error header, instead of resolving with the parsed error body
+
 ## 2.0.0-rc.5
 
 ### Minor Changes

package/dist/config/constants.d.ts

@@ -7,6 +7,7 @@ export declare const VIRTUAL_MODULES: {
     readonly middleware: "solid-start:middleware";
     readonly serovalPlugins: "solid-start:seroval-plugins";
     readonly serverFnManifest: "solid-start:server-fn-manifest";
+    readonly serverFnErrorHandler: "solid-start:server-fn-error-handler";
     readonly clientEntry: "solid-start:client-entry";
     readonly serverEntry: "solid-start:server-entry";
     readonly app: "solid-start:app";

package/dist/config/constants.js

@@ -7,6 +7,7 @@ export const VIRTUAL_MODULES = {
     middleware: "solid-start:middleware",
     serovalPlugins: "solid-start:seroval-plugins",
     serverFnManifest: "solid-start:server-fn-manifest",
+    serverFnErrorHandler: "solid-start:server-fn-error-handler",
     clientEntry: "solid-start:client-entry",
     serverEntry: "solid-start:server-entry",
     app: "solid-start:app",

package/dist/config/index.d.ts

@@ -118,6 +118,23 @@ export interface SolidStartOptions {
      * Options controlling which files are processed as server functions
      * (inclusion / exclusion filters for the `"use server"` transform).
      */
-    serverFunctions?: Pick<ServerFunctionsOptions, "filter">;
+    serverFunctions?: Pick<ServerFunctionsOptions, "filter"> & {
+        /**
+         * Path to a module whose default export is called with whatever a server
+         * function threw, before it is serialized into the response. Return a
+         * value to send it in place of what was thrown, or `undefined` to send the
+         * original.
+         *
+         * Naming the module here rather than registering a handler at runtime
+         * keeps the app in sole control of it: no dependency can reach into the
+         * running server and take over reporting.
+         *
+         * The module is bundled into the server only, so it may import server-only
+         * code such as a monitoring SDK.
+         *
+         * @example "src/server-fn-error.ts"
+         */
+        onError?: string;
+    };
 }
 export declare function solidStart(options?: SolidStartOptions): Array<PluginOption>;

package/dist/config/manifest.js

@@ -34,6 +34,12 @@ export function manifest(start) {
                     return await this.resolve(plugins);
                 return `\0${VIRTUAL_MODULES.serovalPlugins}`;
             }
+            if (id === VIRTUAL_MODULES.serverFnErrorHandler) {
+                const onError = start.serverFunctions?.onError;
+                if (onError)
+                    return await this.resolve(onError);
+                return `\0${VIRTUAL_MODULES.serverFnErrorHandler}`;
+            }
         },
         async load(id) {
             if (id === `\0${VIRTUAL_MODULES.clientViteManifest}`) {
@@ -84,6 +90,8 @@ export function manifest(start) {
                 return "export default {};";
             else if (id === `\0${VIRTUAL_MODULES.serovalPlugins}`)
                 return "export default [];";
+            else if (id === `\0${VIRTUAL_MODULES.serverFnErrorHandler}`)
+                return "export default undefined;";
             else if (id.startsWith("/@manifest")) {
                 if (this.environment.mode !== "dev")
                     throw new Error("@manifest queries are only allowed in dev");

package/dist/fns/client.js

@@ -15,7 +15,6 @@ async function createRequest(base, id, instance, options) {
         },
     });
     if (import.meta.env.DEV) {
-        console.log(pushRequest);
         pushRequest(id, instance, request.clone());
     }
     const response = await fetch(request);
@@ -73,8 +72,8 @@ async function fetchServerFunction(base, id, options, args) {
         return response;
     }
     const result = await extractBody(instance, true, response.clone());
-    if (response.headers.has("X-Error")) {
-        throw result;
+    if (response.headers.has("X-Error") || response.status >= 500) {
+        throw result ?? new Error(`Server function call failed with status ${response.status}`);
     }
     return result;
 }

package/dist/fns/error-handler.d.ts

@@ -0,0 +1,3 @@
+export type ServerFunctionErrorHandler = (thrown: unknown) => unknown;
+/** @internal */
+export declare function applyServerFunctionErrorHandler(thrown: unknown): unknown;

package/dist/fns/error-handler.js

@@ -0,0 +1,5 @@
+import onServerFunctionError from "solid-start:server-fn-error-handler";
+/** @internal */
+export function applyServerFunctionErrorHandler(thrown) {
+    return onServerFunctionError?.(thrown) ?? thrown;
+}

package/dist/fns/handler.d.ts

@@ -2,4 +2,4 @@ import { type H3Event } from "h3";
 import "solid-start:server-fn-manifest";
 import type { FetchEvent } from "../server/types.ts";
 export declare function handleServerFunction(h3Event: H3Event): Promise<unknown>;
-export declare function createSingleFlightHeaders(sourceEvent: FetchEvent): Headers;
+export declare function createSingleFlightHeaders(sourceEvent: FetchEvent, result?: unknown): Headers;

package/dist/fns/handler.js

@@ -17,6 +17,7 @@ import { deserializeFromJSONString, serializeToJSONStream, serializeToJSStream,
 import { BODY_FORMAT_KEY, BodyFormat, extractBody, getHeadersAndBody } from "./shared.js";
 import "solid-start:server-fn-manifest";
 import { getServerFunction, hasServerFunction } from "./registration.js";
+import { applyServerFunctionErrorHandler } from "./error-handler.js";
 import { getExpectedRedirectStatus } from "../server/util.js";
 export async function handleServerFunction(h3Event) {
     const event = getFetchEvent(h3Event);
@@ -124,6 +125,7 @@ export async function handleServerFunction(h3Event) {
         return serializeToJSONStream(result);
     }
     catch (x) {
+        x = applyServerFunctionErrorHandler(x);
         if (x instanceof Response) {
             if (singleFlight && instance) {
                 x = await handleSingleFlight(event, x);
@@ -236,13 +238,19 @@ async function handleNoJS(result, request, parsed, thrown) {
     });
 }
 let App;
-export function createSingleFlightHeaders(sourceEvent) {
+export function createSingleFlightHeaders(sourceEvent, result) {
     // cookie handling logic is pretty simplistic so this might be imperfect
     // unclear if h3 internals are available on all platforms but we need a way to
     // update request headers on the underlying H3 event.
     const headers = new Headers(sourceEvent.request.headers);
     const cookies = parseCookies(sourceEvent.nativeEvent);
     const SetCookies = sourceEvent.response.headers.getSetCookie();
+    // cookies attached to the returned/thrown response (eg. `redirect(to, { headers })`)
+    // haven't been merged onto the event response yet, but a browser round trip would
+    // have sent them back with the next request, so apply them here too. They come after
+    // the ones on the event response, so they win on conflict.
+    if (result instanceof Response)
+        SetCookies.push(...result.headers.getSetCookie());
     headers.delete("cookie");
     // let useH3Internals = false;
     // if (sourceEvent.nativeEvent.node?.req) {
@@ -286,7 +294,7 @@ async function handleSingleFlight(sourceEvent, result) {
     }
     const event = { ...sourceEvent };
     event.request = new Request(url, {
-        headers: createSingleFlightHeaders(sourceEvent),
+        headers: createSingleFlightHeaders(sourceEvent, result),
     });
     return await provideRequestEvent(event, async () => {
         await createPageEvent(event);

package/dist/server/index.d.ts

@@ -3,6 +3,7 @@ export { getServerFunctionMeta } from "../shared/serverFunction.ts";
 export { StartServer } from "./StartServer.tsx";
 export { decorateHandler, decorateMiddleware } from "./fetchEvent.ts";
 export { createHandler } from "./handler.ts";
+export type { ServerFunctionErrorHandler } from "../fns/error-handler.ts";
 export type { APIEvent, APIHandler, Asset, ContextMatches, DocumentComponentProps, FetchEvent, HandlerOptions, PageEvent, ResponseStub, ServerFunctionMeta, StartHandler, } from "./types.ts";
 /**
  * Checks if user has set a redirect status in the response.

package/dist/shared/dev-toolbar/index.jsx

@@ -121,7 +121,6 @@ export function DevToolbar(props) {
     });
     createEffect(() => {
         onCleanup(captureServerFunctionCall(call => {
-            console.log(call);
             if (call.type === "request") {
                 setStore("instances", call.instance, value => {
                     return {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@solidjs/start",
-  "version": "2.0.0-rc.5",
+  "version": "2.0.0-rc.6",
   "repository": {
     "type": "git",
     "url": "git+https://github.com/solidjs/solid-start.git",
@@ -64,8 +64,14 @@
     "vitest": "^4.1.10"
   },
   "peerDependencies": {
+    "@solidjs/router": ">=0.16.0 <2.0.0-0",
     "vite": "^8 || ^9"
   },
+  "peerDependenciesMeta": {
+    "@solidjs/router": {
+      "optional": true
+    }
+  },
   "engines": {
     "node": ">=24"
   },