@primate/core 0.1.9 → 0.2.0

package/lib/private/module/Hook.js

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

package/lib/private/module/Next.d.ts

@@ -0,0 +1,4 @@
+import type MaybePromise from "@rcompat/type/MaybePromise";
+type Next<I, O = I> = (i: I) => MaybePromise<O>;
+export type { Next as default };
+//# sourceMappingURL=Next.d.ts.map

package/lib/private/module/Next.js

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

package/lib/private/module/NextBuild.d.ts

@@ -0,0 +1,5 @@
+import type BuildApp from "#BuildApp";
+import type Next from "#module/Next";
+type NextBuild = Next<BuildApp>;
+export type { NextBuild as default };
+//# sourceMappingURL=NextBuild.d.ts.map

package/lib/private/module/NextBuild.js

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

package/lib/private/module/NextHandle.d.ts

@@ -0,0 +1,5 @@
+import type Next from "#module/Next";
+import type RequestFacade from "#request/RequestFacade";
+type NextHandle = Next<RequestFacade, Response>;
+export type { NextHandle as default };
+//# sourceMappingURL=NextHandle.d.ts.map

package/lib/private/module/NextHandle.js

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

package/lib/private/module/NextRoute.d.ts

@@ -0,0 +1,6 @@
+import type Next from "#module/Next";
+import type RequestFacade from "#request/RequestFacade";
+import type ResponseLike from "#response/ResponseLike";
+type NextRoute = Next<RequestFacade, ResponseLike>;
+export type { NextRoute as default };
+//# sourceMappingURL=NextRoute.d.ts.map

package/lib/private/module/NextRoute.js

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

package/lib/private/module/NextServe.d.ts

@@ -0,0 +1,5 @@
+import type Next from "#module/Next";
+import type ServeApp from "#ServeApp";
+type NextServe = Next<ServeApp>;
+export type { NextServe as default };
+//# sourceMappingURL=NextServe.d.ts.map

package/lib/private/module/NextServe.js

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

package/lib/private/module/RequestHook.d.ts

@@ -0,0 +1,6 @@
+import type Hook from "#module/Hook";
+import type RequestFacade from "#request/RequestFacade";
+import type ResponseLike from "#response/ResponseLike";
+type RequestHook = Hook<RequestFacade, ResponseLike>;
+export type { RequestHook as default };
+//# sourceMappingURL=RequestHook.d.ts.map

package/lib/private/module/RequestHook.js

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

package/lib/private/reducer.d.ts

@@ -0,0 +1,24 @@
+import type App from "#App";
+import type BuildApp from "#BuildApp";
+import type Module from "#Module";
+import type RequestFacade from "#request/RequestFacade";
+import type ResponseLike from "#response/ResponseLike";
+import type ServeApp from "#ServeApp";
+type HookInput = {
+    build: BuildApp;
+    handle: RequestFacade;
+    init: App;
+    route: RequestFacade;
+    serve: ServeApp;
+};
+type HookOutput = {
+    build: BuildApp;
+    handle: ResponseLike;
+    init: App;
+    route: ResponseLike;
+    serve: ServeApp;
+};
+type Hook = keyof HookInput;
+export default function reducer<H extends Hook>(modules: Module[], dragon: HookInput[H], hook: H): Promise<HookOutput[H]>;
+export {};
+//# sourceMappingURL=reducer.d.ts.map

package/lib/private/reducer.js

@@ -0,0 +1,10 @@
+export default async function reducer(modules, dragon, hook) {
+    if (modules.length === 0) {
+        return dragon;
+    }
+    const [head, ...tail] = modules;
+    const method = head[hook].bind(head);
+    return await method(dragon, next => tail.length === 0 ? Promise.resolve(next) : reducer(tail, next, hook));
+}
+;
+//# sourceMappingURL=reducer.js.map

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

@@ -0,0 +1,80 @@
+import type PartialDict from "@rcompat/type/PartialDict";
+type Contents = PartialDict<string>;
+type Normalize = (key: string) => string;
+interface Schema<T> {
+    parse(input: unknown): T;
+}
+type Options = {
+    normalize?: Normalize;
+    raw?: string;
+};
+export default class RequestBag {
+    #private;
+    /**
+     * Create a new RequestBag.
+     *
+     * @param input - Initial key-value entries.
+     * @param name - Human-readable bag name used in error messages.
+     * @param options - Optional `normalize` function and `raw` string.
+     */
+    constructor(input: Contents, name: string, options?: Options);
+    /**
+     * The untouched, original source string for this bag. For example,
+     * - `"?a=1&b=2"` for a query bag,
+     * - the Cookie header for cookies,
+     * - the pathname for request path.
+     */
+    get raw(): string;
+    /**
+     * @returns the number of elements in the bag.
+     */
+    get size(): number;
+    /**
+     * Iterate over `[key, value]` entries in the bag.
+     * Keys are post-normalization; entries with `undefined` values are skipped.
+     */
+    [Symbol.iterator](): IterableIterator<readonly [string, string]>;
+    /**
+     * Get a value by key.
+     *
+     * @param key - Key to look up (pre-normalization).
+     * @returns The defined value.
+     * @throws If the key is absent or its value is `undefined`.
+     */
+    get(key: string): string;
+    /**
+     * Try to get a value by key.
+     *
+     * @param key - Key to look up (pre-normalization).
+     * @returns The value, or `undefined` if absent/undefined.
+     */
+    try(key: string): string | undefined;
+    /**
+     * Whether the bag contains a defined value for the key.
+     *
+     * @param key - Key to test (pre-normalization).
+     * @returns `true` if present with a defined value; otherwise `false`.
+     */
+    has(key: string): boolean;
+    /**
+     * Parse the entire bag with a schema.
+     *
+     * The schema receives the bag's normalized contents.
+     *
+     * @typeParam T - Parsed/validated result type.
+     * @param schema - Object exposing `parse(input)`.
+     * @returns The parsed value.
+     * @throws Whatever the schema throws.
+     */
+    parse<T>(schema: Schema<T>): T;
+    /** Returns {@link raw}. Useful in template strings. */
+    toString(): string;
+    /**
+     * JSON view of the normalized bag.
+     *
+     * @returns A shallow null-prototype clone of the bag's contents.
+     */
+    toJSON(): any;
+}
+export {};
+//# sourceMappingURL=RequestBag.d.ts.map

package/lib/private/request/RequestBag.js

@@ -0,0 +1,119 @@
+import fail from "#fail";
+import is from "@rcompat/assert/is";
+export default class RequestBag {
+    #contents;
+    #name;
+    #normalize;
+    #raw;
+    /**
+     * Create a new RequestBag.
+     *
+     * @param input - Initial key-value entries.
+     * @param name - Human-readable bag name used in error messages.
+     * @param options - Optional `normalize` function and `raw` string.
+     */
+    constructor(input, name, options = {}) {
+        is(input).object();
+        this.#name = name;
+        this.#normalize = options.normalize ?? (k => k);
+        this.#raw = options.raw ?? "";
+        const contents = Object.create(null);
+        for (const key of Object.keys(input)) {
+            const normalized = this.#normalize(key);
+            // last-wins semantics if only case differs
+            contents[normalized] = input[key];
+        }
+        this.#contents = contents;
+    }
+    #hasOwn(k) {
+        return Object.hasOwn(this.#contents, k);
+    }
+    /**
+     * The untouched, original source string for this bag. For example,
+     * - `"?a=1&b=2"` for a query bag,
+     * - the Cookie header for cookies,
+     * - the pathname for request path.
+     */
+    get raw() {
+        return this.#raw;
+    }
+    /**
+     * @returns the number of elements in the bag.
+     */
+    get size() {
+        return Object.keys(this.#contents).length;
+    }
+    /**
+     * Iterate over `[key, value]` entries in the bag.
+     * Keys are post-normalization; entries with `undefined` values are skipped.
+     */
+    *[Symbol.iterator]() {
+        for (const k of Object.keys(this.#contents)) {
+            const v = this.#contents[k];
+            if (v !== undefined)
+                yield [k, v];
+        }
+    }
+    /**
+     * Get a value by key.
+     *
+     * @param key - Key to look up (pre-normalization).
+     * @returns The defined value.
+     * @throws If the key is absent or its value is `undefined`.
+     */
+    get(key) {
+        const k = this.#normalize(key);
+        if (this.#hasOwn(k)) {
+            const v = this.#contents[k];
+            if (v !== undefined)
+                return v;
+        }
+        throw fail("{0} has no key {1}", this.#name, key);
+    }
+    /**
+     * Try to get a value by key.
+     *
+     * @param key - Key to look up (pre-normalization).
+     * @returns The value, or `undefined` if absent/undefined.
+     */
+    try(key) {
+        const k = this.#normalize(key);
+        return this.#hasOwn(k) ? this.#contents[k] : undefined;
+    }
+    /**
+     * Whether the bag contains a defined value for the key.
+     *
+     * @param key - Key to test (pre-normalization).
+     * @returns `true` if present with a defined value; otherwise `false`.
+     */
+    has(key) {
+        const k = this.#normalize(key);
+        return this.#hasOwn(k) && this.#contents[k] !== undefined;
+    }
+    /**
+     * Parse the entire bag with a schema.
+     *
+     * The schema receives the bag's normalized contents.
+     *
+     * @typeParam T - Parsed/validated result type.
+     * @param schema - Object exposing `parse(input)`.
+     * @returns The parsed value.
+     * @throws Whatever the schema throws.
+     */
+    parse(schema) {
+        return schema.parse(this.#contents);
+    }
+    /** Returns {@link raw}. Useful in template strings. */
+    toString() {
+        return this.raw;
+    }
+    /**
+     * JSON view of the normalized bag.
+     *
+     * @returns A shallow null-prototype clone of the bag's contents.
+     */
+    toJSON() {
+        return Object.assign(Object.create(null), this.#contents);
+    }
+}
+//# sourceMappingURL=RequestBag.js.map

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

@@ -0,0 +1,39 @@
+import type Dict from "@rcompat/type/Dict";
+import type JSONValue from "@rcompat/type/JSONValue";
+import type Schema from "@rcompat/type/Schema";
+type Fields = Dict<FormDataEntryValue>;
+type Parsed = {
+    type: "binary";
+    value: Blob;
+} | {
+    type: "fields";
+    value: Fields;
+} | {
+    type: "json";
+    value: JSONValue;
+} | {
+    type: "none";
+    value: null;
+} | {
+    type: "text";
+    value: string;
+};
+type ParseReturn<S> = S extends {
+    parse: (v: unknown) => infer R;
+} ? R : never;
+export default class RequestBody {
+    #private;
+    static parse(request: Request, url: URL): Promise<RequestBody>;
+    static none(): RequestBody;
+    constructor(p: Parsed);
+    get type(): "binary" | "fields" | "json" | "none" | "text";
+    json(): JSONValue;
+    json<S extends Schema<unknown>>(schema: S): ParseReturn<S>;
+    fields(): Fields;
+    fields<S extends Schema<unknown>>(schema: S): ParseReturn<S>;
+    text(): string;
+    binary(): Blob;
+    none(): null;
+}
+export {};
+//# sourceMappingURL=RequestBody.d.ts.map

package/lib/private/request/RequestBody.js

@@ -0,0 +1,91 @@
+import fail from "#fail";
+import json from "@rcompat/http/mime/application/json";
+import binary from "@rcompat/http/mime/application/octet-stream";
+import form from "@rcompat/http/mime/application/x-www-form-urlencoded";
+import formData from "@rcompat/http/mime/multipart/form-data";
+import text from "@rcompat/http/mime/text/plain";
+async function fromForm(request) {
+    const fields = Object.create(null);
+    for (const [key, value] of (await request.formData()).entries()) {
+        fields[key] = value;
+    }
+    return fields;
+}
+;
+export default class RequestBody {
+    #parsed;
+    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 form:
+                case formData:
+                    return new RequestBody({ type: "fields", value: await fromForm(request) });
+                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);
+            }
+        }
+        catch (cause) {
+            const message = "{0}: unparseable content type {1} - cause:\n[2]";
+            throw fail(message, path, type, cause);
+        }
+    }
+    static none() {
+        return new RequestBody({ type: "none", value: null });
+    }
+    constructor(p) {
+        this.#parsed = p;
+    }
+    get type() {
+        return this.#parsed.type;
+    }
+    #value() {
+        return this.#parsed.value;
+    }
+    #throw(expected) {
+        throw fail("request body: expected {0}, got {1}", expected, this.type);
+    }
+    json(schema) {
+        if (this.type !== "json") {
+            this.#throw("JSON");
+        }
+        const value = this.#value();
+        return schema ? schema.parse(value) : value;
+    }
+    fields(schema) {
+        if (this.type !== "fields") {
+            this.#throw("form fields");
+        }
+        const value = this.#value();
+        return schema ? schema.parse(value) : value;
+    }
+    text() {
+        if (this.type !== "text") {
+            this.#throw("plaintext");
+        }
+        return this.#value();
+    }
+    binary() {
+        if (this.type !== "binary") {
+            this.#throw("binary");
+        }
+        return this.#value();
+    }
+    none() {
+        if (this.type !== "none") {
+            this.#throw("none");
+        }
+        return null;
+    }
+}
+//# sourceMappingURL=RequestBody.js.map

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

@@ -0,0 +1,20 @@
+import type RequestBag from "#request/RequestBag";
+import type RequestBody from "#request/RequestBody";
+import type Dict from "@rcompat/type/Dict";
+type RequestFacade = {
+    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>;
+export { RequestFacade as default };
+//# sourceMappingURL=RequestFacade.d.ts.map

package/lib/private/request/RequestFacade.js

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

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

@@ -0,0 +1,4 @@
+import type verbs from "#request/verbs";
+type Verb = typeof verbs[number];
+export type { Verb as default };
+//# sourceMappingURL=Verb.d.ts.map

package/lib/private/request/Verb.js

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

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

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

package/lib/private/request/parse.js

@@ -0,0 +1,69 @@
+import RequestBag from "#request/RequestBag";
+import RequestBody from "#request/RequestBody";
+function decode(s) {
+    try {
+        return decodeURIComponent(s);
+    }
+    catch {
+        return s;
+    }
+}
+;
+const normalize = (k) => k.toLowerCase();
+function bagHeaders(request) {
+    const headers = Object.fromEntries([...request.headers].map(([k, v]) => [k.toLowerCase(), v]));
+    return new RequestBag(headers, "headers", {
+        normalize,
+    });
+}
+function bagCookies(request) {
+    const header = request.headers.get("cookie");
+    const entries = Object.fromEntries(header
+        ? header.split(";").map(s => s.trim()).filter(Boolean).map(s => {
+            const i = s.indexOf("=");
+            const key = i === -1 ? s : s.slice(0, i);
+            const value = i === -1 ? "" : s.slice(i + 1);
+            return [decode(key), decode(value)];
+        })
+        : []);
+    return new RequestBag(entries, "cookies", {
+        raw: header ?? "",
+    });
+}
+function bagQuery(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,
+    });
+}
+export default (request) => {
+    const url = new URL(request.url);
+    return {
+        body: RequestBody.none(),
+        context: {},
+        cookies: bagCookies(request),
+        forward(to, headers) {
+            return fetch(to, {
+                body: request.body,
+                duplex: "half",
+                headers: {
+                    ...headers,
+                    "Content-Type": request.headers.get("Content-Type"),
+                },
+                method: request.method,
+            });
+        },
+        headers: bagHeaders(request),
+        original: request,
+        path: bagPath(url),
+        query: bagQuery(url),
+        target: url.pathname + url.search,
+        url,
+    };
+};
+//# sourceMappingURL=parse.js.map

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

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

package/lib/private/request/route.js

@@ -0,0 +1,61 @@
+import log from "#log";
+import errorResponse from "#response/error";
+import jsonResponse from "#response/json";
+import respond from "#response/respond";
+import guard from "#route/guard";
+import Status from "@rcompat/http/Status";
+import ParseError from "pema/ParseError";
+async function reducer(hooks, request) {
+    const [first, ...rest] = hooks;
+    if (rest.length === 0) {
+        return await first(request, _ => new Response());
+    }
+    ;
+    return await first(request, _ => reducer(rest, _));
+}
+;
+// 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 {
+        const route = await app.route(partial_request);
+        if (route === undefined) {
+            return errorResponse()(app, {}, partial_request);
+        }
+        const { errors, guards, handler, layouts } = 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);
+        return await respond(response)(app, {
+            layouts: await Promise.all(layouts.map(layout => layout(request))),
+        }, request);
+    }
+    catch (error) {
+        const request = partial_request;
+        if (error instanceof ParseError) {
+            return jsonResponse(error.toJSON(), { status: Status.BAD_REQUEST })(app);
+        }
+        log.error(error);
+        // the +error.js page itself could fail
+        try {
+            return respond(await errorRoute(request))(app, {}, request);
+        }
+        catch {
+            return errorResponse()(app, {}, request);
+        }
+    }
+}
+;
+//# sourceMappingURL=route.js.map

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

@@ -0,0 +1,5 @@
+import type FileRef from "@rcompat/fs/FileRef";
+import FileRouter from "@rcompat/fs/FileRouter";
+declare const _default: (directory: FileRef, extensions: string[]) => Promise<FileRouter>;
+export default _default;
+//# sourceMappingURL=router.d.ts.map