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

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

package/src/fns/shared.ts

@@ -1,116 +0,0 @@
-import { deserializeJSONStream, deserializeJSStream } from "./serialization.ts";
-
-export const BODY_FORMAT_KEY = "X-Start-Type";
-
-export const BODY_FORMAL_FILE = "__START__";
-
-export const enum BodyFormat {
-  Seroval = "0",
-  String = "1",
-  FormData = "2",
-  URLSearchParams = "3",
-  Blob = "4",
-  File = "5",
-  ArrayBuffer = "6",
-  Uint8Array = "7",
-}
-
-export function getHeadersAndBody(body: any):
-  | {
-      headers?: HeadersInit;
-      body: BodyInit;
-    }
-  | undefined {
-  switch (true) {
-    case typeof body === "string":
-      return {
-        headers: {
-          "Content-Type": "text/plain",
-          [BODY_FORMAT_KEY]: BodyFormat.String,
-        },
-        body,
-      };
-    case body instanceof FormData:
-      return {
-        headers: {
-          [BODY_FORMAT_KEY]: BodyFormat.FormData,
-        },
-        body,
-      };
-    case body instanceof URLSearchParams:
-      return {
-        headers: {
-          "Content-Type": "application/x-www-form-urlencoded",
-          [BODY_FORMAT_KEY]: BodyFormat.URLSearchParams,
-        },
-        body,
-      };
-    case body instanceof File: {
-      const formData = new FormData();
-      formData.append(BODY_FORMAL_FILE, body, body.name);
-      return {
-        headers: {
-          [BODY_FORMAT_KEY]: BodyFormat.File,
-        },
-        body: formData,
-      };
-    }
-    case body instanceof Blob:
-      return {
-        headers: {
-          [BODY_FORMAT_KEY]: BodyFormat.Blob,
-        },
-        body,
-      };
-    case body instanceof ArrayBuffer:
-      return {
-        headers: {
-          [BODY_FORMAT_KEY]: BodyFormat.ArrayBuffer,
-        },
-        body,
-      };
-    case body instanceof Uint8Array:
-      return {
-        headers: {
-          [BODY_FORMAT_KEY]: BodyFormat.Uint8Array,
-        },
-        body: new Uint8Array(body),
-      };
-    default:
-      return undefined;
-  }
-}
-
-export async function extractBody(instance: string, client: boolean, source: Request | Response) {
-  const contentType = source.headers.get("content-type");
-  const startType = source.headers.get(BODY_FORMAT_KEY);
-  const clone = source.clone();
-
-  switch (true) {
-    case startType === BodyFormat.Seroval:
-      if (client && import.meta.env.SEROVAL_MODE === "js") {
-        return await deserializeJSStream(instance, clone);
-      }
-      return await deserializeJSONStream(clone);
-    case startType === BodyFormat.String:
-      return await clone.text();
-    case startType === BodyFormat.File: {
-      const formData = await clone.formData();
-      return formData.get(BODY_FORMAL_FILE);
-    }
-    case startType === BodyFormat.FormData:
-    case contentType?.startsWith("multipart/form-data"):
-      return await clone.formData();
-    case startType === BodyFormat.URLSearchParams:
-    case contentType?.startsWith("application/x-www-form-urlencoded"):
-      return new URLSearchParams(await clone.text());
-    case startType === BodyFormat.Blob:
-      return await clone.blob();
-    case startType === BodyFormat.ArrayBuffer:
-      return await clone.arrayBuffer();
-    case startType === BodyFormat.Uint8Array:
-      return new Uint8Array(await clone.arrayBuffer());
-  }
-
-  return undefined;
-}

package/src/http/index.ts

@@ -1,216 +0,0 @@
-import type { H3Event, HTTPEvent, InferEventInput } from "h3";
-import * as h3 from "h3";
-import { getRequestEvent } from "solid-js/web";
-
-function _setContext(event: H3Event, key: string, value: any) {
-  event.context[key] = value;
-}
-
-function _getContext(event: H3Event, key: string) {
-  return event.context[key];
-}
-
-function getEvent() {
-  return getRequestEvent()!.nativeEvent;
-}
-
-export function getWebRequest(): Request {
-  return getEvent().req;
-}
-
-export const HTTPEventSymbol = Symbol("$HTTPEvent");
-
-export function isEvent(obj: any): obj is h3.H3Event | { [HTTPEventSymbol]: h3.H3Event } {
-  return (
-    typeof obj === "object" &&
-    (obj instanceof h3.H3Event ||
-      obj?.[HTTPEventSymbol] instanceof h3.H3Event ||
-      obj?.__is_event__ === true)
-  );
-  // Implement logic to check if obj is an H3Event
-}
-
-type Tail<T> = T extends [any, ...infer U] ? U : never;
-
-type PrependOverload<
-  TOriginal extends (...args: Array<any>) => any,
-  TOverload extends (...args: Array<any>) => any,
-> = TOverload & TOriginal;
-
-// add an overload to the function without the event argument
-type WrapFunction<TFn extends (...args: Array<any>) => any> = PrependOverload<
-  TFn,
-  (
-    ...args: Parameters<TFn> extends [h3.HTTPEvent<any> | h3.H3Event<any>, ...infer TArgs]
-      ? TArgs
-      : Parameters<TFn>
-  ) => ReturnType<TFn>
->;
-
-function createWrapperFunction<TFn extends (...args: Array<any>) => any>(
-  h3Function: TFn,
-): WrapFunction<TFn> {
-  return ((...args: Array<any>) => {
-    const event = args[0];
-    if (!isEvent(event)) {
-      args.unshift(getEvent());
-    } else {
-      args[0] =
-        event instanceof h3.H3Event || (event as any).__is_event__ ? event : event[HTTPEventSymbol];
-    }
-
-    return (h3Function as any)(...args);
-  }) as any;
-}
-
-// Creating wrappers for each utility and exporting them with their original names
-// readRawBody => getWebRequest().text()/.arrayBuffer()
-type WrappedReadBody = <T, TEventInput = InferEventInput<"body", H3Event, T>>(
-  ...args: Tail<Parameters<typeof h3.readBody<T, H3Event, TEventInput>>>
-) => ReturnType<typeof h3.readBody<T, h3.H3Event, TEventInput>>;
-export const readBody = createWrapperFunction(h3.readBody) as PrependOverload<
-  typeof h3.readBody,
-  WrappedReadBody
->;
-type WrappedGetQuery = <T, TEventInput = Exclude<InferEventInput<"query", H3Event, T>, undefined>>(
-  ...args: Tail<Parameters<typeof h3.getQuery<T, H3Event, TEventInput>>>
-) => ReturnType<typeof h3.getQuery<T, H3Event, TEventInput>>;
-export const getQuery = createWrapperFunction(h3.getQuery) as PrependOverload<
-  typeof h3.getQuery,
-  WrappedGetQuery
->;
-export const isMethod = createWrapperFunction(h3.isMethod);
-export const isPreflightRequest = createWrapperFunction(h3.isPreflightRequest);
-type WrappedGetValidatedQuery = <
-  T extends HTTPEvent,
-  TEventInput = InferEventInput<"query", H3Event, T>,
->(
-  ...args: Tail<Parameters<typeof h3.getValidatedQuery<T, H3Event, TEventInput>>>
-) => ReturnType<typeof h3.getValidatedQuery<T, H3Event, TEventInput>>;
-export const getValidatedQuery = createWrapperFunction(h3.getValidatedQuery) as PrependOverload<
-  typeof h3.getValidatedQuery,
-  WrappedGetValidatedQuery
->;
-export const getRouterParams = createWrapperFunction(h3.getRouterParams);
-export const getRouterParam = createWrapperFunction(h3.getRouterParam);
-type WrappedGetValidatedRouterParams = <
-  T extends HTTPEvent,
-  TEventInput = InferEventInput<"routerParams", H3Event, T>,
->(
-  ...args: Tail<Parameters<typeof h3.getValidatedRouterParams<T, H3Event, TEventInput>>>
-) => ReturnType<typeof h3.getValidatedRouterParams<T, H3Event, TEventInput>>;
-export const getValidatedRouterParams = createWrapperFunction(
-  h3.getValidatedRouterParams,
-) as PrependOverload<typeof h3.getValidatedRouterParams, WrappedGetValidatedRouterParams>;
-export const assertMethod = createWrapperFunction(h3.assertMethod);
-export const getRequestHeaders = createWrapperFunction(h3.getRequestHeaders);
-export const getRequestHeader = createWrapperFunction(h3.getRequestHeader);
-export const getRequestURL = createWrapperFunction(h3.getRequestURL);
-export const getRequestHost = createWrapperFunction(h3.getRequestHost);
-export const getRequestProtocol = createWrapperFunction(h3.getRequestProtocol);
-export const getRequestIP = createWrapperFunction(h3.getRequestIP);
-export const setResponseStatus = (code?: number, text?: string) => {
-  const e = getEvent();
-
-  if (e.res.status !== undefined) e.res.status = code;
-  if (e.res.statusText !== undefined) e.res.statusText = text;
-};
-export const getResponseStatus = () => getEvent().res.status;
-export const getResponseStatusText = () => getEvent().res.statusText;
-export const getResponseHeaders = () => Object.fromEntries(getEvent().res.headers.entries());
-export const getResponseHeader = (name: string) => getEvent().res.headers.get(name);
-export const setResponseHeaders = (values: Record<string, string>) => {
-  const headers = getEvent().res.headers;
-  for (const [name, value] of Object.entries(values)) {
-    headers.set(name, value);
-  }
-};
-export const setResponseHeader = (name: string, value: string | string[]) => {
-  const headers = getEvent().res.headers;
-
-  (Array.isArray(value) ? value : [value]).forEach(value => {
-    headers.set(name, value);
-  });
-};
-export const appendResponseHeaders = (values: Record<string, string>) => {
-  const headers = getEvent().res.headers;
-  for (const [name, value] of Object.entries(values)) {
-    headers.append(name, value);
-  }
-};
-export const appendResponseHeader = (name: string, value: string | string[]) => {
-  const headers = getEvent().res.headers;
-
-  (Array.isArray(value) ? value : [value]).forEach(value => {
-    headers.append(name, value);
-  });
-};
-export const defaultContentType = (type: string) =>
-  getEvent().res.headers.set("content-type", type);
-export const proxyRequest = createWrapperFunction(h3.proxyRequest);
-export const fetchWithEvent = createWrapperFunction(h3.fetchWithEvent);
-export const getProxyRequestHeaders = createWrapperFunction(h3.getProxyRequestHeaders);
-
-export const parseCookies = createWrapperFunction(h3.parseCookies);
-export const getCookie = createWrapperFunction(h3.getCookie);
-export const setCookie = createWrapperFunction(h3.setCookie);
-export const deleteCookie = createWrapperFunction(h3.deleteCookie);
-// not exported :(
-type SessionDataT = Record<string, any>;
-type WrappedUseSession = <T extends SessionDataT>(
-  ...args: Tail<Parameters<typeof h3.useSession<T>>>
-) => ReturnType<typeof h3.useSession<T>>;
-export const useSession: WrappedUseSession = createWrapperFunction(h3.useSession);
-type WrappedGetSession = <T extends SessionDataT>(
-  ...args: Tail<Parameters<typeof h3.getSession<T>>>
-) => ReturnType<typeof h3.getSession<T>>;
-export const getSession: WrappedGetSession = createWrapperFunction(h3.getSession);
-type WrappedUpdateSession = <T extends SessionDataT>(
-  ...args: Tail<Parameters<typeof h3.updateSession<T>>>
-) => ReturnType<typeof h3.updateSession<T>>;
-export const updateSession: WrappedUpdateSession = createWrapperFunction(h3.updateSession);
-type WrappedSealSession = <T extends SessionDataT>(
-  ...args: Tail<Parameters<typeof h3.sealSession<T>>>
-) => ReturnType<typeof h3.sealSession<T>>;
-export const sealSession: WrappedSealSession = createWrapperFunction(h3.sealSession);
-export const unsealSession = createWrapperFunction(h3.unsealSession);
-export const clearSession = createWrapperFunction(h3.clearSession);
-export const handleCacheHeaders = createWrapperFunction(h3.handleCacheHeaders);
-export const handleCors = createWrapperFunction(h3.handleCors);
-export const appendCorsHeaders = createWrapperFunction(h3.appendCorsHeaders);
-export const appendCorsPreflightHeaders = createWrapperFunction(h3.appendCorsPreflightHeaders);
-export const appendHeader = appendResponseHeader;
-export const appendHeaders = appendResponseHeaders;
-export const setHeader = setResponseHeader;
-export const setHeaders = setResponseHeaders;
-export const getHeader = getRequestHeader;
-export const getHeaders = getRequestHeaders;
-export const getRequestFingerprint = createWrapperFunction(h3.getRequestFingerprint);
-export const getRequestWebStream = () => getEvent().req.body;
-export const readFormData = () => getEvent().req.formData();
-type WrappedReadValidatedBody = <
-  T extends HTTPEvent,
-  TEventInput = InferEventInput<"body", H3Event, T>,
->(
-  ...args: Tail<Parameters<typeof h3.readValidatedBody<T, H3Event, TEventInput>>>
-) => ReturnType<typeof h3.readValidatedBody<T, H3Event, TEventInput>>;
-export const readValidatedBody = createWrapperFunction(h3.readValidatedBody) as PrependOverload<
-  typeof h3.readValidatedBody,
-  WrappedReadValidatedBody
->;
-export const getContext = createWrapperFunction(_getContext);
-export const setContext = createWrapperFunction(_setContext);
-export const removeResponseHeader = (name: string) => getEvent().res.headers.delete(name);
-export const clearResponseHeaders = (headerNames?: string[]) => {
-  const headers = getEvent().res.headers;
-
-  if (headerNames && headerNames.length > 0) {
-    for (const name of headerNames) {
-      headers.delete(name);
-    }
-  } else {
-    for (const name of headers.keys()) {
-      headers.delete(name);
-    }
-  }
-};

package/src/internal.d.ts

@@ -1,14 +0,0 @@
-import "h3";
-declare module "h3" {
-  import { ViteDevServer } from "vite";
-
-  export interface H3EventContext {
-    viteDevServer?: ViteDevServer;
-  }
-}
-
-import type { Rollup } from "vite";
-declare global {
-  var START_CLIENT_BUNDLE: Rollup.OutputBundle;
-  var USING_SOLID_START_DEV_SERVER: boolean | undefined;
-}