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

package/CHANGELOG.md

@@ -1,5 +1,18 @@
 # @solidjs/start
 
+## 2.0.0-rc.8
+
+### Patch Changes
+
+- 3573985: Await asynchronous `serverFunctions.onError` handlers before serializing server function errors.
+  Preserve the original error if the handler throws or rejects.
+
+## 2.0.0-rc.7
+
+### Patch Changes
+
+- 87d73e1: chore: bump seroval to v1.6.0
+
 ## 2.0.0-rc.6
 
 ### Minor Changes

package/dist/config/index.d.ts

@@ -115,22 +115,44 @@ 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"> & {
         /**
-         * 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.
+         * 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.
          *
-         * 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.
+         * 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 module is bundled into the server only, so it may import server-only
-         * code such as a monitoring SDK.
+         * The handler may be asynchronous. SolidStart awaits its return value
+         * before serializing the response, allowing a monitoring service to flush
+         * first. The resolved value 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.
+         * - If the handler throws or rejects, what the server function threw is
+         *   sent unchanged.
+         *
+         * 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.
+         *
+         * 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"
          */

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

@@ -1,3 +1,34 @@
+/**
+ * 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`.
+ *
+ * The handler may be asynchronous. SolidStart awaits its return value before
+ * sending the error to the client. If the handler throws or rejects, SolidStart
+ * sends the original thrown value instead.
+ *
+ * @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
+ * preserve control flow, any other replacement value, or a promise resolving
+ * to any of those values.
+ *
+ * @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;
-/** @internal */
-export declare function applyServerFunctionErrorHandler(thrown: unknown): unknown;
+export declare function applyServerFunctionErrorHandler(thrown: unknown): Promise<unknown>;

package/dist/fns/error-handler.js

@@ -1,5 +1,10 @@
 import onServerFunctionError from "solid-start:server-fn-error-handler";
-/** @internal */
-export function applyServerFunctionErrorHandler(thrown) {
-    return onServerFunctionError?.(thrown) ?? thrown;
+export async function applyServerFunctionErrorHandler(thrown) {
+    try {
+        const replacement = await onServerFunctionError?.(thrown);
+        return replacement ?? thrown;
+    }
+    catch {
+        return thrown;
+    }
 }

package/dist/fns/handler.js

@@ -125,7 +125,7 @@ export async function handleServerFunction(h3Event) {
         return serializeToJSONStream(result);
     }
     catch (x) {
-        x = applyServerFunctionErrorHandler(x);
+        x = await applyServerFunctionErrorHandler(x);
         if (x instanceof Response) {
             if (singleFlight && instance) {
                 x = await handleSingleFlight(event, x);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@solidjs/start",
-  "version": "2.0.0-rc.6",
+  "version": "2.0.0-rc.8",
   "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",