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

package/src/fns/client.ts

@@ -1,141 +0,0 @@
-import { type Component } from "solid-js";
-import {
-  // serializeToJSONStream,
-  serializeToJSONString,
-} from "./serialization.ts";
-import {
-  BODY_FORMAT_KEY,
-  BodyFormat,
-  extractBody,
-  getHeadersAndBody,
-} from "./shared.ts";
-
-let INSTANCE = 0;
-
-function createRequest(base: string, id: string, instance: string, options: RequestInit) {
-  return fetch(base, {
-    method: "POST",
-    ...options,
-    headers: {
-      ...options.headers,
-      "X-Server-Id": id,
-      "X-Server-Instance": instance,
-    },
-  });
-}
-
-async function initializeResponse(
-  base: string,
-  id: string,
-  instance: string,
-  options: RequestInit,
-  args: any[],
-) {
-  // No args, skip serialization
-  if (args.length === 0) {
-    return createRequest(base, id, instance, options);
-  }
-  // For single arguments, we can directly encode as body
-  if (args.length === 1) {
-    const body = args[0];
-    const result = getHeadersAndBody(body);
-    if (result) {
-      return createRequest(base, id, instance, {
-        ...options,
-        body: result.body,
-        headers: {
-          ...options.headers,
-          ...result.headers,
-        },
-      });
-    }
-  }
-  // Fallback to seroval
-  return createRequest(base, id, instance, {
-    ...options,
-    // TODO(Alexis): move to serializeToJSONStream
-    body: await serializeToJSONString(args),
-    // duplex: 'half',
-    // body: serializeToJSONStream(args),
-    headers: {
-      ...options.headers,
-      "Content-Type": "text/plain",
-      [BODY_FORMAT_KEY]: BodyFormat.Seroval,
-    },
-  });
-}
-
-async function fetchServerFunction(
-  base: string,
-  id: string,
-  options: Omit<RequestInit, "body">,
-  args: any[],
-) {
-  const instance = `server-fn:${INSTANCE++}`;
-
-  const response = await initializeResponse(base, id, instance, options, args);
-
-  if (
-    response.headers.has("Location") ||
-    response.headers.has("X-Revalidate") ||
-    response.headers.has("X-Single-Flight")
-  ) {
-    if (response.body) {
-      /* @ts-ignore-next-line */
-      response.customBody = async () => {
-        return await extractBody(instance, true, response.clone());
-      };
-    }
-    return response;
-  }
-
-  const result = await extractBody(instance, true, response.clone());
-  if (response.headers.has("X-Error")) {
-    throw result;
-  }
-  return result;
-}
-
-export function cloneServerReference(id: string) {
-  let baseURL = import.meta.env.BASE_URL ?? "/";
-  if (!baseURL.endsWith("/")) baseURL += "/";
-
-  const fn = (...args: any[]) => fetchServerFunction(`${baseURL}_server`, id, {}, args);
-
-  return new Proxy(fn, {
-    get(target, prop, receiver) {
-      if (prop === "url") {
-        return `${baseURL}_server?id=${encodeURIComponent(id)}`;
-      }
-      if (prop === "GET") {
-        return receiver.withOptions({ method: "GET" });
-      }
-      if (prop === "withOptions") {
-        const url = `${baseURL}_server?id=${encodeURIComponent(id)}`;
-        return (options: RequestInit) => {
-          const fn = async (...args: any[]) => {
-            const encodeArgs = options.method && options.method.toUpperCase() === "GET";
-            return fetchServerFunction(
-              encodeArgs
-                ? url +
-                    (args.length
-                      ? `&args=${encodeURIComponent(await serializeToJSONString(args))}`
-                      : "")
-                : `${baseURL}_server`,
-              id,
-              options,
-              encodeArgs ? [] : args,
-            );
-          };
-          fn.url = url;
-          return fn;
-        };
-      }
-      return (target as any)[prop];
-    },
-  });
-}
-
-export function createClientReference(Component: Component<any>, id: string) {
-  return Component;
-}

package/src/fns/handler.spec.ts

@@ -1,85 +0,0 @@
-import { describe, expect, it, vi, beforeEach } from "vitest";
-import type { FetchEvent } from "./types.ts";
-
-vi.mock("h3", () => ({
-  parseCookies: vi.fn(() => ({})),
-  parseSetCookie: vi.fn(),
-}));
-
-vi.mock("solid-js/web", () => ({
-  renderToString: vi.fn(),
-  provideRequestEvent: vi.fn((_event, fn) => fn()),
-}));
-
-vi.mock("solid-start:server-fn-manifest", () => ({
-  getServerFnById: vi.fn(),
-}));
-
-vi.mock("./handler.ts", () => ({
-  createPageEvent: vi.fn(),
-}));
-
-vi.mock("./fetchEvent.ts", () => ({
-  getFetchEvent: vi.fn(),
-  mergeResponseHeaders: vi.fn(),
-}));
-
-function createMockFetchEvent(headers: Record<string, string> = {}): FetchEvent {
-  return {
-    request: new Request("http://localhost/test", { headers }),
-    response: {
-      headers: {
-        getSetCookie: () => [],
-      },
-    },
-    nativeEvent: {},
-    locals: {},
-  } as FetchEvent;
-}
-
-describe("createSingleFlightHeaders", () => {
-  let createSingleFlightHeaders: (sourceEvent: FetchEvent) => Headers;
-
-  beforeEach(async () => {
-    vi.clearAllMocks();
-    const module = await import("./server-functions-handler.ts");
-    createSingleFlightHeaders = module.createSingleFlightHeaders;
-  });
-
-  it("should create a new Headers object instead of returning the original", () => {
-    const sourceEvent = createMockFetchEvent({
-      "content-type": "application/json",
-    });
-
-    const result = createSingleFlightHeaders(sourceEvent);
-
-    expect(result).not.toBe(sourceEvent.request.headers);
-  });
-
-  it("should not mutate the original request headers", () => {
-    const originalHeaders = new Headers({
-      "content-type": "application/json",
-      "cookie": "session=abc123",
-      "cf-ray": "abc123",
-      "cf-cache-status": "HIT",
-    });
-    const sourceEvent: FetchEvent = {
-      request: new Request("http://localhost/test", { headers: originalHeaders }),
-      response: {
-        headers: {
-          getSetCookie: () => [],
-        },
-      },
-      nativeEvent: {},
-      locals: {},
-    } as FetchEvent;
-
-    const originalCookieHeader = sourceEvent.request.headers.get("cookie");
-    const originalCfRay = sourceEvent.request.headers.get("cf-ray");
-
-    createSingleFlightHeaders(sourceEvent);
-
-    expect(sourceEvent.request.headers.get("cookie")).toBe(originalCookieHeader);
-    expect(sourceEvent.request.headers.get("cf-ray")).toBe(originalCfRay);
-  });
-});

package/src/fns/handler.ts

@@ -1,287 +0,0 @@
-import { parseSetCookie } from "cookie-es";
-import { type H3Event, parseCookies } from "h3";
-import { sharedConfig } from "solid-js";
-import { renderToString } from "solid-js/web";
-import { provideRequestEvent } from "solid-js/web/storage";
-
-import { getFetchEvent, mergeResponseHeaders } from "../server/fetchEvent.ts";
-import { createPageEvent } from "../server/handler.ts";
-import {
-  deserializeFromJSONString,
-  serializeToJSONStream,
-  serializeToJSStream,
-} from "./serialization.ts";
-import {
-  BODY_FORMAT_KEY,
-  BodyFormat,
-  extractBody,
-  getHeadersAndBody,
-} from "./shared.ts";
-import "solid-start:server-fn-manifest";
-
-import { getServerFunction } from "./registration.ts";
-import type { FetchEvent, PageEvent } from "../server/types.ts";
-import { getExpectedRedirectStatus } from "../server/util.ts";
-
-export async function handleServerFunction(h3Event: H3Event) {
-  const event = getFetchEvent(h3Event);
-  const request = event.request;
-
-  const serverReference = request.headers.get("X-Server-Id");
-  const instance = request.headers.get("X-Server-Instance");
-  const singleFlight = request.headers.has("X-Single-Flight");
-  const url = new URL(request.url);
-  let functionId: string | undefined | null;
-  if (serverReference) {
-    // invariant(typeof serverReference === "string", "Invalid server function");
-    [functionId] = serverReference.split("#");
-  } else {
-    functionId = url.searchParams.get("id");
-
-    if (!functionId) {
-      return process.env.NODE_ENV === "development"
-        ? new Response("Server function not found", { status: 404 })
-        : new Response(null, { status: 404 });
-    }
-  }
-
-  const serverFunction = getServerFunction(functionId!);
-
-  let parsed: any[] = [];
-
-  // grab bound arguments from url when no JS
-  if (!instance || request.method === "GET") {
-    const args = url.searchParams.get("args");
-    if (args) {
-      const result = (await deserializeFromJSONString(args)) as any[];
-      for (const arg of result) {
-        parsed.push(arg);
-      }
-    }
-  }
-  if (request.method === "POST" && request.body !== null) {
-    const bodyFormat = request.headers.get(BODY_FORMAT_KEY);
-    const decoded = await extractBody("", false, request.clone());
-    if (bodyFormat === BodyFormat.Seroval) {
-      parsed = decoded as any[];
-    } else {
-      parsed.push(decoded);
-    }
-  }
-  try {
-    let result = await provideRequestEvent(event, async () => {
-      /* @ts-expect-error */
-      sharedConfig.context = { event };
-      event.locals.serverFunctionMeta = {
-        id: functionId,
-      };
-      return serverFunction(...parsed);
-    });
-
-    if (singleFlight && instance) {
-      result = await handleSingleFlight(event, result);
-    }
-
-    // handle responses
-    if (result instanceof Response) {
-      if (result.headers && result.headers.has("X-Content-Raw")) return result;
-      if (instance) {
-        // forward headers
-        if (result.headers) mergeResponseHeaders(h3Event, result.headers);
-        // forward non-redirect statuses
-        if (result.status && (result.status < 300 || result.status >= 400))
-          h3Event.res.status = result.status;
-        if ((result as any).customBody) {
-          result = await (result as any).customBody();
-        } else if (result.body == null) result = null;
-      }
-    }
-
-    // handle no JS success case
-    if (!instance) return handleNoJS(result, request, parsed);
-
-    const body = getHeadersAndBody(result);
-    if (body) {
-      return new Response(body.body, {
-        headers: body.headers,
-      });
-    }
-    h3Event.res.headers.set(BODY_FORMAT_KEY, BodyFormat.Seroval);
-    if (import.meta.env.SEROVAL_MODE === "js") {
-      h3Event.res.headers.set("content-type", "text/javascript");
-      return serializeToJSStream(instance, result);
-    }
-    h3Event.res.headers.set("content-type", "text/plain");
-    return serializeToJSONStream(result);
-  } catch (x) {
-    if (x instanceof Response) {
-      if (singleFlight && instance) {
-        x = await handleSingleFlight(event, x);
-      }
-      // forward headers
-      if ((x as any).headers) mergeResponseHeaders(h3Event, (x as any).headers);
-      // forward non-redirect statuses
-      if ((x as any).status && (!instance || (x as any).status < 300 || (x as any).status >= 400))
-        h3Event.res.status = (x as any).status;
-      if ((x as any).customBody) {
-        x = await (x as any).customBody();
-      } else if ((x as any).body == null) x = null;
-      h3Event.res.headers.set("X-Error", "true");
-    } else if (instance) {
-      const error = x instanceof Error ? x.message : typeof x === "string" ? x : "true";
-
-      h3Event.res.headers.set("X-Error", error.replace(/[\r\n]+/g, ""));
-    } else {
-      x = handleNoJS(x, request, parsed, true);
-    }
-    if (instance) {
-      const body = getHeadersAndBody(x);
-      if (body) {
-        const headers = new Headers(body.headers as HeadersInit);
-        const errorHeader = h3Event.res.headers.get("X-Error");
-        if (errorHeader !== null) {
-          headers.set("X-Error", errorHeader);
-        }
-        return new Response(body.body, {
-          headers: body.headers,
-        });
-      }
-      h3Event.res.headers.set(BODY_FORMAT_KEY, BodyFormat.Seroval);
-      if (import.meta.env.SEROVAL_MODE === "js") {
-        h3Event.res.headers.set("content-type", "text/javascript");
-        return serializeToJSStream(instance, x);
-      }
-      h3Event.res.headers.set("content-type", "text/plain");
-      return serializeToJSONStream(x);
-    }
-    return x;
-  }
-}
-
-function handleNoJS(result: any, request: Request, parsed: any[], thrown?: boolean) {
-  const url = new URL(request.url);
-  const isError = result instanceof Error;
-  let statusCode = 302;
-  let headers: Headers;
-  if (result instanceof Response) {
-    headers = new Headers(result.headers);
-    if (result.headers.has("Location")) {
-      headers.set(
-        `Location`,
-        new URL(result.headers.get("Location")!, url.origin + import.meta.env.BASE_URL).toString(),
-      );
-      statusCode = getExpectedRedirectStatus(result);
-    }
-  } else
-    headers = new Headers({
-      Location: new URL(request.headers.get("referer")!).toString(),
-    });
-  if (result) {
-    headers.append(
-      "Set-Cookie",
-      `flash=${encodeURIComponent(
-        JSON.stringify({
-          url: url.pathname + url.search,
-          result: isError ? result.message : result,
-          thrown: thrown,
-          error: isError,
-          input: [...parsed.slice(0, -1), [...parsed[parsed.length - 1].entries()]],
-        }),
-      )}; Secure; HttpOnly;`,
-    );
-  }
-  return new Response(null, {
-    status: statusCode,
-    headers,
-  });
-}
-
-let App: any;
-export function createSingleFlightHeaders(sourceEvent: FetchEvent) {
-  // cookie handling logic is pretty simplistic so this might be imperfect
-  // unclear if h3 internals are available on all platforms but we need a way to
-  // update request headers on the underlying H3 event.
-
-  const headers = new Headers(sourceEvent.request.headers);
-  const cookies = parseCookies(sourceEvent.nativeEvent);
-  const SetCookies = sourceEvent.response.headers.getSetCookie();
-  headers.delete("cookie");
-  // let useH3Internals = false;
-  // if (sourceEvent.nativeEvent.node?.req) {
-  // 	useH3Internals = true;
-  // 	sourceEvent.nativeEvent.node.req.headers.cookie = "";
-  // }
-  SetCookies.forEach(cookie => {
-    if (!cookie) return;
-    const { maxAge, expires, name, value } = parseSetCookie(cookie);
-    if (maxAge != null && maxAge <= 0) {
-      delete cookies[name];
-      return;
-    }
-    if (expires != null && expires.getTime() <= Date.now()) {
-      delete cookies[name];
-      return;
-    }
-    cookies[name] = value;
-  });
-  Object.entries(cookies).forEach(([key, value]) => {
-    headers.append("cookie", `${key}=${value}`);
-    // useH3Internals &&
-    // 	(sourceEvent.nativeEvent.node.req.headers.cookie += `${key}=${value};`);
-  });
-
-  return headers;
-}
-async function handleSingleFlight(sourceEvent: FetchEvent, result: any): Promise<Response> {
-  let revalidate: string[];
-  let url = new URL(sourceEvent.request.headers.get("referer")!).toString();
-  if (result instanceof Response) {
-    if (result.headers.has("X-Revalidate"))
-      revalidate = result.headers.get("X-Revalidate")!.split(",");
-    if (result.headers.has("Location"))
-      url = new URL(
-        result.headers.get("Location")!,
-        new URL(sourceEvent.request.url).origin + import.meta.env.BASE_URL,
-      ).toString();
-  }
-  const event = { ...sourceEvent } as PageEvent;
-  event.request = new Request(url, {
-    headers: createSingleFlightHeaders(sourceEvent),
-  });
-  return await provideRequestEvent(event, async () => {
-    await createPageEvent(event);
-    App || (App = (await import("solid-start:app")).default);
-    /* @ts-expect-error */
-    event.router.dataOnly = revalidate || true;
-    /* @ts-expect-error */
-    event.router.previousUrl = sourceEvent.request.headers.get("referer");
-    try {
-      renderToString(() => {
-        /* @ts-expect-error */
-        sharedConfig.context.event = event;
-        App();
-      });
-    } catch (e) {
-      console.log(e);
-    }
-
-    /* @ts-expect-error */
-    const body = event.router.data;
-    if (!body) return result;
-    let containsKey = false;
-    for (const key in body) {
-      if (body[key] === undefined) delete body[key];
-      else containsKey = true;
-    }
-    if (!containsKey) return result;
-    if (!(result instanceof Response)) {
-      body["_$value"] = result;
-      result = new Response(null, { status: 200 });
-    } else if ((result as any).customBody) {
-      body["_$value"] = (result as any).customBody();
-    }
-    result.customBody = () => body;
-    result.headers.set("X-Single-Flight", "true");
-    return result;
-  });
-}

package/src/fns/registration.ts

@@ -1,19 +0,0 @@
-const REGISTRATIONS = new Map<string, Function>();
-
-export function registerServerFunction<T extends any[], R>(
-  id: string,
-  callback: (...args: T) => Promise<R>,
-) {
-  REGISTRATIONS.set(id, callback);
-  return callback;
-}
-
-export function getServerFunction<T extends any[], R>(
-  id: string,
-): ((...args: T) => Promise<R>) {
-  const fn = REGISTRATIONS.get(id) as ((...args: T) => Promise<R>) | undefined;
-  if (fn) {
-    return fn;
-  }
-  throw new Error('invalid server function: ' + id);
-}