@solidjs/start 0.7.0 → 0.7.2

package/dist/runtime/server-handler.js

@@ -0,0 +1,242 @@
+/// <reference types="vinxi/types/server" />
+import { crossSerializeStream, fromJSON, getCrossReferenceHeader } from "seroval";
+// @ts-ignore
+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 { eventHandler, setHeader, setResponseStatus } from "vinxi/http";
+import invariant from "vinxi/lib/invariant";
+import { cloneEvent, getFetchEvent, mergeResponseHeaders } from "../server/fetchEvent";
+import { createPageEvent } from "../server/pageEvent";
+function createChunk(data) {
+    const bytes = data.length;
+    const baseHex = bytes.toString(16);
+    const totalHex = "00000000".substring(0, 8 - baseHex.length) + baseHex; // 32-bit
+    return new TextEncoder().encode(`;0x${totalHex};${data}`);
+}
+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);
+                }
+            });
+        }
+    });
+}
+async function handleServerFunction(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 filepath, name;
+    if (serverReference) {
+        invariant(typeof serverReference === "string", "Invalid server function");
+        [filepath, name] = serverReference.split("#");
+    }
+    else {
+        filepath = url.searchParams.get("id");
+        name = url.searchParams.get("name");
+        if (!filepath || !name)
+            throw new Error("Invalid request");
+    }
+    const serverFunction = (await import.meta.env.MANIFEST[import.meta.env.ROUTER_NAME].chunks[filepath].import())[name];
+    let parsed = [];
+    // grab bound arguments from url when no JS
+    if (!instance || h3Event.method === "GET") {
+        const args = url.searchParams.get("args");
+        if (args)
+            JSON.parse(args).forEach((arg) => 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")) {
+            // workaround for https://github.com/unjs/nitro/issues/1721
+            // (issue only in edge runtimes)
+            parsed.push(await new Request(request, { ...request, body: h3Event.node.req.body }).formData());
+            // what should work when #1721 is fixed
+            // parsed.push(await request.formData);
+        }
+        else if (contentType?.startsWith("application/json")) {
+            // workaround for https://github.com/unjs/nitro/issues/1721
+            // (issue only in edge runtimes)
+            const tmpReq = new Request(request, { ...request, body: h3Event.node.req.body });
+            // what should work when #1721 is fixed
+            // just use request.json() here
+            parsed = fromJSON(await tmpReq.json(), {
+                plugins: [
+                    CustomEventPlugin,
+                    DOMExceptionPlugin,
+                    EventPlugin,
+                    FormDataPlugin,
+                    HeadersPlugin,
+                    ReadableStreamPlugin,
+                    RequestPlugin,
+                    ResponsePlugin,
+                    URLSearchParamsPlugin,
+                    URLPlugin
+                ]
+            });
+        }
+    }
+    try {
+        let result = await provideRequestEvent(event, async () => {
+            /* @ts-ignore */
+            sharedConfig.context = { event };
+            event.locals.serverFunctionMeta = {
+                id: filepath + "#" + name,
+            };
+            return serverFunction(...parsed);
+        });
+        if (singleFlight && instance) {
+            result = await handleSingleFlight(event, result);
+        }
+        // handle responses
+        if (result instanceof Response && instance) {
+            // forward headers
+            if (result.headers)
+                mergeResponseHeaders(h3Event, result.headers);
+            // forward non-redirect statuses
+            if (result.status && (result.status < 300 || result.status >= 400))
+                setResponseStatus(h3Event, result.status);
+            if (result.customBody) {
+                result = await result.customBody();
+            }
+            else if (result.body == undefined)
+                result = null;
+        }
+        // handle no JS success case
+        if (!instance) {
+            const isError = result instanceof Error;
+            let redirectUrl = new URL(request.headers.get("referer")).toString();
+            if (result instanceof Response && result.headers.has("Location")) {
+                redirectUrl = new URL(result.headers.get("Location"), new URL(request.url).origin + import.meta.env.SERVER_BASE_URL).toString();
+            }
+            return new Response(null, {
+                status: 302,
+                headers: {
+                    Location: redirectUrl,
+                    ...(result
+                        ? {
+                            "Set-Cookie": `flash=${JSON.stringify({
+                                url: url.pathname + encodeURIComponent(url.search),
+                                result: isError ? result.message : result,
+                                error: isError,
+                                input: [...parsed.slice(0, -1), [...parsed[parsed.length - 1].entries()]]
+                            })}; Secure; HttpOnly;`
+                        }
+                        : {})
+                }
+            });
+        }
+        setHeader(h3Event, "content-type", "text/javascript");
+        return serializeToStream(instance, result);
+    }
+    catch (x) {
+        if (x instanceof Response) {
+            if (singleFlight && instance) {
+                x = await handleSingleFlight(event, x);
+            }
+            // forward headers
+            if (x.headers)
+                mergeResponseHeaders(h3Event, x.headers);
+            // forward non-redirect statuses
+            if (x.status && (!instance || x.status < 300 || x.status >= 400))
+                setResponseStatus(h3Event, x.status);
+            if (x.customBody) {
+                x = x.customBody();
+            }
+            else if (x.body == undefined)
+                x = null;
+        }
+        else {
+            const error = x instanceof Error ? x.message : typeof x === "string" ? x : "true";
+            setHeader(h3Event, "X-Error", error);
+        }
+        if (instance) {
+            setHeader(h3Event, "content-type", "text/javascript");
+            return serializeToStream(instance, x);
+        }
+        return x;
+    }
+}
+let App;
+async function handleSingleFlight(sourceEvent, result) {
+    let revalidate;
+    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.SERVER_BASE_URL).toString();
+    }
+    const event = cloneEvent(sourceEvent);
+    event.request = new Request(url);
+    return await provideRequestEvent(event, async () => {
+        await createPageEvent(event);
+        /* @ts-ignore */
+        App || (App = (await import("#start/app")).default);
+        /* @ts-ignore */
+        event.router.dataOnly = revalidate || true;
+        /* @ts-ignore */
+        event.router.previousUrl = sourceEvent.request.headers.get("referer");
+        try {
+            renderToString(() => {
+                /* @ts-ignore */
+                sharedConfig.context.event = event;
+                App();
+            });
+        }
+        catch (e) {
+            console.log(e);
+        }
+        /* @ts-ignore */
+        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.customBody) {
+            body["_$value"] = result.customBody();
+        }
+        result.customBody = () => body;
+        result.headers.set("X-Single-Flight", "true");
+        return result;
+    });
+}
+export default eventHandler(handleServerFunction);

package/dist/runtime/server-runtime.d.ts

@@ -0,0 +1,3 @@
+import { type Component } from "solid-js";
+export declare function createServerReference(fn: Function, id: string, name: string): Function;
+export declare function createClientReference(Component: Component<any>, id: string, name: string): Component<any>;

package/dist/runtime/server-runtime.js

@@ -0,0 +1,185 @@
+import { deserialize, toJSONAsync } from "seroval";
+import { CustomEventPlugin, DOMExceptionPlugin, EventPlugin, FormDataPlugin, HeadersPlugin, ReadableStreamPlugin, RequestPlugin, ResponsePlugin, URLPlugin, URLSearchParamsPlugin } from "seroval-plugins/web";
+import { createIslandReference } from "../server/islands/index";
+class SerovalChunkReader {
+    reader;
+    buffer;
+    done;
+    constructor(stream) {
+        this.reader = stream.getReader();
+        this.buffer = "";
+        this.done = false;
+    }
+    async readChunk() {
+        // if there's no chunk, read again
+        const chunk = await this.reader.read();
+        if (!chunk.done) {
+            // repopulate the buffer
+            this.buffer += new TextDecoder().decode(chunk.value);
+        }
+        else {
+            this.done = true;
+        }
+    }
+    async next() {
+        // Check if the buffer is empty
+        if (this.buffer === "") {
+            // 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 bytes = Number.parseInt(this.buffer.substring(1, 11), 16); // ;0x00000000;
+        // 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 = this.buffer.substring(12, 12 + bytes);
+        // The rest goes to the buffer
+        this.buffer = this.buffer.substring(12 + bytes);
+        // Deserialize the chunk
+        return {
+            done: false,
+            value: deserialize(partial)
+        };
+    }
+    async drain() {
+        while (true) {
+            const result = await this.next();
+            if (result.done) {
+                break;
+            }
+        }
+    }
+}
+async function deserializeStream(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().then(() => {
+            // @ts-ignore
+            delete $R[id];
+        }, () => {
+            // no-op
+        });
+    }
+    return result.value;
+}
+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 fetchServerFunction(base, id, options, args) {
+    const instance = `server-fn:${INSTANCE++}`;
+    const response = await (args.length === 0
+        ? createRequest(base, id, instance, options)
+        : args.length === 1 && args[0] instanceof FormData
+            ? createRequest(base, id, instance, { ...options, body: args[0] })
+            : createRequest(base, id, instance, {
+                ...options,
+                body: JSON.stringify(await Promise.resolve(toJSONAsync(args, {
+                    plugins: [
+                        CustomEventPlugin,
+                        DOMExceptionPlugin,
+                        EventPlugin,
+                        FormDataPlugin,
+                        HeadersPlugin,
+                        ReadableStreamPlugin,
+                        RequestPlugin,
+                        ResponsePlugin,
+                        URLSearchParamsPlugin,
+                        URLPlugin
+                    ]
+                }))),
+                headers: { ...options.headers, "Content-Type": "application/json" }
+            }));
+    if (response.headers.get("Location") ||
+        response.headers.get("X-Revalidate") ||
+        response.headers.get("X-Single-Flight")) {
+        if (response.body) {
+            /* @ts-ignore-next-line */
+            response.customBody = () => {
+                return deserializeStream(instance, response);
+            };
+        }
+        return response;
+    }
+    const contentType = response.headers.get("Content-Type");
+    let result;
+    if (contentType && contentType.startsWith("text/plain")) {
+        result = await response.text();
+    }
+    else if (contentType && contentType.startsWith("application/json")) {
+        result = await response.json();
+    }
+    else {
+        result = await deserializeStream(instance, response);
+    }
+    if (response.headers.has("X-Error")) {
+        throw result;
+    }
+    return result;
+}
+export function createServerReference(fn, id, name) {
+    const baseURL = import.meta.env.SERVER_BASE_URL;
+    return new Proxy(fn, {
+        get(target, prop, receiver) {
+            if (prop === "url") {
+                return `${baseURL}/_server?id=${encodeURIComponent(id)}&name=${encodeURIComponent(name)}`;
+            }
+            if (prop === "GET") {
+                return receiver.withOptions({ method: "GET" });
+            }
+            if (prop === "withOptions") {
+                const url = `${baseURL}/_server/?id=${encodeURIComponent(id)}&name=${encodeURIComponent(name)}`;
+                return (options) => {
+                    const fn = (...args) => {
+                        const encodeArgs = options.method && options.method.toUpperCase() === "GET";
+                        return fetchServerFunction(encodeArgs
+                            ? url + (args.length ? `&args=${JSON.stringify(args)}` : "")
+                            : `${baseURL}/_server`, `${id}#${name}`, options, encodeArgs ? [] : args);
+                    };
+                    fn.url = url;
+                    return fn;
+                };
+            }
+        },
+        apply(target, thisArg, args) {
+            return fetchServerFunction(`${baseURL}/_server`, `${id}#${name}`, {}, args);
+        }
+    });
+}
+export function createClientReference(Component, id, name) {
+    if (typeof Component === "function") {
+        return createIslandReference(Component, id, name);
+    }
+    return Component;
+}

package/dist/server/StartServer.d.ts

@@ -0,0 +1,5 @@
+import type { Component, JSX } from "solid-js";
+import type { DocumentComponentProps } from "./types";
+export declare function StartServer(props: {
+    document: Component<DocumentComponentProps>;
+}): JSX.Element;

package/dist/server/StartServer.jsx

@@ -0,0 +1,78 @@
+// @refresh skip
+// @ts-ignore
+import App from "#start/app";
+import { Hydration, HydrationScript, NoHydration, getRequestEvent, ssr, useAssets } from "solid-js/web";
+import { ErrorBoundary } from "../shared/ErrorBoundary";
+import { renderAsset } from "./renderAsset";
+const docType = ssr("<!DOCTYPE html>");
+function matchRoute(matches, routes, matched = []) {
+    for (let i = 0; i < routes.length; i++) {
+        const segment = routes[i];
+        if (segment.path !== matches[0].path)
+            continue;
+        let next = [...matched, segment];
+        if (segment.children) {
+            const nextMatches = matches.slice(1);
+            if (nextMatches.length === 0)
+                continue;
+            next = matchRoute(nextMatches, segment.children, next);
+            if (!next)
+                continue;
+        }
+        return next;
+    }
+}
+export function StartServer(props) {
+    const context = getRequestEvent();
+    // @ts-ignore
+    const nonce = context.nonce;
+    let assets = [];
+    Promise.resolve().then(async () => {
+        // @ts-ignore
+        if (context.router && context.router.matches) {
+            // @ts-ignore
+            const matches = [...context.router.matches];
+            while (matches.length && (!matches[0].info || !matches[0].info.filesystem))
+                matches.shift();
+            const matched = matches.length && matchRoute(matches, context.routes);
+            if (matched) {
+                for (let i = 0; i < matched.length; i++) {
+                    const segment = matched[i];
+                    const part = import.meta.env.MANIFEST[import.meta.env.START_ISLANDS ? "ssr" : "client"]
+                        .inputs[segment["$component"].src];
+                    const asset = (await part.assets());
+                    assets.push.apply(assets, asset);
+                }
+            }
+            else
+                console.warn("No route matched for preloading js assets");
+        }
+        // dedupe assets
+        assets = [...new Map(assets.map(item => [item.attrs.key, item])).values()].filter(asset => import.meta.env.START_ISLANDS
+            ? false
+            : asset.attrs.rel === "modulepreload" &&
+                !context.assets.find((a) => a.attrs.key === asset.attrs.key));
+    });
+    useAssets(() => (assets.length ? assets.map(m => renderAsset(m)) : undefined));
+    return (<NoHydration>
+      {docType}
+      <props.document assets={<>
+            <HydrationScript />
+            {context.assets.map((m) => renderAsset(m))}
+          </>} scripts={nonce ? (<>
+              <script nonce={nonce} innerHTML={`window.manifest = ${JSON.stringify(context.manifest)}`}/>
+              <script type="module" nonce={nonce} async src={import.meta.env.MANIFEST["client"].inputs[import.meta.env.MANIFEST["client"].handler].output.path}/>
+            </>) : (<>
+              <script innerHTML={`window.manifest = ${JSON.stringify(context.manifest)}`}/>
+              <script type="module" async src={import.meta.env.MANIFEST["client"].inputs[import.meta.env.MANIFEST["client"].handler].output.path}/>
+            </>)}>
+        {!import.meta.env.START_ISLANDS ? (<Hydration>
+            <ErrorBoundary>
+              <App />
+            </ErrorBoundary>
+          </Hydration>) : (<ErrorBoundary>
+            <App />
+          </ErrorBoundary>)}
+      </props.document>
+    </NoHydration>);
+}

package/dist/server/fetchEvent.d.ts

@@ -0,0 +1,6 @@
+import { H3Event } from "vinxi/http";
+import type { FetchEvent } from "./types";
+export declare function createFetchEvent(event: H3Event): FetchEvent;
+export declare function cloneEvent<T extends FetchEvent>(fetchEvent: T): T;
+export declare function getFetchEvent(h3Event: H3Event): FetchEvent;
+export declare function mergeResponseHeaders(h3Event: H3Event, headers: Headers): void;

package/dist/server/fetchEvent.js

@@ -0,0 +1,88 @@
+import { appendResponseHeader, getRequestIP, getResponseHeader, getResponseHeaders, getResponseStatus, getResponseStatusText, getWebRequest, removeResponseHeader, setHeader, setResponseHeader, setResponseStatus } from "vinxi/http";
+const fetchEventSymbol = Symbol("fetchEvent");
+export function createFetchEvent(event) {
+    return {
+        request: getWebRequest(event),
+        response: createResponseStub(event),
+        clientAddress: getRequestIP(event),
+        locals: {},
+        nativeEvent: event
+    };
+}
+export function cloneEvent(fetchEvent) {
+    return {
+        ...fetchEvent
+    };
+}
+export function getFetchEvent(h3Event) {
+    if (!h3Event[fetchEventSymbol]) {
+        const fetchEvent = createFetchEvent(h3Event);
+        h3Event[fetchEventSymbol] = fetchEvent;
+    }
+    return h3Event[fetchEventSymbol];
+}
+export function mergeResponseHeaders(h3Event, headers) {
+    for (const [key, value] of headers.entries()) {
+        setHeader(h3Event, key, value);
+    }
+}
+class HeaderProxy {
+    event;
+    constructor(event) {
+        this.event = event;
+    }
+    get(key) {
+        const h = getResponseHeader(this.event, key);
+        return Array.isArray(h) ? h.join(", ") : h || null;
+    }
+    has(key) {
+        return this.get(key) !== undefined;
+    }
+    set(key, value) {
+        return setResponseHeader(this.event, key, value);
+    }
+    delete(key) {
+        return removeResponseHeader(this.event, key);
+    }
+    append(key, value) {
+        appendResponseHeader(this.event, key, value);
+    }
+    getSetCookie() {
+        const cookies = getResponseHeader(this.event, "Set-Cookie");
+        return Array.isArray(cookies) ? cookies : [cookies];
+    }
+    forEach(fn) {
+        return Object.entries(getResponseHeaders(this.event)).forEach(([key, value]) => fn(Array.isArray(value) ? value.join(", ") : value, key, this));
+    }
+    entries() {
+        return Object.entries(getResponseHeaders(this.event))
+            .map(([key, value]) => [key, Array.isArray(value) ? value.join(", ") : value])[Symbol.iterator]();
+    }
+    keys() {
+        return Object.keys(getResponseHeaders(this.event))[Symbol.iterator]();
+    }
+    values() {
+        return Object.values(getResponseHeaders(this.event))
+            .map(value => (Array.isArray(value) ? value.join(", ") : value))[Symbol.iterator]();
+    }
+    [Symbol.iterator]() {
+        return this.entries()[Symbol.iterator]();
+    }
+}
+function createResponseStub(event) {
+    return {
+        get status() {
+            return getResponseStatus(event);
+        },
+        set status(v) {
+            setResponseStatus(event, v);
+        },
+        get statusText() {
+            return getResponseStatusText(event);
+        },
+        set statusText(v) {
+            setResponseStatus(event, getResponseStatus(), v);
+        },
+        headers: new HeaderProxy(event)
+    };
+}

package/dist/server/handler.d.ts

@@ -0,0 +1,3 @@
+import type { FetchEvent, HandlerOptions, PageEvent } from "./types";
+export declare function createBaseHandler(fn: (context: PageEvent) => unknown, createPageEvent: (event: FetchEvent) => Promise<PageEvent>, options?: HandlerOptions | ((context: PageEvent) => HandlerOptions | Promise<HandlerOptions>)): import("h3").EventHandler<import("h3").EventHandlerRequest, Promise<any>>;
+export declare function createHandler(fn: (context: PageEvent) => unknown, options?: HandlerOptions | ((context: PageEvent) => HandlerOptions | Promise<HandlerOptions>)): import("h3").EventHandler<import("h3").EventHandlerRequest, Promise<any>>;