@primate/core 0.4.6 → 0.6.0

package/lib/private/config/schema.js

@@ -1,21 +1,39 @@
-import Module from "#Module";
-import FileRef from "@rcompat/fs/FileRef";
+import fs from "@rcompat/fs";
 import p from "pema";
 export default p({
     http: {
-        csp: p.record(p.string, p.array(p.string)).optional(),
-        headers: p.record(p.string, p.string).optional(),
+        csp: p.dict(p.array(p.string)).optional(),
+        headers: p.dict().optional(),
         host: p.string.default("localhost"),
         port: p.uint.port().default(6161),
         ssl: {
-            cert: p.union(FileRef, p.string).optional(),
-            key: p.union(FileRef, p.string).optional(),
+            cert: p.union(p.is(fs.isRef), p.string).optional(),
+            key: p.union(p.is(fs.isRef), p.string).optional(),
         },
         static: {
             root: p.string.default("/"),
         },
     },
-    modules: p.array(p.constructor(Module)).optional(),
+    livereload: {
+        exclude: p.array(p.string).optional(),
+        host: p.string.optional(),
+        port: p.uint.port().optional(),
+    },
+    db: {
+        migrations: p.object({
+            table: p.string,
+            db: p.pure(),
+        }).optional(),
+    },
+    env: {
+        schema: p.pure().optional(),
+    },
+    modules: p.array(p.object({
+        name: p.string,
+        setup: p.function,
+    }).shape())
+        .uniqueBy(member => member.name)
+        .default([]),
     request: {
         body: {
             parse: p.boolean.default(true),

package/lib/private/cookie.d.ts

@@ -1,9 +1,15 @@
-declare const Schema: import("pema").ObjectType<{
-    httpOnly: import("pema").DefaultType<import("pema/boolean").BooleanType, true>;
-    path: import("pema").DefaultType<import("pema/string").StringType, "/">;
-    sameSite: import("pema/union").UnionType<[import("pema").LiteralType<"Lax">, import("pema").LiteralType<"None">, import("pema").LiteralType<"Strict">]>;
-    secure: import("pema/boolean").BooleanType;
-    maxAge: import("pema").OptionalType<import("pema/number").NumberType<"f64">>;
+declare const Schema: import("pema").ObjectType<import("pema").NormalizeSchemaObject<{
+    readonly httpOnly: import("pema").DefaultType<import("pema").BooleanType, true>;
+    readonly path: import("pema").DefaultType<import("pema").StringType, "/">;
+    readonly sameSite: import("pema").UnionType<[import("pema").LiteralType<"Lax">, import("pema").LiteralType<"None">, import("pema").LiteralType<"Strict">]>;
+    readonly secure: import("pema").BooleanType;
+    readonly maxAge: import("pema").OptionalType<import("pema").NumberType<"f64">>;
+}>, {
+    httpOnly: boolean;
+    path: string;
+    sameSite: "Lax" | "None" | "Strict";
+    secure: boolean;
+    maxAge: number | undefined;
 }>;
 type Options = typeof Schema.input;
 export default function cookie(name: string, value: string, options: Options): string;

package/lib/private/cookie.js

@@ -1,19 +1,15 @@
-import is from "@rcompat/assert/is";
-import pema from "pema";
-import boolean from "pema/boolean";
-import number from "pema/number";
-import string from "pema/string";
-import union from "pema/union";
-const Schema = pema({
-    httpOnly: boolean.default(true),
-    path: string.default("/"),
-    sameSite: union("Lax", "None", "Strict"),
-    secure: boolean,
-    maxAge: number.optional(), // seconds
+import assert from "@rcompat/assert";
+import p from "pema";
+const Schema = p({
+    httpOnly: p.boolean.default(true),
+    path: p.string.default("/"),
+    sameSite: p.union("Lax", "None", "Strict"),
+    secure: p.boolean,
+    maxAge: p.number.optional(), // seconds
 });
 export default function cookie(name, value, options) {
-    is(name).string();
-    is(value).string();
+    assert.string(name);
+    assert.string(value);
     const parsed = Schema.parse(options);
     const parts = [`${name}=${value}`];
     parts.push(`Path=${parsed.path}`);

package/lib/private/db/As.d.ts

@@ -0,0 +1,10 @@
+import type Types from "#db/Types";
+import type PK from "#db/PK";
+type As = {
+    table: string;
+    pk: PK;
+    generate_pk?: boolean;
+    types: Types;
+};
+export type { As as default };
+//# sourceMappingURL=As.d.ts.map

package/lib/private/db/DB.d.ts

@@ -0,0 +1,49 @@
+import type As from "#db/As";
+import type PK from "#db/PK";
+import type Sort from "#db/Sort";
+import type Types from "#db/Types";
+import type With from "#db/With";
+import type { Dict, MaybePromise } from "@rcompat/type";
+import type { DataType } from "pema";
+export interface SchemaDiff {
+    add: Types;
+    drop: string[];
+    rename: [string, string][];
+}
+type MaybeTable = Dict<(keyof DataType)[]> | null;
+type PKConfig = {
+    name: PK;
+    generate: boolean;
+};
+export type Schema = {
+    create(name: string, pk: PKConfig, types: Types): MaybePromise<void>;
+    delete(name: string): MaybePromise<void>;
+    introspect(name: string, pk?: PK): MaybePromise<MaybeTable>;
+    alter(name: string, diff: SchemaDiff): MaybePromise<void>;
+};
+export default interface DB {
+    schema: Schema;
+    close(): MaybePromise<void>;
+    create<O extends Dict>(as: As, record: Dict): MaybePromise<O>;
+    read(as: As, args: {
+        count: true;
+        where: Dict;
+        with?: never;
+    }): MaybePromise<number>;
+    read(as: As, args: {
+        where: Dict;
+        fields?: string[];
+        limit?: number;
+        sort?: Sort;
+        with?: With;
+    }): MaybePromise<Dict[]>;
+    update(as: As, args: {
+        set: Dict;
+        where: Dict;
+    }): MaybePromise<number>;
+    delete(as: As, args: {
+        where: Dict;
+    }): MaybePromise<number>;
+}
+export {};
+//# sourceMappingURL=DB.d.ts.map

package/lib/private/db/DB.js

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

package/lib/private/db/DataDict.d.ts

@@ -0,0 +1,5 @@
+import type DataValue from "#db/DataValue";
+import type { Dict } from "@rcompat/type";
+type DataDict = Dict<DataValue>;
+export type { DataDict as default };
+//# sourceMappingURL=DataDict.d.ts.map

package/lib/private/db/DataKey.d.ts

@@ -0,0 +1,4 @@
+import type { DataType } from "pema";
+type DataKey = keyof DataType;
+export type { DataKey as default };
+//# sourceMappingURL=DataKey.d.ts.map

package/lib/private/db/DataValue.d.ts

@@ -0,0 +1,17 @@
+import type DataKey from "#db/DataKey";
+import type { DataType } from "pema";
+type Scalar = DataType[DataKey] | null;
+type OperatorObject = Partial<{
+    $like: string;
+    $ilike: string;
+    $gt: number | bigint;
+    $gte: number | bigint;
+    $lt: number | bigint;
+    $lte: number | bigint;
+    $before: Date;
+    $after: Date;
+    $ne: DataType[DataKey];
+}>;
+type DataValue = Scalar | OperatorObject;
+export type { DataValue as default };
+//# sourceMappingURL=DataValue.d.ts.map

package/lib/private/db/MemoryDB.d.ts

@@ -0,0 +1,33 @@
+import type As from "#db/As";
+import type DB from "#db/DB";
+import type { Schema } from "#db/DB";
+import type DataDict from "#db/DataDict";
+import type Sort from "#db/Sort";
+import type With from "#db/With";
+import type { Dict, MaybePromise } from "@rcompat/type";
+export default class MemoryDB implements DB {
+    #private;
+    get schema(): Schema;
+    close(): void;
+    create<O extends Dict>(as: As, record: Dict): MaybePromise<O>;
+    read(as: As, args: {
+        count: true;
+        where: DataDict;
+        with?: never;
+    }): number;
+    read(as: As, args: {
+        where: DataDict;
+        fields?: string[];
+        limit?: number;
+        sort?: Sort;
+        with?: With;
+    }): Dict[];
+    update(as: As, args: {
+        set: DataDict;
+        where: DataDict;
+    }): Promise<number>;
+    delete(as: As, args: {
+        where: DataDict;
+    }): number;
+}
+//# sourceMappingURL=MemoryDB.d.ts.map

package/lib/private/db/MemoryDB.js

@@ -0,0 +1,335 @@
+import E from "#db/errors";
+import assert from "@rcompat/assert";
+import entries from "@rcompat/dict/entries";
+import is from "@rcompat/is";
+function escape_re(s) {
+    return s.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+function comparable(x) {
+    if (is.date(x))
+        return x.getTime();
+    if (is.url(x))
+        return x.href;
+    return x;
+}
+;
+function like_re(pattern, flags = "") {
+    return new RegExp("^" + escape_re(pattern)
+        .replace(/\\%/g, "<<PERCENT>>")
+        .replace(/\\_/g, "<<UNDERSCORE>>")
+        .replace(/%/g, "[\\s\\S]*")
+        .replace(/_/g, "[\\s\\S]")
+        .replace(/<<PERCENT>>/g, "%")
+        .replace(/<<UNDERSCORE>>/g, "_") +
+        "$", flags);
+}
+function match(record, where) {
+    return Object.entries(where).every(([k, v]) => {
+        const value = record[k];
+        // null where (IS NULL semantics in this DB == key absent)
+        if (v === null)
+            return value === null || value === undefined;
+        // operator objects: only plain dicts
+        if (is.dict(v)) {
+            // NULL / missing values don't match operator predicates
+            if (value === null || value === undefined)
+                return false;
+            for (const [op, op_val] of Object.entries(v)) {
+                switch (op) {
+                    case "$like": {
+                        if (!is.string(value))
+                            return false;
+                        if (!like_re(op_val).test(value))
+                            return false;
+                        break;
+                    }
+                    case "$ilike": {
+                        if (!is.string(value))
+                            return false;
+                        if (!like_re(op_val, "i").test(value))
+                            return false;
+                        break;
+                    }
+                    case "$gte":
+                        if (!(comparable(value) >= comparable(op_val)))
+                            return false;
+                        break;
+                    case "$gt":
+                    case "$after":
+                        if (!(comparable(value) > comparable(op_val)))
+                            return false;
+                        break;
+                    case "$lte":
+                        if (!(comparable(value) <= comparable(op_val)))
+                            return false;
+                        break;
+                    case "$lt":
+                    case "$before":
+                        if (!(comparable(value) < comparable(op_val)))
+                            return false;
+                        break;
+                    case "$ne": {
+                        if (is.date(value) && is.date(op_val)) {
+                            if (value.getTime() === op_val.getTime())
+                                return false;
+                            break;
+                        }
+                        if (is.url(value) && is.url(op_val)) {
+                            if (value.href === op_val.href)
+                                return false;
+                            break;
+                        }
+                        if (value === op_val)
+                            return false;
+                        break;
+                    }
+                    default:
+                        throw E.operator_unknown(k, op);
+                }
+            }
+            return true;
+        }
+        // literal equality
+        if (is.date(value) && is.date(v))
+            return value.getTime() === v.getTime();
+        if (is.url(value) && is.url(v))
+            return value.href === v.href;
+        return value === v;
+    });
+}
+function filter(record, fields) {
+    return Object.fromEntries(Object.entries(record)
+        .filter(([key]) => fields.includes(key)));
+}
+function toSorted(d1, d2, sort) {
+    return [...entries(sort).valmap(([, value]) => value === "asc" ? 1 : -1)]
+        .reduce((sorting, [field, direction]) => {
+        const left = d1[field];
+        const right = d2[field];
+        // if sorting has been established, it stays fixed
+        if (sorting !== 0) {
+            return sorting;
+        }
+        // equal, sorting doesn't change
+        if (left === right) {
+            return sorting;
+        }
+        if (left < right) {
+            return -1 * direction;
+        }
+        return direction;
+    }, 0);
+}
+export default class MemoryDB {
+    #tables = {};
+    #types = {};
+    #use(name) {
+        this.#tables[name] ??= [];
+        return this.#tables[name];
+    }
+    get schema() {
+        return {
+            create: async (table, _pk, types) => {
+                if (this.#tables[table] !== undefined)
+                    return;
+                this.#tables[table] = [];
+                this.#types[table] = types;
+            },
+            delete: table => {
+                if (this.#tables[table] !== undefined)
+                    delete this.#tables[table];
+            },
+            introspect: table => {
+                if (this.#tables[table] === undefined)
+                    return null;
+                const types = this.#types[table] ?? {};
+                return Object.fromEntries(Object.entries(types).map(([field, type]) => [field, [type]]));
+            },
+            alter: (table, diff) => {
+                if (this.#types[table] === undefined)
+                    throw E.table_not_found(table);
+                const types = { ...this.#types[table] };
+                const { add, drop, rename } = diff;
+                for (const [field, type] of Object.entries(add))
+                    types[field] = type;
+                for (const field of drop)
+                    delete types[field];
+                for (const [from, to] of rename) {
+                    types[to] = types[from];
+                    delete types[from];
+                }
+                this.#types[table] = types;
+            },
+        };
+    }
+    // noop
+    close() { }
+    #next_id(as) {
+        const table = this.#use(as.table);
+        const size = table.length;
+        const pk = assert.defined(as.pk);
+        const type = as.types[pk];
+        if (type === "uuid" || type === "uuid_v4" || type === "uuid_v7") {
+            return crypto.randomUUID();
+        }
+        else if (["u64", "u128", "i64", "i128"].includes(type)) {
+            return size === 0 ? 0n : table[size - 1][pk] + 1n;
+        }
+        else {
+            return size === 0 ? 0 : table[size - 1][pk] + 1;
+        }
+    }
+    create(as, record) {
+        assert.nonempty(record);
+        const table = this.#use(as.table);
+        const pk = as.pk;
+        let to_insert = record;
+        if (pk !== null && !(pk in record)) {
+            if (as.generate_pk === false)
+                throw E.pk_required(pk);
+            to_insert = { ...record, [pk]: this.#next_id(as) };
+        }
+        if (pk !== null) {
+            const pv = to_insert[pk];
+            if (table.find(s => s[pk] === pv) !== undefined)
+                throw E.pk_duplicate(pk);
+        }
+        table.push({ ...to_insert });
+        return to_insert;
+    }
+    read(as, args) {
+        assert.dict(args.where);
+        const table = this.#use(as.table);
+        const matches = table.filter(r => match(r, args.where));
+        if (args.count === true)
+            return matches.length;
+        const sort = args.sort ?? {};
+        const sorted = Object.keys(sort).length === 0
+            ? matches
+            : matches.toSorted((a, b) => toSorted(a, b, sort));
+        const limit = args.limit ?? sorted.length;
+        const base_rows = sorted.slice(0, limit);
+        // no relations -> preserve existing behavior
+        if (args.with === undefined) {
+            const fields = args.fields ?? [];
+            return (fields.length === 0
+                ? base_rows
+                : base_rows.map(r => filter(r, fields)));
+        }
+        assert.dict(args.with);
+        const base_fields = args.fields ?? [];
+        // output objects must be detached, so as to not mutate stored rows whilst
+        // attaching relations
+        const out = base_rows.map(full => {
+            return base_fields.length === 0
+                ? { ...full }
+                : filter(full, base_fields);
+        });
+        // need access to the full base rows to read join keys even if not projected
+        const base_full = base_rows;
+        for (const [r_name, rel] of Object.entries(args.with)) {
+            const target_as = rel.as;
+            const kind = rel.kind;
+            const fk = rel.fk;
+            const reverse = rel.reverse === true;
+            const r_where = rel.where;
+            const r_sort = rel.sort;
+            const r_limit = rel.limit;
+            const r_fields = rel.fields ?? [];
+            const target = this.#use(target_as.table);
+            function project_rel(row) {
+                if (r_fields.length === 0)
+                    return { ...row };
+                return filter(row, r_fields);
+            }
+            ;
+            // reverse one: FK on parent points to target PK
+            if (kind === "one" && reverse) {
+                const target_pk = target_as.pk;
+                if (target_pk === null)
+                    throw E.relation_requires_pk("target");
+                for (let i = 0; i < out.length; i++) {
+                    const parent_full = base_full[i];
+                    const fk_value = parent_full[fk];
+                    if (fk_value == null) {
+                        (out[i])[r_name] = null;
+                        continue;
+                    }
+                    // filter by target_pk equality + optional where
+                    let candidates = target.filter(t => t[target_pk] === fk_value && match(t, r_where));
+                    if (r_sort !== undefined && Object.keys(r_sort).length > 0) {
+                        candidates = candidates.toSorted((a, b) => toSorted(a, b, r_sort));
+                    }
+                    if (r_limit !== undefined)
+                        candidates = candidates.slice(0, r_limit);
+                    const got = candidates[0];
+                    (out[i])[r_name] = got ? project_rel(got) : null;
+                }
+                continue;
+            }
+            // non-reverse: FK on target points to parent PK
+            const parent_pk = as.pk;
+            if (parent_pk === null)
+                throw E.relation_requires_pk("parent");
+            const parent_keys = new Set(base_full.map(r => r[parent_pk]));
+            const grouped = new Map();
+            for (const row of target) {
+                const key = row[fk];
+                if (!parent_keys.has(key))
+                    continue;
+                if (!match(row, r_where))
+                    continue;
+                const bucket = grouped.get(key);
+                if (bucket !== undefined)
+                    bucket.push(row);
+                else
+                    grouped.set(key, [row]);
+            }
+            for (let i = 0; i < out.length; i++) {
+                const parent_full = base_full[i];
+                const key = parent_full[parent_pk];
+                let rows = grouped.get(key) ?? [];
+                if (r_sort !== undefined && Object.keys(r_sort).length > 0) {
+                    rows = rows.toSorted((a, b) => toSorted(a, b, r_sort));
+                }
+                if (kind === "one") {
+                    if (r_limit !== undefined)
+                        rows = rows.slice(0, r_limit);
+                    const got = rows[0];
+                    (out[i])[r_name] = got ? project_rel(got) : null;
+                }
+                else {
+                    if (r_limit !== undefined)
+                        rows = rows.slice(0, r_limit);
+                    (out[i])[r_name] = rows.map(project_rel);
+                }
+            }
+        }
+        return out;
+    }
+    async update(as, args) {
+        assert.nonempty(args.set);
+        assert.dict(args.where);
+        const table = this.#use(as.table);
+        const matched = table.filter(record => match(record, args.where));
+        const pk = as.pk;
+        return matched.map(record => {
+            const changed = entries({ ...record, ...args.set })
+                .filter(([, value]) => value !== null)
+                .get();
+            const index = pk !== null
+                ? table.findIndex(stored => stored[pk] === record[pk])
+                : table.findIndex(stored => stored === record);
+            table.splice(index, 1, changed);
+            return changed;
+        }).length;
+    }
+    delete(as, args) {
+        assert.nonempty(args.where);
+        const table = this.#use(as.table);
+        const size_before = table.length;
+        this.#tables[as.table] = table.filter(record => !match(record, args.where));
+        return size_before - this.#use(as.table).length;
+    }
+}
+//# sourceMappingURL=MemoryDB.js.map

package/lib/private/db/PK.d.ts

@@ -0,0 +1,3 @@
+type PK = string | null;
+export type { PK as default };
+//# sourceMappingURL=PK.d.ts.map

package/lib/private/db/PK.js

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

package/lib/private/{database → db}/Query.d.ts

@@ -1,5 +1,5 @@
-import type Schema from "#database/Schema";
-import type StoreSchema from "pema/StoreSchema";
+import type Schema from "#db/Schema";
+import type { StoreSchema } from "pema";
 type X<T> = {
     [K in keyof T]: T[K];
 } & {};

package/lib/private/{database → db}/QueryBuilder.d.ts

@@ -1,6 +1,5 @@
-import type Schema from "#database/Schema";
-import type InferStoreOut from "pema/InferStoreOut";
-import type StoreSchema from "pema/StoreSchema";
+import type Schema from "#db/Schema";
+import type { InferStoreOut, StoreSchema } from "pema";
 type X<T> = {
     [K in keyof T]: T[K];
 } & {};

package/lib/private/db/ReadArgs.d.ts

@@ -0,0 +1,9 @@
+import type DataDict from "#db/DataDict";
+import type Sort from "#db/Sort";
+export default interface ReadArgs {
+    where: DataDict;
+    fields?: string[];
+    sort?: Sort;
+    limit?: number;
+}
+//# sourceMappingURL=ReadArgs.d.ts.map

package/lib/private/db/ReadArgs.js

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

package/lib/private/db/ReadRelationsArgs.d.ts

@@ -0,0 +1,6 @@
+import type ReadArgs from "#db/ReadArgs";
+import type With from "#db/With";
+export default interface ReadRelationsArgs extends ReadArgs {
+    with: With;
+}
+//# sourceMappingURL=ReadRelationsArgs.d.ts.map

package/lib/private/db/ReadRelationsArgs.js

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

package/lib/private/{database → db}/Schema.d.ts

@@ -1,5 +1,4 @@
-import type InferStoreOut from "pema/InferStoreOut";
-import type StoreSchema from "pema/StoreSchema";
+import type { InferStoreOut, StoreSchema } from "pema";
 type X<T> = {
     [K in keyof T]: T[K];
 } & {};

package/lib/private/db/Sort.d.ts

@@ -0,0 +1,4 @@
+import type { Dict } from "@rcompat/type";
+type Sort = Dict<"asc" | "desc">;
+export type { Sort as default };
+//# sourceMappingURL=Sort.d.ts.map

package/lib/private/{database → db}/TypeMap.d.ts

@@ -1,6 +1,5 @@
-import type MaybePromise from "@rcompat/type/MaybePromise";
-import type DataType from "pema/DataType";
-import type Dict from "@rcompat/type/Dict";
+import type { Dict, MaybePromise } from "@rcompat/type";
+import type { DataType } from "pema";
 type TypeMap<Columns extends Dict = Dict> = {
     [K in keyof DataType]: {
         [C in keyof Columns]: {

package/lib/private/{database → db}/Types.d.ts

@@ -1,4 +1,4 @@
-import type DataType from "pema/DataType";
+import type { DataType } from "pema";
 type Types = {
     [k: string]: keyof DataType;
 };

package/lib/private/db/With.d.ts

@@ -0,0 +1,16 @@
+import type As from "#db/As";
+import type DataDict from "#db/DataDict";
+import type Sort from "#db/Sort";
+import type { Dict } from "@rcompat/type";
+type With = Dict<{
+    as: As;
+    kind: "one" | "many";
+    fk: string;
+    reverse?: boolean;
+    where: DataDict;
+    fields?: string[];
+    sort?: Sort;
+    limit?: number;
+}>;
+export type { With as default };
+//# sourceMappingURL=With.d.ts.map