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

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);
-}

package/src/fns/serialization.ts

@@ -1,250 +0,0 @@
-import {
-  crossSerializeStream,
-  deserialize,
-  Feature,
-  fromCrossJSON,
-  getCrossReferenceHeader,
-  type SerovalNode,
-  toCrossJSONStream,
-} from "seroval";
-import {
-  AbortSignalPlugin,
-  CustomEventPlugin,
-  DOMExceptionPlugin,
-  EventPlugin,
-  FormDataPlugin,
-  HeadersPlugin,
-  ReadableStreamPlugin,
-  RequestPlugin,
-  ResponsePlugin,
-  URLPlugin,
-  URLSearchParamsPlugin,
-} from "seroval-plugins/web";
-
-// TODO(Alexis): if we can, allow providing an option to extend these.
-const DEFAULT_PLUGINS = [
-  AbortSignalPlugin,
-  CustomEventPlugin,
-  DOMExceptionPlugin,
-  EventPlugin,
-  FormDataPlugin,
-  HeadersPlugin,
-  ReadableStreamPlugin,
-  RequestPlugin,
-  ResponsePlugin,
-  URLSearchParamsPlugin,
-  URLPlugin,
-];
-const MAX_SERIALIZATION_DEPTH_LIMIT = 64;
-const DISABLED_FEATURES = Feature.RegExp;
-
-/**
- * Alexis:
- *
- * A "chunk" is a piece of data emitted by the streaming serializer.
- * Each chunk is represented by a 32-bit value (encoded in hexadecimal),
- * followed by the encoded string (8-bit representation). This format
- * is important so we know how much of the chunk being streamed we
- * are expecting before parsing the entire string data.
- *
- * This is sort of a bootleg "multipart/form-data" except it's bad at
- * handling File/Blob LOL
- *
- * The format is as follows:
- * ;0xFFFFFFFF;<string data>
- */
-function createChunk(data: string): Uint8Array {
-  const encodeData = new TextEncoder().encode(data);
-  const bytes = encodeData.length;
-  const baseHex = bytes.toString(16);
-  const totalHex = "00000000".substring(0, 8 - baseHex.length) + baseHex; // 32-bit
-  const head = new TextEncoder().encode(`;0x${totalHex};`);
-
-  const chunk = new Uint8Array(12 + bytes);
-  chunk.set(head);
-  chunk.set(encodeData, 12);
-  return chunk;
-}
-
-export function serializeToJSStream(id: string, value: any) {
-  return new ReadableStream({
-    start(controller) {
-      crossSerializeStream(value, {
-        scopeId: id,
-        plugins: DEFAULT_PLUGINS,
-        onSerialize(data: string, initial: boolean) {
-          controller.enqueue(
-            createChunk(initial ? `(${getCrossReferenceHeader(id)},${data})` : data),
-          );
-        },
-        onDone() {
-          controller.close();
-        },
-        onError(error: any) {
-          controller.error(error);
-        },
-      });
-    },
-  });
-}
-
-export function serializeToJSONStream(value: any) {
-  return new ReadableStream({
-    start(controller) {
-      toCrossJSONStream(value, {
-        disabledFeatures: DISABLED_FEATURES,
-        depthLimit: MAX_SERIALIZATION_DEPTH_LIMIT,
-        plugins: DEFAULT_PLUGINS,
-        onParse(node) {
-          controller.enqueue(createChunk(JSON.stringify(node)));
-        },
-        onDone() {
-          controller.close();
-        },
-        onError(error) {
-          controller.error(error);
-        },
-      });
-    },
-  });
-}
-
-class SerovalChunkReader {
-  reader: ReadableStreamDefaultReader<Uint8Array>;
-  buffer: Uint8Array;
-  done: boolean;
-  constructor(stream: ReadableStream<Uint8Array>) {
-    this.reader = stream.getReader();
-    this.buffer = new Uint8Array(0);
-    this.done = false;
-  }
-
-  async readChunk() {
-    // if there's no chunk, read again
-    const chunk = await this.reader.read();
-    if (!chunk.done) {
-      // repopulate the buffer
-      const newBuffer = new Uint8Array(this.buffer.length + chunk.value.length);
-      newBuffer.set(this.buffer);
-      newBuffer.set(chunk.value, this.buffer.length);
-      this.buffer = newBuffer;
-    } else {
-      this.done = true;
-    }
-  }
-
-  async next(): Promise<{ done: true; value: undefined } | { done: false; value: string }> {
-    // Check if the buffer is empty
-    if (this.buffer.length === 0) {
-      // if we are already done...
-      if (this.done) {
-        return {
-          done: true,
-          value: undefined,
-        };
-      }
-      // Otherwise, read a new chunk
-      await this.readChunk();
-      return await this.next();
-    }
-    // Read the "byte header"
-    // The byte header tells us how big the expected data is
-    // so we know how much data we should wait before we
-    // deserialize the data
-    const head = new TextDecoder().decode(this.buffer.subarray(1, 11));
-    const bytes = Number.parseInt(head, 16); // ;0x00000000;
-    if (Number.isNaN(bytes)) {
-      throw new Error("Malformed server function stream.");
-    }
-    // Check if the buffer has enough bytes to be parsed
-    while (bytes > this.buffer.length - 12) {
-      // If it's not enough, and the reader is done
-      // then the chunk is invalid.
-      if (this.done) {
-        throw new Error("Malformed server function stream.");
-      }
-      // Otherwise, we read more chunks
-      await this.readChunk();
-    }
-    // Extract the exact chunk as defined by the byte header
-    const partial = new TextDecoder().decode(this.buffer.subarray(12, 12 + bytes));
-    // The rest goes to the buffer
-    this.buffer = this.buffer.subarray(12 + bytes);
-
-    // Deserialize the chunk
-    return {
-      done: false,
-      value: partial,
-    };
-  }
-
-  async drain(interpret: (chunk: string) => void) {
-    while (true) {
-      const result = await this.next();
-      if (result.done) {
-        break;
-      } else {
-        interpret(result.value);
-      }
-    }
-  }
-}
-
-export async function serializeToJSONString(value: any) {
-  const response = new Response(serializeToJSONStream(value));
-  return await response.text();
-}
-
-export async function deserializeFromJSONString(json: string) {
-  const blob = new Response(json);
-  return await deserializeJSONStream(blob);
-}
-
-export async function deserializeJSONStream(response: Response | Request) {
-  if (!response.body) {
-    throw new Error("missing body");
-  }
-  const reader = new SerovalChunkReader(response.body);
-  const result = await reader.next();
-  if (!result.done) {
-    const refs = new Map();
-
-    function interpretChunk(chunk: string): unknown {
-      const value = fromCrossJSON(JSON.parse(chunk) as SerovalNode, {
-        refs,
-        disabledFeatures: DISABLED_FEATURES,
-        depthLimit: MAX_SERIALIZATION_DEPTH_LIMIT,
-        plugins: DEFAULT_PLUGINS,
-      });
-      return value;
-    }
-
-    void reader.drain(interpretChunk);
-
-    return interpretChunk(result.value);
-  }
-  return undefined;
-}
-
-export async function deserializeJSStream(id: string, response: Request | Response) {
-  if (!response.body) {
-    throw new Error("missing body");
-  }
-  const reader = new SerovalChunkReader(response.body);
-
-  const result = await reader.next();
-
-  if (!result.done) {
-    reader.drain(deserialize).then(
-      () => {
-        // @ts-ignore
-        delete $R[id];
-      },
-      () => {
-        // no-op
-      },
-    );
-    return deserialize(result.value);
-  }
-  return undefined;
-}

package/src/fns/server.ts

@@ -1,46 +0,0 @@
-import { getRequestEvent } from "solid-js/web";
-import { provideRequestEvent } from "solid-js/web/storage";
-import { registerServerFunction } from "./registration.ts";
-
-interface Registration<T extends any[], R> {
-  id: string;
-  fn: (...args: T) => Promise<R>;
-}
-
-export function createServerReference<T extends any[], R>(
-  id: string,
-  fn: (...args: T) => Promise<R>,
-) {
-  const registration: Registration<T, R> = { id, fn };
-  registerServerFunction(id, fn);
-  return registration;
-}
-
-export function cloneServerReference<T extends any[], R>({ id, fn }: Registration<T, R>) {
-  if (typeof fn !== "function")
-    throw new Error("Export from a 'use server' module must be a function");
-  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) {
-      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 as T);
-      });
-    },
-  });
-}