Fix server function handler

Author: lxsmnsyc

packages/start/package.json

@@ -41,7 +41,7 @@
     "@babel/traverse": "^7.28.3",
     "@babel/types": "^7.28.5",
     "@solidjs/meta": "^0.29.4",
-    "dismantle": "^0.6.0",
+    "dismantle": "^0.6.1",
     "@types/babel__traverse": "^7.28.0",
     "@types/micromatch": "^4.0.9",
     "cookie-es": "^2.0.0",

packages/start/src/config/server-functions.ts

@@ -231,7 +231,7 @@ export function serverFunctionsPlugin(
         }
         return null;
       },
-      load(id, opts) {
+      async load(id, opts) {
         const mode = opts?.ssr ? 'server' : 'client';
         if (id === VIRTUAL_MODULE) {
           const current = new Debouncer(() =>
@@ -240,7 +240,8 @@ export function serverFunctionsPlugin(
               .join('\n'),
           );
           preload[mode] = current;
-          return current.promise.reference;
+          const result = await current.promise.reference;
+          return result;
         }
         return null;
       },
@@ -278,24 +279,37 @@ export function serverFunctionsPlugin(
         if (!filter(id)) {
           return null;
         }
-        const preloader = preload[mode];
-        if (preloader) {
-          preloader.defer();
+        const clientPreloader = preload[mode];
+        if (clientPreloader) {
+          clientPreloader.defer();
         }
-        const result = await compile(id, code, {
+        const clientResult = await compile(id!, code, {
           ...options,
-          mode,
+          mode: 'client',
+          env,
+        });
+        invalidateModules(
+          currentServer,
+          mergeManifestRecord(manifest.client, {
+            files: clientResult.files,
+            entries: new Set(clientResult.entries),
+          }),
+        );
+        const serverResult = await compile(id!, code, {
+          ...options,
+          mode: 'server',
           env,
         });
-
         invalidateModules(
           currentServer,
-          mergeManifestRecord(manifest[mode], {
-            files: result.files,
-            entries: new Set(result.entries),
+          mergeManifestRecord(manifest.server, {
+            files: serverResult.files,
+            entries: new Set(serverResult.entries),
           }),
         );
 
+        const result = opts?.ssr ? serverResult : clientResult;
+
         return {
           code: result.code || '',
           map: result.map,

packages/start/src/fns/server.ts

@@ -2,47 +2,53 @@ import { getRequestEvent } from "solid-js/web";
 import { provideRequestEvent } from "solid-js/web/storage";
 import { registerServerFunction } from "./manifest.ts";
 
+function enhanceServerFunction<T extends any[], R>(
+  id: string,
+  fn: (...args: T) => Promise<R>,
+) {
+  let baseURL = import.meta.env.BASE_URL ?? "/";
+  if (!baseURL.endsWith("/")) baseURL += "/";
+
+  return new Proxy(fn, {
+    get(target, prop, receiver) {
+      if (prop === "url") {
+        return `${baseURL}_server?id=${encodeURIComponent(id)}`;
+      }
+      if (prop === "GET") return receiver;
+      return (target as any)[prop];
+    },
+    apply(target, thisArg, args: T) {
+      const ogEvt = getRequestEvent();
+      if (!ogEvt)
+        throw new Error("Cannot call server function outside of a request");
+      const evt = { ...ogEvt };
+      evt.locals.serverFunctionMeta = {
+        id,
+      };
+      evt.serverOnly = true;
+      return provideRequestEvent(evt, () => {
+        return fn.apply(thisArg, args);
+      });
+    },
+  });
+}
+
 export function createServerReference<T extends any[], R>(
   id: string,
   fn: (...args: T) => Promise<R>,
 ) {
   let baseURL = import.meta.env.BASE_URL ?? "/";
   if (!baseURL.endsWith("/")) baseURL += "/";
 
-  return registerServerFunction(
-    id,
-    new Proxy(fn, {
-      get(target, prop, receiver) {
-        if (prop === "url") {
-          return `${baseURL}_server?id=${encodeURIComponent(id)}`;
-        }
-        if (prop === "GET") return receiver;
-        return (target as any)[prop];
-      },
-      apply(target, thisArg, args: T) {
-        const ogEvt = getRequestEvent();
-        if (!ogEvt)
-          throw new Error("Cannot call server function outside of a request");
-        const evt = { ...ogEvt };
-        evt.locals.serverFunctionMeta = {
-          id,
-        };
-        evt.serverOnly = true;
-        return provideRequestEvent(evt, () => {
-          return fn.apply(thisArg, args);
-        });
-      },
-    }),
-  );
+  return registerServerFunction(id, enhanceServerFunction(id, fn));
 }
 
 export function createServerFunction<T extends any[], R>(
   id: string,
   fn: () => Promise<(...args: T) => Promise<R>>,
 ) {
-  let instance: (...args: T) => Promise<R>;
-  return createServerReference(id, async (...args: T) => {
-    instance = instance || (await fn());
-    return instance(...args);
+  let instance = fn();
+  return enhanceServerFunction(id, async (...args: T) => {
+    return (await instance)(...args);
   });
 }