@solidjs/start 2.0.0-beta.0 → 2.0.0-beta.10

package/src/config/dev-server.ts

@@ -1,157 +0,0 @@
-import { NodeRequest, sendNodeResponse } from "srvx/node";
-import {
-  type Connect,
-  isRunnableDevEnvironment,
-  type PluginOption,
-  type ViteDevServer,
-} from "vite";
-import { VITE_ENVIRONMENTS } from "./constants.ts";
-
-export function devServer(): Array<PluginOption> {
-  return [
-    {
-      name: "solid-start-dev-server",
-      configurePreviewServer(server) {
-        return () => {
-          server.middlewares.use(async (req, res) => {
-            res.setHeader("content-encoding", "identity");
-            const webReq = new NodeRequest({ req, res });
-            const def: {
-              default: { fetch: (req: Request) => Promise<Response> };
-            } = await import(process.cwd() + "/dist/server/entry-server.js");
-            sendNodeResponse(res, await def.default.fetch(webReq));
-          });
-        };
-      },
-      configureServer(viteDevServer) {
-        (globalThis as any).VITE_DEV_SERVER = viteDevServer;
-        return async () => {
-          if (viteDevServer.config.server.middlewareMode) return;
-
-          const serverEnv = viteDevServer.environments[VITE_ENVIRONMENTS.server];
-
-          if (!serverEnv) throw new Error("Server environment not found");
-          if (
-            // do not check via `isFetchableDevEnvironment` since nitro does implement the `FetchableDevEnvironment` interface but not via inheritance (which this helper checks)
-            "dispatchFetch" in serverEnv
-          )
-            return;
-          // another plugin is controlling the dev server
-          if (!isRunnableDevEnvironment(serverEnv)) {
-            return;
-          }
-
-          globalThis.USING_SOLID_START_DEV_SERVER = true;
-
-          removeHtmlMiddlewares(viteDevServer);
-
-          viteDevServer.middlewares.use(async (req, res) => {
-            if (req.originalUrl) {
-              req.url = req.originalUrl;
-            }
-            const webReq = new NodeRequest({ req, res });
-
-            try {
-              const serverEntry: {
-                default: { fetch: (req: Request) => Promise<Response> };
-              } = await serverEnv.runner.import("./src/entry-server.tsx");
-
-              const webRes = await serverEntry.default.fetch(webReq);
-
-              return sendNodeResponse(res, webRes);
-            } catch (e: unknown) {
-              console.error(e);
-              viteDevServer.ssrFixStacktrace(e as Error);
-
-              if (webReq.headers.get("content-type")?.includes("application/json")) {
-                return sendNodeResponse(
-                  res,
-                  Response.json(
-                    {
-                      status: 500,
-                      error: "Internal Server Error",
-                      message: "An unexpected error occurred. Please try again later.",
-                      timestamp: new Date().toISOString(),
-                    },
-                    {
-                      status: 500,
-                      headers: {
-                        "Content-Type": "application/json",
-                      },
-                    },
-                  ),
-                );
-              }
-
-              return sendNodeResponse(
-                res,
-                new Response(
-                  `
-                    <!DOCTYPE html>
-                    <html lang="en">
-                      <head>
-                        <meta charset="UTF-8" />
-                        <title>Error</title>
-                        <script type="module">
-                          import { ErrorOverlay } from '/@vite/client'
-                          document.body.appendChild(new ErrorOverlay(${JSON.stringify(
-                            prepareError(req, e),
-                          ).replace(/</g, "\\u003c")}))
-                        </script>
-                      </head>
-                      <body>
-                      </body>
-                    </html>
-                  `,
-                  {
-                    status: 500,
-                    headers: { "Content-Type": "text/html" },
-                  },
-                ),
-              );
-            }
-          });
-        };
-      },
-    },
-  ];
-}
-
-/**
- * Removes Vite internal middleware
- *
- * @param server
- */
-function removeHtmlMiddlewares(server: ViteDevServer) {
-  const html_middlewares = [
-    "viteIndexHtmlMiddleware",
-    "vite404Middleware",
-    "viteSpaFallbackMiddleware",
-  ];
-  for (let i = server.middlewares.stack.length - 1; i > 0; i--) {
-    if (
-      html_middlewares.includes(
-        // @ts-expect-error
-        server.middlewares.stack[i].handle.name,
-      )
-    ) {
-      server.middlewares.stack.splice(i, 1);
-    }
-  }
-}
-
-/**
- * Formats error for SSR message in error overlay
- * @param req
- * @param error
- * @returns
- */
-function prepareError(req: Connect.IncomingMessage, error: unknown) {
-  const e = error as Error;
-  return {
-    message: `An error occured while server rendering ${req.url}:\n\n\t${
-      typeof e === "string" ? e : e.message
-    } `,
-    stack: typeof e === "string" ? "" : e.stack,
-  };
-}

package/src/config/env.ts

@@ -1,105 +0,0 @@
-import { loadEnv, type Plugin } from "vite";
-
-const LOADERS = {
-  node: `export default key => process.env[key];`,
-  "cloudflare-workers": `import { env } from 'cloudflare:workers';export default key => env[key];`,
-  "netlify-edge": `export default key => Netlify.env.get(key);`,
-};
-
-export interface EnvPluginOptions {
-  server?: {
-    runtime?: keyof typeof LOADERS | (string & {});
-    load?: (mode: string) => Record<string, string>;
-    prefix?: string;
-  };
-  client?: {
-    load?: (mode: string) => Record<string, string>;
-    prefix?: string;
-  };
-}
-
-const SERVER_ENV = "env:server";
-const CLIENT_ENV = "env:client";
-
-const SERVER_RUNTIME_ENV = `${SERVER_ENV}/runtime`;
-
-const SERVER_RUNTIME_LOADER = `${SERVER_RUNTIME_ENV}/loader`;
-
-const DEFAULT_SERVER_PREFIX = "SERVER_";
-const DEFAULT_CLIENT_PREFIX = "CLIENT_";
-
-const SERVER_ONLY_MODULE = `throw new Error('Attempt to load server-only environment variables in client runtime.');`;
-
-const SERVER_RUNTIME_CODE = `import load from '${SERVER_RUNTIME_LOADER}';
-
-export default new Proxy({}, {
-  get(_, key) {
-    return load(key);
-  },
-})`;
-
-function convertObjectToModule(object: Record<string, string>): string {
-  let result = "";
-  for (const key in object) {
-    result += `export const ${key} = ${JSON.stringify(object[key])};`;
-  }
-  return result;
-}
-
-export function envPlugin(options?: EnvPluginOptions): Plugin {
-  const currentOptions = options ?? {};
-  let env: string;
-  const serverPrefix = currentOptions.server?.prefix ?? DEFAULT_SERVER_PREFIX;
-  const clientPrefix = currentOptions.client?.prefix ?? DEFAULT_CLIENT_PREFIX;
-  const runtime = options?.server?.runtime ?? "node";
-  const runtimeCode = runtime in LOADERS ? LOADERS[runtime as keyof typeof LOADERS] : runtime;
-
-  return {
-    name: "solid-start:env",
-    enforce: "pre",
-    configResolved(config) {
-      env = config.mode !== "production" ? "development" : "production";
-    },
-    resolveId(id) {
-      if (
-        id === SERVER_ENV ||
-        id === CLIENT_ENV ||
-        id === SERVER_RUNTIME_ENV ||
-        id === SERVER_RUNTIME_LOADER
-      ) {
-        return id;
-      }
-      return undefined;
-    },
-    load(id, opts) {
-      if (id === SERVER_ENV) {
-        if (!opts?.ssr) {
-          return SERVER_ONLY_MODULE;
-        }
-        const vars = currentOptions.server?.load
-          ? currentOptions.server.load(env)
-          : loadEnv(env, '.', serverPrefix);
-        return convertObjectToModule(vars);
-      }
-      if (id === CLIENT_ENV) {
-        const vars = currentOptions.client?.load
-          ? currentOptions.client.load(env)
-          : loadEnv(env, '.', clientPrefix);
-        return convertObjectToModule(vars);
-      }
-      if (id === SERVER_RUNTIME_LOADER) {
-        if (!opts?.ssr) {
-          return SERVER_ONLY_MODULE;
-        }
-        return runtimeCode;
-      }
-      if (id === SERVER_RUNTIME_ENV) {
-        if (!opts?.ssr) {
-          return SERVER_ONLY_MODULE;
-        }
-        return SERVER_RUNTIME_CODE;
-      }
-      return undefined;
-    },
-  };
-}

package/src/config/fs-router.ts

@@ -1,162 +0,0 @@
-import type { ExportSpecifier } from "es-module-lexer";
-import {
-  analyzeModule,
-  BaseFileSystemRouter,
-  cleanPath,
-  type FileSystemRouterConfig,
-} from "./fs-routes/router.ts";
-
-export class SolidStartClientFileRouter extends BaseFileSystemRouter {
-  toPath(src: string) {
-    const routePath = cleanPath(src, this.config)
-      // remove the initial slash
-      .slice(1)
-      .replace(/index$/, "")
-      .replace(/\[([^/]+)\]/g, (_, m) => {
-        if (m.length > 3 && m.startsWith("...")) {
-          return `*${m.slice(3)}`;
-        }
-        if (m.length > 2 && m.startsWith("[") && m.endsWith("]")) {
-          return `:${m.slice(1, -1)}?`;
-        }
-        return `:${m}`;
-      });
-
-    return routePath?.length > 0 ? `/${routePath}` : "/";
-  }
-
-  toRoute(src: string) {
-    const path = this.toPath(src);
-
-    if (src.endsWith(".md") || src.endsWith(".mdx")) {
-      return {
-        page: true,
-        $component: {
-          src: src,
-          pick: ["$css"],
-        },
-        $$route: undefined,
-        path,
-        // filePath: src
-      };
-    }
-
-    const [_, exports] = analyzeModule(src);
-    const hasDefault = !!exports.find(e => e.n === "default");
-    const hasRouteConfig = !!exports.find(e => e.n === "route");
-    if (hasDefault) {
-      return {
-        page: true,
-        $component: {
-          src: src,
-          pick: [
-            ...exports.filter(e => e.n === e.ln && e.n !== "route").map(e => e.n),
-            "default",
-            "$css",
-          ],
-        },
-        $$route: hasRouteConfig
-          ? {
-              src: src,
-              pick: ["route"],
-            }
-          : undefined,
-        path,
-        // filePath: src
-      };
-    }
-  }
-}
-
-const HTTP_METHODS = ["HEAD", "GET", "POST", "PUT", "DELETE", "PATCH", "OPTIONS"];
-function createHTTPHandlers(src: string, exports: readonly ExportSpecifier[]) {
-  const handlers: Record<string, any> = {};
-  for (const exp of exports) {
-    if (HTTP_METHODS.includes(exp.n)) {
-      handlers[`$${exp.n}`] = {
-        src: src,
-        pick: [exp.n],
-      };
-      if (exp.n === "GET" && !exports.find(exp => exp.n === "HEAD")) {
-        handlers.$HEAD = {
-          src: src,
-          pick: [exp.n],
-        };
-      }
-    }
-  }
-
-  return handlers;
-}
-
-export class SolidStartServerFileRouter extends BaseFileSystemRouter {
-  declare config: FileSystemRouterConfig & { dataOnly?: boolean };
-
-  constructor(config: FileSystemRouterConfig & { dataOnly?: boolean }) {
-    super(config);
-  }
-
-  toPath(src: string) {
-    const routePath = cleanPath(src, this.config)
-      // remove the initial slash
-      .slice(1)
-      .replace(/index$/, "")
-      .replace(/\[([^/]+)\]/g, (_, m) => {
-        if (m.length > 3 && m.startsWith("...")) {
-          return `*${m.slice(3)}`;
-        }
-        if (m.length > 2 && m.startsWith("[") && m.endsWith("]")) {
-          return `:${m.slice(1, -1)}?`;
-        }
-        return `:${m}`;
-      });
-
-    return routePath?.length > 0 ? `/${routePath}` : "/";
-  }
-
-  toRoute(src: string) {
-    const path = this.toPath(src);
-    if (src.endsWith(".md") || src.endsWith(".mdx")) {
-      return {
-        page: true,
-        $component: {
-          src: src,
-          pick: ["$css"],
-        },
-        $$route: undefined,
-        path,
-      };
-    }
-
-    const [_, exports] = analyzeModule(src);
-    const hasRouteConfig = exports.find(e => e.n === "route");
-    const hasDefault = !!exports.find(e => e.n === "default");
-    const hasAPIRoutes = !!exports.find(exp => HTTP_METHODS.includes(exp.n));
-    if (hasDefault || hasAPIRoutes) {
-      return {
-        page: hasDefault,
-        $component:
-          !this.config.dataOnly && hasDefault
-            ? {
-                src: src,
-                pick: [
-                  ...exports
-                    .filter(e => e.n === e.ln && e.n !== "route" && !HTTP_METHODS.includes(e.n))
-                    .map(e => e.n),
-                  "default",
-                  "$css",
-                ],
-              }
-            : undefined,
-        $$route: hasRouteConfig
-          ? {
-              src: src,
-              pick: ["route"],
-            }
-          : undefined,
-        ...createHTTPHandlers(src, exports),
-        path,
-      };
-    }
-  }
-}

package/src/config/fs-routes/fs-watcher.ts

@@ -1,66 +0,0 @@
-import type { EnvironmentModuleNode, FSWatcher, PluginOption, ViteDevServer } from "vite";
-import { debounce } from "../../utils/debounce.ts";
-import { VITE_ENVIRONMENTS } from "../constants.ts";
-import { moduleId } from "./index.ts";
-import type { BaseFileSystemRouter } from "./router.ts";
-
-function setupWatcher(watcher: FSWatcher, routes: BaseFileSystemRouter): void {
-  watcher.on("unlink", path => routes.removeRoute(path));
-  watcher.on("add", path => routes.addRoute(path));
-  watcher.on("change", path => routes.updateRoute(path));
-}
-
-function createRoutesReloader(
-  server: ViteDevServer,
-  routes: BaseFileSystemRouter,
-  environment: "client" | "ssr",
-) {
-  const devEnv = server.environments[environment]!;
-  if (!devEnv?.moduleGraph) return;
-
-  /**
-   * Debounce catches multiple route changes in a row
-   * Short timeout for inexpensive invalidations
-   */
-  const invalidateModule = debounce((mod: EnvironmentModuleNode) => {
-    devEnv.moduleGraph.invalidateModule(mod);
-  }, 0);
-
-  /**
-   * Long debounce timeout for expensive reloads
-   */
-  const reloadModule = debounce((mod: EnvironmentModuleNode) => {
-    devEnv.reloadModule(mod);
-  }, 200);
-
-  return routes.on("reload", function handleRoutesReload(evt): void {
-    const mod = devEnv.moduleGraph.getModuleById(moduleId)!;
-    if (!mod) {
-      devEnv.hot.send({ type: "full-reload" });
-      return;
-    }
-
-    if (environment === VITE_ENVIRONMENTS.client && evt.detail.type !== "update") {
-      // Client has to be reloaded when routes are added or removed
-      reloadModule(mod);
-    } else {
-      invalidateModule(mod);
-    }
-  });
-}
-
-export const fileSystemWatcher = (
-  routers: Record<"client" | "ssr", BaseFileSystemRouter>,
-): PluginOption => {
-  const plugin: PluginOption = {
-    name: "fs-watcher",
-    async configureServer(server: ViteDevServer) {
-      for (const environment of [VITE_ENVIRONMENTS.server, VITE_ENVIRONMENTS.client]) {
-        const router = routers[environment];
-        setupWatcher(server.watcher, router);
-        createRoutesReloader(server, router, environment);
-      }
-    },
-  };
-  return plugin;
-};

package/src/config/fs-routes/index.ts

@@ -1,136 +0,0 @@
-import { relative } from "node:path";
-import { type PluginOption } from "vite";
-
-import { fileSystemWatcher } from "./fs-watcher.ts";
-import type { BaseFileSystemRouter } from "./router.ts";
-import { treeShake } from "./tree-shake.ts";
-
-export const moduleId = "solid-start:routes";
-
-export interface FsRoutesArgs {
-  routers: Record<"client" | "ssr", BaseFileSystemRouter>;
-}
-
-export function fsRoutes({ routers }: FsRoutesArgs): Array<PluginOption> {
-  (globalThis as any).ROUTERS = routers;
-
-  return [
-    {
-      name: "solid-start-fs-routes",
-      enforce: "pre",
-      resolveId(id) {
-        if (id === moduleId) return id;
-      },
-      async load(id) {
-        const root = this.environment.config.root;
-        const isBuild = this.environment.mode === "build";
-
-        if (id !== moduleId) return;
-        const js = jsCode();
-
-        const router = (globalThis as any).ROUTERS[this.environment.name];
-
-        const routes = await router.getRoutes();
-
-        let routesCode = JSON.stringify(routes ?? [], (k, v) => {
-          if (v === undefined) return undefined;
-
-          if (k.startsWith("$$")) {
-            const buildId = `${v.src}?${v.pick.map((p: any) => `pick=${p}`).join("&")}`;
-
-            /**
-             * @type {{ [key: string]: string }}
-             */
-            const refs: Record<string, string> = {};
-            for (var pick of v.pick) {
-              refs[pick] = js.addNamedImport(pick, buildId);
-            }
-            return {
-              require: `_$() => ({ ${Object.entries(refs)
-                .map(([pick, namedImport]) => `'${pick}': ${namedImport}`)
-                .join(", ")} })$_`,
-              // src: isBuild ? relative(root, buildId) : buildId
-            };
-          } else if (k.startsWith("$")) {
-            const buildId = `${v.src}?${v.pick.map((p: any) => `pick=${p}`).join("&")}`;
-            return {
-              src: relative(root, buildId),
-              build: isBuild ? `_$() => import('${buildId}')$_` : undefined,
-              import: `_$() => import('${buildId}')$_`,
-            };
-          }
-          return v;
-        });
-
-        routesCode = routesCode.replaceAll('"_$(', "(").replaceAll(')$_"', ")");
-
-        const code = `
-${js.getImportStatements()}
-export default ${routesCode}`;
-        return code;
-      },
-    },
-    treeShake(),
-    fileSystemWatcher(routers),
-  ];
-}
-
-function jsCode() {
-  const imports = new Map();
-  let vars = 0;
-
-  function addImport(p: any) {
-    let id = imports.get(p);
-    if (!id) {
-      id = {};
-      imports.set(p, id);
-    }
-
-    const d = "routeData" + vars++;
-    id["default"] = d;
-    return d;
-  }
-
-  function addNamedImport(name: string | number, p: any) {
-    let id = imports.get(p);
-    if (!id) {
-      id = {};
-      imports.set(p, id);
-    }
-
-    const d = "routeData" + vars++;
-    id[name] = d;
-    return d;
-  }
-
-  const getNamedExport = (p: any) => {
-    const id = imports.get(p);
-
-    delete id["default"];
-
-    return Object.keys(id).length > 0
-      ? `{ ${Object.keys(id)
-          .map(k => `${k} as ${id[k]}`)
-          .join(", ")} }`
-      : "";
-  };
-
-  const getImportStatements = () => {
-    return `${[...imports.keys()]
-      .map(
-        i =>
-          `import ${
-            imports.get(i).default
-              ? `${imports.get(i).default}${Object.keys(imports.get(i)).length > 1 ? ", " : ""}`
-              : ""
-          } ${getNamedExport(i)} from '${i}';`,
-      )
-      .join("\n")}`;
-  };
-
-  return {
-    addImport,
-    addNamedImport,
-    getImportStatements,
-  };
-}