@primate/core 0.4.6 → 0.6.0

package/lib/private/serve/App.js

@@ -1,31 +1,29 @@
 import App from "#App";
-import fail from "#fail";
+import { s_config } from "#app/Facade";
+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 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, Status } from "@rcompat/http";
 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;
@@ -62,13 +60,12 @@ export default class ServeApp extends App {
     #serve_assets;
     #pages;
     #stores;
-    #frontends = {};
+    #frontends = new Map();
     #router;
-    #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,8 +75,8 @@ 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;
-        this.#i18n_config = init.i18n_config;
+        const http = this.#init.facade[s_config].http;
+        this.#i18n_config = init.i18n;
         this.set(s_http, {
             host: http.host,
             port: http.port,
@@ -92,16 +89,39 @@ 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,
-            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() {
@@ -111,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}`;
@@ -124,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;
@@ -133,32 +149,31 @@ 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 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;
     }
     ;
     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 +185,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 +223,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,32 +233,35 @@ 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) {
-        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) {
         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 +276,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 +312,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";
@@ -308,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);
@@ -328,9 +343,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 +370,35 @@ 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) {
-            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 route_path = verbs[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")
             ? 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,15 +19,15 @@ type ServeInit = {
     };
     views?: [string, Import][];
     stores?: [string, Import][];
-    config: Config;
+    facade: AppFacade;
     routes: [string, {
         default: any;
     }][];
     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

package/lib/private/serve/dev-module.js

@@ -0,0 +1,34 @@
+import log from "#log";
+import create from "#module/create";
+import c from "@rcompat/cli/color";
+function pass(address, request) {
+    return fetch(address, {
+        body: request.body,
+        duplex: "half",
+        headers: request.headers,
+        method: request.method,
+    });
+}
+export default function dev() {
+    let paths;
+    let reload;
+    return create({
+        name: "builtin/dev",
+        setup({ onServe, onHandle }) {
+            onServe(app => {
+                const { host, port } = app.livereload;
+                const assets = app.assets.map(asset => asset.src);
+                reload = `http://${host}:${port}`;
+                paths = ["/esbuild"].concat(assets);
+                log.print(`↻ live reload ${c.dim(reload)}\n`);
+            });
+            onHandle((request, next) => {
+                const { pathname } = new URL(request.url);
+                return paths.includes(pathname)
+                    ? pass(`${reload}${pathname}`, request.original)
+                    : next(request);
+            });
+        },
+    });
+}
+//# sourceMappingURL=dev-module.js.map

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

@@ -1,4 +1,3 @@
 import type ServeApp from "#serve/App";
-declare const _default: (app: ServeApp) => Promise<ServeApp>;
-export default _default;
+export default function run_serve_hooks(app: ServeApp): Promise<ServeApp>;
 //# sourceMappingURL=hook.d.ts.map

package/lib/private/serve/hook.js

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

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

@@ -1,5 +1,5 @@
 import ServeApp from "#serve/App";
 import type ServeInit from "#serve/Init";
-declare const _default: (root: string, options: ServeInit) => Promise<ServeApp>;
+declare const _default: (root: string, options: ServeInit) => Promise<ServeApp | undefined>;
 export default _default;
 //# sourceMappingURL=index.d.ts.map

package/lib/private/serve/index.js

@@ -1,6 +1,40 @@
+import { s_attach, s_config } from "#app/Facade";
+import E from "#db/errors";
+import log from "#log";
+import key from "#orm/key";
+import store from "#orm/store";
 import ServeApp from "#serve/App";
-import serve from "#serve/hook";
+import serve_hook from "#serve/hook";
+import p from "pema";
 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);
+    const config = facade[s_config];
+    const migrations = config.db.migrations;
+    try {
+        if (migrations !== undefined) {
+            const { table, db } = migrations;
+            const Migration = store({
+                name: table,
+                db,
+                schema: {
+                    id: key.primary(p.u16, { generate: false }),
+                    applied: p.date,
+                },
+            });
+            await Migration.table.create();
+            const last = await Migration.find({ limit: 1, sort: { id: "desc" } });
+            const last_id = last.length === 0 ? 0 : last[0].id;
+            const build_json = app.root.join("build.json");
+            const { migration_version } = await build_json.json();
+            if (last_id < migration_version)
+                throw E.unapplied_migrations();
+        }
+        return serve_hook(app);
+    }
+    catch (cause) {
+        log.error(cause);
+    }
 };
 //# sourceMappingURL=index.js.map

package/lib/private/server/TAG.d.ts

@@ -0,0 +1,3 @@
+declare const _default: "0.5";
+export default _default;
+//# sourceMappingURL=TAG.d.ts.map

package/lib/private/server/TAG.js

@@ -0,0 +1,2 @@
+export default "0.5";
+//# sourceMappingURL=TAG.js.map

package/lib/private/server/index.d.ts

@@ -0,0 +1,5 @@
+declare const server: {
+    TAG: string;
+};
+export default server;
+//# sourceMappingURL=index.d.ts.map

package/lib/private/server/index.js

@@ -0,0 +1,6 @@
+import TAG from "#server/TAG";
+const server = {
+    TAG,
+};
+export default server;
+//# sourceMappingURL=index.js.map

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]: () => {

package/lib/private/session/SessionHandle.js

@@ -1,20 +1,23 @@
+import E from "#errors";
 import kSerialize from "#session/k-serialize";
 import assert from "@rcompat/assert";
-import maybe from "@rcompat/assert/maybe";
+import is from "@rcompat/is";
 export default class SessionHandle {
     #id;
     #data;
     #schema;
     #dirty = false;
     constructor(id, data, schema) {
-        maybe(id).uuid();
-        maybe(data).record();
-        maybe(schema).object();
-        maybe(schema?.parse).function();
-        assert((id === undefined) === (data === undefined), "both `id` and `data` must be defined or undefined");
+        assert.maybe.uuid(id);
+        assert.maybe.dict(data);
+        assert.maybe.object(schema);
+        assert.maybe.function(schema?.parse);
+        assert.true((id === undefined) === (data === undefined), E.session_id_data());
         this.#id = id;
         this.#data = data;
-        this.#schema = schema ?? { parse: (x) => x };
+        this.#schema = schema?.parse
+            ? schema
+            : { parse: (x) => x };
     }
     get exists() {
         return this.#id !== undefined;
@@ -43,8 +46,7 @@ export default class SessionHandle {
         if (!this.exists)
             throw new Error("cannot set() on non-existent session");
         const previous = this.#data;
-        // @ts-expect-error TEST
-        const candidate = typeof next === "function" ? next(previous) : next;
+        const candidate = is.function(next) ? next(previous) : next;
         this.#data = this.#schema.parse(candidate);
         this.#dirty = true;
     }