@primate/core 0.4.5 → 0.5.0

package/lib/private/response.d.ts

@@ -1,5 +1,5 @@
 import type ServeApp from "#serve/App";
-import type MaybePromise from "@rcompat/type/MaybePromise";
+import type { MaybePromise } from "@rcompat/type";
 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/route/Handler.d.ts

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

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

@@ -0,0 +1,6 @@
+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;
+//# sourceMappingURL=hook.d.ts.map

package/lib/private/route/hook.js

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

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

@@ -1,3 +1,4 @@
+import type RequestHook from "#module/RequestHook";
 import type Verb from "#request/Verb";
 import type RouteHandler from "#route/Handler";
 import type RouteOptions from "#route/Options";
@@ -8,12 +9,15 @@ declare class Router {
     pop(): void;
     get active(): string | undefined;
     add(verb: Verb, handler: RouteHandler, options?: RouteOptions): void;
+    addHook(fn: RequestHook): void;
+    getHooks(path: string): RequestHook[];
+    verifyHook(path: string): void;
     get(path: string): {
-        head?: {
+        options?: {
             handler: RouteHandler;
             options: RouteOptions;
         } | undefined;
-        options?: {
+        head?: {
             handler: RouteHandler;
             options: RouteOptions;
         } | undefined;
@@ -21,15 +25,15 @@ declare class Router {
             handler: RouteHandler;
             options: RouteOptions;
         } | undefined;
-        post?: {
+        delete?: {
             handler: RouteHandler;
             options: RouteOptions;
         } | undefined;
-        put?: {
+        post?: {
             handler: RouteHandler;
             options: RouteOptions;
         } | undefined;
-        delete?: {
+        put?: {
             handler: RouteHandler;
             options: RouteOptions;
         } | undefined;

package/lib/private/route/router.js

@@ -1,29 +1,46 @@
+import fail from "#fail";
 import assert from "@rcompat/assert";
-import is from "@rcompat/assert/is";
-import maybe from "@rcompat/assert/maybe";
 const stack = [];
 export const routes = stack;
+function is_hook_file(p) {
+    const basename = p.split("/").at(-1) ?? p;
+    return basename === "+hook" || basename.startsWith("+hook.");
+}
 class Router {
     #routes = {};
-    push(route) {
-        stack.push(route);
+    #hooks = {};
+    push(route) { stack.push(route); }
+    pop() { stack.pop(); }
+    get active() { return stack.at(-1); }
+    add(verb, handler, options) {
+        assert.string(verb);
+        assert.function(handler);
+        assert.maybe.dict(options);
+        assert.maybe.boolean(options?.parseBody);
+        const active = assert.defined(this.active);
+        if (is_hook_file(active)) {
+            throw fail("route.{0} may not be used inside {1}; use hook(...) instead", verb, active);
+        }
+        const _routes = this.#routes;
+        if (!(active in _routes))
+            _routes[active] = {};
+        _routes[active][verb] = { handler, options: options ?? {} };
     }
-    pop() {
-        stack.pop();
+    addHook(fn) {
+        assert.function(fn);
+        const active = assert.defined(this.active);
+        if (!is_hook_file(active)) {
+            throw fail("hook(...) may only be used inside +hook files, got {0}", active);
+        }
+        (this.#hooks[active] ??= []).push(fn);
     }
-    get active() {
-        return stack.at(-1);
+    getHooks(path) {
+        return [...(this.#hooks[path] ?? [])];
     }
-    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] = {};
+    verifyHook(path) {
+        if ((this.#hooks[path] ?? []).length === 0) {
+            throw fail("hook file {0} did not register any hooks (call hook(...))", path);
         }
-        routes[active][verb] = { handler, options };
     }
     get(path) {
         return { ...this.#routes[path] };

package/lib/private/route/wrap.js

@@ -1,7 +1,7 @@
-import dedent from "@rcompat/string/dedent";
+import string from "@rcompat/string";
 export default function wrap(code, path, build_id) {
     const router = `ROUTER_${build_id}`;
-    const prelude = dedent `
+    const prelude = string.dedent `
     import ${router} from "primate/router";
     ${router}.push("${path}");
   `;

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

@@ -4,14 +4,12 @@ import type ServerView from "#frontend/ServerView";
 import type ViewOptions from "#frontend/ViewOptions";
 import type ViewResponse from "#frontend/ViewResponse";
 import type I18NConfig from "#i18n/Config";
-import RequestBag from "#request/RequestBag";
-import RequestBody from "#request/RequestBody";
 import type RequestFacade from "#request/RequestFacade";
 import type RouteHandler from "#route/Handler";
 import type ServeInit from "#serve/Init";
 import FileRouter from "@rcompat/fs/FileRouter";
 import type Actions from "@rcompat/http/Actions";
-import type Dict from "@rcompat/type/Dict";
+import type { Dict } from "@rcompat/type";
 interface FullViewOptions extends ViewOptions {
     body: string;
 }
@@ -47,27 +45,16 @@ export default class ServeApp extends App {
     create_csp(): void;
     register(extension: string, viewFunction: ViewResponse): void;
     page(name?: string): string;
-    serveAsset(pathname: string): Promise<Response | undefined>;
+    serve_assets(pathname: string): Promise<Response | undefined>;
     start(): Promise<void>;
     stop(): void;
     upgrade(request: Request, actions: Actions): null;
     route(request: RequestFacade): Promise<{
         errors: RouteHandler[];
-        guards: RouteHandler[];
-        handler: RouteHandler;
+        hooks: import("../module/RequestHook.js").default[];
         layouts: RouteHandler[];
-        request: {
-            body: RequestBody;
-            path: RequestBag;
-            context: Dict;
-            cookies: RequestBag;
-            forward(to: string, headers?: Dict<string>): Promise<Response>;
-            headers: RequestBag;
-            original: Request;
-            query: RequestBag;
-            target: string;
-            url: URL;
-        };
+        handler: RouteHandler;
+        request: any;
     } | undefined>;
 }
 export {};

package/lib/private/serve/App.js

@@ -1,4 +1,5 @@
 import App from "#App";
+import { s_config } from "#app/Facade";
 import fail from "#fail";
 import hash from "#hash";
 import I18NModule from "#i18n/Module";
@@ -13,19 +14,15 @@ import DevModule from "#serve/module/Dev";
 import HandleModule from "#serve/module/Handle";
 import SessionModule from "#session/SessionModule";
 import tags from "#tags";
-import is from "@rcompat/assert/is";
-import FileRef from "@rcompat/fs/FileRef";
+import assert from "@rcompat/assert";
+import fs from "@rcompat/fs";
 import FileRouter from "@rcompat/fs/FileRouter";
-import resolve from "@rcompat/http/mime/extension/resolve";
-import TEXT_HTML from "@rcompat/http/mime/text/html";
+import MIME from "@rcompat/http/mime";
 import serve from "@rcompat/http/serve";
 import Status from "@rcompat/http/Status";
-import entries from "@rcompat/record/entries";
-import utf8ByteLength from "@rcompat/string/utf8-bytelength";
-import pema from "pema";
-import record from "pema/record";
-import string from "pema/string";
-import uint from "pema/uint";
+import is from "@rcompat/is";
+import utf8 from "@rcompat/string/utf8";
+import p from "pema";
 const deroot = (pathname) => pathname.endsWith("/") && pathname !== "/"
     ? pathname.slice(0, -1)
     : pathname;
@@ -67,8 +64,8 @@ export default class ServeApp extends App {
     #builtins;
     #i18n_config;
     constructor(rootfile, init) {
-        const dir = new FileRef(rootfile).directory;
-        super(dir, init.config, {
+        const dir = fs.ref(rootfile).directory;
+        super(dir, init.facade[s_config], {
             mode: init.mode,
             target: init.target,
             dir: dir.path,
@@ -78,7 +75,7 @@ export default class ServeApp extends App {
         this.#stores = Object.fromEntries((init.stores?.map(([k, s]) => [k, s.default])) ?? []);
         this.#serve_assets = init.assets;
         this.#pages = init.pages;
-        const http = this.#init.config.http;
+        const http = this.#init.facade[s_config].http;
         this.#i18n_config = init.i18n_config;
         this.set(s_http, {
             host: http.host,
@@ -92,14 +89,16 @@ export default class ServeApp extends App {
             extensions: [".js"],
             specials: {
                 error: { recursive: false },
-                guard: { recursive: true },
                 layout: { recursive: true },
+                hook: { recursive: true },
             },
         }, init.routes.map(s => s[0]));
         this.#builtins = {
             dev: init.mode === "development" ? new DevModule(this) : undefined,
             handle: new HandleModule(this),
-            session: init.session_config ? new SessionModule(this.secure, init.session_config) : undefined,
+            session: init.session_config
+                ? new SessionModule(this.secure, init.session_config)
+                : undefined,
             i18n: init.i18n_config ? new I18NModule(init.i18n_config) : undefined,
         };
     }
@@ -133,7 +132,7 @@ export default class ServeApp extends App {
         return this.#i18n_config;
     }
     loadView(name) {
-        const f = new FileRef(name).path;
+        const f = fs.ref(name).path;
         const frontends = Object.keys(this.frontends);
         const extension = frontends.find(frontend => f.endsWith(frontend));
         const base = extension === undefined ? name : f.slice(0, -extension.length);
@@ -147,18 +146,18 @@ export default class ServeApp extends App {
     }
     ;
     headers(csp = {}) {
-        const http_csp = Object.entries(this.config("http.csp") ?? {});
+        const base = Object.entries(this.config("http.csp") ?? {});
         return {
             ...this.config("http.headers") ?? {},
-            ...http_csp.length === 0 ? {} : {
-                "Content-Security-Policy": to_csp(http_csp, this.#csp, csp),
+            ...base.length === 0 ? {} : {
+                "Content-Security-Policy": to_csp(base, this.#csp, csp),
             },
         };
     }
     ;
     render(content) {
         const { body, head, page, partial, placeholders = {} } = content;
-        ["body", "head"].forEach(key => is(placeholders[key]).undefined());
+        ["body", "head"].forEach(key => assert.undefined(placeholders[key]));
         return partial ? body : Object.entries(placeholders)
             // replace given placeholders, defaulting to ""
             .reduce((rendered, [key, value]) => rendered
@@ -170,20 +169,22 @@ export default class ServeApp extends App {
             .replace("%head%", render_head(this.#assets, head));
     }
     body_length(body) {
-        return typeof body === "string" ? utf8ByteLength(body) : 0;
+        return is.string(body) ? utf8.size(body) : 0;
     }
     respond(body, init) {
-        const { headers, status } = pema({
-            headers: record(string, string),
-            status: uint.values(Status).default(Status.OK),
+        const { headers, status } = p({
+            headers: p.dict(),
+            status: p.uint.values(Status).default(Status.OK),
         }).parse(init);
         const body_length = this.body_length(body);
         return new Response(body, {
             headers: {
-                "Content-Type": TEXT_HTML,
+                "Content-Type": MIME.TEXT_HTML,
                 ...this.headers(),
-                ...body_length ? { ...headers, "Content-Length": String(body_length) } : headers,
-            }, status: status,
+                ...body_length ? {
+                    ...headers, "Content-Length": String(body_length),
+                } : headers,
+            }, status,
         });
     }
     ;
@@ -206,7 +207,7 @@ export default class ServeApp extends App {
                 code: inline ? code : "",
                 inline,
                 integrity: await hash(code),
-                src: FileRef.join(this.#init.config.http.static.root, src ?? "").path,
+                src: fs.join(this.config("http.static.root"), src ?? "").path,
                 type,
             });
         }
@@ -216,7 +217,10 @@ export default class ServeApp extends App {
     ;
     create_csp() {
         this.#csp = this.#assets.map(({ integrity, type: directive }) => [`${directive === "style" ? "style" : "script"}-src`, integrity])
-            .reduce((csp, [directive, hash]) => ({ ...csp, [directive]: csp[directive].concat(`'${hash}'`) }), { "script-src": [], "style-src": [] });
+            .reduce((csp, [directive, _hash]) => ({
+            ...csp,
+            [directive]: csp[directive].concat(`'${_hash}'`),
+        }), { "script-src": [], "style-src": [] });
     }
     ;
     register(extension, viewFunction) {
@@ -230,18 +234,18 @@ export default class ServeApp extends App {
         const page_name = name ?? location.app_html;
         return this.#pages[page_name];
     }
-    async #try_serve(file) {
-        if (await file.exists() && await file.isFile()) {
-            return new Response(file.stream(), {
+    async #try_serve(ref) {
+        if (await ref.exists() && await ref.kind() === "file") {
+            return new Response(ref.stream(), {
                 headers: {
-                    "Content-Type": resolve(file.name),
-                    "Content-Length": String(await file.byteLength()),
+                    "Content-Type": MIME.resolve(ref.name),
+                    "Content-Length": String(await ref.size()),
                 },
                 status: Status.OK,
             });
         }
     }
-    async serveAsset(pathname) {
+    async serve_assets(pathname) {
         const static_root = this.config("http.static.root");
         if (!pathname.startsWith(static_root))
             return undefined;
@@ -256,23 +260,22 @@ export default class ServeApp extends App {
                 return static_response;
             return undefined;
         }
-        const asset = this.#serve_assets.client[pathname] ??
-            this.#serve_assets.static[pathname];
-        if (asset) {
-            const binary = atob(asset.data);
-            const bytes = new Uint8Array(binary.length);
-            for (let i = 0; i < binary.length; i++) {
-                bytes[i] = binary.charCodeAt(i);
-            }
-            return new Response(bytes, {
-                headers: {
-                    "Content-Type": asset.mime,
-                    "Content-Length": String(bytes.length),
-                },
-                status: Status.OK,
-            });
+        const assets = this.#serve_assets;
+        const asset = assets.client[pathname] ?? assets.static[pathname];
+        if (asset === undefined)
+            return undefined;
+        const binary = atob(asset.data);
+        const bytes = new Uint8Array(binary.length);
+        for (let i = 0; i < binary.length; i++) {
+            bytes[i] = binary.charCodeAt(i);
         }
-        return undefined;
+        return new Response(bytes, {
+            headers: {
+                "Content-Type": asset.mime,
+                "Content-Length": String(bytes.length),
+            },
+            status: Status.OK,
+        });
     }
     async start() {
         if (this.mode === "production") {
@@ -293,8 +296,10 @@ export default class ServeApp extends App {
         else {
             const client_dir = this.root.join(location.client);
             const files = await client_dir.exists()
-                ? await client_dir.collect(f => f.extension === ".js"
-                    || f.extension === ".css")
+                ? await client_dir.files({
+                    recursive: true,
+                    filter: info => info.extension === ".js" || info.extension === ".css",
+                })
                 : [];
             this.#assets = await Promise.all(files.map(async (file) => {
                 const type = file.extension === ".css" ? "style" : "js";
@@ -328,9 +333,14 @@ export default class ServeApp extends App {
                     status: Status.INTERNAL_SERVER_ERROR,
                 });
             }
-        }, { ...this.get(s_http),
-            timeout: this.mode === "development" ? 0 : undefined });
-        log.system("started {0}", this.url);
+        }, {
+            ...this.get(s_http),
+            timeout: this.mode === "development" ? 0 : undefined,
+        });
+        function bright(x) {
+            return `\x1b[38;2;0;200;255m${x}\x1b[0m`;
+        }
+        log.print(`» app url     ${bright(this.url)}\n`);
     }
     ;
     stop() {
@@ -350,37 +360,36 @@ export default class ServeApp extends App {
             return;
         }
         const verb = original.method.toLowerCase();
-        const { errors = [], guards = [], layouts = [] } = entries(route.specials)
-            .map(([key, value]) => [`${key}s`, value ?? []])
-            .map(([key, value]) => [key, value.map(v => {
-                const verbs = router.get(v);
-                const routeHandler = verbs[verb];
-                return routeHandler?.handler;
-            }).filter(Boolean).toReversed()])
-            .get();
+        const specials = route.specials;
+        const errors = (specials.error ?? [])
+            .map(v => router.get(v)[verb]?.handler)
+            .filter(Boolean)
+            .toReversed();
+        const layouts = (specials.layout ?? [])
+            .map(v => router.get(v)[verb]?.handler)
+            .filter(Boolean)
+            .toReversed();
+        const hooks = (specials.hook ?? [])
+            .toReversed()
+            .flatMap(v => router.getHooks(v));
         const verbs = router.get(route.path);
-        const routePath = verbs[verb];
-        if (routePath === undefined) {
+        const route_path = verbs[verb];
+        if (route_path === undefined) {
             throw fail("route {0} has no {1} verb", route.path, verb);
         }
-        const parseBody = routePath.options.parseBody;
-        const body = parseBody ?? this.config("request.body.parse")
+        const handler = route_path.handler;
+        const parse_body = route_path.options.parseBody;
+        const body = parse_body ?? this.config("request.body.parse")
             ? await RequestBody.parse(original, url)
             : RequestBody.none();
-        return {
-            errors,
-            guards,
-            handler: routePath.handler,
-            layouts,
-            request: {
-                ...request,
-                body,
-                path: new RequestBag(route.params, "path", {
-                    normalize: k => k.toLowerCase(),
-                    raw: url.pathname,
-                }),
-            },
-        };
+        const refined = Object.assign(Object.create(request), {
+            body,
+            path: new RequestBag(route.params, "path", {
+                normalize: k => k.toLowerCase(),
+                raw: url.pathname,
+            }),
+        });
+        return { errors, hooks, layouts, handler, request: refined };
     }
 }
 //# sourceMappingURL=App.js.map

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

@@ -1,8 +1,8 @@
-import type Config from "#config/Config";
+import type AppFacade from "#app/Facade";
 import type I18NConfig from "#i18n/Config";
 import type Mode from "#Mode";
 import type SessionConfig from "#session/Config";
-import type Dict from "@rcompat/type/Dict";
+import type { Dict } from "@rcompat/type";
 type Import = {
     default: unknown;
 } & Dict;
@@ -19,7 +19,7 @@ type ServeInit = {
     };
     views?: [string, Import][];
     stores?: [string, Import][];
-    config: Config;
+    facade: AppFacade;
     routes: [string, {
         default: any;
     }][];

package/lib/private/serve/hook.js

@@ -1,13 +1,7 @@
-import log from "#log";
 import reducer from "#reducer";
-function pre(app) {
-    log.system("in startup");
-    return app;
-}
-;
 async function post(app) {
     await app.start();
     return app;
 }
-export default async (app) => post(await reducer(app.modules, pre(app), "serve"));
+export default async (app) => post(await reducer(app.modules, app, "serve"));
 //# sourceMappingURL=hook.js.map

package/lib/private/serve/index.js

@@ -1,6 +1,10 @@
+import { s_attach } from "#app/Facade";
 import ServeApp from "#serve/App";
-import serve from "#serve/hook";
+import serve_hook from "#serve/hook";
 export default async (root, options) => {
-    return serve(await new ServeApp(root, options).init());
+    const facade = options.facade;
+    const app = await new ServeApp(root, options).init();
+    facade[s_attach](app);
+    return serve_hook(app);
 };
 //# sourceMappingURL=index.js.map

package/lib/private/serve/module/Dev.d.ts

@@ -6,6 +6,6 @@ export default class DevModule extends Module {
     #private;
     name: string;
     constructor(app: ServeApp);
-    handle(request: RequestFacade, next: NextHandle): import("@rcompat/type/MaybePromise").default<Response>;
+    handle(request: RequestFacade, next: NextHandle): import("@rcompat/type").MaybePromise<Response>;
 }
 //# sourceMappingURL=Dev.d.ts.map

package/lib/private/serve/module/Dev.js

@@ -1,5 +1,6 @@
-import reload from "#build/client/reload";
+import log from "#log";
 import Module from "#Module";
+import c from "@rcompat/cli/color";
 function pass(address, request) {
     return fetch(address, {
         body: request.body,
@@ -8,20 +9,23 @@ function pass(address, request) {
         method: request.method,
     });
 }
+// https://esbuild.github.io/api/#live-reload
 export default class DevModule extends Module {
     name = "builtin/dev";
     #paths;
-    #reload_url;
+    #reload;
     constructor(app) {
         super();
         const assets = app.assets.map(asset => asset.src);
-        this.#paths = ([reload.path]).concat(assets);
-        this.#reload_url = `http://${reload.host}:${reload.port}`;
+        this.#paths = ["/esbuild"].concat(assets);
+        const { host, port } = app.livereload;
+        this.#reload = `http://${host}:${port}`;
+        log.print(`↻ live reload ${c.dim(this.#reload)}\n`);
     }
     handle(request, next) {
         const { pathname } = new URL(request.url);
         return this.#paths.includes(pathname)
-            ? pass(`${this.#reload_url}${pathname}`, request.original)
+            ? pass(`${this.#reload}${pathname}`, request.original)
             : next(request);
     }
 }

package/lib/private/serve/module/Handle.js

@@ -1,5 +1,5 @@
-import route from "#request/route";
 import Module from "#Module";
+import route from "#request/route";
 export default class HandleModule extends Module {
     name = "builtin/handle";
     #app;
@@ -8,7 +8,7 @@ export default class HandleModule extends Module {
         this.#app = app;
     }
     async handle(request) {
-        return await this.#app.serveAsset(request.url.pathname)
+        return await this.#app.serve_assets(request.url.pathname)
             ?? route(this.#app, request);
     }
 }

package/lib/private/session/Data.d.ts

@@ -1,5 +1,4 @@
-import type Dict from "@rcompat/type/Dict";
-import type JSONValue from "@rcompat/type/JSONValue";
+import type { Dict, JSONValue } from "@rcompat/type";
 type Data = Dict<JSONValue>;
 export { Data as default };
 //# sourceMappingURL=Data.d.ts.map

package/lib/private/session/SessionHandle.d.ts

@@ -1,5 +1,5 @@
 import kSerialize from "#session/k-serialize";
-import type Schema from "@rcompat/type/Schema";
+import type { Schema } from "@rcompat/type";
 export default class SessionHandle<Data> {
     #private;
     [kSerialize]: () => {