@primate/core 0.5.0 → 0.6.0

package/lib/private/request/router.js

@@ -1,56 +1,28 @@
-import AppError from "#AppError";
-import fail from "#fail";
+import E from "#errors";
 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 re = /^[a-zA-Z0-9\-_+[\].]+$/;
 const specials = ["error", "hook", "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 },
-                hook: { 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;
+    const router = await FileRouter.load({
+        directory: directory.toString(),
+        extensions,
+        specials: {
+            error: { recursive: false },
+            hook: { recursive: true },
+            layout: { recursive: true },
+        },
+    });
+    router.all().map(route => {
+        const { path, segment } = route;
+        if (!re.test(segment))
+            throw E.route_invalid_characters(path, re);
+        if (segment.startsWith("+") && !specials.includes(segment.slice(1))) {
+            throw E.route_invalid_special_file(path);
         }
-        error_entries.forEach(([key, value]) => {
-            if (key in FileRouter.Error) {
-                throw new AppError(value, error.route);
-            }
-        });
-        // rethrow original error
-        throw error;
-    }
+        if (!p.test(segment))
+            throw E.route_invalid_parameter(path, segment);
+    });
+    return router;
 };
 //# sourceMappingURL=router.js.map

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

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

package/lib/private/request/storage.js

@@ -0,0 +1,5 @@
+import io from "@rcompat/io";
+import cache from "@rcompat/kv/cache";
+const s = Symbol("primate.request");
+export default () => cache.get(s, () => new io.async.Context());
+//# sourceMappingURL=storage.js.map

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

@@ -1,4 +1,4 @@
-import type View from "#frontend/View";
+import type View from "#client/View";
 import type RequestFacade from "#request/RequestFacade";
 import type ServeApp from "#serve/App";
 import type { Dict, MaybePromise } from "@rcompat/type";

package/lib/private/response/binary.js

@@ -1,5 +1,5 @@
 import Streamable from "@rcompat/fs/Streamable";
-import MIME from "@rcompat/http/mime";
+import { MIME } from "@rcompat/http";
 import is from "@rcompat/is";
 const encodeRFC5987 = (s) => encodeURIComponent(s).replace(/['()*]/g, c => `%${c.charCodeAt(0).toString(16).toUpperCase()}`);
 /**

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

@@ -1,5 +1,5 @@
 import type ResponseFunction from "#response/ResponseFunction";
-import type ValidStatus from "@rcompat/http/ValidStatus";
+import type { ValidStatus } from "@rcompat/http";
 type Options = {
     body?: string;
     page?: string;

package/lib/private/response/error.js

@@ -1,5 +1,5 @@
 import location from "#location";
-import Status from "@rcompat/http/Status";
+import { Status } from "@rcompat/http";
 /**
  * Render an error page.
  *

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

@@ -4,6 +4,6 @@
  * @param options response options
  * @return Response rendering function
  */
-declare const _default: (body: unknown, init?: ResponseInit) => (app: import("../serve/App.js").default) => import("@rcompat/type").MaybePromise<Response>;
+declare const _default: (body: unknown, init?: ResponseInit) => (app: import("../index.js").ServeApp) => import("@rcompat/type").MaybePromise<Response>;
 export default _default;
 //# sourceMappingURL=json.d.ts.map

package/lib/private/response/json.js

@@ -1,5 +1,5 @@
 import response from "#response";
-import MIME from "@rcompat/http/mime";
+import { MIME } from "@rcompat/http";
 /**
  * Issue a JSON response
  * @param body body object

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

@@ -1,11 +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
- */
+* 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

@@ -1,4 +1,4 @@
-import Status from "@rcompat/http/Status";
+import { Status } from "@rcompat/http";
 function hasCRLF(s) {
     return /[\r\n]/.test(s);
 }
@@ -22,9 +22,8 @@ function encodePathname(s) {
         .map((each, i) => i === 0 ? "" : encodeURIComponent(each)).join("/");
 }
 function toSearch(query) {
-    if (!query) {
+    if (!query)
         return "";
-    }
     const search = Object.entries(query)
         .filter(([, v]) => v !== null && v !== undefined)
         .reduce((params, [k, v]) => {
@@ -36,7 +35,7 @@ function toSearch(query) {
 }
 function toNormalized(relative, base) {
     // base -> URL resolution
-    if (base) {
+    if (base !== undefined) {
         const url = new URL(relative, new URL(String(base)));
         return url.pathname + url.search;
     }
@@ -48,11 +47,11 @@ function toNormalized(relative, base) {
     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
- */
+* 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, {

package/lib/private/response/respond.js

@@ -1,14 +1,11 @@
-import fail from "#fail";
+import E from "#errors";
 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 { Status } from "@rcompat/http";
 import is from "@rcompat/is";
-function invalid_body(body) {
-    throw fail("invalid body {0} returned from route", body);
-}
 function match(m) {
     return m;
 }
@@ -22,7 +19,12 @@ const guesses = match([
     [is.array, json],
     [is.string, text],
 ]);
-const guess = (value) => guesses.find(([_if]) => _if(value))?.[1](value)
-    ?? invalid_body(`${value}`);
+function guess(value) {
+    const found = guesses.find(([_if]) => _if(value))?.[1](value);
+    if (found === undefined)
+        throw E.response_invalid_body(`${value}`);
+    return found;
+}
+;
 export default (result) => typeof result === "function" ? result : guess(result);
 //# sourceMappingURL=respond.js.map

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

@@ -10,6 +10,6 @@ type Body = {
  * @param options response options
  * @return Response rendering function
  */
-declare const _default: (body: Body, init?: ResponseInit) => (app: import("../serve/App.js").default) => import("@rcompat/type").MaybePromise<Response>;
+declare const _default: (body: Body, init?: ResponseInit) => (app: import("../index.js").ServeApp) => import("@rcompat/type").MaybePromise<Response>;
 export default _default;
 //# sourceMappingURL=sse.d.ts.map

package/lib/private/response/sse.js

@@ -1,5 +1,5 @@
 import response from "#response";
-import MIME from "@rcompat/http/mime";
+import { MIME } from "@rcompat/http";
 const encode = (input) => new TextEncoder().encode(input);
 const handle = (body) => new ReadableStream({
     cancel() {

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

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

package/lib/private/response/text.js

@@ -1,6 +1,6 @@
 import response from "#response";
 import fn from "@rcompat/fn";
-import MIME from "@rcompat/http/mime";
+import { MIME } from "@rcompat/http";
 /**
  * Return a plaintext response
  * @param body plaintext body

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

@@ -1,4 +1,4 @@
-import type ViewOptions from "#frontend/ViewOptions";
+import type ViewOptions from "#client/ViewOptions";
 import type ResponseFunction from "#response/ResponseFunction";
 import type { Dict } from "@rcompat/type";
 declare function view<Props>(component: (props: Props) => any, props: Props, options?: ViewOptions): ResponseFunction;

package/lib/private/response/view.js

@@ -1,4 +1,4 @@
-import fail from "#fail";
+import E from "#errors";
 import fs from "@rcompat/fs";
 const extensions = ["extension", "fullExtension"];
 const backmap = {
@@ -17,14 +17,6 @@ const backmap = {
     tsx: "react",
     jsx: "react",
 };
-function no_frontend(view) {
-    const extension = fs.ref(view).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]}` : "";
-    return fail(`${error}${fix}`, view, pkgname);
-}
 /**
  * Render a view component using a frontend for the given filename extension
  * @param view path to view
@@ -33,14 +25,15 @@ function no_frontend(view) {
  * @return Response rendering function
  */
 function view(name, props, options) {
-    const _name = name;
+    const view_name = name;
     return async (app, transfer, request) => {
         const found_view = extensions
-            .map(extension => app.frontends[fs.ref(_name)[extension]])
-            .find(extension => extension !== undefined)?.(_name, props, options)(app, transfer, request);
+            .map(extension => app.frontends[fs.ref(view_name)[extension]])
+            .find(extension => extension !== undefined)?.(view_name, props, options)(app, transfer, request);
         if (found_view !== undefined)
             return found_view;
-        throw no_frontend(_name);
+        const extension = fs.ref(view_name).fullExtension.slice(1);
+        throw E.frontend_missing(view_name, backmap[extension]);
     };
 }
 export default view;

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

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

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

@@ -25,15 +25,15 @@ declare class Router {
             handler: RouteHandler;
             options: RouteOptions;
         } | undefined;
-        delete?: {
+        post?: {
             handler: RouteHandler;
             options: RouteOptions;
         } | undefined;
-        post?: {
+        put?: {
             handler: RouteHandler;
             options: RouteOptions;
         } | undefined;
-        put?: {
+        delete?: {
             handler: RouteHandler;
             options: RouteOptions;
         } | undefined;

package/lib/private/route/router.js

@@ -1,4 +1,4 @@
-import fail from "#fail";
+import E from "#errors";
 import assert from "@rcompat/assert";
 const stack = [];
 export const routes = stack;
@@ -18,9 +18,8 @@ class Router {
         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);
-        }
+        if (is_hook_file(active))
+            throw E.hook_route_functions_not_allowed(active);
         const _routes = this.#routes;
         if (!(active in _routes))
             _routes[active] = {};
@@ -29,18 +28,16 @@ class Router {
     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);
-        }
+        if (!is_hook_file(active))
+            throw E.hook_not_allowed(active);
         (this.#hooks[active] ??= []).push(fn);
     }
     getHooks(path) {
         return [...(this.#hooks[path] ?? [])];
     }
     verifyHook(path) {
-        if ((this.#hooks[path] ?? []).length === 0) {
-            throw fail("hook file {0} did not register any hooks (call hook(...))", path);
-        }
+        if ((this.#hooks[path] ?? []).length === 0)
+            throw E.hook_unused(path);
     }
     get(path) {
         return { ...this.#routes[path] };

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

@@ -1,14 +1,14 @@
 import App from "#App";
 import type Asset from "#asset/Asset";
-import type ServerView from "#frontend/ServerView";
-import type ViewOptions from "#frontend/ViewOptions";
-import type ViewResponse from "#frontend/ViewResponse";
+import type ServerView from "#client/ServerView";
+import type ViewOptions from "#client/ViewOptions";
+import type ViewResponse from "#client/ViewResponse";
 import type I18NConfig from "#i18n/Config";
 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 { Actions } from "@rcompat/http";
 import type { Dict } from "@rcompat/type";
 interface FullViewOptions extends ViewOptions {
     body: string;
@@ -24,11 +24,10 @@ export default class ServeApp extends App {
     constructor(rootfile: string, init: ServeInit);
     get secure(): boolean;
     get assets(): Asset[];
-    get modules(): import("../Module.js").default[];
     get url(): string;
     get router(): FileRouter;
     get frontends(): {
-        [x: string]: ViewResponse | undefined;
+        [k: string]: ViewResponse;
     };
     get stores(): Dict;
     get i18n(): I18NConfig | undefined;
@@ -43,7 +42,7 @@ export default class ServeApp extends App {
     media(content_type: string, response?: ResponseInit): ResponseInit;
     publish({ code, inline, src, type }: PublishOptions): Promise<void>;
     create_csp(): void;
-    register(extension: string, viewFunction: ViewResponse): void;
+    frontend(extension: string, view_response: ViewResponse): void;
     page(name?: string): string;
     serve_assets(pathname: string): Promise<Response | undefined>;
     start(): Promise<void>;

package/lib/private/serve/App.js

@@ -1,25 +1,26 @@
 import App from "#App";
 import { s_config } from "#app/Facade";
-import fail from "#fail";
+import E from "#errors";
 import hash from "#hash";
-import I18NModule from "#i18n/Module";
+import i18n_module from "#i18n/module";
 import location from "#location";
 import log from "#log";
-import reducer from "#reducer";
+import create from "#module/create";
+import handle from "#request/handle";
 import parse from "#request/parse";
 import RequestBag from "#request/RequestBag";
 import RequestBody from "#request/RequestBody";
+import route from "#request/route";
+import request_storage from "#request/storage";
 import router from "#route/router";
-import DevModule from "#serve/module/Dev";
-import HandleModule from "#serve/module/Handle";
-import SessionModule from "#session/SessionModule";
+import dev_module from "#serve/dev-module";
+import session_module from "#session/module";
 import tags from "#tags";
 import assert from "@rcompat/assert";
 import fs from "@rcompat/fs";
 import FileRouter from "@rcompat/fs/FileRouter";
-import MIME from "@rcompat/http/mime";
+import { MIME, Status } from "@rcompat/http";
 import serve from "@rcompat/http/serve";
-import Status from "@rcompat/http/Status";
 import is from "@rcompat/is";
 import utf8 from "@rcompat/string/utf8";
 import p from "pema";
@@ -59,9 +60,8 @@ export default class ServeApp extends App {
     #serve_assets;
     #pages;
     #stores;
-    #frontends = {};
+    #frontends = new Map();
     #router;
-    #builtins;
     #i18n_config;
     constructor(rootfile, init) {
         const dir = fs.ref(rootfile).directory;
@@ -76,7 +76,7 @@ export default class ServeApp extends App {
         this.#serve_assets = init.assets;
         this.#pages = init.pages;
         const http = this.#init.facade[s_config].http;
-        this.#i18n_config = init.i18n_config;
+        this.#i18n_config = init.i18n;
         this.set(s_http, {
             host: http.host,
             port: http.port,
@@ -93,14 +93,35 @@ export default class ServeApp extends App {
                 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,
-            i18n: init.i18n_config ? new I18NModule(init.i18n_config) : undefined,
-        };
+        if (init.mode === "development")
+            this.register(dev_module());
+        const assets = this.serve_assets.bind(this);
+        const bound_route = (request) => route(this, request);
+        if (init.session !== undefined) {
+            this.register(session_module(init.session));
+        }
+        if (init.i18n !== undefined)
+            this.register(i18n_module(init.i18n));
+        this.register(create({
+            name: "builtin/handle",
+            setup({ onHandle }) {
+                onHandle(async (request) => {
+                    const asset = await assets(request.url.pathname);
+                    if (asset !== undefined)
+                        return asset;
+                    return new Promise((resolve, reject) => {
+                        request_storage().run(request, async () => {
+                            try {
+                                resolve(await bound_route(request));
+                            }
+                            catch (e) {
+                                reject(e);
+                            }
+                        });
+                    });
+                });
+            },
+        }));
     }
     ;
     get secure() {
@@ -110,10 +131,6 @@ export default class ServeApp extends App {
     get assets() {
         return this.#assets;
     }
-    get modules() {
-        const { session, i18n } = this.#builtins;
-        return [session, i18n, ...super.modules].filter(m => m !== undefined);
-    }
     get url() {
         const { host, port } = this.config("http");
         return `http${this.secure ? "s" : ""}://${host}:${port}`;
@@ -123,7 +140,7 @@ export default class ServeApp extends App {
         return this.#router;
     }
     get frontends() {
-        return { ...this.#frontends };
+        return Object.fromEntries(this.#frontends);
     }
     get stores() {
         return this.#stores;
@@ -134,14 +151,13 @@ export default class ServeApp extends App {
     loadView(name) {
         const f = fs.ref(name).path;
         const frontends = Object.keys(this.frontends);
-        const extension = frontends.find(frontend => f.endsWith(frontend));
+        const extension = frontends.find(client => f.endsWith(client));
         const base = extension === undefined ? name : f.slice(0, -extension.length);
         const view = this.#views[base];
         if (view === undefined)
-            throw fail("no view {0}", name);
-        if (view.default === undefined) {
-            throw fail("view {0} must export a default component", name);
-        }
+            throw E.view_missing(name);
+        if (view.default === undefined)
+            throw E.view_missing_default_export(name);
         return view.default;
     }
     ;
@@ -223,11 +239,11 @@ export default class ServeApp extends App {
         }), { "script-src": [], "style-src": [] });
     }
     ;
-    register(extension, viewFunction) {
-        if (this.#frontends[extension] !== undefined) {
-            throw fail("double file extension {0}", extension);
+    frontend(extension, view_response) {
+        if (this.#frontends.has(extension)) {
+            throw E.view_duplicate_extension(extension);
         }
-        this.#frontends[extension] = viewFunction;
+        this.#frontends.set(extension, view_response);
     }
     ;
     page(name) {
@@ -313,15 +329,9 @@ export default class ServeApp extends App {
                 };
             }));
         }
-        const modules = [
-            this.#builtins.dev,
-            ...this.modules,
-            this.#builtins.handle,
-        ].filter(m => m !== undefined);
-        const handle = (request) => reducer(modules, request, "handle");
         this.#server = await serve(async (request) => {
             try {
-                return await handle(parse(request));
+                return await handle(this, parse(request));
             }
             catch (error) {
                 log.error(error);
@@ -374,9 +384,8 @@ export default class ServeApp extends App {
             .flatMap(v => router.getHooks(v));
         const verbs = router.get(route.path);
         const route_path = verbs[verb];
-        if (route_path === undefined) {
-            throw fail("route {0} has no {1} verb", route.path, verb);
-        }
+        if (route_path === undefined)
+            throw E.route_missing_verb(route.path, verb);
         const handler = route_path.handler;
         const parse_body = route_path.options.parseBody;
         const body = parse_body ?? this.config("request.body.parse")

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

@@ -26,8 +26,8 @@ type ServeInit = {
     mode: Mode;
     target: string;
     pages: Dict<string>;
-    session_config?: SessionConfig;
-    i18n_config?: I18NConfig;
+    session?: SessionConfig;
+    i18n?: I18NConfig;
 };
 export type { ServeInit as default };
 //# sourceMappingURL=Init.d.ts.map

package/lib/private/serve/dev-module.d.ts

@@ -0,0 +1,2 @@
+export default function dev(): import("#module/create").Created;
+//# sourceMappingURL=dev-module.d.ts.map