@primate/core 0.1.9 → 0.2.0

package/lib/private/request/router.js

@@ -0,0 +1,56 @@
+import AppError from "#AppError";
+import fail from "#fail";
+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 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;
+        }
+        error_entries.forEach(([key, value]) => {
+            if (key in FileRouter.Error) {
+                throw new AppError(value, error.route);
+            }
+        });
+        // rethrow original error
+        throw error;
+    }
+};
+//# sourceMappingURL=router.js.map

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

@@ -0,0 +1,3 @@
+declare const _default: readonly ["get", "post", "put", "delete", "head", "connect", "options", "trace", "patch"];
+export default _default;
+//# sourceMappingURL=verbs.d.ts.map

package/lib/private/request/verbs.js

@@ -0,0 +1,12 @@
+export default [
+    "get",
+    "post",
+    "put",
+    "delete",
+    "head",
+    "connect",
+    "options",
+    "trace",
+    "patch",
+];
+//# sourceMappingURL=verbs.js.map

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

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

package/lib/private/response/ResponseFunction.js

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

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

@@ -0,0 +1,6 @@
+import type ResponseFunction from "#response/ResponseFunction";
+import type Streamable from "@rcompat/fs/Streamable";
+import type Dict from "@rcompat/type/Dict";
+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/ResponseLike.js

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

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

@@ -0,0 +1,10 @@
+import type ServeApp from "#ServeApp";
+import type StreamSource from "@rcompat/fs/StreamSource";
+/**
+ * Stream a binary response.
+ * @param source streamable source
+ * @param options response options
+ * @return Response rendering function
+ */
+export default function binary(source: StreamSource, init?: ResponseInit): (app: ServeApp) => Response;
+//# sourceMappingURL=binary.d.ts.map

package/lib/private/response/binary.js

@@ -0,0 +1,47 @@
+import Streamable from "@rcompat/fs/Streamable";
+import mime from "@rcompat/http/mime/application/octet-stream";
+const encodeRFC5987 = (s) => encodeURIComponent(s).replace(/['()*]/g, c => `%${c.charCodeAt(0).toString(16).toUpperCase()}`);
+/**
+ * @security
+ * risk: header injection (CWE-113)
+ * assumptions:
+ *   - filename may contain CR/LF and non-ASCII
+ * mitigations:
+ *   - strip CR/LF; escape quotes; add RFC5987 filename*
+ * references: RFC 6266, RFC 5987
+ */
+function toContentDisposition(filename) {
+    // prevent header injection (remove CR/LF) and limit length for safety
+    const clean = filename.replace(/[\r\n]/g, "").slice(0, 255);
+    // create an ASCII-safe version of the filename by replacing non-printable
+    // ASCII chars and quotes/backslashes (RFC 6266)
+    const ascii = clean.replace(/[^\x20-\x7E]/g, "_").replace(/["\\]/g, "_");
+    // encode the clean filename in UTF-8 using percent-encoding.
+    // this prepares it for the 'filename*' extended parameter (RFC 5987)
+    const utf8 = encodeRFC5987(clean);
+    return `attachment; filename="${ascii}"; filename*=UTF-8''${utf8}`;
+}
+;
+/**
+ * Stream a binary response.
+ * @param source streamable source
+ * @param options response options
+ * @return Response rendering function
+ */
+export default function binary(source, init) {
+    return (app) => {
+        const { headers, ...rest } = app.media(mime, 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) {
+            source.type && out.set("Content-Type", source.type);
+            out.set("Content-Length", String(source.size));
+        }
+        return app.respond(Streamable.stream(source), {
+            ...rest, headers: Object.fromEntries(out.entries()),
+        });
+    };
+}
+;
+//# sourceMappingURL=binary.js.map

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

@@ -0,0 +1,18 @@
+import type ResponseFunction from "#response/ResponseFunction";
+import type ValidStatus from "@rcompat/http/ValidStatus";
+type Options = {
+    body?: string;
+    page?: string;
+    status?: ValidStatus;
+};
+/**
+ * Render an error page.
+ *
+ * @param options.body HTML `%body%` replacement (default: `"Not Found"`).
+ * @param options.status Request status (default: `404 Not Found`).
+ * @param options.page HTML page to use (default: `error.html`).
+ * @return Response function.
+ */
+export default function error(options?: Options): ResponseFunction;
+export {};
+//# sourceMappingURL=error.d.ts.map

package/lib/private/response/error.js

@@ -0,0 +1,18 @@
+import location from "#location";
+import Status from "@rcompat/http/Status";
+/**
+ * Render an error page.
+ *
+ * @param options.body HTML `%body%` replacement (default: `"Not Found"`).
+ * @param options.status Request status (default: `404 Not Found`).
+ * @param options.page HTML page to use (default: `error.html`).
+ * @return Response function.
+ */
+export default function error(options) {
+    return app => app.view({
+        body: options?.body ?? "Not Found",
+        page: options?.page ?? location.error_html,
+        status: options?.status ?? Status.NOT_FOUND,
+    });
+}
+//# sourceMappingURL=error.js.map

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

@@ -0,0 +1,9 @@
+/**
+ * Issue a JSON response
+ * @param body body object
+ * @param options response options
+ * @return Response rendering function
+ */
+declare const _default: (body: unknown, init?: ResponseInit) => (app: import("../ServeApp.js").default) => import("@rcompat/type/MaybePromise").default<Response>;
+export default _default;
+//# sourceMappingURL=json.d.ts.map

package/lib/private/response/json.js

@@ -0,0 +1,10 @@
+import response from "#response";
+import mime from "@rcompat/http/mime/application/json";
+/**
+ * Issue a JSON response
+ * @param body body object
+ * @param options response options
+ * @return Response rendering function
+ */
+export default response(mime, JSON.stringify);
+//# sourceMappingURL=json.js.map

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

@@ -0,0 +1,11 @@
+import type ResponseFunction from "#response/ResponseFunction";
+type Redirection = 300 | 301 | 302 | 303 | 304 | 307 | 308;
+/**
+ * Redirect request
+ * @param location location to redirect to
+ * @param status redirection 3xx code
+ * @return Response rendering function
+ */
+declare const _default: (location: string, status?: Redirection) => ResponseFunction;
+export default _default;
+//# sourceMappingURL=redirect.d.ts.map

package/lib/private/response/redirect.js

@@ -0,0 +1,62 @@
+import Status from "@rcompat/http/Status";
+function hasCRLF(s) {
+    return /[\r\n]/.test(s);
+}
+function isAbsoluteUrl(s) {
+    try {
+        new URL(s);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+function encodePathname(s) {
+    // expect strict origin-form path ("/..."), disallow protocol-relative and
+    // backslashes
+    if (!s.startsWith("/") || s.startsWith("//") || s.includes("\\")) {
+        throw new Error("invalid pathname");
+    }
+    // encode per segment to avoid double-encoding present percent-escapes
+    return s.split("/")
+        .map((each, i) => i === 0 ? "" : encodeURIComponent(each)).join("/");
+}
+function toSearch(query) {
+    if (!query) {
+        return "";
+    }
+    const search = Object.entries(query)
+        .filter(([, v]) => v !== null && v !== undefined)
+        .reduce((params, [k, v]) => {
+        params.append(k, String(v));
+        return params;
+    }, new URLSearchParams())
+        .toString();
+    return search ? "?" + search : "";
+}
+function toNormalized(relative, base) {
+    // base -> URL resolution
+    if (base) {
+        const url = new URL(relative, new URL(String(base)));
+        return url.pathname + url.search;
+    }
+    // no base -> enforce strict single-slash path and strip fragment
+    if (!relative.startsWith("/") || relative.startsWith("//")) {
+        throw new Error("bad relative");
+    }
+    const i = relative.indexOf("#");
+    return i === -1 ? relative : relative.slice(0, i);
+}
+/**
+ * Redirect request
+ * @param location location to redirect to
+ * @param status redirection 3xx code
+ * @return Response rendering function
+ */
+export default (location, status) => 
+// no body
+app => app.respond(null, {
+    headers: { Location: location },
+    status: status ?? Status.FOUND,
+});
+//# sourceMappingURL=redirect.js.map

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

@@ -0,0 +1,5 @@
+import type ResponseFunction from "#response/ResponseFunction";
+import type ResponseLike from "#response/ResponseLike";
+declare const _default: (result: ResponseLike) => ResponseFunction;
+export default _default;
+//# sourceMappingURL=respond.d.ts.map

package/lib/private/response/respond.js

@@ -0,0 +1,31 @@
+import fail from "#fail";
+import binary from "#response/binary";
+import json from "#response/json";
+import redirect from "#response/redirect";
+import text from "#response/text";
+import Streamable from "@rcompat/fs/Streamable";
+import Status from "@rcompat/http/Status";
+import proper from "@rcompat/record/proper";
+function invalid_body(body) {
+    throw fail("invalid body {0} returned from route", body);
+}
+const is_instance = (of) => ((value) => value instanceof of);
+const is_response = is_instance(Response);
+const is_url = is_instance(URL);
+const is_null = (value) => value === null;
+function match(m) {
+    return m;
+}
+// [if, then]
+const guesses = match([
+    [is_null, () => () => new Response(null, { status: Status.NO_CONTENT })],
+    [is_url, value => redirect(value.toString())],
+    [Streamable.is, value => binary(value)],
+    [(value) => is_response(value), value => _ => value],
+    [proper, json],
+    [(value) => typeof value === "string", text],
+]);
+const guess = (value) => guesses.find(([_if]) => _if(value))?.[1](value)
+    ?? invalid_body(`${value}`);
+export default (result) => typeof result === "function" ? result : guess(result);
+//# sourceMappingURL=respond.js.map

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

@@ -0,0 +1,15 @@
+type Body = {
+    close?(): undefined;
+    open(events: {
+        send(name: string, data: unknown): undefined;
+    }): undefined;
+};
+/**
+ * Open a server-sent event stream
+ * @param body implementation body
+ * @param options response options
+ * @return Response rendering function
+ */
+declare const _default: (body: Body, init?: ResponseInit) => (app: import("../ServeApp.js").default) => import("@rcompat/type/MaybePromise").default<Response>;
+export default _default;
+//# sourceMappingURL=sse.d.ts.map

package/lib/private/response/sse.js

@@ -0,0 +1,25 @@
+import response from "#response";
+import mime from "@rcompat/http/mime/text/event-stream";
+const encode = (input) => new TextEncoder().encode(input);
+const handle = (body) => new ReadableStream({
+    cancel() {
+        body.close?.();
+    },
+    start(controller) {
+        body.open({
+            send(name, data) {
+                const event = data === undefined ? "" : `event: ${name}\n`;
+                const _data = JSON.stringify(data === undefined ? name : data);
+                controller.enqueue(encode(`${event}data:${_data}\n\n`));
+            },
+        });
+    },
+});
+/**
+ * Open a server-sent event stream
+ * @param body implementation body
+ * @param options response options
+ * @return Response rendering function
+ */
+export default response(mime, handle);
+//# sourceMappingURL=sse.js.map

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

@@ -0,0 +1,9 @@
+/**
+ * Return a plaintext response
+ * @param body plaintext body
+ * @param options response options
+ * @return Response rendering function
+ */
+declare const _default: (body: string, init?: ResponseInit) => (app: import("../ServeApp.js").default) => import("@rcompat/type/MaybePromise").default<Response>;
+export default _default;
+//# sourceMappingURL=text.d.ts.map

package/lib/private/response/text.js

@@ -0,0 +1,11 @@
+import response from "#response";
+import identity from "@rcompat/function/identity";
+import mime from "@rcompat/http/mime/text/plain";
+/**
+ * Return a plaintext response
+ * @param body plaintext body
+ * @param options response options
+ * @return Response rendering function
+ */
+export default response(mime, identity);
+//# sourceMappingURL=text.js.map

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

@@ -0,0 +1,11 @@
+import type ViewResponse from "#frontend/ViewResponse";
+/**
+ * Render a component using a frontend for the given filename extension
+ * @param component path to component
+ * @param props props for component
+ * @param options rendering options
+ * @return Response rendering function
+ */
+declare const view: ViewResponse;
+export default view;
+//# sourceMappingURL=view.d.ts.map

package/lib/private/response/view.js

@@ -0,0 +1,41 @@
+import fail from "#fail";
+import FileRef from "@rcompat/fs/FileRef";
+const extensions = ["extension", "fullExtension"];
+const backmap = {
+    "component.ts": "angular",
+    eta: "eta",
+    hbs: "handlebars",
+    html: "html",
+    htmx: "htmx",
+    marko: "marko",
+    md: "markdown",
+    poly: "poly",
+    solid: "solid",
+    svelte: "svelte",
+    voby: "voby",
+    vue: "vue",
+    webc: "webc",
+};
+function no_frontend(component) {
+    const extension = new FileRef(component).fullExtension.slice(1);
+    const hasPkg = extension in backmap;
+    const error = "No frontend for {0}";
+    const fix = hasPkg ? "" : ", did you configure {1}?";
+    const pkgname = hasPkg ? "" : `@primate/${backmap[extension]}`;
+    throw fail(`${error}${fix}`, component, pkgname);
+}
+/**
+ * Render a component using a frontend for the given filename extension
+ * @param component path to component
+ * @param props props for component
+ * @param options rendering options
+ * @return Response rendering function
+ */
+const view = (function viewResponse(component, props, options) {
+    return (app, transfer, request) => extensions
+        .map(extension => app.frontends[new FileRef(component)[extension]])
+        .find(extension => extension !== undefined)?.(component, props, options)(app, transfer, request)
+        ?? no_frontend(component);
+});
+export default view;
+//# sourceMappingURL=view.js.map

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

@@ -0,0 +1,5 @@
+import type ResponseFunction from "#response/ResponseFunction";
+import type Actions from "@rcompat/http/Actions";
+declare const _default: (actions: Actions) => ResponseFunction;
+export default _default;
+//# sourceMappingURL=ws.d.ts.map

package/lib/private/response/ws.js

@@ -0,0 +1,2 @@
+export default (actions) => (app, _, request) => app.upgrade(request.original, actions);
+//# sourceMappingURL=ws.js.map

package/lib/private/response.d.ts

@@ -0,0 +1,5 @@
+import type ServeApp from "#ServeApp";
+import type MaybePromise from "@rcompat/type/MaybePromise";
+declare const _default: <T>(mime: string, mapper: (input: T) => BodyInit) => (body: T, init?: ResponseInit) => (app: ServeApp) => MaybePromise<Response>;
+export default _default;
+//# sourceMappingURL=response.d.ts.map

package/lib/private/response.js

@@ -0,0 +1,2 @@
+export default (mime, mapper) => (body, init) => (app => app.respond(mapper(body), app.media(mime, init)));
+//# sourceMappingURL=response.js.map

package/lib/private/route/Handler.d.ts

@@ -0,0 +1,6 @@
+import type RequestFacade from "#request/RequestFacade";
+import type ResponseLike from "#response/ResponseLike";
+import type MaybePromise from "@rcompat/type/MaybePromise";
+type RouteHandler = (request: RequestFacade) => MaybePromise<ResponseLike>;
+export { RouteHandler as default };
+//# sourceMappingURL=Handler.d.ts.map

package/lib/private/route/Handler.js

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

package/lib/private/route/Options.d.ts

@@ -0,0 +1,5 @@
+type RouteOptions = {
+    parseBody?: boolean;
+};
+export type { RouteOptions as default };
+//# sourceMappingURL=Options.d.ts.map

package/lib/private/route/Options.js

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

package/lib/private/route/Path.d.ts

@@ -0,0 +1,11 @@
+import type Verb from "#request/Verb";
+import type RouteHandler from "#route/Handler";
+import type RouteOptions from "#route/Options";
+type RoutePath = {
+    [key in Verb]?: {
+        handler: RouteHandler;
+        options: RouteOptions;
+    };
+};
+export type { RoutePath as default };
+//# sourceMappingURL=Path.d.ts.map

package/lib/private/route/Path.js

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

package/lib/private/route/guard.d.ts

@@ -0,0 +1,4 @@
+import type RequestHook from "#module/RequestHook";
+import type RouteHandler from "#route/Handler";
+export default function (guards: RouteHandler[]): RequestHook;
+//# sourceMappingURL=guard.d.ts.map

package/lib/private/route/guard.js

@@ -0,0 +1,22 @@
+const sError = Symbol("guard_error");
+export default function (guards) {
+    return async (request, next) => {
+        try {
+            for (const guard of guards) {
+                const response = await guard(request);
+                if (response !== null)
+                    throw { response, type: sError };
+            }
+            return next(request);
+        }
+        catch (error) {
+            const guard_error = error;
+            if (guard_error.type === sError) {
+                return { request, response: guard_error.response };
+            }
+            // rethrow if not guard error
+            throw error;
+        }
+    };
+}
+//# sourceMappingURL=guard.js.map

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

@@ -0,0 +1,51 @@
+import type Verb from "#request/Verb";
+import type RouteHandler from "#route/Handler";
+import type RouteOptions from "#route/Options";
+declare class Router {
+    #private;
+    push(route: string): void;
+    pop(): void;
+    get active(): string | undefined;
+    add(verb: Verb, handler: RouteHandler, options?: RouteOptions): void;
+    get(path: string): {
+        options?: {
+            handler: RouteHandler;
+            options: RouteOptions;
+        } | undefined;
+        head?: {
+            handler: RouteHandler;
+            options: RouteOptions;
+        } | undefined;
+        get?: {
+            handler: RouteHandler;
+            options: RouteOptions;
+        } | undefined;
+        post?: {
+            handler: RouteHandler;
+            options: RouteOptions;
+        } | undefined;
+        put?: {
+            handler: RouteHandler;
+            options: RouteOptions;
+        } | undefined;
+        delete?: {
+            handler: RouteHandler;
+            options: RouteOptions;
+        } | undefined;
+        connect?: {
+            handler: RouteHandler;
+            options: RouteOptions;
+        } | undefined;
+        trace?: {
+            handler: RouteHandler;
+            options: RouteOptions;
+        } | undefined;
+        patch?: {
+            handler: RouteHandler;
+            options: RouteOptions;
+        } | undefined;
+    };
+}
+declare const _default: Router;
+export default _default;
+//# sourceMappingURL=router.d.ts.map

package/lib/private/route/router.js

@@ -0,0 +1,32 @@
+import assert from "@rcompat/assert";
+import is from "@rcompat/assert/is";
+import maybe from "@rcompat/assert/maybe";
+class Router {
+    #routes = {};
+    #stack = [];
+    push(route) {
+        this.#stack.push(route);
+    }
+    pop() {
+        this.#stack.pop();
+    }
+    get active() {
+        return this.#stack.at(-1);
+    }
+    add(verb, handler, options = {}) {
+        assert(this.active !== undefined);
+        is(handler).function();
+        maybe(options).object();
+        const active = this.active;
+        const routes = this.#routes;
+        if (!(active in routes)) {
+            routes[active] = {};
+        }
+        routes[active][verb] = { handler, options };
+    }
+    get(path) {
+        return { ...this.#routes[path] };
+    }
+}
+export default new Router();
+//# sourceMappingURL=router.js.map

package/lib/private/route/wrap.d.ts

@@ -0,0 +1,6 @@
+import type FileRef from "@rcompat/fs/FileRef";
+export default function wrap(code: string, file: FileRef, build: {
+    id: string;
+    stage: FileRef;
+}): string;
+//# sourceMappingURL=wrap.d.ts.map