@primate/core 0.6.3 → 0.7.0

package/lib/private/serve/App.js

@@ -4,12 +4,11 @@ import E from "#errors";
 import hash from "#hash";
 import i18n_module from "#i18n/module";
 import location from "#location";
-import log from "#log";
 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 { BodyPatch } from "#request/RequestBody";
 import route from "#request/route";
 import request_storage from "#request/storage";
 import router from "#route/router";
@@ -19,7 +18,7 @@ import tags from "#tags";
 import assert from "@rcompat/assert";
 import fs from "@rcompat/fs";
 import FileRouter from "@rcompat/fs/FileRouter";
-import { MIME, Status } from "@rcompat/http";
+import http from "@rcompat/http";
 import serve from "@rcompat/http/serve";
 import is from "@rcompat/is";
 import utf8 from "@rcompat/string/utf8";
@@ -50,6 +49,13 @@ const render_head = (assets, head) => {
         : tags.script({ code, inline, integrity, src, type })).join("\n")).concat("\n", head ?? "");
 };
 const s_http = Symbol("s_http");
+const content_type_method = {
+    "application/json": "json",
+    "text/plain": "text",
+    "application/x-www-form-urlencoded": "form",
+    "multipart/form-data": "multipart",
+    "application/octet-stream": "blob",
+};
 ;
 export default class ServeApp extends App {
     #init;
@@ -68,21 +74,22 @@ export default class ServeApp extends App {
         super(dir, init.facade[s_config], {
             mode: init.mode,
             target: init.target,
-            dir: dir.path,
+            outdir: dir.path,
+            log: init.log,
         });
         this.#init = init;
         this.#views = Object.fromEntries(init.views ?? []);
         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.facade[s_config].http;
+        const http_config = this.#init.facade[s_config].http;
         this.#i18n_config = init.i18n;
         this.set(s_http, {
-            host: http.host,
-            port: http.port,
+            host: http_config.host,
+            port: http_config.port,
             ssl: this.secure ? {
-                cert: this.root.join(http.ssl.cert),
-                key: this.root.join(http.ssl.key),
+                cert: this.root.join(http_config.ssl.cert),
+                key: this.root.join(http_config.ssl.key),
             } : {},
         });
         this.#router = FileRouter.init({
@@ -123,19 +130,9 @@ export default class ServeApp extends App {
             },
         }));
     }
-    ;
-    get secure() {
-        const ssl = this.config("http.ssl");
-        return ssl.key !== undefined && ssl.cert !== undefined;
-    }
     get assets() {
         return this.#assets;
     }
-    get url() {
-        const { host, port } = this.config("http");
-        return `http${this.secure ? "s" : ""}://${host}:${port}`;
-    }
-    ;
     get router() {
         return this.#router;
     }
@@ -152,11 +149,11 @@ export default class ServeApp extends App {
         const f = fs.ref(name).path;
         const frontends = Object.keys(this.frontends);
         const extension = frontends.find(client => f.endsWith(client));
-        const base = extension === undefined ? name : f.slice(0, -extension.length);
+        const base = is.undefined(extension) ? name : f.slice(0, -extension.length);
         const view = this.#views[base];
-        if (view === undefined)
+        if (is.undefined(view))
             throw E.view_missing(name);
-        if (view.default === undefined)
+        if (is.undefined(view.default))
             throw E.view_missing_default_export(name);
         return view.default;
     }
@@ -174,7 +171,7 @@ export default class ServeApp extends App {
     render(content) {
         const { body, head, page, partial, placeholders = {} } = content;
         ["body", "head"].forEach(key => assert.undefined(placeholders[key]));
-        return partial ? body : Object.entries(placeholders)
+        return partial === true ? body : Object.entries(placeholders)
             // replace given placeholders, defaulting to ""
             .reduce((rendered, [key, value]) => rendered
             .replaceAll(`%${key}%`, value?.toString() ?? ""), this.page(page))
@@ -190,12 +187,12 @@ export default class ServeApp extends App {
     respond(body, init) {
         const { headers, status } = p({
             headers: p.dict(),
-            status: p.uint.values(Status).default(Status.OK),
+            status: p.uint.values(http.Status).default(http.Status.OK),
         }).parse(init);
         const body_length = this.body_length(body);
         return new Response(body, {
             headers: {
-                "Content-Type": MIME.TEXT_HTML,
+                "Content-Type": http.MIME.TEXT_HTML,
                 ...this.headers(),
                 ...body_length ? {
                     ...headers, "Content-Length": String(body_length),
@@ -206,14 +203,14 @@ export default class ServeApp extends App {
     ;
     view(options) {
         // split render and respond options
-        const { headers = {}, status = Status.OK, statusText, ...rest } = options;
+        const { headers = {}, status = http.Status.OK, statusText, ...rest } = options;
         return this.respond(this.render(rest), { headers, status });
     }
     ;
     media(content_type, response = {}) {
         return {
             headers: { ...response.headers, "Content-Type": content_type },
-            status: response.status ?? Status.OK,
+            status: response.status ?? http.Status.OK,
         };
     }
     ;
@@ -251,13 +248,13 @@ export default class ServeApp extends App {
         return this.#pages[page_name];
     }
     async #try_serve(ref) {
-        if (await ref.exists() && await ref.kind() === "file") {
+        if (await ref.exists() && await ref.type() === "file") {
             return new Response(ref.stream(), {
                 headers: {
-                    "Content-Type": MIME.resolve(ref.name),
+                    "Content-Type": http.toMIME(ref.name),
                     "Content-Length": String(await ref.size()),
                 },
-                status: Status.OK,
+                status: http.Status.OK,
             });
         }
     }
@@ -278,7 +275,7 @@ export default class ServeApp extends App {
         }
         const assets = this.#serve_assets;
         const asset = assets.client[pathname] ?? assets.static[pathname];
-        if (asset === undefined)
+        if (is.undefined(asset))
             return undefined;
         const binary = atob(asset.data);
         const bytes = new Uint8Array(binary.length);
@@ -290,7 +287,7 @@ export default class ServeApp extends App {
                 "Content-Type": asset.mime,
                 "Content-Length": String(bytes.length),
             },
-            status: Status.OK,
+            status: http.Status.OK,
         });
     }
     async start() {
@@ -334,13 +331,13 @@ export default class ServeApp extends App {
                 return await handle(this, parse(request));
             }
             catch (error) {
-                log.error(error);
+                this.log.error(error);
                 return new Response(null, {
                     headers: {
                         "Content-Length": String(0),
                         "Cache-Control": "no-cache",
                     },
-                    status: Status.INTERNAL_SERVER_ERROR,
+                    status: http.Status.INTERNAL_SERVER_ERROR,
                 });
             }
         }, {
@@ -350,55 +347,64 @@ export default class ServeApp extends App {
         function bright(x) {
             return `\x1b[38;2;0;200;255m${x}\x1b[0m`;
         }
-        log.print(`» app url     ${bright(this.url)}\n`);
+        this.log.print `» app url     ${bright(this.url)}\n`;
     }
     ;
     stop() {
         this.#server.stop();
-        log.system("stopped {0}", this.url);
+        this.log.system `stopped ${this.url}`;
     }
     ;
     upgrade(request, actions) {
         return this.#server.upgrade(request, actions);
     }
     async route(request) {
-        const { original, url } = request;
-        const pathname = normalize(url.pathname);
-        const route = this.router.match(original);
-        if (route === undefined) {
-            log.info("no {0} route to {1}", original.method, pathname);
-            return;
+        const pathname = normalize(request.url.pathname);
+        const matched = this.router.match(request.original);
+        if (is.undefined(matched)) {
+            this.log.trace `no ${request.method} route to ${pathname}`;
+            return undefined;
         }
-        const verb = original.method.toLowerCase();
-        const specials = route.specials;
+        const method = request.method.toLowerCase();
+        const specials = matched.specials;
         const errors = (specials.error ?? [])
-            .map(v => router.get(v)[verb]?.handler)
+            .map(v => router.get(v)[method]?.handler)
             .filter(Boolean)
             .toReversed();
         const layouts = (specials.layout ?? [])
-            .map(v => router.get(v)[verb]?.handler)
+            .map(v => router.get(v)[method]?.handler)
             .filter(Boolean)
             .toReversed();
         const hooks = (specials.hook ?? [])
             .toReversed()
             .flatMap(v => router.getHooks(v));
-        const verbs = router.get(route.path);
-        const route_path = verbs[verb];
-        if (route_path === undefined)
-            throw E.route_missing_verb(route.path, verb);
+        const methods = router.get(matched.path);
+        const is_head = method === "head";
+        const actual_method = is_head && is.undefined(methods.head) ? "get" : method;
+        const route_path = methods[actual_method];
+        if (is.undefined(route_path)) {
+            this.log.trace `${matched.path} has no method ${method}`;
+            return undefined;
+        }
         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();
+        const { contentType, body } = route_path.options;
+        if (contentType !== undefined) {
+            const raw = request.headers.try("content-type") ?? "";
+            const actual = raw.split(";")[0].trim().toLowerCase();
+            if (actual !== contentType) {
+                throw E.request_content_type_mismatch(contentType, actual);
+            }
+        }
         const refined = Object.assign(Object.create(request), {
-            body,
-            path: new RequestBag(route.params, "path", {
+            path: new RequestBag(matched.params, "path", {
                 normalize: k => k.toLowerCase(),
-                raw: url.pathname,
+                raw: request.url.pathname,
             }),
+            ...(body !== undefined && contentType !== undefined
+                ? { body: request.body[BodyPatch]({ contentType, schema: body }) }
+                : {}),
         });
-        return { errors, hooks, layouts, handler, request: refined };
+        return { errors, hooks, layouts, handler, request: refined, is_head };
     }
 }
 //# sourceMappingURL=App.js.map

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

@@ -1,5 +1,6 @@
 import type AppFacade from "#app/Facade";
 import type I18NConfig from "#i18n/Config";
+import type { Schema as LogSchema } from "#logger";
 import type Mode from "#Mode";
 import type SessionConfig from "#session/Config";
 import type { Dict } from "@rcompat/type";
@@ -25,6 +26,7 @@ type ServeInit = {
     }][];
     mode: Mode;
     target: string;
+    log: typeof LogSchema.infer;
     pages: Dict<string>;
     session?: SessionConfig;
     i18n?: I18NConfig;

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

@@ -1,6 +1,5 @@
-import log from "#log";
 import create from "#module/create";
-import c from "@rcompat/cli/color";
+import cli from "@rcompat/cli";
 function pass(address, request) {
     return fetch(address, {
         body: request.body,
@@ -20,7 +19,7 @@ export default function dev() {
                 const assets = app.assets.map(asset => asset.src);
                 reload = `http://${host}:${port}`;
                 paths = ["/esbuild"].concat(assets);
-                log.print(`↻ live reload ${c.dim(reload)}\n`);
+                app.log.print `↻ live reload ${cli.fg.dim(reload)}\n`;
             });
             onHandle((request, next) => {
                 const { pathname } = new URL(request.url);

package/lib/private/serve/index.js

@@ -1,8 +1,7 @@
 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 key from "#store/key";
+import store from "#store";
 import ServeApp from "#serve/App";
 import serve_hook from "#serve/hook";
 import p from "pema";
@@ -16,14 +15,14 @@ export default async (root, options) => {
         if (migrations !== undefined) {
             const { table, db } = migrations;
             const Migration = store({
-                name: table,
+                table,
                 db,
                 schema: {
                     id: key.primary(p.u16, { generate: false }),
                     applied: p.date,
                 },
             });
-            await Migration.table.create();
+            await Migration.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");
@@ -34,7 +33,7 @@ export default async (root, options) => {
         return serve_hook(app);
     }
     catch (cause) {
-        log.error(cause);
+        app.log.error(cause);
     }
 };
 //# sourceMappingURL=index.js.map

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

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

package/lib/private/server/TAG.js

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

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

@@ -1,6 +1,6 @@
-import type { Store } from "#orm/store";
 import configSchema from "#session/schema";
 import type SessionFacade from "#session/SessionFacade";
+import type Store from "#store/Store";
 import type { InferStore, StoreSchema } from "pema";
 type ConfigInput = typeof configSchema.input;
 type X<T> = {

package/lib/private/session/index.js

@@ -1,3 +1,4 @@
+import E from "#errors";
 import configSchema from "#session/schema";
 import local_storage from "#session/storage";
 import s_config from "#symbol/config";
@@ -8,8 +9,8 @@ export default function session(config) {
     const storage = local_storage();
     const current = () => {
         const s = storage.getStore();
-        if (!s)
-            throw new Error("Session handle not available in this context");
+        if (s === undefined)
+            throw E.session_handle_unavailable();
         return s;
     };
     const facade = {

package/lib/private/session/module.js

@@ -20,7 +20,7 @@ function cookie(name, value, options) {
 export default function session_module(config) {
     let secure;
     const store = config.store;
-    const props = store.type.properties;
+    const props = store.schema.properties;
     if (!("session_id" in props))
         throw E.session_missing_id();
     try {
@@ -34,7 +34,7 @@ export default function session_module(config) {
         setup({ onServe, onHandle }) {
             onServe(async (app) => {
                 secure = app.secure;
-                await store.table.create();
+                await store.create();
             });
             onHandle(async (request, next) => {
                 const { name, ...cookie_config } = config.cookie;
@@ -52,7 +52,7 @@ export default function session_module(config) {
                     data = rest;
                     db_id = _id;
                 }
-                const session_type = p.omit(store.type, "id", "session_id");
+                const session_type = p.omit(store.schema, "id", "session_id");
                 const session = new SessionHandle(sid, data, session_type);
                 const response = await new Promise((resolve, reject) => {
                     storage().run(session, async () => {

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

@@ -1,4 +1,4 @@
-import { Store } from "#orm/store";
+import Store from "#store/Store";
 declare const _default: import("pema").ObjectType<import("pema").NormalizeSchemaObject<{
     readonly cookie: {
         readonly httpOnly: import("pema").DefaultType<import("pema").BooleanType, true>;
@@ -6,7 +6,7 @@ declare const _default: import("pema").ObjectType<import("pema").NormalizeSchema
         readonly path: import("pema").DefaultType<import("pema").StringType, "/">;
         readonly sameSite: import("pema").DefaultType<import("pema").UnionType<[import("pema").LiteralType<"Strict">, import("pema").LiteralType<"Lax">, import("pema").LiteralType<"None">]>, "Lax" | "None" | "Strict">;
     };
-    readonly store: import("pema").DefaultType<import("pema").ConstructorType<typeof Store>, Store<import("../orm/StoreInput.js").default, import("@rcompat/type").Dict<import("../orm/relation.js").Relation>>>;
+    readonly store: import("pema").DefaultType<import("pema").ConstructorType<typeof Store>, Store<import("../store/StoreInput.js").default, string>>;
 }>, {
     cookie: {
         httpOnly: boolean;
@@ -14,7 +14,7 @@ declare const _default: import("pema").ObjectType<import("pema").NormalizeSchema
         path: string;
         sameSite: "Lax" | "None" | "Strict";
     };
-    store: Store<import("../orm/StoreInput.js").default, import("@rcompat/type").Dict<import("../orm/relation.js").Relation>>;
+    store: Store<import("../store/StoreInput.js").default, string>;
 }>;
 export default _default;
 //# sourceMappingURL=schema.d.ts.map

package/lib/private/session/schema.js

@@ -1,6 +1,7 @@
 import MemoryDB from "#db/MemoryDB";
-import key from "#orm/key";
-import store, { Store } from "#orm/store";
+import store from "#store";
+import Store from "#store/Store";
+import key from "#store/key";
 import p from "pema";
 export default p({
     cookie: {
@@ -16,7 +17,7 @@ export default p({
                 session_id: p.uuid,
             },
             db: new MemoryDB(),
-            name: "session",
+            table: "session",
         });
     }),
 });

package/lib/private/store/ExtractRelation.d.ts

@@ -0,0 +1,7 @@
+import type StoreInput from "#store/StoreInput";
+import type { ManyRelation, OneRelation } from "#store/relation";
+type ExtractRelations<T extends StoreInput> = {
+    [K in keyof T as T[K] extends OneRelation<string, string> | ManyRelation<string, string> ? K : never]: T[K] extends OneRelation<string, string> | ManyRelation<string, string> ? T[K] : never;
+};
+export type { ExtractRelations as default };
+//# sourceMappingURL=ExtractRelation.d.ts.map

package/lib/private/store/ExtractRelation.js

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

package/lib/private/store/ExtractSchema.d.ts

@@ -0,0 +1,10 @@
+import type ForeignKey from "#store/ForeignKey";
+import type PrimaryKey from "#store/PrimaryKey";
+import type { ManyRelation, OneRelation } from "#store/relation";
+import type StoreInput from "#store/StoreInput";
+import type { DataKey, Storable } from "pema";
+type ExtractSchema<T extends StoreInput> = {
+    [K in keyof T as T[K] extends OneRelation<string, string> | ManyRelation<string, string> ? never : K]: T[K] extends PrimaryKey<infer P> ? P : T[K] extends ForeignKey<infer P> ? P : T[K] extends Storable<DataKey> ? T[K] : never;
+};
+export type { ExtractSchema as default };
+//# sourceMappingURL=ExtractSchema.d.ts.map

package/lib/private/{orm → store}/ForeignKey.d.ts

@@ -1,4 +1,4 @@
-import type { AllowedPKType } from "#orm/PrimaryKey";
+import type { AllowedPKType } from "#store/PrimaryKey";
 import type { OptionalType } from "pema";
 export type AllowedFKType = AllowedPKType | OptionalType<AllowedPKType>;
 export default class ForeignKey<T extends AllowedFKType> {

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

@@ -0,0 +1,13 @@
+import type DB from "#db/DB";
+import type StoreInput from "#store/StoreInput";
+import type { Dict } from "@rcompat/type";
+type Init<S extends StoreInput, N extends string> = {
+    table: N;
+    db: DB;
+    id?: symbol;
+    schema: S;
+    migrate?: boolean;
+    extend?: Dict;
+};
+export type { Init as default };
+//# sourceMappingURL=Init.d.ts.map

package/lib/private/store/Init.js

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