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

package/dist/fns/client.js

@@ -0,0 +1,106 @@
+import { 
+// serializeToJSONStream,
+serializeToJSONString, } from "./serialization.js";
+import { BODY_FORMAT_KEY, BodyFormat, extractBody, getHeadersAndBody, } from "./shared.js";
+let INSTANCE = 0;
+function createRequest(base, id, instance, options) {
+    return fetch(base, {
+        method: "POST",
+        ...options,
+        headers: {
+            ...options.headers,
+            "X-Server-Id": id,
+            "X-Server-Instance": instance,
+        },
+    });
+}
+async function initializeResponse(base, id, instance, options, args) {
+    // 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, id, options, args) {
+    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) {
+    let baseURL = import.meta.env.BASE_URL ?? "/";
+    if (!baseURL.endsWith("/"))
+        baseURL += "/";
+    const fn = (...args) => 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) => {
+                    const fn = async (...args) => {
+                        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[prop];
+        },
+    });
+}
+export function createClientReference(Component, id) {
+    return Component;
+}

package/dist/fns/handler.d.ts

@@ -0,0 +1,5 @@
+import { type H3Event } from "h3";
+import "solid-start:server-fn-manifest";
+import type { FetchEvent } from "../server/types.ts";
+export declare function handleServerFunction(h3Event: H3Event): Promise<unknown>;
+export declare function createSingleFlightHeaders(sourceEvent: FetchEvent): Headers;

package/dist/{server/server-functions-handler.js → fns/handler.js}

@@ -1,55 +1,15 @@
-import { getServerFnById } from "solidstart:server-fn-manifest";
 import { parseSetCookie } from "cookie-es";
 import { parseCookies } from "h3";
-import { crossSerializeStream, fromJSON, getCrossReferenceHeader } from "seroval";
-import { CustomEventPlugin, DOMExceptionPlugin, EventPlugin, FormDataPlugin, HeadersPlugin, ReadableStreamPlugin, RequestPlugin, ResponsePlugin, URLPlugin, URLSearchParamsPlugin, } from "seroval-plugins/web";
 import { sharedConfig } from "solid-js";
 import { renderToString } from "solid-js/web";
 import { provideRequestEvent } from "solid-js/web/storage";
-import { getFetchEvent, mergeResponseHeaders } from "./fetchEvent.js";
-import { createPageEvent } from "./handler.js";
-import { getExpectedRedirectStatus } from "./util.js";
-function createChunk(data) {
-    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;
-}
-function serializeToStream(id, value) {
-    return new ReadableStream({
-        start(controller) {
-            crossSerializeStream(value, {
-                scopeId: id,
-                plugins: [
-                    CustomEventPlugin,
-                    DOMExceptionPlugin,
-                    EventPlugin,
-                    FormDataPlugin,
-                    HeadersPlugin,
-                    ReadableStreamPlugin,
-                    RequestPlugin,
-                    ResponsePlugin,
-                    URLSearchParamsPlugin,
-                    URLPlugin,
-                ],
-                onSerialize(data, initial) {
-                    controller.enqueue(createChunk(initial ? `(${getCrossReferenceHeader(id)},${data})` : data));
-                },
-                onDone() {
-                    controller.close();
-                },
-                onError(error) {
-                    controller.error(error);
-                },
-            });
-        },
-    });
-}
+import { getFetchEvent, mergeResponseHeaders } from "../server/fetchEvent.js";
+import { createPageEvent } from "../server/handler.js";
+import { deserializeFromJSONString, serializeToJSONStream, serializeToJSStream, } from "./serialization.js";
+import { BODY_FORMAT_KEY, BodyFormat, extractBody, getHeadersAndBody, } from "./shared.js";
+import "solid-start:server-fn-manifest";
+import { getServerFunction } from "./registration.js";
+import { getExpectedRedirectStatus } from "../server/util.js";
 export async function handleServerFunction(h3Event) {
     const event = getFetchEvent(h3Event);
     const request = event.request;
@@ -70,54 +30,26 @@ export async function handleServerFunction(h3Event) {
                 : new Response(null, { status: 404 });
         }
     }
-    const serverFunction = await getServerFnById(functionId);
+    const serverFunction = getServerFunction(functionId);
     let parsed = [];
     // grab bound arguments from url when no JS
-    if (!instance || h3Event.method === "GET") {
+    if (!instance || request.method === "GET") {
         const args = url.searchParams.get("args");
         if (args) {
-            const json = JSON.parse(args);
-            (json.t
-                ? fromJSON(json, {
-                    plugins: [
-                        CustomEventPlugin,
-                        DOMExceptionPlugin,
-                        EventPlugin,
-                        FormDataPlugin,
-                        HeadersPlugin,
-                        ReadableStreamPlugin,
-                        RequestPlugin,
-                        ResponsePlugin,
-                        URLSearchParamsPlugin,
-                        URLPlugin,
-                    ],
-                })
-                : json).forEach((arg) => {
+            const result = (await deserializeFromJSONString(args));
+            for (const arg of result) {
                 parsed.push(arg);
-            });
+            }
         }
     }
-    if (h3Event.method === "POST") {
-        const contentType = request.headers.get("content-type");
-        if (contentType?.startsWith("multipart/form-data") ||
-            contentType?.startsWith("application/x-www-form-urlencoded")) {
-            parsed.push(await event.request.formData());
+    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;
         }
-        else if (contentType?.startsWith("application/json")) {
-            parsed = fromJSON(await event.request.json(), {
-                plugins: [
-                    CustomEventPlugin,
-                    DOMExceptionPlugin,
-                    EventPlugin,
-                    FormDataPlugin,
-                    HeadersPlugin,
-                    ReadableStreamPlugin,
-                    RequestPlugin,
-                    ResponsePlugin,
-                    URLSearchParamsPlugin,
-                    URLPlugin,
-                ],
-            });
+        else {
+            parsed.push(decoded);
         }
     }
     try {
@@ -146,15 +78,26 @@ export async function handleServerFunction(h3Event) {
                 if (result.customBody) {
                     result = await result.customBody();
                 }
-                else if (result.body == undefined)
+                else if (result.body == null)
                     result = null;
             }
         }
         // handle no JS success case
         if (!instance)
             return handleNoJS(result, request, parsed);
-        h3Event.res.headers.set("content-type", "text/javascript");
-        return serializeToStream(instance, result);
+        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) {
@@ -168,9 +111,9 @@ export async function handleServerFunction(h3Event) {
             if (x.status && (!instance || x.status < 300 || x.status >= 400))
                 h3Event.res.status = x.status;
             if (x.customBody) {
-                x = x.customBody();
+                x = await x.customBody();
             }
-            else if (x.body === undefined)
+            else if (x.body == null)
                 x = null;
             h3Event.res.headers.set("X-Error", "true");
         }
@@ -182,8 +125,24 @@ export async function handleServerFunction(h3Event) {
             x = handleNoJS(x, request, parsed, true);
         }
         if (instance) {
-            h3Event.res.headers.set("content-type", "text/javascript");
-            return serializeToStream(instance, x);
+            const body = getHeadersAndBody(x);
+            if (body) {
+                const headers = new Headers(body.headers);
+                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;
     }
@@ -219,11 +178,11 @@ function handleNoJS(result, request, parsed, thrown) {
     });
 }
 let App;
-function createSingleFlightHeaders(sourceEvent) {
+export function createSingleFlightHeaders(sourceEvent) {
     // 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 = sourceEvent.request.headers;
+    const headers = new Headers(sourceEvent.request.headers);
     const cookies = parseCookies(sourceEvent.nativeEvent);
     const SetCookies = sourceEvent.response.headers.getSetCookie();
     headers.delete("cookie");

package/dist/fns/registration.d.ts

@@ -0,0 +1,2 @@
+export declare function registerServerFunction<T extends any[], R>(id: string, callback: (...args: T) => Promise<R>): (...args: T) => Promise<R>;
+export declare function getServerFunction<T extends any[], R>(id: string): ((...args: T) => Promise<R>);

package/dist/fns/registration.js

@@ -0,0 +1,12 @@
+const REGISTRATIONS = new Map();
+export function registerServerFunction(id, callback) {
+    REGISTRATIONS.set(id, callback);
+    return callback;
+}
+export function getServerFunction(id) {
+    const fn = REGISTRATIONS.get(id);
+    if (fn) {
+        return fn;
+    }
+    throw new Error('invalid server function: ' + id);
+}

package/dist/fns/serialization.d.ts

@@ -0,0 +1,6 @@
+export declare function serializeToJSStream(id: string, value: any): ReadableStream<any>;
+export declare function serializeToJSONStream(value: any): ReadableStream<any>;
+export declare function serializeToJSONString(value: any): Promise<string>;
+export declare function deserializeFromJSONString(json: string): Promise<unknown>;
+export declare function deserializeJSONStream(response: Response | Request): Promise<unknown>;
+export declare function deserializeJSStream(id: string, response: Request | Response): Promise<unknown>;

package/dist/fns/serialization.js

@@ -0,0 +1,208 @@
+import { crossSerializeStream, deserialize, Feature, fromCrossJSON, getCrossReferenceHeader, 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) {
+    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, value) {
+    return new ReadableStream({
+        start(controller) {
+            crossSerializeStream(value, {
+                scopeId: id,
+                plugins: DEFAULT_PLUGINS,
+                onSerialize(data, initial) {
+                    controller.enqueue(createChunk(initial ? `(${getCrossReferenceHeader(id)},${data})` : data));
+                },
+                onDone() {
+                    controller.close();
+                },
+                onError(error) {
+                    controller.error(error);
+                },
+            });
+        },
+    });
+}
+export function serializeToJSONStream(value) {
+    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;
+    buffer;
+    done;
+    constructor(stream) {
+        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() {
+        // 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) {
+        while (true) {
+            const result = await this.next();
+            if (result.done) {
+                break;
+            }
+            else {
+                interpret(result.value);
+            }
+        }
+    }
+}
+export async function serializeToJSONString(value) {
+    const response = new Response(serializeToJSONStream(value));
+    return await response.text();
+}
+export async function deserializeFromJSONString(json) {
+    const blob = new Response(json);
+    return await deserializeJSONStream(blob);
+}
+export async function deserializeJSONStream(response) {
+    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) {
+            const value = fromCrossJSON(JSON.parse(chunk), {
+                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, 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/dist/fns/server.d.ts

@@ -0,0 +1,7 @@
+interface Registration<T extends any[], R> {
+    id: string;
+    fn: (...args: T) => Promise<R>;
+}
+export declare function createServerReference<T extends any[], R>(id: string, fn: (...args: T) => Promise<R>): Registration<T, R>;
+export declare function cloneServerReference<T extends any[], R>({ id, fn }: Registration<T, R>): (...args: T) => Promise<R>;
+export {};

package/dist/{server/server-fns-runtime.js → fns/server.js}

@@ -1,6 +1,12 @@
 import { getRequestEvent } from "solid-js/web";
 import { provideRequestEvent } from "solid-js/web/storage";
-export function createServerReference(fn, id) {
+import { registerServerFunction } from "./registration.js";
+export function createServerReference(id, fn) {
+    const registration = { id, fn };
+    registerServerFunction(id, fn);
+    return registration;
+}
+export function cloneServerReference({ id, fn }) {
     if (typeof fn !== "function")
         throw new Error("Export from a 'use server' module must be a function");
     let baseURL = import.meta.env.BASE_URL ?? "/";

package/dist/fns/shared.d.ts

@@ -0,0 +1,17 @@
+export declare const BODY_FORMAT_KEY = "X-Start-Type";
+export declare const BODY_FORMAL_FILE = "__START__";
+export declare const enum BodyFormat {
+    Seroval = "0",
+    String = "1",
+    FormData = "2",
+    URLSearchParams = "3",
+    Blob = "4",
+    File = "5",
+    ArrayBuffer = "6",
+    Uint8Array = "7"
+}
+export declare function getHeadersAndBody(body: any): {
+    headers?: HeadersInit;
+    body: BodyInit;
+} | undefined;
+export declare function extractBody(instance: string, client: boolean, source: Request | Response): Promise<unknown>;