@primate/core 0.5.0 → 0.6.0

package/lib/private/orm/{Store.js → store.js}

@@ -1,5 +1,4 @@
-import E from "#db/error";
-import wrap from "#db/symbol/wrap";
+import E from "#db/errors";
 import parse from "#orm/parse";
 import assert from "@rcompat/assert";
 import is from "@rcompat/is";
@@ -64,35 +63,55 @@ const DATE_OPS = ["$before", "$after", "$ne"];
  * document database table/collection. It pairs a Pema schema with a uniform
  * CRUD/query API.
  */
-export default class Store {
+export class Store {
     #schema;
     #type;
     #types;
     #nullables;
-    #db;
     #name;
+    #db;
     #pk;
     #generate_pk;
     #fks;
     #relations;
-    constructor(input, config = {}) {
-        const { pk, generate_pk, fks, schema } = parse(input);
+    #migrate;
+    constructor(init) {
+        const { pk, generate_pk, fks, schema } = parse(init.schema);
+        const { name, db, migrate } = init;
+        if (name === undefined)
+            throw E.store_name_required();
+        assert.string(name);
+        if (!VALID_IDENTIFIER.test(name))
+            throw E.identifier_invalid(name);
+        assert.defined(db, E.db_missing);
+        assert.dict(schema);
+        assert.maybe.boolean(migrate);
+        assert.maybe.dict(init.extend);
         this.#schema = schema;
         this.#type = new StoreType(schema, pk);
         this.#types = Object.fromEntries(Object.entries(schema).map(([key, value]) => [key, value.datatype]));
-        this.#name = config.name;
-        this.#db = config.db;
+        this.#name = name;
+        this.#db = db;
         this.#pk = pk;
         this.#generate_pk = generate_pk;
         this.#fks = fks;
-        this.#relations = config.relations ?? {};
+        this.#relations = init.relations ?? {};
+        this.#migrate = migrate ?? true;
+        for (const relation of Object.keys(this.#relations)) {
+            if (relation in schema)
+                throw E.relation_conflicts_with_field(relation);
+        }
         this.#nullables = new Set(Object.entries(this.#type.properties)
             .filter(([, v]) => v.nullable)
             .map(([k]) => k));
-        registry.set(input, this);
-    }
-    static new(input, config = {}) {
-        return new Store(input, config);
+        if (init.extend !== undefined) {
+            for (const [k, v] of Object.entries(init.extend)) {
+                if (k in this)
+                    throw E.key_duplicate(k);
+                this[k] = v;
+            }
+        }
+        registry.set(init.schema, this);
     }
     get #as() {
         return {
@@ -102,14 +121,15 @@ export default class Store {
             types: this.#types,
         };
     }
-    get collection() {
+    get table() {
         const db = this.db;
-        const name = this.name;
-        const schema = this.#schema;
-        const as = this.#as;
+        const pk = {
+            name: this.#pk,
+            generate: this.#generate_pk,
+        };
         return {
-            create: () => db.schema.create(as, schema),
-            delete: () => db.schema.delete(name),
+            create: () => db.schema.create(this.#name, pk, this.#types),
+            delete: () => db.schema.delete(this.#name),
         };
     }
     get infer() {
@@ -121,26 +141,32 @@ export default class Store {
     get type() {
         return this.#type;
     }
-    [wrap](name, db) {
-        this.#db ??= db;
-        this.#name ??= name;
-        return this;
+    get migrate() {
+        return this.#migrate;
+    }
+    get name() {
+        return this.#name;
+    }
+    get pk() {
+        return this.#pk;
     }
     get db() {
-        if (this.#db === undefined)
-            throw E.db_missing();
         return this.#db;
     }
     get types() {
         return this.#types;
     }
-    get name() {
-        const name = this.#name;
-        if (name === undefined)
-            throw E.store_name_required();
-        if (!VALID_IDENTIFIER.test(name))
-            throw E.identifier_invalid(name);
-        return name;
+    #parse_pk(pkv) {
+        const pk = this.#pk;
+        if (pk === null)
+            throw E.pk_undefined(this.name);
+        try {
+            this.#schema[pk].parse(pkv);
+        }
+        catch {
+            throw E.pk_invalid(pkv);
+        }
+        return pk;
     }
     #parse_query(query, types) {
         const { where, select, sort, limit } = query;
@@ -294,6 +320,12 @@ export default class Store {
                     if (!is.blob(value))
                         throw E.wrong_type("blob", k, value);
                     continue;
+                case "uuid":
+                case "uuid_v4":
+                case "uuid_v7":
+                    if (!is.string(value))
+                        throw E.wrong_type("string", k, value);
+                    continue;
                 default:
                     throw E.where_invalid_value(k, value);
             }
@@ -360,14 +392,11 @@ export default class Store {
      * Check whether a record with the given primary key exists.
      */
     async has(pkv) {
-        if (this.#pk === null)
-            throw E.pk_undefined(this.name);
-        return (await this.count({ where: { [this.#pk]: pkv } })) === 1;
+        const pk = this.#parse_pk(pkv);
+        return (await this.count({ where: { [pk]: pkv } })) === 1;
     }
     async get(pkv, options) {
-        const pk = this.#pk;
-        if (pk === null)
-            throw E.pk_undefined(this.name);
+        const pk = this.#parse_pk(pkv);
         guard_options(options, ["select", "with"]);
         this.#parse_query(options ?? {}, this.#types);
         const $with = this.#with(options?.with);
@@ -376,8 +405,9 @@ export default class Store {
             fields: options?.select ? [...options.select] : undefined,
             with: $with,
         });
-        assert.true(records.length <= 1);
-        if (records.length === 0) {
+        const n = records.length;
+        assert.true(n <= 1, E.record_number_invalid(n, "get"));
+        if (n === 0) {
             const err = E.record_not_found(pk, pkv);
             err.not_found = true;
             throw err;
@@ -442,29 +472,20 @@ export default class Store {
             ...this.#type.partial().parse(to_parse),
             ...nulls,
         };
-        if (by_pk) {
+        if (by_pk)
             return this.#update_1(arg0, parsed);
-        }
         const where = arg0.where;
         if (where !== undefined)
             this.#parse_where(where, this.#types);
         return this.#update_n((where ?? {}), parsed);
     }
     async #update_1(pkv, set) {
-        const pk = this.#pk;
-        if (pk === null)
-            throw E.pk_undefined(this.name);
-        const n = await this.db.update(this.#as, {
-            set: set,
-            where: { [pk]: pkv },
-        });
-        assert.true(n === 1, `${n} records updated instead of 1`);
+        const pk = this.#parse_pk(pkv);
+        const n = await this.db.update(this.#as, { set, where: { [pk]: pkv } });
+        assert.true(n === 1, E.record_number_invalid(n, "update"));
     }
     async #update_n(where, set) {
-        return await this.db.update(this.#as, {
-            set: set,
-            where: where,
-        });
+        return await this.db.update(this.#as, { set, where });
     }
     async delete(pkv_or_options) {
         if (is.dict(pkv_or_options)) {
@@ -477,11 +498,9 @@ export default class Store {
         return this.#delete_1(pkv_or_options);
     }
     async #delete_1(pkv) {
-        const pk = this.#pk;
-        if (pk === null)
-            throw E.pk_undefined(this.name);
+        const pk = this.#parse_pk(pkv);
         const n = await this.db.delete(this.#as, { where: { [pk]: pkv } });
-        assert.true(n === 1, `${n} records deleted instead of 1`);
+        assert.true(n === 1, E.record_number_invalid(n, "delete"));
     }
     async #delete_n(where) {
         return await this.db.delete(this.#as, { where: where });
@@ -495,7 +514,7 @@ export default class Store {
         this.#parse_query(options ?? {}, this.#types);
         const result = await this.db.read(this.#as, {
             where: options?.where ?? {},
-            fields: options?.select ? [...options.select] : undefined,
+            fields: options?.select !== undefined ? [...options.select] : undefined,
             limit: options?.limit,
             sort: options?.sort,
             with: this.#with(options?.with),
@@ -506,13 +525,18 @@ export default class Store {
         return this.#type.toJSON();
     }
     extend(extensor) {
-        const extensions = extensor(this);
-        const keys = Object.keys(extensions);
-        for (const k of keys)
-            if (k in this)
-                throw E.key_duplicate(k);
-        Object.assign(this, extensions);
-        return this;
+        return new Store({
+            name: this.name,
+            db: this.db,
+            schema: this.#schema,
+            relations: this.#relations,
+            migrate: false,
+            extend: extensor(this),
+        });
     }
 }
-//# sourceMappingURL=Store.js.map
+function store(init) {
+    return new Store(init);
+}
+export default store;
+//# sourceMappingURL=store.js.map

package/lib/private/paths.js

@@ -1,4 +1,4 @@
-import fail from "#fail";
+import E from "#errors";
 import log from "#log";
 async function resolve(root, config_paths) {
     const tsconfig_path = root.join("tsconfig.json");
@@ -13,13 +13,13 @@ async function resolve(root, config_paths) {
             const config = JSON.parse(text);
             const ts_paths = config.compilerOptions?.paths ?? {};
             if (config_paths !== undefined && Object.keys(ts_paths).length > 0) {
-                return fail("tsconfig.json exists with paths, remove config paths");
+                return E.config_tsconfig_has_paths();
             }
             // merge with defaults (user paths override)
             return { ...ts_paths };
         }
         catch {
-            log.warn("Failed to parse tsconfig.json, falling back to config");
+            log.warn("failed to parse tsconfig.json, falling back to config");
         }
     }
     if (config_paths !== undefined)

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

@@ -4,6 +4,9 @@ type Normalize = (key: string) => string;
 interface Schema<T> {
     parse(input: unknown): T;
 }
+interface CoercibleSchema<T> extends Schema<T> {
+    coerce(input: unknown): T;
+}
 type Options = {
     normalize?: Normalize;
     raw?: string;
@@ -67,6 +70,7 @@ export default class RequestBag {
      * @throws Whatever the schema throws.
      */
     parse<T>(schema: Schema<T>): T;
+    coerce<T>(schema: CoercibleSchema<T>): T;
     /** Returns {@link raw}. Useful in template strings. */
     toString(): string;
     /**

package/lib/private/request/RequestBag.js

@@ -1,4 +1,4 @@
-import fail from "#fail";
+import E from "#errors";
 import assert from "@rcompat/assert";
 import fn from "@rcompat/fn";
 export default class RequestBag {
@@ -72,7 +72,7 @@ export default class RequestBag {
             if (v !== undefined)
                 return v;
         }
-        throw fail("{0} has no key {1}", this.#name, key);
+        throw E.request_bag_missing_key(this.#name, key);
     }
     /**
      * Try to get a value by key.
@@ -107,6 +107,9 @@ export default class RequestBag {
     parse(schema) {
         return schema.parse(this.#contents);
     }
+    coerce(schema) {
+        return schema.coerce(this.#contents);
+    }
     /** Returns {@link raw}. Useful in template strings. */
     toString() {
         return this.raw;

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

@@ -1,4 +1,4 @@
-import type { Dict, JSONValue, Schema } from "@rcompat/type";
+import type { Dict, JSONValue } from "@rcompat/type";
 type Form = Dict<string>;
 type Parsed = {
     type: "binary";
@@ -16,19 +16,16 @@ type Parsed = {
     type: "text";
     value: string;
 };
-type ParseReturn<S> = S extends {
-    parse: (v: unknown) => infer R;
-} ? R : never;
+declare function parse(request: Request, url: URL): Promise<RequestBody>;
+declare function none(): RequestBody;
 export default class RequestBody {
     #private;
-    static parse(request: Request, url: URL): Promise<RequestBody>;
-    static none(): RequestBody;
+    static parse: typeof parse;
+    static none: typeof none;
     constructor(parsed: Parsed, files?: Dict<File>);
-    get type(): "binary" | "json" | "text" | "none" | "form";
+    get type(): "json" | "binary" | "text" | "none" | "form";
     json(): JSONValue;
-    json<S extends Schema<unknown>>(schema: S): ParseReturn<S>;
     form(): Form;
-    form<S extends Schema<unknown>>(schema: S): ParseReturn<S>;
     files(): Dict<File>;
     text(): string;
     binary(): Blob;

package/lib/private/request/RequestBody.js

@@ -1,5 +1,5 @@
-import fail from "#fail";
-import MIME from "@rcompat/http/mime";
+import E from "#errors";
+import { MIME } from "@rcompat/http";
 import is from "@rcompat/is";
 async function anyform(request) {
     const form = Object.create(null);
@@ -15,40 +15,41 @@ async function anyform(request) {
     return { form, files };
 }
 ;
-export default class RequestBody {
-    #parsed;
-    #files;
-    static async parse(request, url) {
-        const raw = request.headers.get("content-type") ?? "none";
-        const type = raw.split(";")[0].trim().toLowerCase();
-        const path = url.pathname;
-        try {
-            switch (type) {
-                case MIME.APPLICATION_OCTET_STREAM:
-                    return new RequestBody({ type: "binary", value: await request.blob() });
-                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 MIME.APPLICATION_JSON:
-                    return new RequestBody({ type: "json", value: await request.json() });
-                case MIME.TEXT_PLAIN:
-                    return new RequestBody({ type: "text", value: await request.text() });
-                case "none":
-                    return RequestBody.none();
-                default:
-                    throw fail("{0}: unsupported content type {1}", path, type);
+async function parse(request, url) {
+    const raw = request.headers.get("content-type") ?? "none";
+    const type = raw.split(";")[0].trim().toLowerCase();
+    const path = url.pathname;
+    try {
+        switch (type) {
+            case MIME.APPLICATION_OCTET_STREAM:
+                return new RequestBody({ type: "binary", value: await request.blob() });
+            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);
             }
-        }
-        catch (cause) {
-            const message = "{0}: unparseable content type {1} - cause:\n[2]";
-            throw fail(message, path, type, cause);
+            case MIME.APPLICATION_JSON:
+                return new RequestBody({ type: "json", value: await request.json() });
+            case MIME.TEXT_PLAIN:
+                return new RequestBody({ type: "text", value: await request.text() });
+            case "none":
+                return RequestBody.none();
+            default:
+                throw E.request_unsupported_mime(path, type);
         }
     }
-    static none() {
-        return new RequestBody({ type: "none", value: null });
+    catch (cause) {
+        throw E.request_unparsable_mime(path, type, cause);
     }
+}
+function none() {
+    return new RequestBody({ type: "none", value: null });
+}
+export default class RequestBody {
+    #parsed;
+    #files;
+    static parse = parse;
+    static none = none;
     constructor(parsed, files = {}) {
         this.#parsed = parsed;
         this.#files = files;
@@ -59,44 +60,38 @@ export default class RequestBody {
     #value() {
         return this.#parsed.value;
     }
-    #throw(expected) {
-        throw fail("request body: expected {0}, got {1}", expected, this.type);
+    #unexpected_body(expected) {
+        throw E.request_unexpected_body(expected, this.type);
     }
-    json(schema) {
-        if (this.type !== "json") {
-            this.#throw("JSON");
-        }
-        const value = this.#value();
-        return schema ? schema.parse(value) : value;
+    json() {
+        if (this.type !== "json")
+            this.#unexpected_body("JSON");
+        return this.#value();
     }
-    form(schema) {
-        if (this.type !== "form") {
-            this.#throw("form");
-        }
-        const value = this.#value();
-        return schema ? schema.parse(value) : value;
+    form() {
+        if (this.type !== "form")
+            this.#unexpected_body("form");
+        return this.#value();
     }
     files() {
-        if (this.type !== "form") {
-            this.#throw("form");
-        }
+        if (this.type !== "form")
+            this.#unexpected_body("form");
         return this.#files;
     }
     text() {
-        if (this.type !== "text") {
-            this.#throw("plaintext");
-        }
+        if (this.type !== "text")
+            this.#unexpected_body("plaintext");
         return this.#value();
     }
     binary() {
         if (this.type !== "binary") {
-            this.#throw("binary");
+            this.#unexpected_body("binary");
         }
         return this.#value();
     }
     none() {
         if (this.type !== "none") {
-            this.#throw("none");
+            this.#unexpected_body("none");
         }
         return null;
     }

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

@@ -1,15 +1,10 @@
 import type RequestBag from "#request/RequestBag";
 import type RequestBody from "#request/RequestBody";
+import type RequestView from "#request/RequestView";
+import type Verb from "#request/Verb";
 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 = {
+    method: Verb;
     body: RequestBody;
     cookies: RequestBag;
     forward(to: string, headers?: Dict<string>): Promise<Response>;

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

@@ -0,0 +1,9 @@
+import type { Dict } from "@rcompat/type";
+type RequestPublic = {
+    cookies: Dict<string>;
+    headers: Dict<string>;
+    query: Dict<string>;
+    url: URL;
+};
+export type { RequestPublic as default };
+//# sourceMappingURL=RequestPublic.d.ts.map

package/lib/private/request/RequestPublic.js

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

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

@@ -0,0 +1,11 @@
+import type { Dict } from "@rcompat/type";
+type RequestView = {
+    context: Dict;
+    cookies: Dict<string>;
+    headers: Dict<string>;
+    path: Dict<string>;
+    query: Dict<string>;
+    url: URL;
+};
+export type { RequestView as default };
+//# sourceMappingURL=RequestView.d.ts.map

package/lib/private/request/RequestView.js

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

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

@@ -0,0 +1,4 @@
+import type RequestFacade from "#request/RequestFacade";
+import type ServeApp from "#serve/App";
+export default function handle(app: ServeApp, request: RequestFacade): Promise<Response>;
+//# sourceMappingURL=handle.d.ts.map

package/lib/private/request/handle.js

@@ -0,0 +1,18 @@
+import { Status } from "@rcompat/http";
+async function run(hooks, request) {
+    const [first, ...rest] = hooks;
+    if (first === undefined) {
+        return new Response(null, {
+            headers: {
+                "Content-Length": String(0),
+                "Cache-Control": "no-cache",
+            },
+            status: Status.INTERNAL_SERVER_ERROR,
+        });
+    }
+    return await first(request, next => run(rest, next));
+}
+export default function handle(app, request) {
+    return run(app.handle_hooks, request);
+}
+//# sourceMappingURL=handle.js.map

package/lib/private/request/parse.js

@@ -48,6 +48,7 @@ function parse(request) {
     const url = new URL(request.url);
     const facade = {
         body: RequestBody.none(),
+        method: request.method.toLowerCase(),
         cookies: cookie_bag(request),
         forward(to, headers) {
             return fetch(to, {

package/lib/private/request/route.js

@@ -1,9 +1,9 @@
-import fail from "#fail";
+import E from "#errors";
 import log from "#log";
 import response_error from "#response/error";
 import response_json from "#response/json";
 import respond from "#response/respond";
-import Status from "@rcompat/http/Status";
+import { Status } from "@rcompat/http";
 import ParseError from "pema/ParseError";
 const result = (request, response) => ({ request, response });
 function wrap_hook(h) {
@@ -12,17 +12,16 @@ function wrap_hook(h) {
         let called_next = false;
         const response = await h(request, async (r) => {
             if (called_next)
-                throw fail("hook called next() more than once");
+                throw E.hook_reused_next();
             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 (called_next)
+                throw E.hook_no_return();
+            throw E.hook_bad_return();
         }
         // if the hook called next(), we preserve the downstream request (mutations) but
         // allow the hook to override the response by returning something else.
@@ -48,10 +47,10 @@ export default async function (app, partial_request) {
         }
         const { errors, hooks, layouts, handler } = route;
         errorRoute = errors[0];
-        const module_hooks = app.modules.map(m => wrap_hook(m.route.bind(m)));
+        const internal_hooks = app.route_hooks.map(wrap_hook);
         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);
+        const { request, response } = await run([...internal_hooks, ...route_hooks, last], route.request);
         return await respond(response)(app, {
             layouts: await Promise.all(layouts.map(layout => layout(request))),
         }, request);