@primate/core 0.4.5 → 0.5.0

package/lib/private/database/Store.js

@@ -1,261 +0,0 @@
-import wrap from "#database/symbol/wrap";
-import fail from "#fail";
-import assert from "@rcompat/assert";
-import is from "@rcompat/assert/is";
-import maybe from "@rcompat/assert/maybe";
-import StoreType from "pema/StoreType";
-/**
- * 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 {
-    #schema;
-    #type;
-    #types;
-    #nullables;
-    #database;
-    #name;
-    constructor(schema, config = {}) {
-        this.#schema = schema;
-        this.#type = new StoreType(schema);
-        this.#types = Object.fromEntries(Object.entries(schema)
-            .map(([key, value]) => [key, value.datatype]));
-        this.#name = config.name;
-        this.#database = config.database;
-        this.#nullables = new Set(Object.entries(this.#type.properties)
-            .filter(([, v]) => v.nullable)
-            .map(([k]) => k));
-    }
-    #parseCriteria(criteria) {
-        for (const [field, value] of Object.entries(criteria)) {
-            if (!(field in this.#types))
-                throw fail("unknown field {0}", field);
-            // skip null/undefined values
-            if (value === null)
-                continue;
-            // if it's an operator object, validate
-            if (typeof value === "object") {
-                const type = this.#types[field];
-                if ("$like" in value && type !== "string") {
-                    throw fail("$like operator not supported in {0} ({1})", field, type);
-                }
-                /*const n_ops = ["$gte", "$gt", "$lte", "$lt"];
-                if (n_ops.some(op => op in value) && !["number", "i8", "i16", "i32",
-                  "i64", "i128", "u8", "u16", "u32", "u64", "u128", "f32", "f64"]
-                  .includes(type)) {
-                  const used = n_ops.filter(op => op in value).join(", ");
-                  throw fail("operators {0} not supported in {1} ({2})", used, field,
-                    type);
-                }*/
-            }
-        }
-    }
-    static new(schema, config = {}) {
-        return new DatabaseStore(schema, config);
-    }
-    get #as() {
-        return {
-            name: this.name,
-            types: this.#types,
-        };
-    }
-    get collection() {
-        const database = this.database;
-        const name = this.name;
-        const schema = this.#schema;
-        return {
-            create: () => database.schema.create(name, schema),
-            delete: () => database.schema.delete(name),
-        };
-    }
-    get infer() {
-        return undefined;
-    }
-    get schema() {
-        return this.#schema;
-    }
-    get type() {
-        return this.#type;
-    }
-    [wrap](name, database) {
-        this.#database ??= database;
-        this.#name ??= name;
-        return this;
-    }
-    get database() {
-        if (this.#database === undefined)
-            throw fail("store missing database");
-        return this.#database;
-    }
-    get types() {
-        return this.#types;
-    }
-    get name() {
-        if (this.#name === undefined)
-            throw fail("store missing name");
-        return this.#name;
-    }
-    /**
-     * Count records.
-     *
-     * @param criteria Criteria to limit which records are counted.
-     * @returns Number of matching records (or total if no criteria given).
-     */
-    async count(criteria) {
-        maybe(criteria).record();
-        if (criteria)
-            this.#parseCriteria(criteria);
-        return (await this.database.read(this.#as, {
-            count: true,
-            criteria: criteria ?? {},
-        }));
-    }
-    /**
-     * 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`.
-     */
-    async has(id) {
-        is(id).string();
-        // invariant: ids are primary keys and must be unique.
-        // if the driver ever returns more than one record, assert will fail.
-        // public contract remains just "true if it exists, false otherwise".
-        return (await this.count({ id })) === 1;
-    }
-    /**
-     * 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.
-     */
-    async get(id) {
-        is(id).string();
-        const records = await this.database.read(this.#as, {
-            criteria: { id },
-            limit: 1,
-        });
-        assert(records.length <= 1);
-        if (records.length === 0)
-            throw fail("no record with id {0}", id);
-        return this.#type.parse(records[0]);
-    }
-    /**
-     * Try to get a record by id.
-     *
-     * @param id Record id.
-     * @returns The record if found, otherwise `undefined`.
-     */
-    async try(id) {
-        try {
-            return await this.get(id);
-        }
-        catch {
-            return 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.
-     */
-    async insert(record) {
-        is(record).record();
-        return this.database.create(this.#as, { record: this.#type.parse(record) });
-    }
-    async update(criteria, changes) {
-        is(changes).record();
-        if ("id" in changes)
-            throw fail("{0} cannot be updated", ".id");
-        const changeEntries = Object.entries(changes);
-        for (const [k, v] of changeEntries) {
-            if (v === null && !this.#nullables.has(k)) {
-                throw fail(".{0}: null not allowed (field not nullable)", k);
-            }
-        }
-        const toParse = Object.fromEntries(changeEntries
-            .filter(([key, value]) => value !== null || !this.#nullables.has(key)));
-        const nulls = Object.fromEntries(changeEntries
-            .filter(([key, value]) => value === null && this.#nullables.has(key)));
-        const parsed = {
-            // parse delta, without nullable nulls
-            ...this.#type.partial().parse(toParse),
-            ...nulls,
-        };
-        return typeof criteria === "string"
-            ? this.#update_1(criteria, parsed)
-            : this.#update_n(criteria, parsed);
-    }
-    async #update_1(id, changes) {
-        is(id).string();
-        const n = await this.database.update(this.#as, {
-            changes,
-            criteria: { id },
-        });
-        assert(n === 1, `${n} records updated instead of 1`);
-    }
-    async #update_n(criteria, changes) {
-        is(criteria).record();
-        this.#parseCriteria(criteria);
-        const count = await this.database.update(this.#as, {
-            changes,
-            criteria,
-        });
-        return count;
-    }
-    async delete(criteria) {
-        return typeof criteria === "string"
-            ? this.#delete_1(criteria)
-            : this.#delete_n(criteria);
-    }
-    async #delete_1(id) {
-        is(id).string();
-        const n = await this.database.delete(this.#as, { criteria: { id } });
-        assert(n === 1, `${n} records deleted instead of 1`);
-    }
-    async #delete_n(criteria) {
-        is(criteria).record();
-        this.#parseCriteria(criteria);
-        return await this.database.delete(this.#as, { criteria });
-    }
-    async find(criteria, options) {
-        is(criteria).record();
-        this.#parseCriteria(criteria);
-        maybe(options).record();
-        maybe(options?.select).record();
-        maybe(options?.sort).record();
-        maybe(options?.limit).usize();
-        const result = await this.database.read(this.#as, {
-            criteria,
-            fields: options?.select ? Object.keys(options.select) : undefined,
-            limit: options?.limit,
-            sort: options?.sort,
-        });
-        return result;
-    }
-    ;
-    toJSON() {
-        return this.#type.toJSON();
-    }
-    extend(extensor) {
-        const extensions = extensor(this);
-        for (const k of Object.keys(extensions)) {
-            if (k in this)
-                throw fail("key {0} already exists on store", k);
-        }
-        Object.assign(this, extensions);
-        return this;
-    }
-}
-;
-//# sourceMappingURL=Store.js.map

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

@@ -1,4 +0,0 @@
-import AsyncLocalStorage from "@rcompat/async/context";
-declare const _default: AsyncLocalStorage<unknown>;
-export default _default;
-//# sourceMappingURL=storage.d.ts.map

package/lib/private/database/storage.js

@@ -1,3 +0,0 @@
-import AsyncLocalStorage from "@rcompat/async/context";
-export default new AsyncLocalStorage();
-//# sourceMappingURL=storage.js.map

package/lib/private/database/symbol/wrap.js

@@ -1,2 +0,0 @@
-export default Symbol("@primate/core/database/wrap");
-//# sourceMappingURL=wrap.js.map

package/lib/private/database/symbol.js

@@ -1,2 +0,0 @@
-export default Symbol("@primate/core/database");
-//# sourceMappingURL=symbol.js.map

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

@@ -1,4 +0,0 @@
-import type Database from "#database/Database";
-declare const _default: <D extends Database>(database: D) => void;
-export default _default;
-//# sourceMappingURL=test.d.ts.map