@primate/core 0.4.6 → 0.6.0

package/lib/private/request/RequestBody.js

@@ -1,14 +1,11 @@
-import fail from "#fail";
-import json from "@rcompat/http/mime/application/json";
-import binary from "@rcompat/http/mime/application/octet-stream";
-import www_form from "@rcompat/http/mime/application/x-www-form-urlencoded";
-import form_data from "@rcompat/http/mime/multipart/form-data";
-import text from "@rcompat/http/mime/text/plain";
+import E from "#errors";
+import { MIME } from "@rcompat/http";
+import is from "@rcompat/is";
 async function anyform(request) {
     const form = Object.create(null);
     const files = Object.create(null);
     for (const [key, value] of (await request.formData()).entries()) {
-        if (typeof value === "string") {
+        if (is.string(value)) {
             form[key] = value;
         }
         else {
@@ -18,40 +15,41 @@ async function anyform(request) {
     return { form, files };
 }
 ;
-export default class RequestBody {
-    #parsed;
-    #files;
-    static async parse(request, url) {
-        const raw = request.headers.get("content-type") ?? "none";
-        const type = raw.split(";")[0].trim().toLowerCase();
-        const path = url.pathname;
-        try {
-            switch (type) {
-                case binary:
-                    return new RequestBody({ type: "binary", value: await request.blob() });
-                case www_form:
-                case form_data: {
-                    const { form, files } = await anyform(request);
-                    return new RequestBody({ type: "form", value: form }, files);
-                }
-                case json:
-                    return new RequestBody({ type: "json", value: await request.json() });
-                case text:
-                    return new RequestBody({ type: "text", value: await request.text() });
-                case "none":
-                    return RequestBody.none();
-                default:
-                    throw fail("{0}: unsupported content type {1}", path, type);
+async function parse(request, url) {
+    const raw = request.headers.get("content-type") ?? "none";
+    const type = raw.split(";")[0].trim().toLowerCase();
+    const path = url.pathname;
+    try {
+        switch (type) {
+            case MIME.APPLICATION_OCTET_STREAM:
+                return new RequestBody({ type: "binary", value: await request.blob() });
+            case MIME.APPLICATION_X_WWW_FORM_URLENCODED:
+            case MIME.MULTIPART_FORM_DATA: {
+                const { form, files } = await anyform(request);
+                return new RequestBody({ type: "form", value: form }, files);
             }
-        }
-        catch (cause) {
-            const message = "{0}: unparseable content type {1} - cause:\n[2]";
-            throw fail(message, path, type, cause);
+            case MIME.APPLICATION_JSON:
+                return new RequestBody({ type: "json", value: await request.json() });
+            case MIME.TEXT_PLAIN:
+                return new RequestBody({ type: "text", value: await request.text() });
+            case "none":
+                return RequestBody.none();
+            default:
+                throw E.request_unsupported_mime(path, type);
         }
     }
-    static none() {
-        return new RequestBody({ type: "none", value: null });
+    catch (cause) {
+        throw E.request_unparsable_mime(path, type, cause);
     }
+}
+function none() {
+    return new RequestBody({ type: "none", value: null });
+}
+export default class RequestBody {
+    #parsed;
+    #files;
+    static parse = parse;
+    static none = none;
     constructor(parsed, files = {}) {
         this.#parsed = parsed;
         this.#files = files;
@@ -62,44 +60,38 @@ export default class RequestBody {
     #value() {
         return this.#parsed.value;
     }
-    #throw(expected) {
-        throw fail("request body: expected {0}, got {1}", expected, this.type);
+    #unexpected_body(expected) {
+        throw E.request_unexpected_body(expected, this.type);
     }
-    json(schema) {
-        if (this.type !== "json") {
-            this.#throw("JSON");
-        }
-        const value = this.#value();
-        return schema ? schema.parse(value) : value;
+    json() {
+        if (this.type !== "json")
+            this.#unexpected_body("JSON");
+        return this.#value();
     }
-    form(schema) {
-        if (this.type !== "form") {
-            this.#throw("form");
-        }
-        const value = this.#value();
-        return schema ? schema.parse(value) : value;
+    form() {
+        if (this.type !== "form")
+            this.#unexpected_body("form");
+        return this.#value();
     }
     files() {
-        if (this.type !== "form") {
-            this.#throw("form");
-        }
+        if (this.type !== "form")
+            this.#unexpected_body("form");
         return this.#files;
     }
     text() {
-        if (this.type !== "text") {
-            this.#throw("plaintext");
-        }
+        if (this.type !== "text")
+            this.#unexpected_body("plaintext");
         return this.#value();
     }
     binary() {
         if (this.type !== "binary") {
-            this.#throw("binary");
+            this.#unexpected_body("binary");
         }
         return this.#value();
     }
     none() {
         if (this.type !== "none") {
-            this.#throw("none");
+            this.#unexpected_body("none");
         }
         return null;
     }

package/lib/private/request/RequestContext.d.ts

@@ -0,0 +1,12 @@
+import type { Dict } from "@rcompat/type";
+export default class RequestContext {
+    #private;
+    set<T>(key: string, value: T): void;
+    update<T>(key: string, fn: (prev: T | undefined) => T): void;
+    has(key: string): boolean;
+    try<T>(key: string): T | undefined;
+    get<T>(key: string): T;
+    delete(key: string): void;
+    toJSON(): Dict;
+}
+//# sourceMappingURL=RequestContext.d.ts.map

package/lib/private/request/RequestContext.js

@@ -0,0 +1,31 @@
+export default class RequestContext {
+    #data = new Map();
+    set(key, value) {
+        this.#data.set(key, value);
+    }
+    update(key, fn) {
+        const prev = this.try(key);
+        this.set(key, fn(prev));
+    }
+    has(key) {
+        return this.#data.has(key);
+    }
+    try(key) {
+        return this.#data.get(key);
+    }
+    get(key) {
+        if (!this.#data.has(key))
+            throw new Error(`Missing context key: ${key}`);
+        return this.#data.get(key);
+    }
+    delete(key) {
+        this.#data.delete(key);
+    }
+    toJSON() {
+        const out = Object.create(null);
+        for (const [k, v] of this.#data)
+            out[k] = v;
+        return out;
+    }
+}
+//# sourceMappingURL=RequestContext.js.map

package/lib/private/request/RequestFacade.d.ts

@@ -1,20 +1,25 @@
 import type RequestBag from "#request/RequestBag";
 import type RequestBody from "#request/RequestBody";
-import type Dict from "@rcompat/type/Dict";
+import type RequestView from "#request/RequestView";
+import type Verb from "#request/Verb";
+import type { Dict } from "@rcompat/type";
 type RequestFacade = {
+    method: Verb;
     body: RequestBody;
-    context: Dict;
     cookies: RequestBag;
     forward(to: string, headers?: Dict<string>): Promise<Response>;
     headers: RequestBag;
     original: Request;
     path: RequestBag;
     query: RequestBag;
-    /**
-     * The request's pathname + querystring.
-     */
     target: string;
     url: URL;
-} & Dict<Dict | unknown>;
+    has(key: string): boolean;
+    try<T>(key: string): T | undefined;
+    get<T>(key: string): T;
+    set<T>(key: string, value: T | ((prev: T | undefined) => T)): RequestFacade;
+    delete(key: string): RequestFacade;
+    toJSON(): RequestView;
+};
 export { RequestFacade as default };
 //# sourceMappingURL=RequestFacade.d.ts.map

package/lib/private/request/RequestPublic.d.ts

@@ -0,0 +1,9 @@
+import type { Dict } from "@rcompat/type";
+type RequestPublic = {
+    cookies: Dict<string>;
+    headers: Dict<string>;
+    query: Dict<string>;
+    url: URL;
+};
+export type { RequestPublic as default };
+//# sourceMappingURL=RequestPublic.d.ts.map

package/lib/private/request/RequestPublic.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=RequestPublic.js.map

package/lib/private/request/RequestView.d.ts

@@ -0,0 +1,11 @@
+import type { Dict } from "@rcompat/type";
+type RequestView = {
+    context: Dict;
+    cookies: Dict<string>;
+    headers: Dict<string>;
+    path: Dict<string>;
+    query: Dict<string>;
+    url: URL;
+};
+export type { RequestView as default };
+//# sourceMappingURL=RequestView.d.ts.map

package/lib/private/request/RequestView.js

@@ -0,0 +1,3 @@
+;
+export {};
+//# sourceMappingURL=RequestView.js.map

package/lib/private/request/handle.d.ts

@@ -0,0 +1,4 @@
+import type RequestFacade from "#request/RequestFacade";
+import type ServeApp from "#serve/App";
+export default function handle(app: ServeApp, request: RequestFacade): Promise<Response>;
+//# sourceMappingURL=handle.d.ts.map

package/lib/private/request/handle.js

@@ -0,0 +1,18 @@
+import { Status } from "@rcompat/http";
+async function run(hooks, request) {
+    const [first, ...rest] = hooks;
+    if (first === undefined) {
+        return new Response(null, {
+            headers: {
+                "Content-Length": String(0),
+                "Cache-Control": "no-cache",
+            },
+            status: Status.INTERNAL_SERVER_ERROR,
+        });
+    }
+    return await first(request, next => run(rest, next));
+}
+export default function handle(app, request) {
+    return run(app.handle_hooks, request);
+}
+//# sourceMappingURL=handle.js.map

package/lib/private/request/parse.d.ts

@@ -1,4 +1,4 @@
 import type RequestFacade from "#request/RequestFacade";
-declare const _default: (request: Request) => RequestFacade;
-export default _default;
+declare function parse(request: Request): RequestFacade;
+export default parse;
 //# sourceMappingURL=parse.d.ts.map

package/lib/private/request/parse.js

@@ -1,5 +1,8 @@
 import RequestBag from "#request/RequestBag";
 import RequestBody from "#request/RequestBody";
+import RequestContext from "#request/RequestContext";
+import sContext from "#request/sContext";
+import is from "@rcompat/is";
 function decode(s) {
     try {
         return decodeURIComponent(s);
@@ -9,14 +12,16 @@ function decode(s) {
     }
 }
 ;
-const normalize = (k) => k.toLowerCase();
-function bagHeaders(request) {
+function normalize(k) {
+    return k.toLowerCase();
+}
+function header_bag(request) {
     const headers = Object.fromEntries([...request.headers].map(([k, v]) => [k.toLowerCase(), v]));
     return new RequestBag(headers, "headers", {
         normalize,
     });
 }
-function bagCookies(request) {
+function cookie_bag(request) {
     const header = request.headers.get("cookie");
     const entries = Object.fromEntries(header
         ? header.split(";").map(s => s.trim()).filter(Boolean).map(s => {
@@ -30,23 +35,21 @@ function bagCookies(request) {
         raw: header ?? "",
     });
 }
-function bagQuery(url) {
+function query_bag(url) {
     return new RequestBag(Object.fromEntries(url.searchParams), "query", {
         normalize,
         raw: url.search,
     });
 }
-function bagPath(url) {
-    return new RequestBag(Object.create(null), "path", {
-        raw: url.pathname,
-    });
+function path_bag(url) {
+    return new RequestBag(Object.create(null), "path", { raw: url.pathname });
 }
-export default (request) => {
+function parse(request) {
     const url = new URL(request.url);
-    return {
+    const facade = {
         body: RequestBody.none(),
-        context: {},
-        cookies: bagCookies(request),
+        method: request.method.toLowerCase(),
+        cookies: cookie_bag(request),
         forward(to, headers) {
             return fetch(to, {
                 body: request.body,
@@ -58,12 +61,48 @@ export default (request) => {
                 method: request.method,
             });
         },
-        headers: bagHeaders(request),
+        headers: header_bag(request),
         original: request,
-        path: bagPath(url),
-        query: bagQuery(url),
+        path: path_bag(url),
+        query: query_bag(url),
         target: url.pathname + url.search,
         url,
+        has(key) {
+            return this[sContext].has(key);
+        },
+        try(key) {
+            return this[sContext].try(key);
+        },
+        get(key) {
+            return this[sContext].get(key);
+        },
+        set(key, value) {
+            if (is.function(value)) {
+                this[sContext].update(key, value);
+            }
+            else {
+                this[sContext].set(key, value);
+            }
+            return this;
+        },
+        delete(key) {
+            this[sContext].delete(key);
+            return this;
+        },
+        toJSON() {
+            return {
+                context: this[sContext].toJSON(),
+                cookies: this.cookies.toJSON(),
+                headers: this.headers.toJSON(),
+                path: this.path.toJSON(),
+                query: this.query.toJSON(),
+                url: this.url,
+            };
+        },
+        [sContext]: new RequestContext(),
     };
-};
+    return facade;
+}
+;
+export default parse;
 //# sourceMappingURL=parse.js.map

package/lib/private/request/route.js

@@ -1,28 +1,43 @@
+import E from "#errors";
 import log from "#log";
 import response_error from "#response/error";
 import response_json from "#response/json";
 import respond from "#response/respond";
-import guard from "#route/guard";
-import Status from "@rcompat/http/Status";
+import { Status } from "@rcompat/http";
 import ParseError from "pema/ParseError";
-async function reducer(hooks, request) {
+const result = (request, response) => ({ request, response });
+function wrap_hook(h) {
+    return async (request, next) => {
+        let downstream;
+        let called_next = false;
+        const response = await h(request, async (r) => {
+            if (called_next)
+                throw E.hook_reused_next();
+            called_next = true;
+            downstream = await next(r);
+            return downstream.response;
+        });
+        // hook returned nothing
+        if (response === undefined) {
+            if (called_next)
+                throw E.hook_no_return();
+            throw E.hook_bad_return();
+        }
+        // if the hook called next(), we preserve the downstream request (mutations) but
+        // allow the hook to override the response by returning something else.
+        return downstream !== undefined
+            ? result(downstream.request, response)
+            : result(request, response);
+    };
+}
+async function run(hooks, request) {
     const [first, ...rest] = hooks;
+    if (first === undefined)
+        return result(request, new Response());
     if (rest.length === 0)
-        return await first(request, _ => new Response());
-    return await first(request, _ => reducer(rest, _));
+        return first(request, async (r) => result(r, new Response()));
+    return first(request, r => run(rest, r));
 }
-;
-// last, preserve final request form
-function last(handler) {
-    return async (request) => {
-        const response = await handler(request);
-        return {
-            request,
-            response: response,
-        };
-    };
-}
-;
 export default async function (app, partial_request) {
     let errorRoute;
     try {
@@ -30,12 +45,12 @@ export default async function (app, partial_request) {
         if (route === undefined) {
             return response_error()(app, {}, partial_request);
         }
-        const { errors, guards, handler, layouts } = route;
+        const { errors, hooks, layouts, handler } = route;
         errorRoute = errors[0];
-        const route_hooks = app.modules.map(module => module.route.bind(module));
-        const hooks = [...route_hooks, guard(guards), last(handler)];
-        // handle request
-        const { request, response } = await reducer(hooks, route.request);
+        const internal_hooks = app.route_hooks.map(wrap_hook);
+        const route_hooks = hooks.map(wrap_hook);
+        const last = async (req, _next) => result(req, await handler(req));
+        const { request, response } = await run([...internal_hooks, ...route_hooks, last], route.request);
         return await respond(response)(app, {
             layouts: await Promise.all(layouts.map(layout => layout(request))),
         }, request);

package/lib/private/request/router.d.ts

@@ -1,4 +1,4 @@
-import type FileRef from "@rcompat/fs/FileRef";
+import type { FileRef } from "@rcompat/fs";
 import FileRouter from "@rcompat/fs/FileRouter";
 declare const _default: (directory: FileRef, extensions: string[]) => Promise<FileRouter>;
 export default _default;

package/lib/private/request/router.js

@@ -1,56 +1,28 @@
-import AppError from "#AppError";
-import fail from "#fail";
+import E from "#errors";
 import FileRouter from "@rcompat/fs/FileRouter";
-const error_entries = Object.entries({
-    DoubleRoute: "double route {0}, disambiguate routes",
-    OptionalRoute: "optional route {0} may not be a directory",
-    RestRoute: "rest route {0} may not be a directory",
-});
-const allowed = {
-    re: /^[a-zA-Z0-9\-_+[\].]+$/,
-    replacements: ["a-Z", "0-9", "-", "_", "+", "[", "]", "."],
-    text: "letters ({1}), digits ({2}), {3}, {4}, {5}, {6}, {7}",
-};
-const specials = ["guard", "error", "layout"];
-const _ = allowed.re.source.slice(1, -1);
+const re = /^[a-zA-Z0-9\-_+[\].]+$/;
+const specials = ["error", "hook", "layout"];
 const p = /^(?:[^[\]]+|\[(?:\.{3})?[a-zA-Z0-9_]+\]|\[\[(?:\.{3})?[a-zA-Z0-9_]+\]\])$/;
 export default async (directory, extensions) => {
-    try {
-        const router = await FileRouter.load({
-            directory: directory.toString(),
-            extensions,
-            specials: {
-                error: { recursive: false },
-                guard: { recursive: true },
-                layout: { recursive: true },
-            },
-        });
-        router.all().map(route => {
-            const { path, segment } = route;
-            if (!allowed.re.test(segment)) {
-                const message = `route {0} may only contain ${allowed.text}`;
-                throw fail(message, path, ...allowed.replacements);
-            }
-            if (segment.startsWith("+") && !specials.includes(segment.slice(1))) {
-                throw fail("route {0} is not a valid special file", path);
-            }
-            if (!p.test(segment)) {
-                throw fail("route {0} has an invalid parameter", path);
-            }
-        });
-        return router;
-    }
-    catch (error) {
-        if (error instanceof AppError) {
-            throw error;
+    const router = await FileRouter.load({
+        directory: directory.toString(),
+        extensions,
+        specials: {
+            error: { recursive: false },
+            hook: { recursive: true },
+            layout: { recursive: true },
+        },
+    });
+    router.all().map(route => {
+        const { path, segment } = route;
+        if (!re.test(segment))
+            throw E.route_invalid_characters(path, re);
+        if (segment.startsWith("+") && !specials.includes(segment.slice(1))) {
+            throw E.route_invalid_special_file(path);
         }
-        error_entries.forEach(([key, value]) => {
-            if (key in FileRouter.Error) {
-                throw new AppError(value, error.route);
-            }
-        });
-        // rethrow original error
-        throw error;
-    }
+        if (!p.test(segment))
+            throw E.route_invalid_parameter(path, segment);
+    });
+    return router;
 };
 //# sourceMappingURL=router.js.map

package/lib/private/{database/symbol/wrap.d.ts → request/sContext.d.ts}

@@ -1,3 +1,3 @@
 declare const _default: symbol;
 export default _default;
-//# sourceMappingURL=wrap.d.ts.map
+//# sourceMappingURL=sContext.d.ts.map

package/lib/private/request/sContext.js

@@ -0,0 +1,2 @@
+export default Symbol("primate.request.context");
+//# sourceMappingURL=sContext.js.map

package/lib/private/request/storage.d.ts

@@ -0,0 +1,4 @@
+import type RequestFacade from "#request/RequestFacade";
+declare const _default: () => import("node:async_hooks").AsyncLocalStorage<RequestFacade>;
+export default _default;
+//# sourceMappingURL=storage.d.ts.map

package/lib/private/request/storage.js

@@ -0,0 +1,5 @@
+import io from "@rcompat/io";
+import cache from "@rcompat/kv/cache";
+const s = Symbol("primate.request");
+export default () => cache.get(s, () => new io.async.Context());
+//# sourceMappingURL=storage.js.map

package/lib/private/response/ResponseFunction.d.ts

@@ -1,8 +1,7 @@
-import type View from "#frontend/View";
+import type View from "#client/View";
 import type RequestFacade from "#request/RequestFacade";
 import type ServeApp from "#serve/App";
-import type Dict from "@rcompat/type/Dict";
-import type MaybePromise from "@rcompat/type/MaybePromise";
+import type { Dict, MaybePromise } from "@rcompat/type";
 type ResponseFunction = (app: ServeApp, transfer: Dict, request: RequestFacade) => MaybePromise<View | null | Response | undefined>;
 export { ResponseFunction as default };
 //# sourceMappingURL=ResponseFunction.d.ts.map

package/lib/private/response/ResponseLike.d.ts

@@ -1,6 +1,6 @@
 import type ResponseFunction from "#response/ResponseFunction";
 import type Streamable from "@rcompat/fs/Streamable";
-import type Dict from "@rcompat/type/Dict";
+import type { Dict } from "@rcompat/type";
 type ResponseLike = string | Dict | Dict[] | URL | Blob | ReadableStream | Streamable | Response | ResponseFunction | null;
 export { ResponseLike as default };
 //# sourceMappingURL=ResponseLike.d.ts.map

package/lib/private/response/binary.d.ts

@@ -1,5 +1,5 @@
 import type ServeApp from "#serve/App";
-import type StreamSource from "@rcompat/fs/StreamSource";
+import type { StreamSource } from "@rcompat/fs";
 /**
  * Stream a binary response.
  * @param source streamable source

package/lib/private/response/binary.js

@@ -1,5 +1,6 @@
 import Streamable from "@rcompat/fs/Streamable";
-import mime from "@rcompat/http/mime/application/octet-stream";
+import { MIME } from "@rcompat/http";
+import is from "@rcompat/is";
 const encodeRFC5987 = (s) => encodeURIComponent(s).replace(/['()*]/g, c => `%${c.charCodeAt(0).toString(16).toUpperCase()}`);
 /**
  * @security
@@ -30,11 +31,11 @@ function toContentDisposition(filename) {
  */
 export default function binary(source, init) {
     return (app) => {
-        const { headers, ...rest } = app.media(mime, init);
+        const { headers, ...rest } = app.media(MIME.APPLICATION_OCTET_STREAM, init);
         const name = Streamable.named(source) ? source.name : "default.bin";
         const out = new Headers(headers);
         out.set("Content-Disposition", toContentDisposition(name));
-        if (source instanceof Blob) {
+        if (is.blob(source)) {
             source.type && out.set("Content-Type", source.type);
             out.set("Content-Length", String(source.size));
         }

package/lib/private/response/error.d.ts

@@ -1,5 +1,5 @@
 import type ResponseFunction from "#response/ResponseFunction";
-import type ValidStatus from "@rcompat/http/ValidStatus";
+import type { ValidStatus } from "@rcompat/http";
 type Options = {
     body?: string;
     page?: string;