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

package/CHANGELOG.md

@@ -1,5 +1,18 @@
 # @solidjs/start
 
+## 2.0.0-rc.9
+
+### Patch Changes
+
+- 8eef552: Remove type-only import remnants from client server-function transforms so they do not retain server-only dependency chains.
+
+## 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

package/dist/config/index.d.ts

@@ -131,14 +131,17 @@ export interface SolidStartOptions {
          * 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:
+         * 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.
@@ -147,10 +150,6 @@ export interface SolidStartOptions {
          * 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.

package/dist/directives/remove-unused-variables.js

@@ -12,6 +12,18 @@ function isInvalidForRemoval(path) {
     }
     return isPathValid(target, t.isObjectPattern) || isPathValid(target, t.isArrayPattern);
 }
+function countValidImport(node) {
+    if (node.importKind === "type") {
+        return 0;
+    }
+    let count = 0;
+    for (const specifier of node.specifiers) {
+        if (specifier.type !== "ImportSpecifier" || specifier.importKind === "value") {
+            count += 1;
+        }
+    }
+    return count;
+}
 export function removeUnusedVariables(program) {
     // TODO(Alexis):
     // This implementation is simple but slow
@@ -34,7 +46,7 @@ export function removeUnusedVariables(program) {
                             if (binding.references === 0 && !binding.path.removed) {
                                 const parent = binding.path.parentPath;
                                 if (isPathValid(parent, t.isImportDeclaration)) {
-                                    if (parent.node.specifiers.length === 1) {
+                                    if (countValidImport(parent.node) <= 1) {
                                         parent.remove();
                                     }
                                     else {

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

@@ -3,14 +3,15 @@
  * 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.
+ * 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
- * pass control flow through untouched, or any other value to send in place of
- * `thrown`.
+ * preserve control flow, any other replacement value, or a promise resolving
+ * to any of those values.
  *
  * @example
  * ```ts
@@ -30,4 +31,4 @@
  * ```
  */
 export type ServerFunctionErrorHandler = (thrown: unknown) => unknown;
-export declare function applyServerFunctionErrorHandler(thrown: unknown): unknown;
+export declare function applyServerFunctionErrorHandler(thrown: unknown): Promise<unknown>;

package/dist/fns/error-handler.js

@@ -1,4 +1,10 @@
 import onServerFunctionError from "solid-start:server-fn-error-handler";
-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.7",
+  "version": "2.0.0-rc.9",
   "repository": {
     "type": "git",
     "url": "git+https://github.com/solidjs/solid-start.git",