@solidjs/start 2.0.0-beta.7 → 2.0.0-beta.8

package/CHANGELOG.md

@@ -1,5 +1,12 @@
 # @solidjs/start
 
+## 2.0.0-beta.8
+
+### Patch Changes
+
+- ecc02be: fix: resolve server functions in dev when their route was reached through client-side navigation before its module was evaluated on the server
+- 85b24b2: Use per-environment Vite plugin hook APIs for forward compatibility with Vite 9.
+
 ## 2.0.0-beta.7
 
 ### Patch Changes

package/dist/config/env.js

@@ -47,9 +47,10 @@ export function envPlugin(options) {
             }
             return undefined;
         },
-        load(id, opts) {
+        load(id) {
+            const isServer = this.environment.config.consumer === "server";
             if (id === SERVER_ENV) {
-                if (!opts?.ssr) {
+                if (!isServer) {
                     return SERVER_ONLY_MODULE;
                 }
                 const vars = currentOptions.server?.load
@@ -64,13 +65,13 @@ export function envPlugin(options) {
                 return convertObjectToModule(vars);
             }
             if (id === SERVER_RUNTIME_LOADER) {
-                if (!opts?.ssr) {
+                if (!isServer) {
                     return SERVER_ONLY_MODULE;
                 }
                 return runtimeCode;
             }
             if (id === SERVER_RUNTIME_ENV) {
-                if (!opts?.ssr) {
+                if (!isServer) {
                     return SERVER_ONLY_MODULE;
                 }
                 return SERVER_RUNTIME_CODE;

package/dist/directives/index.js

@@ -1,8 +1,14 @@
 import { createFilter, } from "vite";
+import fg from "fast-glob";
 import { compile } from "./compile.js";
+import xxHash32 from "./xxhash32.js";
 const DEFAULT_INCLUDE = "src/**/*.{jsx,tsx,ts,js,mjs,cjs}";
 const DEFAULT_EXCLUDE = "node_modules/**/*.{jsx,tsx,ts,js,mjs,cjs}";
 const DIRECTIVE = "use server";
+// Dev-only virtual module used by fns/handler.ts to lazily resolve a server
+// function id back to its owning module when the function was never evaluated
+// in the server environment (e.g. its route was only client-side navigated to).
+const LOOKUP_ID = "solid-start:server-fn-lookup";
 function createManifest() {
     return {
         server: new Set(),
@@ -63,8 +69,11 @@ function invalidateModule(moduleGraph, path) {
 function invalidateModules(server, result, manifest) {
     if (server) {
         if (result.invalidPreload) {
-            invalidateModule(server.environments.client.moduleGraph, manifest);
-            invalidateModule(server.environments.ssr.moduleGraph, manifest);
+            // Environments are not limited to "client"/"ssr": plugins like nitro
+            // render in their own environment (e.g. "nitro"), so invalidate everywhere.
+            for (const environment of Object.values(server.environments)) {
+                invalidateModule(environment.moduleGraph, manifest);
+            }
         }
     }
 }
@@ -125,24 +134,47 @@ export function serverFunctionsPlugin(options) {
                 if (source === options.manifest) {
                     return { id: options.manifest, moduleSideEffects: true };
                 }
+                if (source.startsWith(LOOKUP_ID)) {
+                    return { id: source, moduleSideEffects: true };
+                }
                 return null;
             },
-            async load(id, opts) {
-                const mode = opts?.ssr ? "server" : "client";
+            async load(id) {
+                const mode = this.environment.config.consumer;
                 if (id === options.manifest) {
                     const current = new Debouncer(() => [...manifest[mode]].map(entry => `import "${entry}";`).join("\n"));
                     preload[mode] = current;
                     const result = await current.promise.reference;
                     return result;
                 }
+                if (id.startsWith(LOOKUP_ID)) {
+                    if (this.environment.mode !== "dev") {
+                        throw new Error(`${LOOKUP_ID} is only available in dev`);
+                    }
+                    const functionId = new URLSearchParams(id.slice(LOOKUP_ID.length + 1)).get("id");
+                    // dev function ids are `${xxHash32(file)}-${count}-${name}`
+                    const hash = functionId?.split("-")[0];
+                    if (!hash)
+                        return "export {};";
+                    // Look through the files already discovered by the transform first;
+                    // fall back to scanning the project so a function is found even when
+                    // the browser kept a chunk from before a dev server restart.
+                    let files = [...manifest.server].filter(file => xxHash32(file).toString(16) === hash);
+                    if (files.length === 0) {
+                        files = fg
+                            .sync(DEFAULT_INCLUDE, { cwd: this.environment.config.root, absolute: true })
+                            .filter(file => filter(file) && xxHash32(file).toString(16) === hash);
+                    }
+                    return files.map(file => `import ${JSON.stringify(file)};`).join("\n") || "export {};";
+                }
                 return null;
             },
         },
         {
             name: "solid-start:server-functions/compiler",
-            enforce: 'pre',
-            async transform(code, fileId, opts) {
-                const mode = opts?.ssr ? "server" : "client";
+            enforce: "pre",
+            async transform(code, fileId) {
+                const mode = this.environment.config.consumer;
                 const [id] = fileId.split("?");
                 if (!filter(id)) {
                     return null;

package/dist/fns/handler.js

@@ -1,3 +1,11 @@
+var __rewriteRelativeImportExtension = (this && this.__rewriteRelativeImportExtension) || function (path, preserveJsx) {
+    if (typeof path === "string" && /^\.\.?\//.test(path)) {
+        return path.replace(/\.(tsx)$|((?:\.d)?)((?:\.[^./]+?)?)\.([cm]?)ts$/i, function (m, tsx, d, ext, cm) {
+            return tsx ? preserveJsx ? ".jsx" : ".js" : d && (!ext || !cm) ? m : (d + ext + "." + cm.toLowerCase() + "js");
+        });
+    }
+    return path;
+};
 import { parseSetCookie } from "cookie-es";
 import { parseCookies } from "h3";
 import { sharedConfig } from "solid-js";
@@ -6,9 +14,9 @@ import { provideRequestEvent } from "solid-js/web/storage";
 import { getFetchEvent, mergeResponseHeaders } from "../server/fetchEvent.js";
 import { createPageEvent } from "../server/handler.js";
 import { deserializeFromJSONString, serializeToJSONStream, serializeToJSStream, } from "./serialization.js";
-import { BODY_FORMAT_KEY, BodyFormat, extractBody, getHeadersAndBody, } from "./shared.js";
+import { BODY_FORMAT_KEY, BodyFormat, extractBody, getHeadersAndBody } from "./shared.js";
 import "solid-start:server-fn-manifest";
-import { getServerFunction } from "./registration.js";
+import { getServerFunction, hasServerFunction } from "./registration.js";
 import { getExpectedRedirectStatus } from "../server/util.js";
 export async function handleServerFunction(h3Event) {
     const event = getFetchEvent(h3Event);
@@ -30,6 +38,23 @@ export async function handleServerFunction(h3Event) {
                 : new Response(null, { status: 404 });
         }
     }
+    if (import.meta.env.DEV && !hasServerFunction(functionId)) {
+        // The module that owns this function has not been evaluated in the server
+        // environment yet (e.g. the route was reached by client-side navigation, so
+        // it was only ever loaded in the browser). Ask the dev server to resolve the
+        // function id back to its owning module and import it, which registers it.
+        // Resolved by the "solid-start:server-functions/preload" plugin.
+        try {
+            // the /@id/ prefix routes the request through the plugin container so the
+            // virtual module can be resolved (bare ids get node-resolved by the runner)
+            await import(__rewriteRelativeImportExtension(
+            /* @vite-ignore */ `/@id/solid-start:server-fn-lookup?id=${encodeURIComponent(functionId)}`, true));
+        }
+        catch (error) {
+            // fall through to getServerFunction, which reports the missing function
+            console.error("[solid-start] server function lookup failed:", error);
+        }
+    }
     const serverFunction = getServerFunction(functionId);
     let parsed = [];
     // grab bound arguments from url when no JS

package/dist/fns/registration.d.ts

@@ -1,2 +1,3 @@
 export declare function registerServerFunction<T extends any[], R>(id: string, callback: (...args: T) => Promise<R>): (...args: T) => Promise<R>;
-export declare function getServerFunction<T extends any[], R>(id: string): ((...args: T) => Promise<R>);
+export declare function hasServerFunction(id: string): boolean;
+export declare function getServerFunction<T extends any[], R>(id: string): (...args: T) => Promise<R>;

package/dist/fns/registration.js

@@ -3,10 +3,13 @@ export function registerServerFunction(id, callback) {
     REGISTRATIONS.set(id, callback);
     return callback;
 }
+export function hasServerFunction(id) {
+    return REGISTRATIONS.has(id);
+}
 export function getServerFunction(id) {
     const fn = REGISTRATIONS.get(id);
     if (fn) {
         return fn;
     }
-    throw new Error('invalid server function: ' + id);
+    throw new Error("invalid server function: " + id);
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@solidjs/start",
-  "version": "2.0.0-beta.7",
+  "version": "2.0.0-beta.8",
   "type": "module",
   "files": [
     "dist",
@@ -66,13 +66,14 @@
     "vitest": "^4.1.0"
   },
   "peerDependencies": {
-    "vite": "^8"
+    "vite": "^8 || ^9"
   },
   "scripts": {
     "build": "pnpm validate-imports && tsc && node scripts/build.js",
     "dev": "tsc --watch",
     "test": "vitest",
     "test:ci": "vitest run",
+    "typecheck": "tsc --noEmit",
     "typecheck:dist": "pnpm build && pnpx @arethetypeswrong/cli --pack . --profile esm-only",
     "validate-imports": "node scripts/validate-imports.js"
   }