@solidjs/start 2.0.0-alpha.1 → 2.0.0-alpha.3

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

package/dist/fns/shared.js

@@ -0,0 +1,105 @@
+import { deserializeJSONStream, deserializeJSStream } from "./serialization.js";
+export const BODY_FORMAT_KEY = "X-Start-Type";
+export const BODY_FORMAL_FILE = "__START__";
+export var BodyFormat;
+(function (BodyFormat) {
+    BodyFormat["Seroval"] = "0";
+    BodyFormat["String"] = "1";
+    BodyFormat["FormData"] = "2";
+    BodyFormat["URLSearchParams"] = "3";
+    BodyFormat["Blob"] = "4";
+    BodyFormat["File"] = "5";
+    BodyFormat["ArrayBuffer"] = "6";
+    BodyFormat["Uint8Array"] = "7";
+})(BodyFormat || (BodyFormat = {}));
+export function getHeadersAndBody(body) {
+    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, client, source) {
+    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/dist/http/index.d.ts

@@ -70,7 +70,7 @@ export declare const setHeaders: (values: Record<string, string>) => void;
 export declare const getHeader: WrapFunction<typeof h3.getRequestHeader>;
 export declare const getHeaders: WrapFunction<typeof h3.getRequestHeaders>;
 export declare const getRequestFingerprint: WrapFunction<typeof h3.getRequestFingerprint>;
-export declare const getRequestWebStream: () => ReadableStream<Uint8Array<ArrayBufferLike>> | null;
+export declare const getRequestWebStream: () => ReadableStream<Uint8Array<ArrayBuffer>> | null;
 export declare const readFormData: () => Promise<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 declare const readValidatedBody: PrependOverload<typeof h3.readValidatedBody, WrappedReadValidatedBody>;

package/dist/middleware/index.d.ts

@@ -9,6 +9,26 @@ type ResponseMiddlewareResponseParam = {
     body?: Awaited<EventHandlerResponse>;
 };
 export type ResponseMiddleware = (event: FetchEvent, response: ResponseMiddlewareResponseParam) => Response | Promise<Response> | void | Promise<void>;
+/**
+ * Creates middleware for handling requests and responses.
+ *
+ * @see https://docs.solidjs.com/solid-start/reference/server/create-middleware
+/**
+ * Creates request/response middlewares via H3.
+ *
+ * Accepts an array of H3 {@link Middleware}
+ *
+ * @tip To run your middleware before response, `await next()` in your function block.
+ *@example
+ * const middleware = createMiddleware([
+ *   async (event, next) => {
+ *     const resp = await next();
+ *     if (resp instanceof Response) return resp;
+ *     return new Response("Not found", { status: 404 });
+ *   },
+ * ]);
+ *
+ */
 export declare function createMiddleware(args: {
     /** @deprecated Use H3 `Middleware` */
     onRequest?: RequestMiddleware | RequestMiddleware[] | undefined;

package/dist/middleware/index.js

@@ -13,12 +13,32 @@ function wrapResponseMiddleware(onBeforeResponse) {
         const resp = await next();
         const fetchEvent = getFetchEvent(h3Event);
         const mwResponse = await onBeforeResponse(fetchEvent, {
-            body: resp?.body,
+            body: resp,
         });
         if (mwResponse)
             return mwResponse;
     };
 }
+/**
+ * Creates middleware for handling requests and responses.
+ *
+ * @see https://docs.solidjs.com/solid-start/reference/server/create-middleware
+/**
+ * Creates request/response middlewares via H3.
+ *
+ * Accepts an array of H3 {@link Middleware}
+ *
+ * @tip To run your middleware before response, `await next()` in your function block.
+ *@example
+ * const middleware = createMiddleware([
+ *   async (event, next) => {
+ *     const resp = await next();
+ *     if (resp instanceof Response) return resp;
+ *     return new Response("Not found", { status: 404 });
+ *   },
+ * ]);
+ *
+ */
 export function createMiddleware(args) {
     if (Array.isArray(args))
         return args;