@primate/core 0.4.6 → 0.5.0

package/lib/private/orm/types.js

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

package/lib/private/orm/wrap.d.ts

@@ -0,0 +1,5 @@
+import type DB from "#db/DB";
+import type Store from "#orm/Store";
+import type { StoreSchema } from "pema";
+export default function wrapStore<T extends StoreSchema>(name: string, store: Store<T>, db: DB): Store<T, {}>;
+//# sourceMappingURL=wrap.d.ts.map

package/lib/private/orm/wrap.js

@@ -0,0 +1,5 @@
+import wrap from "#db/symbol/wrap";
+export default function wrapStore(name, store, db) {
+    return store[wrap](name, db);
+}
+//# sourceMappingURL=wrap.js.map

package/lib/private/paths.d.ts

@@ -1,5 +1,5 @@
-import type FileRef from "@rcompat/fs/FileRef";
-import type Dict from "@rcompat/type/Dict";
+import type { FileRef } from "@rcompat/fs";
+import type { Dict } from "@rcompat/type";
 declare function resolve(root: FileRef, config_paths?: Dict<string[]>): Promise<any>;
 export default resolve;
 //# sourceMappingURL=paths.d.ts.map

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

@@ -1,4 +1,4 @@
-import type PartialDict from "@rcompat/type/PartialDict";
+import type { PartialDict } from "@rcompat/type";
 type Contents = PartialDict<string>;
 type Normalize = (key: string) => string;
 interface Schema<T> {

package/lib/private/request/RequestBag.js

@@ -1,5 +1,6 @@
 import fail from "#fail";
-import is from "@rcompat/assert/is";
+import assert from "@rcompat/assert";
+import fn from "@rcompat/fn";
 export default class RequestBag {
     #contents;
     #name;
@@ -12,16 +13,19 @@ export default class RequestBag {
      * @param name - Human-readable bag name used in error messages.
      * @param options - Optional `normalize` function and `raw` string.
      */
-    constructor(input, name, options = {}) {
-        is(input).object();
+    constructor(input, name, options) {
+        assert.dict(input);
+        assert.string(name);
+        assert.maybe.dict(options);
+        assert.maybe.function(options?.normalize);
+        assert.maybe.string(options?.raw);
         this.#name = name;
-        this.#normalize = options.normalize ?? (k => k);
-        this.#raw = options.raw ?? "";
+        this.#normalize = options?.normalize ?? fn.identity;
+        this.#raw = options?.raw ?? "";
         const contents = Object.create(null);
         for (const key of Object.keys(input)) {
-            const normalized = this.#normalize(key);
             // last-wins semantics if only case differs
-            contents[normalized] = input[key];
+            contents[this.#normalize(key)] = input[key];
         }
         this.#contents = contents;
     }

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

@@ -1,6 +1,4 @@
-import type Dict from "@rcompat/type/Dict";
-import type JSONValue from "@rcompat/type/JSONValue";
-import type Schema from "@rcompat/type/Schema";
+import type { Dict, JSONValue, Schema } from "@rcompat/type";
 type Form = Dict<string>;
 type Parsed = {
     type: "binary";
@@ -26,7 +24,7 @@ export default class RequestBody {
     static parse(request: Request, url: URL): Promise<RequestBody>;
     static none(): RequestBody;
     constructor(parsed: Parsed, files?: Dict<File>);
-    get type(): "binary" | "form" | "json" | "none" | "text";
+    get type(): "binary" | "json" | "text" | "none" | "form";
     json(): JSONValue;
     json<S extends Schema<unknown>>(schema: S): ParseReturn<S>;
     form(): Form;

package/lib/private/request/RequestBody.js

@@ -1,14 +1,11 @@
 import fail from "#fail";
-import json from "@rcompat/http/mime/application/json";
-import binary from "@rcompat/http/mime/application/octet-stream";
-import www_form from "@rcompat/http/mime/application/x-www-form-urlencoded";
-import form_data from "@rcompat/http/mime/multipart/form-data";
-import text from "@rcompat/http/mime/text/plain";
+import MIME from "@rcompat/http/mime";
+import is from "@rcompat/is";
 async function anyform(request) {
     const form = Object.create(null);
     const files = Object.create(null);
     for (const [key, value] of (await request.formData()).entries()) {
-        if (typeof value === "string") {
+        if (is.string(value)) {
             form[key] = value;
         }
         else {
@@ -27,16 +24,16 @@ export default class RequestBody {
         const path = url.pathname;
         try {
             switch (type) {
-                case binary:
+                case MIME.APPLICATION_OCTET_STREAM:
                     return new RequestBody({ type: "binary", value: await request.blob() });
-                case www_form:
-                case form_data: {
+                case MIME.APPLICATION_X_WWW_FORM_URLENCODED:
+                case MIME.MULTIPART_FORM_DATA: {
                     const { form, files } = await anyform(request);
                     return new RequestBody({ type: "form", value: form }, files);
                 }
-                case json:
+                case MIME.APPLICATION_JSON:
                     return new RequestBody({ type: "json", value: await request.json() });
-                case text:
+                case MIME.TEXT_PLAIN:
                     return new RequestBody({ type: "text", value: await request.text() });
                 case "none":
                     return RequestBody.none();

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

@@ -0,0 +1,12 @@
+import type { Dict } from "@rcompat/type";
+export default class RequestContext {
+    #private;
+    set<T>(key: string, value: T): void;
+    update<T>(key: string, fn: (prev: T | undefined) => T): void;
+    has(key: string): boolean;
+    try<T>(key: string): T | undefined;
+    get<T>(key: string): T;
+    delete(key: string): void;
+    toJSON(): Dict;
+}
+//# sourceMappingURL=RequestContext.d.ts.map

package/lib/private/request/RequestContext.js

@@ -0,0 +1,31 @@
+export default class RequestContext {
+    #data = new Map();
+    set(key, value) {
+        this.#data.set(key, value);
+    }
+    update(key, fn) {
+        const prev = this.try(key);
+        this.set(key, fn(prev));
+    }
+    has(key) {
+        return this.#data.has(key);
+    }
+    try(key) {
+        return this.#data.get(key);
+    }
+    get(key) {
+        if (!this.#data.has(key))
+            throw new Error(`Missing context key: ${key}`);
+        return this.#data.get(key);
+    }
+    delete(key) {
+        this.#data.delete(key);
+    }
+    toJSON() {
+        const out = Object.create(null);
+        for (const [k, v] of this.#data)
+            out[k] = v;
+        return out;
+    }
+}
+//# sourceMappingURL=RequestContext.js.map

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

@@ -1,20 +1,30 @@
 import type RequestBag from "#request/RequestBag";
 import type RequestBody from "#request/RequestBody";
-import type Dict from "@rcompat/type/Dict";
+import type { Dict } from "@rcompat/type";
+type RequestView = {
+    context: Dict;
+    cookies: Dict<string>;
+    headers: Dict<string>;
+    path: Dict<string>;
+    query: Dict<string>;
+    url: URL;
+};
 type RequestFacade = {
     body: RequestBody;
-    context: Dict;
     cookies: RequestBag;
     forward(to: string, headers?: Dict<string>): Promise<Response>;
     headers: RequestBag;
     original: Request;
     path: RequestBag;
     query: RequestBag;
-    /**
-     * The request's pathname + querystring.
-     */
     target: string;
     url: URL;
-} & Dict<Dict | unknown>;
+    has(key: string): boolean;
+    try<T>(key: string): T | undefined;
+    get<T>(key: string): T;
+    set<T>(key: string, value: T | ((prev: T | undefined) => T)): RequestFacade;
+    delete(key: string): RequestFacade;
+    toJSON(): RequestView;
+};
 export { RequestFacade as default };
 //# sourceMappingURL=RequestFacade.d.ts.map

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

@@ -1,4 +1,4 @@
 import type RequestFacade from "#request/RequestFacade";
-declare const _default: (request: Request) => RequestFacade;
-export default _default;
+declare function parse(request: Request): RequestFacade;
+export default parse;
 //# sourceMappingURL=parse.d.ts.map

package/lib/private/request/parse.js

@@ -1,5 +1,8 @@
 import RequestBag from "#request/RequestBag";
 import RequestBody from "#request/RequestBody";
+import RequestContext from "#request/RequestContext";
+import sContext from "#request/sContext";
+import is from "@rcompat/is";
 function decode(s) {
     try {
         return decodeURIComponent(s);
@@ -9,14 +12,16 @@ function decode(s) {
     }
 }
 ;
-const normalize = (k) => k.toLowerCase();
-function bagHeaders(request) {
+function normalize(k) {
+    return k.toLowerCase();
+}
+function header_bag(request) {
     const headers = Object.fromEntries([...request.headers].map(([k, v]) => [k.toLowerCase(), v]));
     return new RequestBag(headers, "headers", {
         normalize,
     });
 }
-function bagCookies(request) {
+function cookie_bag(request) {
     const header = request.headers.get("cookie");
     const entries = Object.fromEntries(header
         ? header.split(";").map(s => s.trim()).filter(Boolean).map(s => {
@@ -30,23 +35,20 @@ function bagCookies(request) {
         raw: header ?? "",
     });
 }
-function bagQuery(url) {
+function query_bag(url) {
     return new RequestBag(Object.fromEntries(url.searchParams), "query", {
         normalize,
         raw: url.search,
     });
 }
-function bagPath(url) {
-    return new RequestBag(Object.create(null), "path", {
-        raw: url.pathname,
-    });
+function path_bag(url) {
+    return new RequestBag(Object.create(null), "path", { raw: url.pathname });
 }
-export default (request) => {
+function parse(request) {
     const url = new URL(request.url);
-    return {
+    const facade = {
         body: RequestBody.none(),
-        context: {},
-        cookies: bagCookies(request),
+        cookies: cookie_bag(request),
         forward(to, headers) {
             return fetch(to, {
                 body: request.body,
@@ -58,12 +60,48 @@ export default (request) => {
                 method: request.method,
             });
         },
-        headers: bagHeaders(request),
+        headers: header_bag(request),
         original: request,
-        path: bagPath(url),
-        query: bagQuery(url),
+        path: path_bag(url),
+        query: query_bag(url),
         target: url.pathname + url.search,
         url,
+        has(key) {
+            return this[sContext].has(key);
+        },
+        try(key) {
+            return this[sContext].try(key);
+        },
+        get(key) {
+            return this[sContext].get(key);
+        },
+        set(key, value) {
+            if (is.function(value)) {
+                this[sContext].update(key, value);
+            }
+            else {
+                this[sContext].set(key, value);
+            }
+            return this;
+        },
+        delete(key) {
+            this[sContext].delete(key);
+            return this;
+        },
+        toJSON() {
+            return {
+                context: this[sContext].toJSON(),
+                cookies: this.cookies.toJSON(),
+                headers: this.headers.toJSON(),
+                path: this.path.toJSON(),
+                query: this.query.toJSON(),
+                url: this.url,
+            };
+        },
+        [sContext]: new RequestContext(),
     };
-};
+    return facade;
+}
+;
+export default parse;
 //# sourceMappingURL=parse.js.map

package/lib/private/request/route.js

@@ -1,28 +1,44 @@
+import fail from "#fail";
 import log from "#log";
 import response_error from "#response/error";
 import response_json from "#response/json";
 import respond from "#response/respond";
-import guard from "#route/guard";
 import Status from "@rcompat/http/Status";
 import ParseError from "pema/ParseError";
-async function reducer(hooks, request) {
+const result = (request, response) => ({ request, response });
+function wrap_hook(h) {
+    return async (request, next) => {
+        let downstream;
+        let called_next = false;
+        const response = await h(request, async (r) => {
+            if (called_next)
+                throw fail("hook called next() more than once");
+            called_next = true;
+            downstream = await next(r);
+            return downstream.response;
+        });
+        // hook returned nothing
+        if (response === undefined) {
+            if (called_next) {
+                throw fail("hook called next() but did not return a result; did you forget `return next(request)`?");
+            }
+            throw fail("hook must return a response-like value or return next(request)");
+        }
+        // if the hook called next(), we preserve the downstream request (mutations) but
+        // allow the hook to override the response by returning something else.
+        return downstream !== undefined
+            ? result(downstream.request, response)
+            : result(request, response);
+    };
+}
+async function run(hooks, request) {
     const [first, ...rest] = hooks;
+    if (first === undefined)
+        return result(request, new Response());
     if (rest.length === 0)
-        return await first(request, _ => new Response());
-    return await first(request, _ => reducer(rest, _));
+        return first(request, async (r) => result(r, new Response()));
+    return first(request, r => run(rest, r));
 }
-;
-// last, preserve final request form
-function last(handler) {
-    return async (request) => {
-        const response = await handler(request);
-        return {
-            request,
-            response: response,
-        };
-    };
-}
-;
 export default async function (app, partial_request) {
     let errorRoute;
     try {
@@ -30,12 +46,12 @@ export default async function (app, partial_request) {
         if (route === undefined) {
             return response_error()(app, {}, partial_request);
         }
-        const { errors, guards, handler, layouts } = route;
+        const { errors, hooks, layouts, handler } = route;
         errorRoute = errors[0];
-        const route_hooks = app.modules.map(module => module.route.bind(module));
-        const hooks = [...route_hooks, guard(guards), last(handler)];
-        // handle request
-        const { request, response } = await reducer(hooks, route.request);
+        const module_hooks = app.modules.map(m => wrap_hook(m.route.bind(m)));
+        const route_hooks = hooks.map(wrap_hook);
+        const last = async (req, _next) => result(req, await handler(req));
+        const { request, response } = await run([...module_hooks, ...route_hooks, last], route.request);
         return await respond(response)(app, {
             layouts: await Promise.all(layouts.map(layout => layout(request))),
         }, request);

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

@@ -1,4 +1,4 @@
-import type FileRef from "@rcompat/fs/FileRef";
+import type { FileRef } from "@rcompat/fs";
 import FileRouter from "@rcompat/fs/FileRouter";
 declare const _default: (directory: FileRef, extensions: string[]) => Promise<FileRouter>;
 export default _default;

package/lib/private/request/router.js

@@ -11,7 +11,7 @@ const allowed = {
     replacements: ["a-Z", "0-9", "-", "_", "+", "[", "]", "."],
     text: "letters ({1}), digits ({2}), {3}, {4}, {5}, {6}, {7}",
 };
-const specials = ["guard", "error", "layout"];
+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) => {
@@ -21,7 +21,7 @@ export default async (directory, extensions) => {
             extensions,
             specials: {
                 error: { recursive: false },
-                guard: { recursive: true },
+                hook: { recursive: true },
                 layout: { recursive: true },
             },
         });

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

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

package/lib/private/request/sContext.js

@@ -0,0 +1,2 @@
+export default Symbol("primate.request.context");
+//# sourceMappingURL=sContext.js.map

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

@@ -1,8 +1,7 @@
 import type View from "#frontend/View";
 import type RequestFacade from "#request/RequestFacade";
 import type ServeApp from "#serve/App";
-import type Dict from "@rcompat/type/Dict";
-import type MaybePromise from "@rcompat/type/MaybePromise";
+import type { Dict, MaybePromise } from "@rcompat/type";
 type ResponseFunction = (app: ServeApp, transfer: Dict, request: RequestFacade) => MaybePromise<View | null | Response | undefined>;
 export { ResponseFunction as default };
 //# sourceMappingURL=ResponseFunction.d.ts.map

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

@@ -1,6 +1,6 @@
 import type ResponseFunction from "#response/ResponseFunction";
 import type Streamable from "@rcompat/fs/Streamable";
-import type Dict from "@rcompat/type/Dict";
+import type { Dict } from "@rcompat/type";
 type ResponseLike = string | Dict | Dict[] | URL | Blob | ReadableStream | Streamable | Response | ResponseFunction | null;
 export { ResponseLike as default };
 //# sourceMappingURL=ResponseLike.d.ts.map

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

@@ -1,5 +1,5 @@
 import type ServeApp from "#serve/App";
-import type StreamSource from "@rcompat/fs/StreamSource";
+import type { StreamSource } from "@rcompat/fs";
 /**
  * Stream a binary response.
  * @param source streamable source

package/lib/private/response/binary.js

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

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").default<Response>;
+declare const _default: (body: unknown, init?: ResponseInit) => (app: import("../serve/App.js").default) => import("@rcompat/type").MaybePromise<Response>;
 export default _default;
 //# sourceMappingURL=json.d.ts.map

package/lib/private/response/json.js

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

package/lib/private/response/redirect.js

@@ -59,7 +59,7 @@ app => app.respond(null, {
     headers: {
         "Content-Length": String(0),
         Location: location,
-        "Cache-Control": 'no-cache',
+        "Cache-Control": "no-cache",
     },
     status: status ?? Status.FOUND,
 });

package/lib/private/response/respond.js

@@ -5,25 +5,22 @@ import redirect from "#response/redirect";
 import text from "#response/text";
 import Streamable from "@rcompat/fs/Streamable";
 import Status from "@rcompat/http/Status";
-import proper from "@rcompat/record/proper";
+import is from "@rcompat/is";
 function invalid_body(body) {
     throw fail("invalid body {0} returned from route", body);
 }
-const is_instance = (of) => ((value) => value instanceof of);
-const is_response = is_instance(Response);
-const is_url = is_instance(URL);
-const is_null = (value) => value === null;
 function match(m) {
     return m;
 }
 // [if, then]
 const guesses = match([
-    [is_null, () => () => new Response(null, { status: Status.NO_CONTENT })],
-    [is_url, value => redirect(value.toString())],
+    [is.null, () => () => new Response(null, { status: Status.NO_CONTENT })],
+    [is.url, value => redirect(value.toString())],
     [Streamable.is, value => binary(value)],
-    [(value) => is_response(value), value => _ => value],
-    [proper, json],
-    [(value) => typeof value === "string", text],
+    [is.response, value => _ => value],
+    [is.dict, json],
+    [is.array, json],
+    [is.string, text],
 ]);
 const guess = (value) => guesses.find(([_if]) => _if(value))?.[1](value)
     ?? invalid_body(`${value}`);

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").default<Response>;
+declare const _default: (body: Body, init?: ResponseInit) => (app: import("../serve/App.js").default) => 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/text/event-stream";
+import MIME from "@rcompat/http/mime";
 const encode = (input) => new TextEncoder().encode(input);
 const handle = (body) => new ReadableStream({
     cancel() {
@@ -21,5 +21,5 @@ const handle = (body) => new ReadableStream({
  * @param options response options
  * @return Response rendering function
  */
-export default response(mime, handle);
+export default response(MIME.TEXT_EVENT_STREAM, handle);
 //# sourceMappingURL=sse.js.map

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").default<Response>;
+declare const _default: (body: string, init?: ResponseInit) => (app: import("../serve/App.js").default) => import("@rcompat/type").MaybePromise<Response>;
 export default _default;
 //# sourceMappingURL=text.d.ts.map

package/lib/private/response/text.js

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

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

@@ -1,6 +1,6 @@
 import type ViewOptions from "#frontend/ViewOptions";
-import type Dict from "@rcompat/type/Dict";
-import type ResponseFunction from "./ResponseFunction.js";
+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;
 declare function view(component: () => any, props?: Dict, options?: ViewOptions): ResponseFunction;
 declare function view(name: string, props?: Dict, options?: ViewOptions): ResponseFunction;

package/lib/private/response/view.js

@@ -1,5 +1,5 @@
 import fail from "#fail";
-import FileRef from "@rcompat/fs/FileRef";
+import fs from "@rcompat/fs";
 const extensions = ["extension", "fullExtension"];
 const backmap = {
     "component.ts": "angular",
@@ -18,7 +18,7 @@ const backmap = {
     jsx: "react",
 };
 function no_frontend(view) {
-    const extension = new FileRef(view).fullExtension.slice(1);
+    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}?" : "";
@@ -36,7 +36,7 @@ function view(name, props, options) {
     const _name = name;
     return async (app, transfer, request) => {
         const found_view = extensions
-            .map(extension => app.frontends[new FileRef(_name)[extension]])
+            .map(extension => app.frontends[fs.ref(_name)[extension]])
             .find(extension => extension !== undefined)?.(_name, props, options)(app, transfer, request);
         if (found_view !== undefined)
             return found_view;