@primate/core 0.4.6 → 0.5.0

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

@@ -0,0 +1,35 @@
+import type As from "#db/As";
+import type DB 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(): {
+        create: (as: As) => void;
+        delete: (table: string) => void;
+    };
+    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,317 @@
+import E from "#db/error";
+import assert from "@rcompat/assert";
+import entries from "@rcompat/dict/entries";
+import is from "@rcompat/is";
+const PK_TYPES = ["string", "bigint", "number"];
+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 = {};
+    #new(as) {
+        if (this.#tables[as.table] !== undefined)
+            return;
+        this.#tables[as.table] = [];
+    }
+    #drop(table) {
+        if (this.#tables[table] !== undefined)
+            delete this.#tables[table];
+    }
+    #use(name) {
+        this.#tables[name] ??= [];
+        return this.#tables[name];
+    }
+    get schema() {
+        return {
+            create: this.#new.bind(this),
+            delete: this.#drop.bind(this),
+        };
+    }
+    // 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 === "string") {
+            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, "empty 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 pkv = to_insert[pk];
+            if (!PK_TYPES.includes(typeof pkv))
+                throw E.pk_invalid(pkv);
+            if (table.find(stored => stored[pk] === pkv))
+                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 && 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)
+                    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 && 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

package/lib/private/db/With.js

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

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

@@ -0,0 +1,18 @@
+import type As from "#db/As";
+import type ReadArgs from "#db/ReadArgs";
+import type ReadRelationsArgs from "#db/ReadRelationsArgs";
+import type With from "#db/With";
+import type { Dict } from "@rcompat/type";
+declare const BASE: {
+    withed(args: ReadArgs & {
+        with?: With;
+    }): args is ReadRelationsArgs;
+    fields(base: string[] | undefined, ...add: (string | null)[]): string[] | undefined;
+    project(row: Dict, fields?: string[]): Dict;
+    expand(as: As, fields: string[] | undefined, relations: With): string[] | undefined;
+    BIGINT_STRING_TYPES: string[];
+    UNSIGNED_BIGINT_TYPES: string[];
+    INT_TYPES: string[];
+};
+export default BASE;
+//# sourceMappingURL=common.d.ts.map

package/lib/private/db/common.js

@@ -0,0 +1,36 @@
+const UNSIGNED_BIGINT_TYPES = ["u64", "u128"];
+const SIGNED_BIGINT_TYPES = ["i128"];
+const BIGINT_STRING_TYPES = [...UNSIGNED_BIGINT_TYPES, ...SIGNED_BIGINT_TYPES];
+const INT_TYPES = ["u8", "u16", "u32", "i8", "i16", "i32"];
+const BASE = {
+    withed(args) {
+        return args.with !== undefined;
+    },
+    fields(base, ...add) {
+        if (base === undefined)
+            return undefined;
+        const set = new Set(base);
+        for (const f of add)
+            if (f !== null)
+                set.add(f);
+        return [...set];
+    },
+    project(row, fields) {
+        if (fields === undefined || fields.length === 0)
+            return { ...row };
+        const out = {};
+        for (const k of fields)
+            if (k in row)
+                out[k] = row[k];
+        return out;
+    },
+    expand(as, fields, relations) {
+        const fks = Object.values(relations).flatMap(r => r.reverse ? [r.fk] : []);
+        return BASE.fields(fields, as.pk, ...fks);
+    },
+    BIGINT_STRING_TYPES,
+    UNSIGNED_BIGINT_TYPES,
+    INT_TYPES,
+};
+export default BASE;
+//# sourceMappingURL=common.js.map

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

@@ -0,0 +1,81 @@
+declare function db_missing(): import("../AppError.js").default;
+declare function store_name_required(): import("../AppError.js").default;
+declare function unregistered_schema(): import("../AppError.js").default;
+declare function record_not_found(field: string, value: string | number | bigint): import("../AppError.js").default;
+declare function key_duplicate(key: string): import("../AppError.js").default;
+declare function pk_undefined(store: string): import("../AppError.js").default;
+declare function pk_immutable(pk: string): import("../AppError.js").default;
+declare function pk_duplicate(pk: string): import("../AppError.js").default;
+declare function pk_invalid(pk: unknown): import("../AppError.js").default;
+declare function pk_required(table: string): import("../AppError.js").default;
+type Context = "select" | "where" | "sort" | "insert" | "set";
+declare function field_unknown(field: string, context: Context): import("../AppError.js").default;
+declare function field_duplicate(field: string, context: Context): import("../AppError.js").default;
+declare function field_required(operator: string): import("../AppError.js").default;
+declare function field_undefined(field: string, context: Context): import("../AppError.js").default;
+declare function fields_unknown(fields: string[]): import("../AppError.js").default;
+declare function null_not_allowed(field: string): import("../AppError.js").default;
+declare function wrong_type(type: "string" | "number" | "bigint" | "boolean" | "url" | "date" | "blob", field: string, got: unknown, op?: string): import("../AppError.js").default;
+declare function operator_unknown(field: string, operator: string): import("../AppError.js").default;
+declare function operator_empty(field: string): import("../AppError.js").default;
+declare function operator_scalar(field: string): import("../AppError.js").default;
+declare function sort_empty(): import("../AppError.js").default;
+declare function sort_invalid(): import("../AppError.js").default;
+declare function sort_invalid_value(field: string, value: unknown): import("../AppError.js").default;
+declare function select_empty(): import("../AppError.js").default;
+declare function select_invalid(): import("../AppError.js").default;
+declare function limit_invalid(): import("../AppError.js").default;
+declare function select_invalid_value(index: number, x: unknown): import("../AppError.js").default;
+declare function where_required(): import("../AppError.js").default;
+declare function where_invalid(): import("../AppError.js").default;
+declare function where_invalid_value(field: string, value: unknown): import("../AppError.js").default;
+declare function set_empty(): import("../AppError.js").default;
+declare function relation_unknown(relation: string): import("../AppError.js").default;
+declare function relation_requires_pk(type: "target" | "parent"): import("../AppError.js").default;
+declare function option_unknown(option: string): import("../AppError.js").default;
+declare function identifier_invalid(identifier: string): import("../AppError.js").default;
+declare function count_with_invalid(): import("../AppError.js").default;
+declare function count_overflow(table: string, count: unknown): import("../AppError.js").default;
+declare const errors: {
+    option_unknown: typeof option_unknown;
+    identifier_invalid: typeof identifier_invalid;
+    count_with_invalid: typeof count_with_invalid;
+    count_overflow: typeof count_overflow;
+    relation_unknown: typeof relation_unknown;
+    relation_requires_pk: typeof relation_requires_pk;
+    sort_empty: typeof sort_empty;
+    sort_invalid: typeof sort_invalid;
+    sort_invalid_value: typeof sort_invalid_value;
+    select_empty: typeof select_empty;
+    select_invalid: typeof select_invalid;
+    select_invalid_value: typeof select_invalid_value;
+    where_required: typeof where_required;
+    where_invalid: typeof where_invalid;
+    where_invalid_value: typeof where_invalid_value;
+    set_empty: typeof set_empty;
+    limit_invalid: typeof limit_invalid;
+    operator_unknown: typeof operator_unknown;
+    operator_empty: typeof operator_empty;
+    wrong_type: typeof wrong_type;
+    operator_scalar: typeof operator_scalar;
+    null_not_allowed: typeof null_not_allowed;
+    field_unknown: typeof field_unknown;
+    field_duplicate: typeof field_duplicate;
+    field_required: typeof field_required;
+    field_undefined: typeof field_undefined;
+    fields_unknown: typeof fields_unknown;
+    pk_undefined: typeof pk_undefined;
+    pk_immutable: typeof pk_immutable;
+    pk_duplicate: typeof pk_duplicate;
+    pk_invalid: typeof pk_invalid;
+    pk_required: typeof pk_required;
+    db_missing: typeof db_missing;
+    store_name_required: typeof store_name_required;
+    unregistered_schema: typeof unregistered_schema;
+    record_not_found: typeof record_not_found;
+    key_duplicate: typeof key_duplicate;
+};
+export type Code = keyof typeof errors;
+export declare const Code: { [K in Code]: K; };
+export default errors;
+//# sourceMappingURL=error.d.ts.map