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

package/CHANGELOG.md

@@ -1,5 +1,11 @@
 # @solidjs/start
 
+## 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,45 @@ 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 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"
          */

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

@@ -1,3 +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;
-/** @internal */
 export declare function applyServerFunctionErrorHandler(thrown: unknown): unknown;

package/dist/fns/error-handler.js

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

package/package.json

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