@primate/core 0.6.3 → 0.7.0

package/lib/private/i18n/module.js

@@ -4,7 +4,8 @@ import PERSIST_HEADER from "#i18n/constant/PERSIST_HEADER";
 import E from "#i18n/errors";
 import storage from "#i18n/storage";
 import create from "#module/create";
-import { Status } from "@rcompat/http";
+import http from "@rcompat/http";
+import is from "@rcompat/is";
 function toLowerCase(string) {
     return string.toLowerCase();
 }
@@ -12,7 +13,7 @@ function pick(client, server) {
     const lower = server.map(toLowerCase);
     for (const raw of client.map(toLowerCase)) {
         const locale = raw.trim();
-        if (!locale)
+        if (!is.text(locale))
             continue;
         const exact = lower.indexOf(locale);
         if (exact !== -1)
@@ -67,7 +68,7 @@ export default function i18n_module(config) {
                         headers: {
                             "Content-Length": String(0),
                         },
-                        status: Status.NO_CONTENT,
+                        status: http.Status.NO_CONTENT,
                     });
                 // only accept existing locales
                 if (!locales.includes(requested))
@@ -75,7 +76,7 @@ export default function i18n_module(config) {
                         headers: {
                             "Content-Length": String(0),
                         },
-                        status: Status.NO_CONTENT,
+                        status: http.Status.NO_CONTENT,
                     });
                 const header = cookie(COOKIE_NAME, requested, {
                     secure,
@@ -87,7 +88,7 @@ export default function i18n_module(config) {
                         "Set-Cookie": header,
                         "Content-Length": String(0),
                     },
-                    status: Status.NO_CONTENT,
+                    status: http.Status.NO_CONTENT,
                 });
             });
             onRoute((request, next) => {

package/lib/private/index.d.ts

@@ -2,13 +2,21 @@ export type { default as App } from "#App";
 export type { default as BuildApp } from "#build/App";
 export type { default as Mode } from "#Mode";
 export type { default as Module } from "#Module";
-export type { BuildHook, HandleHook, InitHook, RouteHook, ServeHook, default as Setup } from "#module/Setup";
+export type { BuildHook, HandleHook, InitHook, RouteHook, ServeHook, default as Setup, } from "#module/Setup";
+export type { default as RequestContentType } from "#request/ContentType";
 export type { default as RequestBag } from "#request/RequestBag";
 export type { default as RequestBody } from "#request/RequestBody";
 export type { default as RequestFacade } from "#request/RequestFacade";
 export type { default as RequestPublic } from "#request/RequestPublic";
 export type { default as RequestView } from "#request/RequestView";
-export type { default as RequestVerb } from "#request/Verb";
+export type { default as ResponseFunction } from "#response/ResponseFunction";
+export type { default as ResponseLike } from "#response/ResponseLike";
 export type { default as ServeApp } from "#serve/App";
 export type { default as Target } from "#target/Target";
+import logger from "#logger";
+declare const core: {
+    logger: typeof logger;
+    try(fn: () => Promise<unknown>): Promise<void>;
+};
+export default core;
 //# sourceMappingURL=index.d.ts.map

package/lib/private/index.js

@@ -1,2 +1,14 @@
-export {};
+import logger from "#logger";
+const core = {
+    logger,
+    async try(fn) {
+        try {
+            await fn();
+        }
+        catch (cause) {
+            logger("error").error(cause);
+        }
+    },
+};
+export default core;
 //# sourceMappingURL=index.js.map

package/lib/private/logger.d.ts

@@ -0,0 +1,24 @@
+import type { LogHook } from "#module/Setup";
+declare const Schema: import("pema").DefaultType<import("pema").UnionType<[import("pema").LiteralType<"error">, import("pema").LiteralType<"warn">, import("pema").LiteralType<"info">, import("pema").LiteralType<"trace">]>, "trace" | "info" | "error" | "warn">;
+export { Schema };
+declare const levels: {
+    readonly error: 0;
+    readonly warn: 1;
+    readonly info: 2;
+    readonly trace: 3;
+};
+type Level = keyof typeof levels;
+export type LogEntry = {
+    level: Level;
+    message: string;
+};
+export default function logger(level?: string, hooks?: LogHook[]): {
+    readonly level: string;
+    print(strings: TemplateStringsArray, ...params: unknown[]): void;
+    system(strings: TemplateStringsArray, ...params: unknown[]): void;
+    trace(strings: TemplateStringsArray, ...params: unknown[]): void;
+    info(strings: TemplateStringsArray, ...params: unknown[]): void;
+    warn(strings: TemplateStringsArray, ...params: unknown[]): void;
+    error(error: unknown): void;
+};
+//# sourceMappingURL=logger.d.ts.map

package/lib/private/logger.js

@@ -0,0 +1,66 @@
+import cli from "@rcompat/cli";
+import { CodeError } from "@rcompat/error";
+import p from "pema";
+const Schema = p.union("error", "warn", "info", "trace").default("warn");
+export { Schema };
+const levels = {
+    error: 0,
+    warn: 1,
+    info: 2,
+    trace: 3,
+};
+function mark(strings, params) {
+    return strings.reduce((acc, str, i) => acc + (i > 0 ? cli.fg.bold(String(params[i - 1])) : "") + str, "");
+}
+function format(strings, params) {
+    return strings.reduce((acc, str, i) => acc + (i > 0 ? String(params[i - 1]) : "") + str, "");
+}
+function run_hooks(level, message, hooks) {
+    for (const hook of hooks) {
+        hook({ level, message });
+    }
+}
+// param is intentionally relaxed and not Schema.input
+export default function logger(level = "warn", hooks = []) {
+    const n = levels[Schema.parse(level)];
+    return {
+        get level() {
+            return level;
+        },
+        print(strings, ...params) {
+            cli.print(format(strings, params));
+        },
+        system(strings, ...params) {
+            cli.print(`  ${format(strings, params)}\n`);
+        },
+        trace(strings, ...params) {
+            if (n === levels.trace) {
+                cli.print(cli.fg.blue("[TRACE]"), mark(strings, params), "\n");
+            }
+            run_hooks("trace", format(strings, params), hooks);
+        },
+        info(strings, ...params) {
+            if (n >= levels.info) {
+                cli.print(cli.fg.green("[INFO]"), mark(strings, params), "\n");
+            }
+            run_hooks("info", format(strings, params), hooks);
+        },
+        warn(strings, ...params) {
+            if (n >= levels.warn) {
+                cli.print(cli.fg.yellow("[WARN]"), mark(strings, params), "\n");
+            }
+            run_hooks("warn", format(strings, params), hooks);
+        },
+        error(error) {
+            if (CodeError.is(error)) {
+                cli.print(cli.fg.red("[ERROR]"), mark(error.strings, error.params), "\n");
+                run_hooks("error", format(error.strings, error.params), hooks);
+            }
+            else {
+                console.error(error);
+                run_hooks("error", error.message, hooks);
+            }
+        },
+    };
+}
+//# sourceMappingURL=logger.js.map

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

@@ -1,5 +1,6 @@
 import type App from "#App";
 import type BuildApp from "#build/App";
+import type { LogEntry } from "#logger";
 import type NextHandle from "#module/NextHandle";
 import type NextRoute from "#module/NextRoute";
 import type RequestFacade from "#request/RequestFacade";
@@ -9,6 +10,7 @@ import type { MaybePromise } from "@rcompat/type";
 export type InitHook = (app: App) => MaybePromise<void>;
 export type BuildHook = (app: BuildApp) => MaybePromise<void>;
 export type ServeHook = (app: ServeApp) => MaybePromise<void>;
+export type LogHook = (entry: LogEntry) => void;
 export type HandleHook = (request: RequestFacade, next: NextHandle) => MaybePromise<Response>;
 export type RouteHook = (request: RequestFacade, next: NextRoute) => MaybePromise<ResponseLike>;
 export default interface Setup {
@@ -17,5 +19,6 @@ export default interface Setup {
     onServe(hook: ServeHook): void;
     onHandle(hook: HandleHook): void;
     onRoute(hook: RouteHook): void;
+    onLog(hook: LogHook): void;
 }
 //# sourceMappingURL=Setup.d.ts.map

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

@@ -1,11 +1,12 @@
 import type Module from "#Module";
-import type { BuildHook, HandleHook, InitHook, RouteHook, ServeHook } from "#module/Setup";
+import type { BuildHook, HandleHook, InitHook, LogHook, RouteHook, ServeHook } from "#module/Setup";
 type Hooks = {
     init: InitHook[];
     build: BuildHook[];
     serve: ServeHook[];
     handle: HandleHook[];
     route: RouteHook[];
+    log: LogHook[];
 };
 type Created = {
     name: string;

package/lib/private/module/create.js

@@ -5,6 +5,7 @@ export default function create({ name, setup }) {
         serve: [],
         handle: [],
         route: [],
+        log: [],
     };
     setup({
         onInit(hook) {
@@ -22,6 +23,9 @@ export default function create({ name, setup }) {
         onRoute(hook) {
             hooks.route.push(hook);
         },
+        onLog(hook) {
+            hooks.log.push(hook);
+        },
     });
     return { name, hooks };
 }

package/lib/private/paths.d.ts

@@ -1,5 +1,4 @@
-import type { FileRef } from "@rcompat/fs";
-import type { Dict } from "@rcompat/type";
-declare function resolve(root: FileRef, config_paths?: Dict<string[]>): Promise<any>;
+import type BuildApp from "#build/App";
+declare function resolve(app: BuildApp): Promise<any>;
 export default resolve;
 //# sourceMappingURL=paths.d.ts.map

package/lib/private/paths.js

@@ -1,7 +1,6 @@
 import E from "#errors";
-import log from "#log";
-async function resolve(root, config_paths) {
-    const tsconfig_path = root.join("tsconfig.json");
+async function resolve(app) {
+    const tsconfig_path = app.root.join("tsconfig.json");
     if (await tsconfig_path.exists()) {
         try {
             let text = await tsconfig_path.text();
@@ -11,19 +10,14 @@ async function resolve(root, config_paths) {
                 .replace(/\/\/.*/g, "")
                 .replace(/,(\s*[}\]])/g, "$1");
             const config = JSON.parse(text);
-            const ts_paths = config.compilerOptions?.paths ?? {};
-            if (config_paths !== undefined && Object.keys(ts_paths).length > 0) {
-                return E.config_tsconfig_has_paths();
-            }
+            const paths = config.compilerOptions?.paths ?? {};
             // merge with defaults (user paths override)
-            return { ...ts_paths };
+            return { ...paths };
         }
-        catch {
-            log.warn("failed to parse tsconfig.json, falling back to config");
+        catch (cause) {
+            throw E.config_failed_to_parse_tsconfig(tsconfig_path, cause);
         }
     }
-    if (config_paths !== undefined)
-        return config_paths;
     return {};
 }
 export default resolve;

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

@@ -0,0 +1,3 @@
+type RequestContentType = "application/json" | "text/plain" | "application/x-www-form-urlencoded" | "multipart/form-data" | "application/octet-stream";
+export type { RequestContentType as default };
+//# sourceMappingURL=ContentType.d.ts.map

package/lib/private/request/ContentType.js

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

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

@@ -1,18 +1,14 @@
+import symbol from "@rcompat/symbol";
 import type { PartialDict } from "@rcompat/type";
 type Contents = PartialDict<string>;
 type Normalize = (key: string) => string;
-interface Schema<T> {
-    parse(input: unknown): T;
-}
-interface CoercibleSchema<T> extends Schema<T> {
-    coerce(input: unknown): T;
-}
 type Options = {
     normalize?: Normalize;
     raw?: string;
 };
 export default class RequestBag {
     #private;
+    [symbol.parse](): any;
     /**
      * Create a new RequestBag.
      *
@@ -59,18 +55,6 @@ export default class RequestBag {
      * @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;
-    coerce<T>(schema: CoercibleSchema<T>): T;
     /** Returns {@link raw}. Useful in template strings. */
     toString(): string;
     /**

package/lib/private/request/RequestBag.js

@@ -1,11 +1,15 @@
 import E from "#errors";
 import assert from "@rcompat/assert";
 import fn from "@rcompat/fn";
+import symbol from "@rcompat/symbol";
 export default class RequestBag {
     #contents;
     #name;
     #normalize;
     #raw;
+    [symbol.parse]() {
+        return this.toJSON();
+    }
     /**
      * Create a new RequestBag.
      *
@@ -94,22 +98,6 @@ export default class RequestBag {
         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);
-    }
-    coerce(schema) {
-        return schema.coerce(this.#contents);
-    }
     /** Returns {@link raw}. Useful in template strings. */
     toString() {
         return this.raw;

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

@@ -1,35 +1,27 @@
+import http from "@rcompat/http";
 import type { Dict, JSONValue } from "@rcompat/type";
+import type { Parsed } from "pema";
 type Form = Dict<string>;
-type Parsed = {
-    type: "binary";
-    value: Blob;
-} | {
-    type: "form";
-    value: Dict<string>;
-} | {
-    type: "json";
-    value: JSONValue;
-} | {
-    type: "none";
-    value: null;
-} | {
-    type: "text";
-    value: string;
+type Files = Dict<File>;
+type MIMES = typeof http.MIME;
+type MIME = MIMES[keyof MIMES];
+type BodyOptions = {
+    contentType: MIME;
+    schema: Parsed<unknown>;
 };
-declare function parse(request: Request, url: URL): Promise<RequestBody>;
-declare function none(): RequestBody;
+declare const patched: unique symbol;
 export default class RequestBody {
     #private;
-    static parse: typeof parse;
-    static none: typeof none;
-    constructor(parsed: Parsed, files?: Dict<File>);
-    get type(): "json" | "binary" | "text" | "none" | "form";
-    json(): JSONValue;
-    form(): Form;
-    files(): Dict<File>;
-    text(): string;
-    binary(): Blob;
-    none(): null;
+    constructor(request: Request, options?: BodyOptions);
+    [patched](options: BodyOptions): RequestBody;
+    json(): Promise<JSONValue>;
+    form(): Promise<Form>;
+    multipart(): Promise<{
+        form: Form;
+        files: Files;
+    }>;
+    text(): Promise<string>;
+    blob(): Promise<Blob>;
 }
-export {};
+export { patched as BodyPatch };
 //# sourceMappingURL=RequestBody.d.ts.map

package/lib/private/request/RequestBody.js

@@ -1,99 +1,76 @@
 import E from "#errors";
-import { MIME } from "@rcompat/http";
+import assert from "@rcompat/assert";
+import http 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 (is.string(value)) {
-            form[key] = value;
-        }
-        else {
-            files[key] = value;
-        }
-    }
-    return { form, files };
-}
-;
-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);
-            }
-            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);
-        }
-    }
-    catch (cause) {
-        throw E.request_unparsable_mime(path, type, cause);
-    }
-}
-function none() {
-    return new RequestBody({ type: "none", value: null });
-}
+const patched = Symbol("RequestBody.patch");
 export default class RequestBody {
-    #parsed;
-    #files;
-    static parse = parse;
-    static none = none;
-    constructor(parsed, files = {}) {
-        this.#parsed = parsed;
-        this.#files = files;
-    }
-    get type() {
-        return this.#parsed.type;
-    }
-    #value() {
-        return this.#parsed.value;
-    }
-    #unexpected_body(expected) {
-        throw E.request_unexpected_body(expected, this.type);
-    }
-    json() {
-        if (this.type !== "json")
-            this.#unexpected_body("JSON");
-        return this.#value();
+    #request;
+    #parsed = false;
+    #options;
+    constructor(request, options) {
+        this.#request = request;
+        this.#options = options;
     }
-    form() {
-        if (this.type !== "form")
-            this.#unexpected_body("form");
-        return this.#value();
+    #parse(mime) {
+        if (this.#parsed)
+            throw E.request_body_already_parsed();
+        const raw = this.#request.headers.get("content-type") ?? "none";
+        const content_type = raw.split(";")[0].trim().toLowerCase();
+        assert.true(mime === content_type);
+        this.#parsed = true;
     }
-    files() {
-        if (this.type !== "form")
-            this.#unexpected_body("form");
-        return this.#files;
+    [patched](options) {
+        return new RequestBody(this.#request, options);
     }
-    text() {
-        if (this.type !== "text")
-            this.#unexpected_body("plaintext");
-        return this.#value();
+    async json() {
+        this.#parse(http.MIME.APPLICATION_JSON);
+        const raw = await this.#request.json();
+        return this.#options?.contentType === http.MIME.APPLICATION_JSON
+            ? this.#options.schema.parse(raw)
+            : raw;
     }
-    binary() {
-        if (this.type !== "binary") {
-            this.#unexpected_body("binary");
+    async form() {
+        this.#parse(http.MIME.APPLICATION_X_WWW_FORM_URLENCODED);
+        const form = Object.create(null);
+        for (const [key, value] of (await this.#request.formData()).entries()) {
+            form[key] = assert.string(value);
         }
-        return this.#value();
+        const raw = form;
+        return this.#options?.contentType === http.MIME.APPLICATION_X_WWW_FORM_URLENCODED
+            ? this.#options.schema.parse(raw)
+            : raw;
     }
-    none() {
-        if (this.type !== "none") {
-            this.#unexpected_body("none");
+    async multipart() {
+        this.#parse(http.MIME.MULTIPART_FORM_DATA);
+        const form = Object.create(null);
+        const files = Object.create(null);
+        for (const [key, value] of (await this.#request.formData()).entries()) {
+            if (is.string(value)) {
+                form[key] = value;
+            }
+            else {
+                files[key] = value;
+            }
         }
-        return null;
+        const raw = { form, files };
+        return this.#options?.contentType === http.MIME.MULTIPART_FORM_DATA
+            ? this.#options.schema.parse(raw)
+            : raw;
+    }
+    async text() {
+        this.#parse(http.MIME.TEXT_PLAIN);
+        const raw = await this.#request.text();
+        return this.#options?.contentType === http.MIME.TEXT_PLAIN
+            ? this.#options.schema.parse(raw)
+            : raw;
+    }
+    async blob() {
+        this.#parse(http.MIME.APPLICATION_OCTET_STREAM);
+        const raw = await this.#request.blob();
+        return this.#options?.contentType === http.MIME.APPLICATION_OCTET_STREAM
+            ? this.#options.schema.parse(raw)
+            : raw;
     }
 }
+export { patched as BodyPatch };
 //# sourceMappingURL=RequestBody.js.map

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

@@ -1,10 +1,10 @@
 import type RequestBag from "#request/RequestBag";
 import type RequestBody from "#request/RequestBody";
 import type RequestView from "#request/RequestView";
-import type Verb from "#request/Verb";
+import type { Method } from "@rcompat/http";
 import type { Dict } from "@rcompat/type";
 type RequestFacade = {
-    method: Verb;
+    method: Method;
     body: RequestBody;
     cookies: RequestBag;
     forward(to: string, headers?: Dict<string>): Promise<Response>;

package/lib/private/request/handle.js

@@ -1,4 +1,4 @@
-import { Status } from "@rcompat/http";
+import http from "@rcompat/http";
 async function run(hooks, request) {
     const [first, ...rest] = hooks;
     if (first === undefined) {
@@ -7,7 +7,7 @@ async function run(hooks, request) {
                 "Content-Length": String(0),
                 "Cache-Control": "no-cache",
             },
-            status: Status.INTERNAL_SERVER_ERROR,
+            status: http.Status.INTERNAL_SERVER_ERROR,
         });
     }
     return await first(request, next => run(rest, next));

package/lib/private/request/parse.js

@@ -17,9 +17,7 @@ function normalize(k) {
 }
 function header_bag(request) {
     const headers = Object.fromEntries([...request.headers].map(([k, v]) => [k.toLowerCase(), v]));
-    return new RequestBag(headers, "headers", {
-        normalize,
-    });
+    return new RequestBag(headers, "headers", { normalize });
 }
 function cookie_bag(request) {
     const header = request.headers.get("cookie");
@@ -47,7 +45,7 @@ function path_bag(url) {
 function parse(request) {
     const url = new URL(request.url);
     const facade = {
-        body: RequestBody.none(),
+        body: new RequestBody(request),
         method: request.method.toLowerCase(),
         cookies: cookie_bag(request),
         forward(to, headers) {