@primate/core 0.6.3 → 0.7.1

package/lib/private/request/route.js

@@ -1,9 +1,9 @@
-import E from "#errors";
-import log from "#log";
+import E, { Code } from "#errors";
 import response_error from "#response/error";
 import response_json from "#response/json";
 import respond from "#response/respond";
-import { Status } from "@rcompat/http";
+import { CodeError } from "@rcompat/error";
+import http from "@rcompat/http";
 import ParseError from "pema/ParseError";
 const result = (request, response) => ({ request, response });
 function wrap_hook(h) {
@@ -43,24 +43,31 @@ export default async function (app, partial_request) {
     try {
         const route = await app.route(partial_request);
         if (route === undefined) {
+            app.log.trace `no route for pathname ${partial_request.url.pathname}`;
             return response_error()(app, {}, partial_request);
         }
-        const { errors, hooks, layouts, handler } = route;
+        const { errors, hooks = [], layouts, handler, is_head } = route;
         errorRoute = errors[0];
         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, {
+        const full = await respond(response)(app, {
             layouts: await Promise.all(layouts.map(layout => layout(request))),
         }, request);
+        return is_head
+            ? new Response(null, { headers: full.headers, status: full.status })
+            : full;
     }
     catch (error) {
         const request = partial_request;
-        if (error instanceof ParseError) {
-            return response_json(error.toJSON(), { status: Status.BAD_REQUEST })(app);
+        if (ParseError.is(error)) {
+            return response_json(error.toJSON(), { status: http.Status.BAD_REQUEST })(app);
         }
-        log.error(error);
+        if (CodeError.matches(error, Code.request_content_type_mismatch)) {
+            return response_json({ error: error.message }, { status: http.Status.UNSUPPORTED_MEDIA_TYPE })(app);
+        }
+        app.log.error(error);
         // the +error.js page itself could fail
         try {
             return respond(await errorRoute(request))(app, {}, request);

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

@@ -1,10 +1,10 @@
 import type ServeApp from "#serve/App";
-import type { StreamSource } from "@rcompat/fs";
+import type { Streamable } from "@rcompat/fs";
 /**
  * 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;
+export default function binary(source: Streamable, init?: ResponseInit): (app: ServeApp) => Response;
 //# sourceMappingURL=binary.d.ts.map

package/lib/private/response/binary.js

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

package/lib/private/response/error.js

@@ -1,5 +1,8 @@
 import location from "#location";
-import { Status } from "@rcompat/http";
+import http from "@rcompat/http";
+const sse_reload = `<script>
+  new EventSource("/esbuild").addEventListener("change", () => location.reload());
+</script>`;
 /**
  * Render an error page.
  *
@@ -11,8 +14,9 @@ import { Status } from "@rcompat/http";
 export default function error(options) {
     return app => app.view({
         body: options?.body ?? "Not Found",
+        head: app.mode === "development" ? sse_reload : undefined,
         page: options?.page ?? location.error_html,
-        status: options?.status ?? Status.NOT_FOUND,
+        status: options?.status ?? http.Status.NOT_FOUND,
     });
 }
 //# sourceMappingURL=error.js.map

package/lib/private/response/json.js

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

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

@@ -0,0 +1,3 @@
+declare function $null(): () => Response;
+export default $null;
+//# sourceMappingURL=null.d.ts.map

package/lib/private/response/null.js

@@ -0,0 +1,6 @@
+import http from "@rcompat/http";
+function $null() {
+    return () => new Response(null, { status: http.Status.NO_CONTENT });
+}
+export default $null;
+//# sourceMappingURL=null.js.map

package/lib/private/response/redirect.js

@@ -1,4 +1,5 @@
-import { Status } from "@rcompat/http";
+import http from "@rcompat/http";
+import is from "@rcompat/is";
 function hasCRLF(s) {
     return /[\r\n]/.test(s);
 }
@@ -31,7 +32,7 @@ function toSearch(query) {
         return params;
     }, new URLSearchParams())
         .toString();
-    return search ? "?" + search : "";
+    return is.text(search) ? "?" + search : "";
 }
 function toNormalized(relative, base) {
     // base -> URL resolution
@@ -60,6 +61,6 @@ app => app.respond(null, {
         Location: location,
         "Cache-Control": "no-cache",
     },
-    status: status ?? Status.FOUND,
+    status: status ?? http.Status.FOUND,
 });
 //# sourceMappingURL=redirect.js.map

package/lib/private/response/respond.js

@@ -1,19 +1,19 @@
 import E from "#errors";
 import binary from "#response/binary";
 import json from "#response/json";
+import $null from "#response/null";
 import redirect from "#response/redirect";
 import text from "#response/text";
-import Streamable from "@rcompat/fs/Streamable";
-import { Status } from "@rcompat/http";
+import fs from "@rcompat/fs";
 import is from "@rcompat/is";
 function match(m) {
     return m;
 }
 // [if, then]
 const guesses = match([
-    [is.null, () => () => new Response(null, { status: Status.NO_CONTENT })],
+    [is.null, $null],
     [is.url, value => redirect(value.toString())],
-    [Streamable.is, value => binary(value)],
+    [fs.isStream, value => binary(value)],
     [is.response, value => _ => value],
     [is.dict, json],
     [is.array, json],

package/lib/private/response/sse.js

@@ -1,5 +1,5 @@
 import response from "#response";
-import { MIME } from "@rcompat/http";
+import http from "@rcompat/http";
 const encode = (input) => new TextEncoder().encode(input);
 const handle = (body) => new ReadableStream({
     cancel() {
@@ -21,5 +21,5 @@ const handle = (body) => new ReadableStream({
  * @param options response options
  * @return Response rendering function
  */
-export default response(MIME.TEXT_EVENT_STREAM, handle);
+export default response(http.MIME.TEXT_EVENT_STREAM, handle);
 //# sourceMappingURL=sse.js.map

package/lib/private/response/text.js

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

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

@@ -0,0 +1,10 @@
+import type { Dict, JSONValue } from "@rcompat/type";
+type ContentTypeMap = {
+    "application/json": JSONValue;
+    "text/plain": string;
+    "application/x-www-form-urlencoded": URLSearchParams | Dict<string>;
+    "multipart/form-data": FormData | Dict<FormDataEntryValue>;
+    "application/octet-stream": Blob;
+};
+export type { ContentTypeMap as default };
+//# sourceMappingURL=ContentTypeMap.d.ts.map

package/lib/private/route/ContentTypeMap.js

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

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

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

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

@@ -0,0 +1,23 @@
+import type RequestBody from "#request/RequestBody";
+import type RequestFacade from "#request/RequestFacade";
+import type RouteOptions from "#route/Options";
+import type { Unpack } from "@rcompat/type";
+import type { Parsed } from "pema";
+type ContentTypeMethod = {
+    "application/json": "json";
+    "text/plain": "text";
+    "application/x-www-form-urlencoded": "form";
+    "multipart/form-data": "multipart";
+    "application/octet-stream": "blob";
+};
+type NarrowedBody<O extends RouteOptions, B extends RequestBody> = O extends {
+    contentType: infer CT extends keyof ContentTypeMethod;
+    body: Parsed<infer T>;
+} ? Omit<B, ContentTypeMethod[CT]> & {
+    [K in ContentTypeMethod[CT]]: () => Promise<Unpack<T>>;
+} : B;
+type NarrowedRequest<O extends RouteOptions> = Omit<RequestFacade, "body"> & {
+    body: NarrowedBody<O, RequestBody>;
+};
+export type { NarrowedRequest as default };
+//# sourceMappingURL=NarrowedRequest.d.ts.map

package/lib/private/route/NarrowedRequest.js

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

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

@@ -1,5 +1,10 @@
+import type http from "@rcompat/http";
+import type { Parsed } from "pema";
+type MIME = Omit<typeof http.MIME, "resolve" | "extension">;
+type MIMEValue = MIME[keyof MIME];
 type RouteOptions = {
-    parseBody?: boolean;
+    contentType?: MIMEValue;
+    body?: Parsed<unknown>;
 };
 export type { RouteOptions as default };
 //# sourceMappingURL=Options.d.ts.map

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

@@ -1,8 +1,8 @@
-import type Verb from "#request/Verb";
+import type { Method } from "@rcompat/http";
 import type RouteHandler from "#route/Handler";
 import type RouteOptions from "#route/Options";
 type RoutePath = {
-    [key in Verb]?: {
+    [key in Method]?: {
         handler: RouteHandler;
         options: RouteOptions;
     };

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

@@ -2,5 +2,7 @@ import type NextRoute from "#module/NextRoute";
 import type RequestFacade from "#request/RequestFacade";
 import type ResponseLike from "#response/ResponseLike";
 import type { MaybePromise } from "@rcompat/type";
-export default function hook(fn: (request: RequestFacade, next: NextRoute) => MaybePromise<ResponseLike>): void;
+type HookFn = (request: RequestFacade, next: NextRoute) => MaybePromise<ResponseLike>;
+export default function hook(fn: HookFn): HookFn;
+export {};
 //# sourceMappingURL=hook.d.ts.map

package/lib/private/route/hook.js

@@ -1,5 +1,4 @@
-import router from "#route/router";
 export default function hook(fn) {
-    router.addHook(fn);
+    return fn;
 }
 //# sourceMappingURL=hook.js.map

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

@@ -1,15 +1,11 @@
 import type RequestHook from "#module/RequestHook";
-import type Verb from "#request/Verb";
 import type RouteHandler from "#route/Handler";
 import type RouteOptions from "#route/Options";
-export declare const routes: string[];
+import type { Method } from "@rcompat/http";
 declare class Router {
     #private;
-    push(route: string): void;
-    pop(): void;
-    get active(): string | undefined;
-    add(verb: Verb, handler: RouteHandler, options?: RouteOptions): void;
-    addHook(fn: RequestHook): void;
+    add(path: string, method: Method, handler: RouteHandler, options?: RouteOptions): void;
+    addHook(path: string, fn: RequestHook): void;
     getHooks(path: string): RequestHook[];
     verifyHook(path: string): void;
     get(path: string): {
@@ -17,10 +13,6 @@ declare class Router {
             handler: RouteHandler;
             options: RouteOptions;
         } | undefined;
-        head?: {
-            handler: RouteHandler;
-            options: RouteOptions;
-        } | undefined;
         get?: {
             handler: RouteHandler;
             options: RouteOptions;
@@ -37,6 +29,10 @@ declare class Router {
             handler: RouteHandler;
             options: RouteOptions;
         } | undefined;
+        head?: {
+            handler: RouteHandler;
+            options: RouteOptions;
+        } | undefined;
         connect?: {
             handler: RouteHandler;
             options: RouteOptions;

package/lib/private/route/router.js

@@ -1,7 +1,5 @@
 import E from "#errors";
 import assert from "@rcompat/assert";
-const stack = [];
-export const routes = stack;
 function is_hook_file(p) {
     const basename = p.split("/").at(-1) ?? p;
     return basename === "+hook" || basename.startsWith("+hook.");
@@ -9,28 +7,23 @@ function is_hook_file(p) {
 class Router {
     #routes = {};
     #hooks = {};
-    push(route) { stack.push(route); }
-    pop() { stack.pop(); }
-    get active() { return stack.at(-1); }
-    add(verb, handler, options) {
-        assert.string(verb);
+    add(path, method, handler, options) {
+        assert.string(path);
+        assert.string(method);
         assert.function(handler);
         assert.maybe.dict(options);
-        assert.maybe.boolean(options?.parseBody);
-        const active = assert.defined(this.active);
-        if (is_hook_file(active))
-            throw E.hook_route_functions_not_allowed(active);
-        const _routes = this.#routes;
-        if (!(active in _routes))
-            _routes[active] = {};
-        _routes[active][verb] = { handler, options: options ?? {} };
+        if (is_hook_file(path))
+            throw E.hook_route_functions_not_allowed(path);
+        if (!(path in this.#routes))
+            this.#routes[path] = {};
+        this.#routes[path][method] = { handler, options: options ?? {} };
     }
-    addHook(fn) {
+    addHook(path, fn) {
+        assert.string(path);
         assert.function(fn);
-        const active = assert.defined(this.active);
-        if (!is_hook_file(active))
-            throw E.hook_not_allowed(active);
-        (this.#hooks[active] ??= []).push(fn);
+        if (!is_hook_file(path))
+            throw E.hook_not_allowed(path);
+        (this.#hooks[path] ??= []).push(fn);
     }
     getHooks(path) {
         return [...(this.#hooks[path] ?? [])];

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

@@ -0,0 +1,36 @@
+import type ContentTypeMap from "#route/ContentTypeMap";
+import type RouteHandler from "#route/Handler";
+import type RouteOptions from "#route/Options";
+import type { Unpack } from "@rcompat/type";
+import type { Parsed } from "pema";
+type Body<O extends RouteOptions> = O extends {
+    contentType: infer _CT extends keyof ContentTypeMap;
+    body: infer S extends Parsed<unknown>;
+} ? Unpack<S["infer"]> : O extends {
+    contentType: infer CT extends keyof ContentTypeMap;
+} ? ContentTypeMap[CT] : never;
+type MethodMeta = {
+    contentType?: string;
+};
+type ClientMethod<O extends RouteOptions> = MethodMeta & (Body<O> extends never ? () => Promise<Response> : (args: {
+    body: Body<O>;
+}) => Promise<Response>);
+type ClientRoute<R> = {
+    [K in keyof R]: R[K] extends {
+        options: infer O extends RouteOptions;
+    } ? ClientMethod<O> : () => Promise<Response>;
+};
+type WithResult<O extends RouteOptions> = {
+    handler: RouteHandler<O>;
+    options: O;
+};
+type RouteHandlers = {
+    [key: string]: RouteHandler | WithResult<RouteOptions>;
+};
+declare function route<R extends RouteHandlers>(handlers: R): ClientRoute<R>;
+declare namespace route {
+    var _a: <O extends RouteOptions>(options: O, handler: RouteHandler<O>) => WithResult<O>;
+    export { _a as with };
+}
+export default route;
+//# sourceMappingURL=route.client.d.ts.map

package/lib/private/route.client.js

@@ -0,0 +1,8 @@
+function route(handlers) {
+    return {};
+}
+route.with = function (options, handler) {
+    return { handler, options };
+};
+export default route;
+//# sourceMappingURL=route.client.js.map

package/lib/private/route.d.ts

@@ -1,9 +1,25 @@
-import type Verb from "#request/Verb";
 import type RouteHandler from "#route/Handler";
 import type RouteOptions from "#route/Options";
-type Route = {
-    [key in Verb]: (handler: RouteHandler, options?: RouteOptions) => void;
+import type { Method } from "@rcompat/http";
+declare const BRAND: unique symbol;
+type WithResult<O extends RouteOptions> = {
+    [BRAND]: true;
+    handler: RouteHandler;
+    options: O;
 };
-declare const _default: Route;
-export default _default;
+type AnyHandler = RouteHandler | WithResult<RouteOptions>;
+type RouteHandlers = {
+    [key in Method]?: AnyHandler;
+};
+declare function route(handlers: RouteHandlers): {
+    [k: string]: {
+        handler: RouteHandler;
+        options: RouteOptions;
+    };
+};
+declare namespace route {
+    var _a: <O extends RouteOptions>(options: O, handler: RouteHandler<O>) => WithResult<O>;
+    export { _a as with };
+}
+export default route;
 //# sourceMappingURL=route.d.ts.map

package/lib/private/route.js

@@ -1,6 +1,22 @@
-import verbs from "#request/verbs";
-import router from "#route/router";
-export default Object.fromEntries(verbs.map(verb => [verb, (handler, options) => {
-        router.add(verb, handler, options);
-    }]));
+import E from "#errors";
+import is from "@rcompat/is";
+const BRAND = Symbol("route.with");
+function is_with(value) {
+    return is.branded(value, BRAND);
+}
+function route(handlers) {
+    return Object.fromEntries(Object.entries(handlers).map(([method, value]) => {
+        if (is_with(value)) {
+            return [method, { handler: value.handler, options: value.options }];
+        }
+        return [method, { handler: value, options: {} }];
+    }));
+}
+route.with = function (options, handler) {
+    if (options.body !== undefined && options.contentType === undefined) {
+        throw E.build_body_requires_content_type();
+    }
+    return { [BRAND]: true, handler, options };
+};
+export default route;
 //# sourceMappingURL=route.js.map

package/lib/private/serve/App.d.ts

@@ -22,9 +22,7 @@ interface PublishOptions {
 export default class ServeApp extends App {
     #private;
     constructor(rootfile: string, init: ServeInit);
-    get secure(): boolean;
     get assets(): Asset[];
-    get url(): string;
     get router(): FileRouter;
     get frontends(): {
         [k: string]: ViewResponse;
@@ -54,6 +52,7 @@ export default class ServeApp extends App {
         layouts: RouteHandler[];
         handler: RouteHandler;
         request: any;
+        is_head: boolean;
     } | undefined>;
 }
 export {};