solidstep 0.1.0

package/utils/server-action.client.js

@@ -0,0 +1,200 @@
+import fetch from './fetch.client';
+import { deserialize, toJSONAsync } from 'seroval';
+import { CustomEventPlugin, DOMExceptionPlugin, EventPlugin, FormDataPlugin, HeadersPlugin, ReadableStreamPlugin, RequestPlugin, ResponsePlugin, URLPlugin, URLSearchParamsPlugin } from 'seroval-plugins/web';
+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
+            let 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 header: ${head}`);
+        }
+        // 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: 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,
+            'server-action': id,
+        },
+        serverAction: true,
+    }, false);
+}
+const plugins = [
+    CustomEventPlugin,
+    DOMExceptionPlugin,
+    EventPlugin,
+    FormDataPlugin,
+    HeadersPlugin,
+    ReadableStreamPlugin,
+    RequestPlugin,
+    ResponsePlugin,
+    URLSearchParamsPlugin,
+    URLPlugin
+];
+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] })
+            : args.length === 1 && args[0] instanceof URLSearchParams
+                ? createRequest(base, id, instance, {
+                    ...options,
+                    body: args[0],
+                    headers: { ...options.headers, 'Content-Type': 'application/x-www-form-urlencoded' }
+                })
+                : createRequest(base, id, instance, {
+                    ...options,
+                    body: JSON.stringify(await Promise.resolve(toJSONAsync(args, { plugins }))),
+                    headers: { ...options.headers, 'Content-Type': 'application/json' }
+                }));
+    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 = () => {
+                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')) {
+        if (result.name === 'RedirectError') {
+            window.location.href = result.message;
+        }
+        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 = async (...args) => {
+                        const encodeArgs = options.method && options.method.toUpperCase() === 'GET';
+                        return fetchServerFunction(encodeArgs
+                            ? url +
+                                (args.length
+                                    ? `&args=${encodeURIComponent(JSON.stringify(await Promise.resolve(toJSONAsync(args, { plugins }))))}`
+                                    : '')
+                            : `${baseURL}/_server`, `${id}#${name}`, options, encodeArgs ? [] : args);
+                    };
+                    fn.url = url;
+                    return fn;
+                };
+            }
+            return target[prop];
+        },
+        apply(target, thisArg, args) {
+            return fetchServerFunction(`${baseURL}/_server`, `${id}#${name}`, {}, args);
+        }
+    });
+}

package/utils/server-action.server.d.ts

@@ -0,0 +1,5 @@
+import { type HTTPEvent } from 'vinxi/http';
+export declare function handleServerFunction(event: HTTPEvent): Promise<unknown>;
+declare const _default: import("vinxi/http").EventHandler<import("vinxi/http").EventHandlerRequest, Promise<unknown>>;
+export default _default;
+//# sourceMappingURL=server-action.server.d.ts.map

package/utils/server-action.server.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"server-action.server.d.ts","sourceRoot":"","sources":["../../utils/server-action.server.ts"],"names":[],"mappings":"AAgBA,OAAO,EAIN,KAAK,SAAS,EAWd,MAAM,YAAY,CAAC;AAoHpB,wBAAsB,oBAAoB,CAAC,KAAK,EAAE,SAAS,oBAqK1D;;AAED,wBAAkD"}

package/utils/server-action.server.js

@@ -0,0 +1,264 @@
+/// <reference types='vinxi/types/server' />
+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 { provideRequestEvent } from 'solid-js/web/storage';
+import { eventHandler, setHeader, setResponseStatus, appendResponseHeader, toWebRequest, getWebRequest, getRequestIP, getResponseStatus, getResponseStatusText, getResponseHeader, getResponseHeaders, removeResponseHeader, setResponseHeader } from 'vinxi/http';
+import invariant from 'vinxi/lib/invariant';
+import { getManifest } from 'vinxi/manifest';
+import { RedirectError } from './redirect';
+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);
+                }
+            });
+        }
+    });
+}
+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(event), v);
+        },
+        headers: new HeaderProxy(event)
+    };
+}
+export async function handleServerFunction(event) {
+    const request = toWebRequest(event);
+    const serverReference = request.headers.get('X-Server-Id');
+    const instance = request.headers.get('X-Server-Instance');
+    const url = new URL(request.url);
+    let functionId;
+    let name;
+    if (serverReference) {
+        invariant(typeof serverReference === 'string', 'Invalid server function');
+        [functionId, name] = serverReference.split('#');
+    }
+    else {
+        functionId = url.searchParams.get('id');
+        name = url.searchParams.get('name');
+        if (!functionId || !name) {
+            return process.env.NODE_ENV === 'development'
+                ? new Response('Server function not found', { status: 404 })
+                : new Response(null, { status: 404 });
+        }
+    }
+    const serverFunction = (await getManifest(import.meta.env.ROUTER_NAME).chunks[functionId].import())[name];
+    let parsed = [];
+    // grab bound arguments from url when no JS
+    if (!instance || event.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) => parsed.push(arg));
+        }
+    }
+    if (event.method === 'POST') {
+        const contentType = request.headers.get('content-type');
+        const h3Request = event.node.req;
+        // This should never be the case in 'proper' Nitro presets since node.req has to be IncomingMessage,
+        // But the new azure-functions preset for some reason uses a ReadableStream in node.req (#1521)
+        const isReadableStream = h3Request instanceof ReadableStream;
+        const hasReadableStream = h3Request.body instanceof ReadableStream;
+        const isH3EventBodyStreamLocked = (isReadableStream && h3Request.locked) ||
+            (hasReadableStream && h3Request.body.locked);
+        const requestBody = isReadableStream ? h3Request : h3Request.body;
+        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 and netlify preset)
+            parsed.push(await (isH3EventBodyStreamLocked
+                ? request
+                : new Request(request, { ...request, body: requestBody })).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 and netlify preset)
+            const tmpReq = isH3EventBodyStreamLocked
+                ? request
+                : new Request(request, { ...request, body: requestBody });
+            // 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({
+            request: getWebRequest(event),
+            response: createResponseStub(event),
+            clientAddress: getRequestIP(event),
+            locals: {},
+            nativeEvent: event
+        }, async () => {
+            sharedConfig.context = { event };
+            event.locals.serverFunctionMeta = {
+                id: `${functionId}#${name}`
+            };
+            return serverFunction(...parsed);
+        });
+        // handle responses
+        if (result instanceof Response) {
+            if (result.headers?.has('X-Content-Raw'))
+                return result;
+            if (instance) {
+                // forward headers
+                // if (result.headers) mergeResponseHeaders(event, result.headers);
+                // forward non-redirect statuses
+                if (result.status && (result.status < 300 || result.status >= 400))
+                    setResponseStatus(event, result.status);
+                if (result.customBody) {
+                    result = await result.customBody();
+                }
+                else if (result.body === undefined)
+                    result = null;
+            }
+        }
+        setHeader(event, 'content-type', 'text/javascript');
+        return serializeToStream(instance, result);
+    }
+    catch (x) {
+        if (x instanceof Response) {
+            // forward headers
+            // if ((x as any).headers) mergeResponseHeaders(event, (x as any).headers);
+            // forward non-redirect statuses
+            if (x.status && (!instance || x.status < 300 || x.status >= 400))
+                setResponseStatus(event, x.status);
+            if (x.customBody) {
+                // biome-ignore lint/suspicious/noCatchAssign: <explanation>
+                x = x.customBody();
+                // biome-ignore lint/suspicious/noCatchAssign: <explanation>
+            }
+            else if (x.body === undefined)
+                x = null;
+            setHeader(event, 'X-Error', 'true');
+        }
+        else if (instance) {
+            const error = x instanceof Error ? x.message : typeof x === 'string' ? x : 'true';
+            setHeader(event, 'X-Error', error.replace(/[\r\n]+/g, ''));
+            if (!(x instanceof RedirectError)) {
+                setResponseStatus(event, 500);
+            }
+        }
+        if (instance) {
+            setHeader(event, 'content-type', 'text/javascript');
+            return serializeToStream(instance, x);
+        }
+        return x;
+    }
+}
+export default eventHandler(handleServerFunction);

package/utils/server-only.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=server-only.d.ts.map

package/utils/server-only.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"server-only.d.ts","sourceRoot":"","sources":["../../utils/server-only.ts"],"names":[],"mappings":""}

package/utils/server-only.js

@@ -0,0 +1,4 @@
+import { isServer } from 'solid-js/web';
+if (!isServer) {
+    throw new Error('This module is only available on the server side.');
+}

package/utils/types.d.ts

@@ -0,0 +1,8 @@
+export type Meta = {
+    [key: string]: {
+        type: 'link' | 'meta' | 'script' | 'style' | 'title';
+        attributes: Record<string, string>;
+        content?: string;
+    };
+};
+//# sourceMappingURL=types.d.ts.map

package/utils/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../utils/types.ts"],"names":[],"mappings":"AACA,MAAM,MAAM,IAAI,GAAG;IACf,CAAC,GAAG,EAAE,MAAM,GAAG;QACX,IAAI,EAAE,MAAM,GAAG,MAAM,GAAG,QAAQ,GAAG,OAAO,GAAG,OAAO,CAAC;QACrD,UAAU,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;QACnC,OAAO,CAAC,EAAE,MAAM,CAAC;KACpB,CAAC;CACL,CAAC"}

package/utils/types.js

@@ -0,0 +1 @@
+export {};