move server fns to dismantle

Author: lxsmnsyc

apps/tests/src/entry-server.tsx

@@ -19,3 +19,6 @@ export default createHandler(() => (
     )}
   />
 ));
+
+
+import 'solid-start/fns/preload';

packages/start/package.json

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

packages/start/src/config/index.ts

@@ -1,8 +1,7 @@
-import { TanStackServerFnPlugin } from "@tanstack/server-functions-plugin";
+
 import { defu } from "defu";
 import { globSync } from "node:fs";
 import { extname, isAbsolute, join } from "node:path";
-import { fileURLToPath } from "node:url";
 import { normalizePath, type PluginOption } from "vite";
 import solid, { type Options as SolidOptions } from "vite-plugin-solid";
 
@@ -14,6 +13,7 @@ import type { BaseFileSystemRouter } from "./fs-routes/router.ts";
 import lazy from "./lazy.ts";
 import { manifest } from "./manifest.ts";
 import { parseIdQuery } from "./utils.ts";
+import { serverFunctionsPlugin } from "./server-functions.ts";
 
 export interface SolidStartOptions {
   solid?: Partial<SolidOptions>;
@@ -163,42 +163,9 @@ export function solidStart(options?: SolidStartOptions): Array<PluginOption> {
       },
     }),
     lazy(),
+    serverFunctionsPlugin({}),
     // Must be placed after fsRoutes, as treeShake will remove the
     // server fn exports added in by this plugin
-    TanStackServerFnPlugin({
-      // This is the ID that will be available to look up and import
-      // our server function manifest and resolve its module
-      manifestVirtualImportId: VIRTUAL_MODULES.serverFnManifest,
-      directive: "use server",
-      callers: [
-        {
-          envConsumer: "client",
-          envName: VITE_ENVIRONMENTS.client,
-          getRuntimeCode: () =>
-            `import { createServerReference } from "${normalizePath(
-              fileURLToPath(new URL("../server/server-runtime", import.meta.url))
-            )}"`,
-          replacer: opts => `createServerReference('${opts.functionId}')`,
-        },
-        {
-          envConsumer: "server",
-          envName: VITE_ENVIRONMENTS.server,
-          getRuntimeCode: () =>
-            `import { createServerReference } from '${normalizePath(
-              fileURLToPath(new URL("../server/server-fns-runtime", import.meta.url))
-            )}'`,
-          replacer: opts => `createServerReference(${opts.fn}, '${opts.functionId}')`,
-        },
-      ],
-      provider: {
-        envName: VITE_ENVIRONMENTS.server,
-        getRuntimeCode: () =>
-          `import { createServerReference } from '${normalizePath(
-            fileURLToPath(new URL("../server/server-fns-runtime", import.meta.url))
-          )}'`,
-        replacer: opts => `createServerReference(${opts.fn}, '${opts.functionId}')`,
-      },
-    }),
     {
       name: "solid-start:virtual-modules",
       async resolveId(id) {

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

@@ -0,0 +1,305 @@
+import * as dismantle from "dismantle";
+import { fileURLToPath } from "node:url";
+import {
+  createFilter,
+  normalizePath,
+  type FilterPattern,
+  type Plugin,
+  type ViteDevServer,
+} from "vite";
+
+type CompileOptions = Pick<dismantle.Options, "mode" | "env">;
+
+type CompileOutput = dismantle.Output;
+
+const CLIENT = normalizePath(fileURLToPath(new URL("../fns/client", import.meta.url)));
+const SERVER = normalizePath(fileURLToPath(new URL("../fns/server", import.meta.url)));
+const RUNTIME = normalizePath(fileURLToPath(new URL("../fns/runtime", import.meta.url)));
+
+async function compile(
+  id: string,
+  code: string,
+  options: CompileOptions,
+): Promise<CompileOutput> {
+  return await dismantle.compile(id, code, {
+    runtime: RUNTIME,
+    key: "solid-start",
+    mode: options.mode,
+    env: options.env,
+    definitions: [
+      {
+        type: "function-directive",
+        directive: "use server",
+        pure: true,
+        // Where to instanciate the handlers
+        target: {
+          kind: "named",
+          name: "createServerReference",
+          source:
+            options.mode === "client"
+              ? CLIENT
+              : SERVER,
+        },
+        /**
+         * A resolver for the replaced functions
+         *
+         * dismantle will output something like this:
+         * const foo = handler(async () => {
+         *   const mod = (await import(modulePath)).default;
+         *   return (...args) => {
+         *     // ...
+         *   };
+         * });
+         */
+        handle: {
+          kind: "named",
+          name: "createServerFunction",
+          source:
+            options.mode === "client"
+              ? CLIENT
+              : SERVER,
+        },
+        // isomorphic: true,
+      },
+    ],
+  });
+}
+
+interface ManifestRecord {
+  files: CompileOutput["files"];
+  entries: Set<string>;
+}
+
+type Manifest = Record<CompileOptions["mode"], ManifestRecord>;
+
+function createManifest(): Manifest {
+  return {
+    server: {
+      files: new Map(),
+      entries: new Set(),
+    },
+    client: {
+      files: new Map(),
+      entries: new Set(),
+    },
+  };
+}
+
+function mergeManifestRecord(
+  source: ManifestRecord,
+  target: ManifestRecord,
+): { invalidePreload: boolean; invalidated: string[] } {
+  const invalidated: string[] = [];
+  for (const [file, content] of target.files) {
+    if (source.files.has(file)) {
+      invalidated.push(file);
+    }
+    source.files.set(file, content);
+  }
+
+  const current = source.entries.size;
+  for (const entry of target.entries) {
+    source.entries.add(entry);
+  }
+  return {
+    invalidePreload: current !== source.entries.size,
+    invalidated,
+  };
+}
+
+export interface ServerFunctionsFilter {
+  include?: FilterPattern;
+  exclude?: FilterPattern;
+}
+
+export interface ServerFunctionsOptions {
+  filter?: ServerFunctionsFilter;
+}
+
+const DEFAULT_INCLUDE = "src/**/*.{jsx,tsx,ts,js,mjs,cjs}";
+const DEFAULT_EXCLUDE = "node_modules/**/*.{jsx,tsx,ts,js,mjs,cjs}";
+
+const VIRTUAL_MODULE = "solid-start/fns/preload";
+
+interface DeferredPromise<T> {
+  reference: Promise<T>;
+  resolve: (value: T) => void;
+  reject: (value: any) => void;
+}
+
+function createDeferredPromise<T>(): DeferredPromise<T> {
+  let resolve: DeferredPromise<T>["resolve"];
+  let reject: DeferredPromise<T>["reject"];
+
+  return {
+    reference: new Promise((res, rej) => {
+      resolve = res;
+      reject = rej;
+    }),
+    resolve(value) {
+      resolve(value);
+    },
+    reject(value) {
+      reject(value);
+    },
+  };
+}
+
+class Debouncer<T> {
+  promise: DeferredPromise<T>;
+
+  private timeout: ReturnType<typeof setTimeout> | undefined;
+
+  constructor(private source: () => T) {
+    this.promise = createDeferredPromise();
+    this.defer();
+  }
+
+  defer(): void {
+    if (this.timeout) {
+      clearTimeout(this.timeout);
+      this.timeout = undefined;
+    }
+    this.timeout = setTimeout(() => {
+      this.promise.resolve(this.source());
+    }, 1000);
+  }
+}
+
+function invalidateModules(
+  server: ViteDevServer | undefined,
+  result: ReturnType<typeof mergeManifestRecord>,
+): void {
+  if (server) {
+    for (let i = 0, len = result.invalidated.length; i < len; i++) {
+      const invalidated = result.invalidated[i];
+      if (invalidated) {
+        const target = server.moduleGraph.getModuleById(invalidated);
+        if (target) {
+          server.moduleGraph.invalidateModule(target);
+        }
+      }
+    }
+    if (result.invalidePreload) {
+      const target = server.moduleGraph.getModuleById(VIRTUAL_MODULE);
+      if (target) {
+        server.moduleGraph.invalidateModule(target);
+      }
+    }
+  }
+}
+
+export function serverFunctionsPlugin(
+  options: ServerFunctionsOptions,
+): Plugin[] {
+  const filter = createFilter(
+    options.filter?.include || DEFAULT_INCLUDE,
+    options.filter?.exclude || DEFAULT_EXCLUDE,
+  );
+
+  let env: CompileOptions["env"];
+
+  const manifest = createManifest();
+
+  const preload: Record<
+    CompileOptions["mode"],
+    Debouncer<string> | undefined
+  > = {
+    server: undefined,
+    client: undefined,
+  };
+
+  let currentServer: ViteDevServer;
+
+  return [
+    {
+      name: "solid-start:server-functions/setup",
+      enforce: "pre",
+      configResolved(config) {
+        env = config.mode !== "production" ? "development" : "production";
+      },
+      configureServer(server) {
+        currentServer = server;
+      },
+    },
+    {
+      name: "solid-start:server-functions/preload",
+      enforce: "pre",
+      resolveId(source) {
+        if (source === VIRTUAL_MODULE) {
+          return { id: VIRTUAL_MODULE, moduleSideEffects: true };
+        }
+        return null;
+      },
+      load(id, opts) {
+        const mode = opts?.ssr ? 'server' : 'client';
+        if (id === VIRTUAL_MODULE) {
+          const current = new Debouncer(() =>
+            [...manifest[mode].entries]
+              .map(entry => `import "${entry}";`)
+              .join('\n'),
+          );
+          preload[mode] = current;
+          return current.promise.reference;
+        }
+        return null;
+      },
+    },
+    {
+      name: "solid-start:server-functions/virtuals",
+      enforce: "pre",
+      async resolveId(source, importer, opts) {
+        if (importer) {
+          const result = await this.resolve(source, importer, opts);
+          const mode = opts?.ssr ? 'server' : 'client';
+          if (result && manifest[mode].files.has(result.id)) {
+            return result;
+          }
+        }
+        return null;
+      },
+      load(id, opts) {
+        const mode = opts?.ssr ? 'server' : 'client';
+        const result = manifest[mode].files.get(id);
+        if (result) {
+          return {
+            code: result.code || '',
+            map: result.map,
+          };
+        }
+        return null;
+      },
+    },
+    {
+      name: "solid-start:server-functions/compiler",
+      async transform(code, id, opts) {
+        const mode = opts?.ssr ? 'server' : 'client';
+        if (!filter(id)) {
+          return null;
+        }
+        const preloader = preload[mode];
+        if (preloader) {
+          preloader.defer();
+        }
+        const result = await compile(id, code, {
+          ...options,
+          mode,
+          env,
+        });
+
+        invalidateModules(
+          currentServer,
+          mergeManifestRecord(manifest[mode], {
+            files: result.files,
+            entries: new Set(result.entries),
+          }),
+        );
+
+        return {
+          code: result.code || '',
+          map: result.map,
+        };
+      },
+    },
+  ];
+}