@primate/core 0.4.6 → 0.5.0

package/lib/private/database/Changes.d.ts

@@ -1,11 +0,0 @@
-import type InferStore from "pema/InferStore";
-import type StoreSchema from "pema/StoreSchema";
-type X<T> = {
-    [K in keyof T]: T[K];
-} & {};
-type OrNull<T> = {
-    [P in keyof T]?: null | T[P];
-};
-type Changes<T extends StoreSchema> = X<OrNull<InferStore<T>>>;
-export type { Changes as default };
-//# sourceMappingURL=Changes.d.ts.map

package/lib/private/database/Changes.js

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

package/lib/private/database/ColumnTypes.d.ts

@@ -1,11 +0,0 @@
-type ColumnTypes = {
-    BIGINT: bigint;
-    BLOB: Blob;
-    BOOLEAN: boolean;
-    DATE: Date;
-    NUMBER: number;
-    STRING: string;
-    URL: URL;
-};
-export type { ColumnTypes as default };
-//# sourceMappingURL=ColumnTypes.d.ts.map

package/lib/private/database/ColumnTypes.js

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

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

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

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

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

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

@@ -1,5 +0,0 @@
-import type DataKey from "#database/DataKey";
-import type DataType from "pema/DataType";
-type DataValue = DataType[DataKey] | null;
-export type { DataValue as default };
-//# sourceMappingURL=DataValue.d.ts.map

package/lib/private/database/Database.d.ts

@@ -1,56 +0,0 @@
-import type As from "#database/As";
-import type Binds from "#database/Binds";
-import type DataDict from "#database/DataDict";
-import type DataKey from "#database/DataKey";
-import type Sort from "#database/Sort";
-import type TypeMap from "#database/TypeMap";
-import type Types from "#database/Types";
-import type Dict from "@rcompat/type/Dict";
-import type MaybePromise from "@rcompat/type/MaybePromise";
-import type StoreSchema from "pema/StoreSchema";
-export default abstract class Database {
-    #private;
-    abstract close(): MaybePromise<void>;
-    constructor(bindPrefix?: string);
-    ident(name: string): string;
-    table(as: As): string;
-    toSelect(types: Types, columns?: string[]): string;
-    toSort(types: Types, sort?: Sort): string;
-    toLimit(limit?: number): string;
-    toWhere(types: Types, criteria: DataDict): string;
-    toSet(types: Types, changes: DataDict): Promise<{
-        set: string;
-        binds: Binds;
-    }>;
-    column(key: DataKey): string;
-    abstract get typemap(): TypeMap;
-    abstract schema: {
-        create(name: string, description: StoreSchema): MaybePromise<void>;
-        delete(name: string): MaybePromise<void>;
-    };
-    formatBinds(binds: Binds): Binds;
-    bind<In extends DataDict>(types: Types, object: In): Promise<Binds>;
-    bindCriteria(types: Types, criteria: DataDict): Promise<Binds>;
-    unbind(types: Types, object: Dict): Dict;
-    abstract create<O extends Dict>(as: As, args: {
-        record: Dict;
-    }): MaybePromise<O>;
-    abstract read(as: As, args: {
-        count: true;
-        criteria: Dict;
-    }): MaybePromise<number>;
-    abstract read(as: As, args: {
-        criteria: Dict;
-        fields?: string[];
-        limit?: number;
-        sort?: Sort;
-    }): MaybePromise<Dict[]>;
-    abstract update(as: As, args: {
-        changes: Dict;
-        criteria: Dict;
-    }): MaybePromise<number>;
-    abstract delete(as: As, args: {
-        criteria: Dict;
-    }): MaybePromise<number>;
-}
-//# sourceMappingURL=Database.d.ts.map

package/lib/private/database/Database.js

@@ -1,153 +0,0 @@
-import fail from "#fail";
-import maybe from "@rcompat/assert/maybe";
-import entries from "@rcompat/record/entries";
-function required(operation) {
-    fail("{0}: at least one column required", operation);
-}
-function normalizeSort(direction) {
-    if (typeof direction !== "string")
-        throw fail("invalid sort direction {0}", direction);
-    const lowered = direction.toLowerCase();
-    if (lowered !== "asc" && lowered !== "desc")
-        throw fail("invalid sort direction {0}", direction);
-    return lowered.toUpperCase();
-}
-export default class Database {
-    #bindPrefix;
-    constructor(bindPrefix) {
-        this.#bindPrefix = bindPrefix ?? "";
-    }
-    #assert(types, columns) {
-        const known = new Set(Object.keys(types));
-        const unknown = columns.filter(c => !known.has(c));
-        if (unknown.length > 0) {
-            throw fail("unknown column(s) {0}", unknown.join(", "));
-        }
-    }
-    #quote(name) {
-        if (!/^[a-zA-Z_][a-zA-Z0-9_]*$/.test(name)) {
-            throw fail("invalid identifier {0}", name);
-        }
-        return `\`${name}\``;
-    }
-    ident(name) {
-        return this.#quote(name);
-    }
-    table(as) {
-        return this.#quote(as.name);
-    }
-    toSelect(types, columns) {
-        maybe(columns).array();
-        if (!columns)
-            return "*";
-        if (columns.length === 0)
-            throw required("select");
-        this.#assert(types, columns);
-        return columns.map(this.#quote).join(", ");
-    }
-    toSort(types, sort) {
-        maybe(sort).record();
-        if (!sort)
-            return "";
-        const columns = Object.entries(sort);
-        if (columns.length === 0)
-            throw required("sort");
-        this.#assert(types, columns.map(([k]) => k));
-        const order = columns
-            .map(([k, direction]) => `${this.#quote(k)} ${normalizeSort(direction)}`)
-            .join(", ");
-        return ` ORDER BY ${order}`;
-    }
-    toLimit(limit) {
-        maybe(limit).usize();
-        return limit !== undefined ? ` LIMIT ${limit}` : "";
-    }
-    toWhere(types, criteria) {
-        const columns = Object.keys(criteria);
-        this.#assert(types, columns);
-        if (columns.length === 0)
-            return "";
-        const p = this.#bindPrefix; // "$" or ":"
-        const parts = columns.map(column => {
-            const value = criteria[column];
-            // null criteria
-            if (value === null)
-                return `${this.#quote(column)} IS NULL`;
-            if (typeof value === "object") {
-                if ("$like" in value) {
-                    return `${this.#quote(column)} LIKE ${p}${column}`;
-                }
-                //if ("$gte" in value) return `${this.#quote(column)} >= ${p}${column}`;
-                throw fail("unsupported operator in field {0}", column);
-            }
-            return `${this.#quote(column)}=${p}${column}`;
-        });
-        return `WHERE ${parts.join(" AND ")}`;
-    }
-    async toSet(types, changes) {
-        const columns = Object.keys(changes);
-        this.#assert(types, columns);
-        if (columns.length === 0)
-            throw required("set");
-        const p = this.#bindPrefix; // "$" or ":"
-        const set = `SET ${columns.map(c => `${this.#quote(c)}=${p}s_${c}`).join(", ")}`;
-        const raw = Object.fromEntries(columns.map(c => [`s_${c}`, changes[c]]));
-        // bind original keys (e.g. { age: 35 } -> { $age: 35 })
-        const binds = await this.bind(types, raw);
-        return { set, binds };
-    }
-    #bind(key, value) {
-        return value === null
-            ? null
-            : this.typemap[key].bind(value);
-    }
-    #unbind(key, value) {
-        return this.typemap[key].unbind(value);
-    }
-    column(key) {
-        return this.typemap[key].column;
-    }
-    ;
-    // identity
-    formatBinds(binds) {
-        return binds;
-    }
-    async bind(types, object) {
-        const out = Object.fromEntries(await Promise.all(Object.entries(object).map(async ([key, value]) => {
-            // support "s_" pseudo-namespace for SET params
-            const base = key.startsWith("s_") ? key.slice(2) : key;
-            const bound = await this.#bind(types[base], value);
-            return [`${this.#bindPrefix}${key}`, bound];
-        })));
-        return this.formatBinds(out);
-    }
-    async bindCriteria(types, criteria) {
-        const filtered = {};
-        for (const [key, value] of Object.entries(criteria)) {
-            // null isn't bound
-            if (value === null)
-                continue;
-            if (typeof value === "object") {
-                // extract primitive value from operator object
-                if ("$like" in value) {
-                    if (typeof value.$like !== "string") {
-                        throw fail("$like operator requires string value, got {0}", typeof value.$like);
-                    }
-                    filtered[key] = value.$like;
-                }
-            }
-            else {
-                filtered[key] = value;
-            }
-        }
-        return this.bind(types, filtered);
-    }
-    unbind(types, object) {
-        return entries(object)
-            .filter(([, value]) => value !== null)
-            .map(([key, value]) => [key, this.#unbind(types[key], value)])
-            .get();
-    }
-}
-;
-//# sourceMappingURL=Database.js.map

package/lib/private/database/InMemoryDatabase.d.ts

@@ -1,37 +0,0 @@
-import type As from "#database/As";
-import Database from "#database/Database";
-import type DataDict from "#database/DataDict";
-import type Sort from "#database/Sort";
-import type TypeMap from "#database/TypeMap";
-import type Dict from "@rcompat/type/Dict";
-import type MaybePromise from "@rcompat/type/MaybePromise";
-export default class InMemoryDatabase extends Database {
-    #private;
-    get typemap(): TypeMap<Dict>;
-    get schema(): {
-        create: (name: string) => void;
-        delete: (name: string) => void;
-    };
-    close(): void;
-    create<O extends Dict>(as: As, args: {
-        record: Dict;
-    }): MaybePromise<O>;
-    read(as: As, args: {
-        count: true;
-        criteria: DataDict;
-    }): number;
-    read(as: As, args: {
-        criteria: DataDict;
-        fields?: string[];
-        limit?: number;
-        sort?: Sort;
-    }): Dict[];
-    update(as: As, args: {
-        changes: DataDict;
-        criteria: DataDict;
-    }): Promise<number>;
-    delete(as: As, args: {
-        criteria: DataDict;
-    }): number;
-}
-//# sourceMappingURL=InMemoryDatabase.d.ts.map

package/lib/private/database/InMemoryDatabase.js

@@ -1,181 +0,0 @@
-import Database from "#database/Database";
-import fail from "#fail";
-import assert from "@rcompat/assert";
-import entries from "@rcompat/record/entries";
-function match(record, criteria) {
-    return Object.entries(criteria).every(([k, v]) => {
-        const value = record[k];
-        // null criteria (IS NULL semantics)
-        if (v === null)
-            return !Object.hasOwn(record, k);
-        // handle operator objects
-        if (typeof v === "object") {
-            // $like operator
-            if ("$like" in v) {
-                // NULL values don't match LIKE patterns
-                if (value === null || value === undefined)
-                    return false;
-                const $like = v.$like;
-                if (typeof $like !== "string")
-                    throw fail("$like operator requires string, got {0}", typeof $like);
-                const regex = new RegExp("^" + $like.replace(/%/g, ".*").replace(/\?/g, ".") + "$");
-                return regex.test(String(value));
-            }
-            // future: number operators
-            // if ("$gte" in v) return recordValue >= v.$gte;
-            // if ("$gt" in v) return recordValue > v.$gt;
-            // if ("$lte" in v) return recordValue <= v.$lte;
-            // if ("$lt" in v) return recordValue < v.$lt;
-            return false; // unknown operator
-        }
-        // direct equality match
-        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);
-}
-function ident(column) {
-    return {
-        bind: value => value,
-        column,
-        unbind: value => value,
-    };
-}
-const typemap = {
-    blob: ident("BLOB"),
-    boolean: ident("BOOLEAN"),
-    datetime: ident("DATE"),
-    f32: ident("NUMBER"),
-    f64: ident("NUMBER"),
-    i128: ident("BIGINT"),
-    i16: ident("NUMBER"),
-    i32: ident("NUMBER"),
-    i64: ident("BIGINT"),
-    i8: ident("NUMBER"),
-    primary: ident("STRING"),
-    string: ident("STRING"),
-    time: ident("STRING"),
-    u128: ident("BIGINT"),
-    u16: ident("NUMBER"),
-    u32: ident("NUMBER"),
-    u64: ident("BIGINT"),
-    u8: ident("NUMBER"),
-    url: ident("URL"),
-};
-export default class InMemoryDatabase extends Database {
-    #collections = {};
-    get typemap() {
-        return typemap;
-    }
-    #new(name) {
-        if (this.#collections[name] !== undefined) {
-            throw fail("collection {0} already exists", name);
-        }
-        this.#collections[name] = [];
-    }
-    #drop(name) {
-        if (this.#collections[name] === undefined) {
-            // do nothing
-        }
-        delete this.#collections[name];
-    }
-    #use(name) {
-        if (this.#collections[name] === undefined) {
-            this.#collections[name] = [];
-        }
-        return this.#collections[name];
-    }
-    get schema() {
-        return {
-            create: this.#new.bind(this),
-            delete: this.#drop.bind(this),
-        };
-    }
-    // noop
-    close() { }
-    create(as, args) {
-        const collection = this.#use(as.name);
-        const record = { ...args.record };
-        if (record.id === undefined) {
-            record.id = crypto.randomUUID();
-        }
-        ;
-        if (typeof record.id !== "string") {
-            throw fail("id must be string, got {0}", record.id);
-        }
-        if (collection.find(stored => stored.id === record.id)) {
-            throw fail("id {0} already exists in the database", record.id);
-        }
-        collection.push({ ...record });
-        return record;
-    }
-    read(as, args) {
-        this.toWhere(as.types, args.criteria);
-        if (args.fields !== undefined)
-            this.toSelect(as.types, args.fields);
-        if (args.sort !== undefined)
-            this.toSort(as.types, args.sort);
-        const collection = this.#use(as.name);
-        const matches = collection.filter(r => match(r, args.criteria));
-        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 fields = args.fields ?? [];
-        return (fields.length === 0
-            ? sorted
-            : sorted.map(s => filter(s, fields))).slice(0, limit);
-    }
-    async update(as, args) {
-        assert(Object.keys(args.criteria).length > 0, "update: no criteria");
-        this.toWhere(as.types, args.criteria);
-        await this.toSet(as.types, args.changes);
-        const collection = this.#use(as.name);
-        const matched = collection.filter(record => match(record, args.criteria));
-        return matched.map(record => {
-            const changed = entries({ ...record, ...args.changes })
-                .filter(([, value]) => value !== null)
-                .get();
-            const index = collection.findIndex(stored => stored.id === record.id);
-            collection.splice(index, 1, changed);
-            return changed;
-        }).length;
-    }
-    delete(as, args) {
-        if (Object.keys(args.criteria).length === 0) {
-            throw fail("delete: no criteria");
-        }
-        this.toWhere(as.types, args.criteria);
-        const collection = this.#use(as.name);
-        const size_before = collection.length;
-        this.#collections[as.name] = collection
-            .filter(record => !match(record, args.criteria));
-        return size_before - this.#use(as.name).length;
-    }
-}
-//# sourceMappingURL=InMemoryDatabase.js.map

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

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

package/lib/private/database/Store.d.ts

@@ -1,172 +0,0 @@
-import type Changes from "#database/Changes";
-import type Database from "#database/Database";
-import type Schema from "#database/Schema";
-import wrap from "#database/symbol/wrap";
-import type Types from "#database/Types";
-import type Dict from "@rcompat/type/Dict";
-import type Serializable from "@rcompat/type/Serializable";
-import type Id from "pema/Id";
-import type InferStore from "pema/InferStore";
-import type StoreId from "pema/StoreId";
-import type StoreSchema from "pema/StoreSchema";
-import StoreType from "pema/StoreType";
-type X<T> = {
-    [K in keyof T]: T[K];
-} & {};
-type StringOperators = {
-    $like?: string;
-};
-type QueryOperators<T> = T extends string ? T | StringOperators | null : T | null;
-type Criteria<T extends StoreSchema> = X<{
-    [K in keyof Omit<InferStore<T>, "id">]?: QueryOperators<InferStore<T>[K]>;
-} & {
-    id?: StoreId<T> | null;
-}>;
-type Select<T> = {
-    [K in keyof T]?: true;
-};
-type Sort<T> = {
-    [K in keyof T]?: "asc" | "desc";
-};
-type Insertable<T extends StoreSchema> = Omit<InferStore<T>, "id"> & {
-    id?: StoreId<T>;
-};
-type Filter<A, B = undefined> = B extends undefined ? A : {
-    [K in keyof A as K extends keyof B ? B[K] extends true ? K : never : never]: A[K];
-};
-type Config = {
-    database?: Database;
-    name?: string;
-};
-/**
- * Database-backed store.
- *
- * A `DatabaseStore` exposes a typed, validated interface over a relational or
- * document database table/collection. It pairs a Pema schema with a uniform
- * CRUD/query API.
- *
- */
-export default class DatabaseStore<S extends StoreSchema> implements Serializable {
-    #private;
-    [wrap]: (name: string, database: Database) => this;
-    readonly Schema: Schema<S>;
-    constructor(schema: S, config?: Config);
-    static new<S extends StoreSchema>(schema: S, config?: Config): DatabaseStore<S>;
-    get collection(): {
-        create: () => import("@rcompat/type/MaybePromise").default<void>;
-        delete: () => import("@rcompat/type/MaybePromise").default<void>;
-    };
-    get infer(): InferStore<S>;
-    get schema(): S;
-    get type(): StoreType<S>;
-    get database(): Database;
-    get types(): Types;
-    get name(): string;
-    /**
-     * Count records.
-     *
-     * @param criteria Criteria to limit which records are counted.
-     * @returns Number of matching records (or total if no criteria given).
-     */
-    count(criteria?: Criteria<S> | {
-        id: StoreId<S>;
-    }): Promise<number>;
-    /**
-     * Check whether a record with the given id exists.
-     *
-     * @param id Record id.
-     * @returns `true` if a record with the given id exists, otherwise `false`.
-     */
-    has(id: StoreId<S>): Promise<boolean>;
-    /**
-     * Get a record by id.
-     *
-     * @param id Record id.
-     * @throws If no record with the given id exists.
-     * @returns The record for the given id.
-     */
-    get(id: Id): Promise<Schema<S>>;
-    /**
-     * Try to get a record by id.
-     *
-     * @param id Record id.
-     * @returns The record if found, otherwise `undefined`.
-     */
-    try(id: Id): Promise<Schema<S> | undefined>;
-    /**
-     * Insert a single record.
-     *
-     * If `id` is omitted, the driver generates one. Input is validated
-     * according to the store schema.
-     *
-     * @param record Record to insert (id optional).
-     * @throws If a record with the same id already exists or validation fails.
-     * @returns The inserted record with id.
-     */
-    insert(record: Insertable<S>): Promise<Schema<S>>;
-    /**
-     * Update a single record.
-     *
-     * Change semantics:
-     * - missing / undefined -> leave field unchanged
-     * - null -> unset field (only for nullable fields, otherwise throw)
-     * - value -> set field to value
-     *
-     * Change input is validated according to the store schema.
-     *
-     * @param id Record id.
-     * @param changes Partial changes per the rules above.
-     * @throws If the id is missing, `.id` is present in `changes`, attempting to
-     * unset a non-nullable field, validation fails, or no record is updated.
-     */
-    update(id: Id, changes: Changes<S>): Promise<void>;
-    /**
-     * Update multiple records.
-     *
-     * Same change semantics as when updating a single record.
-     *
-     * @param criteria Criteria selecting which records to update.
-     * @param changes Partial changes per the rules above.
-     * @returns Number of updated records (may be 0).
-     */
-    update(criteria: Criteria<S>, changes: Changes<S>): Promise<number>;
-    /**
-     * Delete a single record.
-     *
-     * @param id Record id.
-     * @throws If no records with the given id exists.
-     */
-    delete(id: Id): Promise<void>;
-    /**
-     * Delete multiple records.
-     *
-     * @param criteria Criteria selecting which records to delete.
-     * @returns Number of records deleted (may be 0).
-     */
-    delete(criteria: Criteria<S>): Promise<number>;
-    /**
-     * Find matching records.
-     *
-     * @param criteria Criteria to match records by.
-     * @param options Query options.
-     * @returns Matching records, possibly projected/limited/sorted.
-     */
-    find(criteria: Criteria<S>): Promise<Filter<Schema<S>>[]>;
-    find(criteria: Criteria<S>, options: {
-        limit?: number;
-        select?: undefined;
-        sort?: Sort<Schema<S>>;
-    }): Promise<Filter<Schema<S>>[]>;
-    find<F extends Select<Schema<S>>>(criteria: Criteria<S>, options?: {
-        limit?: number;
-        select?: F;
-        sort?: Sort<Schema<S>>;
-    }): Promise<Filter<Schema<S>, F>[]>;
-    toJSON(): {
-        type: "object";
-        properties: Dict<import("pema/StoreType").Serialized>;
-    };
-    extend<A extends Dict>(extensor: (This: this) => A): this & A;
-}
-export {};
-//# sourceMappingURL=Store.d.ts.map