@solidjs/start 2.0.0-beta.1 → 2.0.0-beta.2

package/src/server/handler.ts

@@ -1,261 +0,0 @@
-import middleware from "solid-start:middleware";
-import { defineHandler, getCookie, H3, type H3Event, redirect, setCookie } from "h3/generic";
-import { join } from "pathe";
-import type { JSX } from "solid-js";
-import { sharedConfig } from "solid-js";
-import { getRequestEvent, renderToStream, renderToString } from "solid-js/web";
-
-import { createRoutes } from "../router.tsx";
-import { decorateHandler, decorateMiddleware } from "./fetchEvent.ts";
-import { getSsrManifest } from "./manifest/ssr-manifest.ts";
-import { matchAPIRoute } from "./routes.ts";
-import { handleServerFunction } from "../fns/handler.ts";
-import type { APIEvent, FetchEvent, HandlerOptions, PageEvent } from "./types.ts";
-import { getExpectedRedirectStatus } from "./util.ts";
-
-const SERVER_FN_BASE = "/_server";
-
-export function createBaseHandler(
-  createPageEvent: (e: FetchEvent) => Promise<PageEvent>,
-  fn: (context: PageEvent) => JSX.Element,
-  options: HandlerOptions | ((context: PageEvent) => HandlerOptions | Promise<HandlerOptions>) = {},
-) {
-  const handler = defineHandler({
-    middleware: middleware.length ? middleware.map(decorateMiddleware) : undefined,
-    handler: decorateHandler(async (e: H3Event) => {
-      const event = getRequestEvent()!;
-      const url = new URL(event.request.url);
-      const pathname = stripBaseUrl(url.pathname);
-
-      if (pathname.startsWith(SERVER_FN_BASE)) {
-        const serverFnResponse = await handleServerFunction(e);
-
-        if (serverFnResponse instanceof Response)
-          return produceResponseWithEventHeaders(serverFnResponse);
-
-        return new Response(serverFnResponse as any, {
-          headers: e.res.headers,
-        });
-      }
-
-      const match = matchAPIRoute(pathname, event.request.method);
-      if (match) {
-        const mod = await match.handler.import();
-        const fn =
-          event.request.method === "HEAD" ? mod["HEAD"] || mod["GET"] : mod[event.request.method];
-        if (typeof fn === "function") {
-          (event as APIEvent).params = match.params || {};
-          // @ts-expect-error
-          sharedConfig.context = { event };
-          const res = await fn(event);
-          if (res !== undefined) {
-            if (res instanceof Response) return produceResponseWithEventHeaders(res);
-
-            return res;
-          }
-          if (event.request.method !== "GET") {
-            throw new Error(
-              `API handler for ${event.request.method} "${event.request.url}" did not return a response.`,
-            );
-          }
-          if (!match.isPage) return;
-        }
-      }
-
-      const context = await createPageEvent(event);
-
-      const resolvedOptions =
-        typeof options === "function" ? await options(context) : { ...options };
-      const mode = resolvedOptions.mode || "stream";
-      if (resolvedOptions.nonce) context.nonce = resolvedOptions.nonce;
-
-      if (mode === "sync" || !import.meta.env.START_SSR) {
-        const html = renderToString(() => {
-          (sharedConfig.context as any).event = context;
-          return fn(context);
-        }, resolvedOptions);
-        context.complete = true;
-
-        if (context.response && context.response.headers.get("Location")) {
-          const status = getExpectedRedirectStatus(context.response);
-          return redirect(context.response.headers.get("Location")!, status);
-        }
-
-        event.response.headers.set("content-type", "text/html");
-
-        return html;
-      }
-
-      if (resolvedOptions.onCompleteAll) {
-        const og = resolvedOptions.onCompleteAll;
-        resolvedOptions.onCompleteAll = options => {
-          handleStreamCompleteRedirect(context)(options);
-          og(options);
-        };
-      } else resolvedOptions.onCompleteAll = handleStreamCompleteRedirect(context);
-      if (resolvedOptions.onCompleteShell) {
-        const og = resolvedOptions.onCompleteShell;
-        resolvedOptions.onCompleteShell = options => {
-          handleShellCompleteRedirect(context, e)();
-          og(options);
-        };
-      } else resolvedOptions.onCompleteShell = handleShellCompleteRedirect(context, e);
-
-      const _stream = renderToStream(() => {
-        (sharedConfig.context as any).event = context;
-        return fn(context);
-      }, resolvedOptions);
-      const stream = _stream as typeof _stream & PromiseLike<string>; // stream has a hidden 'then' method
-
-      if (context.response && context.response.headers.get("Location")) {
-        const status = getExpectedRedirectStatus(context.response);
-        return redirect(context.response.headers.get("Location")!, status);
-      }
-
-      if (mode === "async") return await stream;
-
-      delete (stream as any).then;
-
-      // using TransformStream in dev can cause solid-start-dev-server to crash
-      // when stream is cancelled
-      if (globalThis.USING_SOLID_START_DEV_SERVER) return stream;
-
-      // returning stream directly breaks cloudflare workers
-      const { writable, readable } = new TransformStream();
-      stream.pipeTo(writable);
-      return readable;
-    }),
-  });
-
-  const app = new H3();
-
-  app.use(handler);
-
-  return app;
-}
-
-export function createHandler(
-  fn: (context: PageEvent) => JSX.Element,
-  options: HandlerOptions | ((context: PageEvent) => HandlerOptions | Promise<HandlerOptions>) = {},
-) {
-  return createBaseHandler(createPageEvent, fn, options);
-}
-
-export async function createPageEvent(ctx: FetchEvent) {
-  ctx.response.headers.set("Content-Type", "text/html");
-  // const prevPath = ctx.request.headers.get("x-solid-referrer");
-  // const mutation = ctx.request.headers.get("x-solid-mutation") === "true";
-  const manifest = getSsrManifest(import.meta.env.SSR && import.meta.env.DEV ? "ssr" : "client");
-
-  // Handle Vite build.cssCodeSplit
-  // When build.cssCodeSplit is false, a single CSS file is generated with the key style.css
-  const mergedCSS = import.meta.env.PROD ? await manifest.getAssets("style.css") : [];
-
-  const assets = [
-    ...mergedCSS,
-    ...(await manifest.getAssets(import.meta.env.START_CLIENT_ENTRY)),
-    ...(await manifest.getAssets(import.meta.env.START_APP_ENTRY)),
-    // ...(import.meta.env.START_ISLANDS
-    //   ? (await serverManifest.inputs[serverManifest.handler]!.assets()).filter(
-    //       s => (s as any).attrs.rel !== "modulepreload"
-    //     )
-    //   : [])
-  ];
-  const pageEvent: PageEvent = Object.assign(ctx, {
-    assets,
-    router: {
-      submission: initFromFlash(ctx) as any,
-    },
-    routes: createRoutes(),
-    // prevUrl: prevPath || "",
-    // mutation: mutation,
-    // $type: FETCH_EVENT,
-    complete: false,
-    $islands: new Set<string>(),
-  });
-
-  return pageEvent;
-}
-
-function initFromFlash(ctx: FetchEvent) {
-  const flash = getCookie(ctx.nativeEvent, "flash");
-  if (!flash) return;
-  try {
-    const param = JSON.parse(flash);
-    if (!param || !param.result) return;
-    const input = [...param.input.slice(0, -1), new Map(param.input[param.input.length - 1])];
-    const result = param.error ? new Error(param.result) : param.result;
-    return {
-      input,
-      url: param.url,
-      pending: false,
-      result: param.thrown ? undefined : result,
-      error: param.thrown ? result : undefined,
-    };
-  } catch (e) {
-    console.error(e);
-  } finally {
-    setCookie(ctx.nativeEvent, "flash", "", { maxAge: 0 });
-  }
-}
-
-function handleShellCompleteRedirect(context: PageEvent, e: H3Event) {
-  return () => {
-    if (context.response && context.response.headers.get("Location")) {
-      const status = getExpectedRedirectStatus(context.response);
-      e.res.status = status;
-      e.res.headers.set("Location", context.response.headers.get("Location")!);
-    }
-  };
-}
-
-function handleStreamCompleteRedirect(context: PageEvent) {
-  return ({ write }: { write: (html: string) => void }) => {
-    context.complete = true;
-    const to = context.response && context.response.headers.get("Location");
-    to && write(`<script>window.location=${JSON.stringify(to).replace(/</g, "\\u003c")}</script>`);
-  };
-}
-
-function produceResponseWithEventHeaders(res: Response) {
-  const event = getRequestEvent()!;
-
-  let ret = res;
-
-  // Response.redirect returns an immutable value, so we clone on any redirect just in case
-  if (300 <= res.status && res.status < 400) {
-    const cookies = res.headers.getSetCookie?.() ?? [];
-    const headers = new Headers();
-    res.headers.forEach((value, key) => {
-      if (key.toLowerCase() !== "set-cookie") {
-        headers.set(key, value);
-      }
-    });
-    for (const cookie of cookies) {
-      headers.append("Set-Cookie", cookie);
-    }
-    ret = new Response(res.body, {
-      status: res.status,
-      statusText: res.statusText,
-      headers,
-    });
-  }
-
-  const eventCookies = event.response.headers.getSetCookie?.() ?? [];
-  for (const cookie of eventCookies) {
-    ret.headers.append("Set-Cookie", cookie);
-  }
-
-  for (const [name, value] of event.response.headers) {
-    if (name.toLowerCase() !== "set-cookie") {
-      ret.headers.set(name, value);
-    }
-  }
-
-  return ret;
-}
-
-function stripBaseUrl(path: string) {
-  if (import.meta.env.BASE_URL === "/" || import.meta.env.BASE_URL === "") return path;
-  return path.slice(import.meta.env.BASE_URL.length);
-}

package/src/server/manifest/client-manifest.ts

@@ -1,8 +0,0 @@
-import { getClientDevManifest } from "./dev-client-manifest.ts";
-import { getClientProdManifest } from "./prod-client-manifest.ts";
-
-export function getClientManifest() {
-  return import.meta.env.DEV ? getClientDevManifest() : getClientProdManifest();
-}
-
-export { getClientManifest as getManifest };

package/src/server/manifest/dev-client-manifest.ts

@@ -1,21 +0,0 @@
-import { join } from "pathe";
-
-export function getClientDevManifest() {
-  return {
-    import(id) {
-      return import(/* @vite-ignore */ join("/", id));
-    },
-    async getAssets(id) {
-      const assetsPath = `/@manifest/client/${Date.now()}/assets?id=${id}`;
-
-      const assets = (await import(/* @vite-ignore */ assetsPath)).default;
-
-      return await Promise.all(
-        assets.map(async (v: any) => ({
-          ...v,
-          children: await v.children(),
-        })),
-      );
-    },
-  } satisfies StartManifest & { import(id: string): Promise<any> };
-}

package/src/server/manifest/dev-ssr-manifest.ts

@@ -1,23 +0,0 @@
-import { join, normalize } from "pathe";
-
-export function getSsrDevManifest(environment: "client" | "ssr") {
-  return {
-    path: (id: string) => normalize(join(import.meta.env.BASE_URL, id)),
-    async getAssets(id) {
-      const assetsPath = `/@manifest/${environment}/${Date.now()}/assets?id=${id}`;
-
-      const assets = (await import(/* @vite-ignore */ assetsPath)).default;
-
-      return await Promise.all(
-        assets.map(async (v: any) => ({
-          ...v,
-          children: await v.children(),
-        })),
-      );
-    },
-  } satisfies StartManifest & {
-    path(id: string): string;
-  };
-}
-
-export { getSsrDevManifest as getSsrManifest };

package/src/server/manifest/prod-client-manifest.ts

@@ -1,21 +0,0 @@
-export function getClientProdManifest() {
-  return {
-    import(id) {
-      // @ts-ignore
-      return import(/* @vite-ignore */ window.manifest[id].output);
-    },
-    async getAssets(id) {
-      if (id.startsWith("./")) id = id.slice(2);
-
-      // @ts-ignore
-      return window.manifest[id]?.assets ?? [];
-    },
-    async json() {
-      // @ts-ignore
-      return window.manifest;
-    },
-  } satisfies StartManifest & {
-    json(): Promise<Record<string, any>>;
-    import(id: string): Promise<any>;
-  };
-}

package/src/server/manifest/prod-ssr-manifest.ts

@@ -1,109 +0,0 @@
-import { clientViteManifest } from "solid-start:client-vite-manifest";
-import { join } from "pathe";
-import { Manifest } from "vite";
-import type { Asset } from "../assets/render.tsx";
-
-// Only reads from client manifest atm, might need server support for islands
-export function getSsrProdManifest() {
-  const viteManifest = clientViteManifest;
-  return {
-    path(id: string) {
-      if (id.startsWith("./")) id = id.slice(2);
-
-      const viteManifestEntry = clientViteManifest[id /*import.meta.env.START_CLIENT_ENTRY*/];
-      if (!viteManifestEntry) throw new Error(`No entry found in vite manifest for '${id}'`);
-
-      return join("/", viteManifestEntry.file);
-    },
-    async getAssets(id) {
-      if (id.startsWith("./")) id = id.slice(2);
-
-      return createHtmlTagsForAssets(findAssetsInViteManifest(clientViteManifest, id));
-    },
-    async json() {
-      const json: Record<string, any> = {};
-
-      const entryKeys = Object.keys(viteManifest)
-        .filter(id => viteManifest[id]?.isEntry || viteManifest[id]?.isDynamicEntry)
-        .map(id => id);
-
-      for (const entryKey of entryKeys) {
-        json[entryKey] = {
-          output: join("/", viteManifest[entryKey]!.file),
-          assets: await this.getAssets(entryKey),
-        };
-      }
-
-      return json;
-    },
-  } satisfies StartManifest & {
-    json(): Promise<Record<string, any>>;
-    path(id: string): string;
-  };
-}
-
-function createHtmlTagsForAssets(assets: string[]) {
-  return assets
-    .filter(
-      asset =>
-        asset.endsWith(".css") ||
-        asset.endsWith(".js") ||
-        asset.endsWith(".ts") ||
-        asset.endsWith(".mjs"),
-    )
-    .map<Asset>(asset => ({
-      tag: "link",
-      attrs: {
-        href: "/" + asset,
-        key: asset,
-        ...(asset.endsWith(".css") ? { rel: "stylesheet" } : { rel: "modulepreload" }),
-      },
-    }));
-}
-
-const entryId = import.meta.env.START_CLIENT_ENTRY.slice(2);
-let entryImports: string[] | undefined = undefined;
-
-function findAssetsInViteManifest(
-  manifest: Manifest,
-  id: string,
-  assetMap = new Map(),
-  stack: string[] = [],
-) {
-  if (stack.includes(id)) {
-    return [];
-  }
-
-  const cached = assetMap.get(id);
-  if (cached) {
-    return cached;
-  }
-  const chunk = manifest[id];
-  if (!chunk) {
-    return [];
-  }
-
-  if (!entryImports) {
-    entryImports = [entryId, ...(manifest[entryId]?.imports ?? [])];
-  }
-
-  // Only include entry imports, if we are specifically crawling the entry
-  // Chunks (e.g. routes) that import something from entry, should not render entry css redundantly
-  const excludeEntryImports = id !== entryId;
-
-  const assets = chunk.css?.filter(Boolean) || [];
-  if (chunk.imports) {
-    stack.push(id);
-    for (let i = 0, l = chunk.imports.length; i < l; i++) {
-      const importId = chunk.imports[i];
-      if (!importId || (excludeEntryImports && entryImports.includes(importId))) continue;
-      assets.push(...findAssetsInViteManifest(manifest, importId, assetMap, stack));
-    }
-    stack.pop();
-  }
-  assets.push(chunk.file);
-  const all = Array.from(new Set(assets));
-  assetMap.set(id, all);
-
-  return all;
-}

package/src/server/manifest/ssr-manifest.ts

@@ -1,10 +0,0 @@
-import { getSsrDevManifest } from "./dev-ssr-manifest.ts";
-import { getSsrProdManifest } from "./prod-ssr-manifest.ts";
-
-export function getSsrManifest(
-  target: "client" | "ssr",
-): ReturnType<typeof getSsrDevManifest> | ReturnType<typeof getSsrProdManifest> {
-  return import.meta.env.DEV ? getSsrDevManifest(target) : getSsrProdManifest();
-}
-
-export { getSsrManifest as getManifest };

package/src/server/routes.ts

@@ -1,126 +0,0 @@
-// @ts-expect-error
-import fileRoutes from "solid-start:routes";
-import { createRouter } from "radix3";
-
-import type { FetchEvent } from "./types.ts";
-
-interface Route {
-  path: string;
-  id: string;
-  children?: Route[];
-  page?: boolean;
-  $component?: any;
-  $HEAD?: any;
-  $GET?: any;
-  $POST?: any;
-  $PUT?: any;
-  $PATCH?: any;
-  $DELETE?: any;
-}
-
-export const pageRoutes = defineRoutes((fileRoutes as unknown as Route[]).filter(o => o.page));
-
-function defineRoutes(fileRoutes: Route[]) {
-  function processRoute(routes: Route[], route: Route, id: string, full: string) {
-    const parentRoute = Object.values(routes).find(o => {
-      return id.startsWith(o.id + "/");
-    });
-
-    if (!parentRoute) {
-      routes.push({
-        ...route,
-        id,
-        path: id.replace(/\([^)/]+\)/g, "").replace(/\/+/g, "/"),
-      });
-      return routes;
-    }
-    processRoute(
-      parentRoute.children || (parentRoute.children = []),
-      route,
-      id.slice(parentRoute.id.length),
-      full,
-    );
-
-    return routes;
-  }
-
-  return fileRoutes
-    .sort((a, b) => a.path.length - b.path.length)
-    .reduce((prevRoutes: Route[], route) => {
-      return processRoute(prevRoutes, route, route.path, route.path);
-    }, []);
-}
-
-const router = createRouter({
-  routes: (fileRoutes as unknown as Route[]).reduce(
-    (memo, route) => {
-      if (!containsHTTP(route)) return memo;
-      const path = route.path
-        .replace(/\([^)/]+\)/g, "")
-        .replace(/\/+/g, "/")
-        .replace(/\*([^/]*)/g, (_, m) => `**:${m}`)
-        .split("/")
-        .map(s => (s.startsWith(":") || s.startsWith("*") ? s : encodeURIComponent(s)))
-        .join("/");
-      if (/:[^/]*\?/g.test(path)) {
-        throw new Error(`Optional parameters are not supported in API routes: ${path}`);
-      }
-      if (memo[path]) {
-        throw new Error(
-          `Duplicate API routes for "${path}" found at "${memo[path]!.route.path}" and "${
-            route.path
-          }"`,
-        );
-      }
-      memo[path] = { route };
-      return memo;
-    },
-    {} as Record<string, { route: Route }>,
-  ),
-});
-
-function containsHTTP(route: Route) {
-  return (
-    route["$HEAD"] ||
-    route["$GET"] ||
-    route["$POST"] ||
-    route["$PUT"] ||
-    route["$PATCH"] ||
-    route["$DELETE"]
-  );
-}
-
-export function matchAPIRoute(
-  path: string,
-  method: string,
-):
-  | {
-      params?: Record<string, any>;
-      handler: {
-        import: () => Promise<Record<string, (e: FetchEvent) => Promise<any>>>;
-      };
-      isPage: boolean;
-    }
-  | undefined {
-  const match = router.lookup(path);
-  if (match && match.route) {
-    const route = match.route;
-
-    // Find the appropriate handler for the HTTP method
-    const handler = method === "HEAD" ? route.$HEAD || route.$GET : route[`$${method}`];
-
-    if (handler === undefined) return;
-
-    // Check if this is a page route
-    const isPage = route.page === true && route.$component !== undefined;
-
-    // Return comprehensive route information
-    return {
-      handler,
-      params: match.params,
-      isPage,
-    };
-  }
-
-  return undefined;
-}

package/src/server/spa/StartServer.tsx

@@ -1,42 +0,0 @@
-// @refresh skip
-// @ts-ignore
-import type { Component } from "solid-js";
-import { NoHydration, getRequestEvent, ssr } from "solid-js/web";
-import { getSsrManifest } from "../manifest/ssr-manifest.ts";
-
-import { TopErrorBoundary } from "../../shared/ErrorBoundary.tsx";
-import { useAssets } from "../assets/index.ts";
-import PatchVirtualDevStyles from "../assets/PatchVirtualDevStyles.tsx";
-import type { DocumentComponentProps, PageEvent } from "../types.ts";
-
-const docType = ssr("<!DOCTYPE html>");
-
-/**
- *
- * Read more: https://docs.solidjs.com/solid-start/reference/server/start-server
- */
-export function StartServer(props: { document: Component<DocumentComponentProps> }) {
-  const context = getRequestEvent() as PageEvent;
-  // @ts-ignore
-  const nonce = context.nonce;
-  useAssets(context.assets, nonce);
-
-  return (
-    <NoHydration>
-      {docType as unknown as any}
-      <TopErrorBoundary>
-        <props.document
-          scripts={
-            <>
-              <PatchVirtualDevStyles nonce={nonce} />
-              <script
-                type="module"
-                src={getSsrManifest("client").path(import.meta.env.START_CLIENT_ENTRY)}
-              />
-            </>
-          }
-        />
-      </TopErrorBoundary>
-    </NoHydration>
-  );
-}

package/src/server/spa/handler.ts

@@ -1,29 +0,0 @@
-import type { JSX } from "solid-js";
-
-import { createBaseHandler } from "../handler.ts";
-import { getSsrManifest } from "../manifest/ssr-manifest.ts";
-import type { FetchEvent, HandlerOptions, PageEvent } from "../types.ts";
-
-/**
- *
- * Read more: https://docs.solidjs.com/solid-start/reference/server/create-handler
- */
-export function createHandler(
-  fn: (context: PageEvent) => JSX.Element,
-  options?: HandlerOptions | ((context: PageEvent) => HandlerOptions),
-) {
-  return createBaseHandler(createPageEvent, fn, options);
-}
-
-async function createPageEvent(ctx: FetchEvent) {
-  const manifest = getSsrManifest("ssr");
-  const pageEvent: PageEvent = Object.assign(ctx, {
-    manifest: "json" in manifest ? await manifest.json() : {},
-    assets: await manifest.getAssets(import.meta.env.START_CLIENT_ENTRY),
-    routes: [],
-    complete: false,
-    $islands: new Set<string>(),
-  });
-
-  return pageEvent;
-}