@primate/core 0.1.10 → 0.2.0

package/lib/private/database/Store.js

@@ -0,0 +1,255 @@
+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.schema)
+            .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 schema() {
+        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;
+    }
+    [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/TypeMap.d.ts

@@ -0,0 +1,14 @@
+import type MaybePromise from "@rcompat/type/MaybePromise";
+import type DataType from "pema/DataType";
+import type Dict from "@rcompat/type/Dict";
+type TypeMap<Columns extends Dict = Dict> = {
+    [K in keyof DataType]: {
+        [C in keyof Columns]: {
+            bind: (value: DataType[K]) => MaybePromise<Columns[C]>;
+            column: C;
+            unbind: (value: Columns[C]) => DataType[K];
+        };
+    }[keyof Columns];
+};
+export type { TypeMap as default };
+//# sourceMappingURL=TypeMap.d.ts.map

package/lib/private/database/TypeMap.js

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

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

@@ -0,0 +1,6 @@
+import type DataType from "pema/DataType";
+type Types = {
+    [k: string]: keyof DataType;
+};
+export type { Types as default };
+//# sourceMappingURL=Types.d.ts.map

package/lib/private/database/Types.js

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

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

@@ -0,0 +1,3 @@
+declare const _default: "id";
+export default _default;
+//# sourceMappingURL=primary.d.ts.map

package/lib/private/database/primary.js

@@ -0,0 +1,2 @@
+export default "id";
+//# sourceMappingURL=primary.js.map

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

@@ -0,0 +1,4 @@
+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

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

package/lib/private/database/symbol/wrap.d.ts

@@ -0,0 +1,3 @@
+declare const _default: symbol;
+export default _default;
+//# sourceMappingURL=wrap.d.ts.map

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

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

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

@@ -0,0 +1,3 @@
+declare const _default: symbol;
+export default _default;
+//# sourceMappingURL=symbol.d.ts.map

package/lib/private/database/symbol.js

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

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

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