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

package/CHANGELOG.md

@@ -1,5 +1,24 @@
 # @solidjs/start
 
+## 2.0.0-rc.7
+
+### Patch Changes
+
+- 87d73e1: chore: bump seroval to v1.6.0
+
+## 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

@@ -115,9 +115,49 @@ export interface SolidStartOptions {
      */
     env?: EnvPluginOptions;
     /**
-     * Options controlling which files are processed as server functions
-     * (inclusion / exclusion filters for the `"use server"` transform).
+     * Options for server functions: which files the `"use server"` transform
+     * processes (inclusion / exclusion filters), and what happens when a server
+     * function throws.
      */
-    serverFunctions?: Pick<ServerFunctionsOptions, "filter">;
+    serverFunctions?: Pick<ServerFunctionsOptions, "filter"> & {
+        /**
+         * Path to a module whose default export handles whatever a server function
+         * throws, before it reaches the client. Use it to report failures to a
+         * monitoring service, or to replace an error carrying internal detail with
+         * one that is safe to send.
+         *
+         * Only server function calls made over the network run through it. A
+         * server function called during rendering runs in process and throws
+         * straight to its caller, and errors from API routes never reach it
+         * either.
+         *
+         * The export is called synchronously with the thrown value, and what it
+         * returns decides what the client sees:
+         *
+         * - `undefined` (or `null`) sends what was thrown, unchanged.
+         * - A `Response` is passed through unchanged, which keeps a thrown
+         *   `redirect()` working.
+         * - Any other value is sent in place of what was thrown, and the client
+         *   call rejects with it.
+         *
+         * Control flow reaches the export the same way errors do, so a handler
+         * that replaces everything it sees turns redirects into errors.
+         *
+         * Whatever is sent gets serialized to the client along with its own
+         * properties, so an error meant to be safe to expose must not carry
+         * internal detail.
+         *
+         * The return value is not awaited, so make the export a plain function
+         * rather than an `async` one, and report failures with calls that do not
+         * need awaiting.
+         *
+         * Type the export as `ServerFunctionErrorHandler` from
+         * `@solidjs/start/server`. 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,33 @@
+/**
+ * Handles whatever a server function threw, before it reaches the client. Use
+ * it to type the default export of the module named by the
+ * `serverFunctions.onError` option in `vite.config.ts`.
+ *
+ * Called synchronously, and the value it returns is not awaited, so it cannot
+ * be an `async` function.
+ *
+ * @param thrown The value the server function threw. This is a `Response` when
+ * the server function threw control flow such as a `redirect()`.
+ * @returns `undefined` (or `null`) to send `thrown` unchanged, a `Response` to
+ * pass control flow through untouched, or any other value to send in place of
+ * `thrown`.
+ *
+ * @example
+ * ```ts
+ * // src/server-fn-error.ts
+ * import type { ServerFunctionErrorHandler } from "@solidjs/start/server";
+ * import { captureException } from "./your-monitoring-client";
+ *
+ * const onServerFunctionError: ServerFunctionErrorHandler = thrown => {
+ *   // redirect() throws a Response, so returning it preserves that control flow.
+ *   if (thrown instanceof Response) return thrown;
+ *
+ *   captureException(thrown); // or console.error, or any reporter
+ *   return new Error("Something went wrong");
+ * };
+ *
+ * export default onServerFunctionError;
+ * ```
+ */
+export type ServerFunctionErrorHandler = (thrown: unknown) => unknown;
+export declare function applyServerFunctionErrorHandler(thrown: unknown): unknown;

package/dist/fns/error-handler.js

@@ -0,0 +1,4 @@
+import onServerFunctionError from "solid-start:server-fn-error-handler";
+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.7",
   "repository": {
     "type": "git",
     "url": "git+https://github.com/solidjs/solid-start.git",
@@ -48,8 +48,8 @@
     "path-to-regexp": "^8.4.2",
     "pathe": "^2.0.3",
     "radix3": "^1.1.2",
-    "seroval": "^1.5.6",
-    "seroval-plugins": "^1.5.6",
+    "seroval": "^1.6.0",
+    "seroval-plugins": "^1.6.0",
     "shiki": "^4.3.1",
     "solid-js": "^1.9.14",
     "source-map-js": "^1.2.1",
@@ -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"
   },