@primate/core 0.6.3 → 0.7.0

package/lib/private/{orm/store.js → store/Store.js}

@@ -1,8 +1,11 @@
 import E from "#db/errors";
-import parse from "#orm/parse";
+import parse from "#store/parse";
+import relation from "#store/relation";
 import assert from "@rcompat/assert";
+import dict from "@rcompat/dict";
 import is from "@rcompat/is";
 import StoreType from "pema/StoreType";
+const brand = Symbol.for("@primate/core/Store/v0");
 const NUMBER_KEYS = [
     "u8", "u16", "u32",
     "i8", "i16", "i32",
@@ -13,7 +16,7 @@ const is_number_key = (d) => NUMBER_KEYS.includes(d);
 const is_bigint_key = (d) => BIGINT_KEYS.includes(d);
 const VALID_IDENTIFIER = /^[a-zA-Z_][a-zA-Z0-9_]*$/;
 function guard_options(options, allowed) {
-    if (options === undefined)
+    if (is.undefined(options))
         return;
     const allowed_set = new Set(allowed);
     for (const k of Object.keys(options)) {
@@ -38,7 +41,7 @@ const BIGINT_LIMITS = {
 function assert_number_value(key, datatype, value) {
     if (!is.finite(value))
         throw E.where_invalid_value(key, value);
-    if (datatype in INT_LIMITS) {
+    if (dict.has(INT_LIMITS, datatype)) {
         if (!is.safeint(value))
             throw E.where_invalid_value(key, value);
         const [min, max] = INT_LIMITS[datatype];
@@ -51,11 +54,10 @@ function assert_bigint_value(key, datatype, value) {
     if (value < min || value > max)
         throw E.where_invalid_value(key, value);
 }
-const registry = new Map();
-const STRING_OPS = ["$like", "$ilike"];
-const NUMBER_OPS = ["$gt", "$gte", "$lt", "$lte", "$ne"];
-const BIGINT_OPS = ["$gt", "$gte", "$lt", "$lte", "$ne"];
-const DATE_OPS = ["$before", "$after", "$ne"];
+const STRING_OPS = ["$like", "$ilike", "$in"];
+const NUMBER_OPS = ["$gt", "$gte", "$lt", "$lte", "$ne", "$in"];
+const BIGINT_OPS = ["$gt", "$gte", "$lt", "$lte", "$ne", "$in"];
+const DATE_OPS = ["$before", "$after", "$ne", "$in"];
 /**
  * Database-backed store.
  *
@@ -63,13 +65,13 @@ const DATE_OPS = ["$before", "$after", "$ne"];
  * document database table/collection. It pairs a Pema schema with a uniform
  * CRUD/query API.
  */
-export class Store {
+export default class Store {
+    [brand] = true;
     #input;
     #schema;
-    #type;
     #types;
     #nullables;
-    #name;
+    #table;
     #db;
     #pk;
     #generate_pk;
@@ -77,65 +79,60 @@ export class Store {
     #relations;
     #migrate;
     #id;
+    static is(x) {
+        return is.branded(x, brand);
+    }
     constructor(init) {
-        const { name, db, migrate, id } = init;
+        const { table, db, migrate, id } = init;
         const { pk, generate_pk, fks, schema } = parse(init.schema);
-        if (name === undefined)
-            throw E.store_name_required();
-        assert.string(name);
-        if (!VALID_IDENTIFIER.test(name))
-            throw E.identifier_invalid(name);
+        if (is.undefined(table))
+            throw E.store_table_required();
+        assert.string(table);
+        if (!VALID_IDENTIFIER.test(table))
+            throw E.identifier_invalid(table);
         assert.defined(db, E.db_missing);
         assert.dict(schema);
         assert.maybe.boolean(migrate);
         assert.maybe.dict(init.extend);
         assert.maybe.symbol(id);
         this.#id = id ?? Symbol();
-        this.#schema = schema;
-        this.#type = new StoreType(schema, pk);
+        this.#schema = new StoreType(schema, pk);
         this.#types = Object.fromEntries(Object.entries(schema).map(([key, value]) => [key, value.datatype]));
-        this.#name = name;
+        this.#table = table;
         this.#db = db;
         this.#pk = pk;
         this.#generate_pk = generate_pk;
         this.#fks = fks;
         this.#input = init.schema;
-        this.#relations = init.relations ?? {};
+        this.#relations = Object.fromEntries(Object.entries(init.schema).filter(([, v]) => relation.is(v)));
         this.#migrate = migrate ?? true;
-        for (const relation of Object.keys(this.#relations)) {
-            if (relation in schema)
-                throw E.relation_conflicts_with_field(relation);
-        }
-        this.#nullables = new Set(Object.entries(this.#type.properties)
+        this.#nullables = new Set(Object.entries(this.#schema.properties)
             .filter(([, v]) => v.nullable)
             .map(([k]) => k));
-        if (init.extend !== undefined) {
+        if (is.defined(init.extend)) {
             for (const [k, v] of Object.entries(init.extend)) {
                 if (k in this)
                     throw E.key_duplicate(k);
                 this[k] = v;
             }
         }
-        registry.set(init.schema, this);
     }
     get #as() {
         return {
-            table: this.name,
+            table: this.#table,
             pk: this.#pk,
             generate_pk: this.#generate_pk,
             types: this.#types,
         };
     }
-    get table() {
-        const db = this.db;
-        const pk = {
+    async create() {
+        return this.db.schema.create(this.#table, {
             name: this.#pk,
             generate: this.#generate_pk,
-        };
-        return {
-            create: () => db.schema.create(this.#name, pk, this.#types),
-            delete: () => db.schema.delete(this.#name),
-        };
+        }, this.#types);
+    }
+    async drop() {
+        return this.db.schema.delete(this.#table);
     }
     get infer() {
         return undefined;
@@ -143,17 +140,14 @@ export class Store {
     get schema() {
         return this.#schema;
     }
-    get type() {
-        return this.#type;
-    }
     get migrate() {
         return this.#migrate;
     }
     get id() {
         return this.#id;
     }
-    get name() {
-        return this.#name;
+    get table() {
+        return this.#table;
     }
     get pk() {
         return this.#pk;
@@ -166,10 +160,10 @@ export class Store {
     }
     #parse_pk(pkv) {
         const pk = this.#pk;
-        if (pk === null)
-            throw E.pk_undefined(this.name);
+        if (is.null(pk))
+            throw E.pk_undefined(this.#table);
         try {
-            this.#schema[pk].parse(pkv);
+            this.#schema.properties[pk].parse(pkv);
         }
         catch {
             throw E.pk_invalid(pkv);
@@ -177,52 +171,58 @@ export class Store {
         return pk;
     }
     #parse_query(query, types) {
-        const { where, select, sort, limit } = query;
-        if (where !== undefined)
+        const { where, select, sort, limit, offset } = query;
+        if (is.defined(where))
             this.#parse_where(where, types);
-        if (select !== undefined)
+        if (is.defined(select))
             this.#parse_select(select, types);
-        if (sort !== undefined)
+        if (is.defined(sort))
             this.#parse_sort(sort, types);
-        if (limit !== undefined && !is.uint(limit))
+        if (is.defined(limit) && !is.uint(limit))
             throw E.limit_invalid();
+        if (is.defined(offset)) {
+            if (!is.uint(offset))
+                throw E.offset_invalid();
+            if (is.undefined(limit))
+                throw E.offset_requires_limit();
+        }
     }
     #with(options) {
-        if (options === undefined)
+        if (is.undefined(options))
             return undefined;
         const plan = {};
-        for (const [name, query] of Object.entries(options)) {
-            if (query === undefined)
+        for (const [name, input] of dict.entries(options)) {
+            if (is.undefined(input))
                 continue;
             const relation = this.#relations[name];
-            if (relation === undefined)
+            if (is.undefined(relation))
                 throw E.relation_unknown(name);
-            const store = registry.get(relation.schema);
-            if (store === undefined)
-                throw E.unregistered_schema();
-            const { pk: target_pk } = parse(relation.schema);
-            const target_types = store.types;
-            const base = {
+            const is_query = is.dict(input) && "store" in input;
+            const passed_store = is_query
+                ? input.store
+                : Store.is(input) ? input : undefined;
+            if (is.undefined(passed_store))
+                throw E.relation_store_required(name);
+            const query = is_query
+                ? input
+                : undefined;
+            if (passed_store.table !== relation.table) {
+                throw E.relation_table_mismatch(relation.table, passed_store.table);
+            }
+            this.#parse_query(query ?? {}, passed_store.types);
+            plan[name] = {
                 as: {
-                    table: store.name,
-                    pk: target_pk,
-                    types: target_types,
+                    table: passed_store.table,
+                    pk: passed_store.pk,
+                    types: passed_store.types,
                 },
                 kind: relation.type,
                 fk: relation.fk,
                 reverse: "reverse" in relation && relation.reverse === true,
-            };
-            if (query === true) {
-                plan[name] = { ...base, where: {} };
-                continue;
-            }
-            this.#parse_query(query, target_types);
-            plan[name] = {
-                ...base,
-                where: query.where ?? {},
-                fields: query.select ? [...query.select] : undefined,
-                sort: query.sort,
-                limit: query.limit,
+                where: query?.where ?? {},
+                fields: query?.select ? [...query.select] : undefined,
+                sort: query?.sort,
+                limit: query?.limit,
             };
         }
         return plan;
@@ -233,13 +233,13 @@ export class Store {
         for (const [k, value] of Object.entries(where)) {
             if (!VALID_IDENTIFIER.test(k))
                 throw E.identifier_invalid(k);
-            if (!(k in types))
+            if (!dict.has(types, k))
                 throw E.field_unknown(k, "where");
-            if (value === undefined)
+            if (is.undefined(value))
                 throw E.field_undefined(k, "where");
             const datatype = types[k];
             // null criteria (IS NULL semantics)
-            if (value === null)
+            if (is.null(value))
                 continue;
             // arrays are always invalid
             if (is.array(value))
@@ -254,6 +254,17 @@ export class Store {
                     if (datatype === "string" || datatype === "time") {
                         if (!STRING_OPS.includes(op))
                             throw E.operator_unknown(k, op);
+                        if (op === "$in") {
+                            if (!is.array(op_val))
+                                throw E.wrong_type("array", k, op_val, op);
+                            if (op_val.length === 0)
+                                throw E.operator_empty_in(k);
+                            for (const v of op_val) {
+                                if (!is.string(v))
+                                    throw E.wrong_type("string", k, v, op);
+                            }
+                            continue;
+                        }
                         if (!is.string(op_val))
                             throw E.wrong_type("string", k, op_val, op);
                         continue;
@@ -261,6 +272,18 @@ export class Store {
                     if (is_number_key(datatype)) {
                         if (!NUMBER_OPS.includes(op))
                             throw E.operator_unknown(k, op);
+                        if (op === "$in") {
+                            if (!is.array(op_val))
+                                throw E.wrong_type("array", k, op_val, op);
+                            if (op_val.length === 0)
+                                throw E.operator_empty_in(k);
+                            for (const v of op_val) {
+                                if (!is.number(v))
+                                    throw E.wrong_type("number", k, v, op);
+                                assert_number_value(k, datatype, v);
+                            }
+                            continue;
+                        }
                         if (!is.number(op_val))
                             throw E.wrong_type("number", k, op_val, op);
                         assert_number_value(k, datatype, op_val);
@@ -269,6 +292,18 @@ export class Store {
                     if (is_bigint_key(datatype)) {
                         if (!BIGINT_OPS.includes(op))
                             throw E.operator_unknown(k, op);
+                        if (op === "$in") {
+                            if (!is.array(op_val))
+                                throw E.wrong_type("array", k, op_val, op);
+                            if (op_val.length === 0)
+                                throw E.operator_empty_in(k);
+                            for (const v of op_val) {
+                                if (!is.bigint(v))
+                                    throw E.wrong_type("bigint", k, v, op);
+                                assert_bigint_value(k, datatype, v);
+                            }
+                            continue;
+                        }
                         if (!is.bigint(op_val))
                             throw E.wrong_type("bigint", k, op_val, op);
                         assert_bigint_value(k, datatype, op_val);
@@ -277,10 +312,34 @@ export class Store {
                     if (datatype === "datetime") {
                         if (!DATE_OPS.includes(op))
                             throw E.operator_unknown(k, op);
+                        if (op === "$in") {
+                            if (!is.array(op_val))
+                                throw E.wrong_type("array", k, op_val, op);
+                            if (op_val.length === 0)
+                                throw E.operator_empty_in(k);
+                            for (const v of op_val) {
+                                if (!is.date(v))
+                                    throw E.wrong_type("date", k, v, op);
+                            }
+                            continue;
+                        }
                         if (!is.date(op_val))
                             throw E.wrong_type("date", k, op_val, op);
                         continue;
                     }
+                    if (datatype === "uuid" || datatype === "uuid_v4" || datatype === "uuid_v7") {
+                        if (op !== "$in")
+                            throw E.operator_unknown(k, op);
+                        if (!is.array(op_val))
+                            throw E.wrong_type("array", k, op_val, op);
+                        if (op_val.length === 0)
+                            throw E.operator_empty_in(k);
+                        for (const v of op_val) {
+                            if (!is.string(v))
+                                throw E.wrong_type("string", k, v, op);
+                        }
+                        continue;
+                    }
                     // url/boolean/blob: no operator objects
                     throw E.operator_unknown(k, op);
                 }
@@ -350,7 +409,7 @@ export class Store {
                 throw E.select_invalid_value(i, v);
             if (!VALID_IDENTIFIER.test(v))
                 throw E.identifier_invalid(v);
-            if (!(v in types))
+            if (!dict.has(types, v))
                 throw E.field_unknown(v, "select");
             // duplicate isn't harmful, but usually a thought error
             if (seen.has(v))
@@ -367,22 +426,25 @@ export class Store {
         for (const [k, direction] of Object.entries(sort)) {
             if (!is.string(direction))
                 throw E.sort_invalid_value(k, direction);
-            if (!(k in types))
+            if (!dict.has(types, k))
                 throw E.field_unknown(k, "sort");
             const l = direction.toLowerCase();
             if (l !== "asc" && l !== "desc")
                 throw E.sort_invalid_value(k, direction);
         }
     }
-    #parse_insert(record) {
+    #prepare_insert(record) {
+        const out = {};
         for (const [k, v] of Object.entries(record)) {
-            if (!(k in this.#types))
+            if (!dict.has(this.#types, k))
                 throw E.field_unknown(k, "insert");
-            if (v === undefined)
-                throw E.field_undefined(k, "insert");
-            if (v === null)
+            if (is.undefined(v))
+                continue; // treat as omission
+            if (is.null(v))
                 throw E.null_not_allowed(k);
+            out[k] = v;
         }
+        return out;
     }
     /**
      * Count records
@@ -422,13 +484,13 @@ export class Store {
         }
         const raw = records[0];
         // if projected, keep it as-is (no parse)
-        if (options?.select)
+        if (is.defined(options?.select))
             return raw;
         // parse *only* base fields (exclude relation keys)
         const base_only = Object.fromEntries(Object.entries(raw)
-            .filter(([k]) => k in this.#types));
-        const parsed = this.#type.parse(base_only);
-        if ($with === undefined)
+            .filter(([k]) => dict.has(this.#types, k)));
+        const parsed = this.#schema.parse(base_only);
+        if (is.undefined($with))
             return parsed;
         return {
             ...parsed,
@@ -450,10 +512,8 @@ export class Store {
      */
     async insert(record) {
         assert.dict(record);
-        this.#parse_insert(record);
-        const entries = Object.entries(record);
-        const to_parse = Object.fromEntries(entries.filter(([k, v]) => !(v === null && this.#nullables.has(k))));
-        return this.db.create(this.#as, this.#type.parse(to_parse));
+        const prepared = this.#prepare_insert(record);
+        return this.db.create(this.#as, this.#schema.parse(prepared));
     }
     async update(arg0, options) {
         const by_pk = options !== undefined;
@@ -466,9 +526,9 @@ export class Store {
         if (pk !== null && pk in set)
             throw E.pk_immutable(pk);
         for (const [k, v] of Object.entries(set)) {
-            if (!(k in this.#types))
+            if (!dict.has(this.#types, k))
                 throw E.field_unknown(k, "set");
-            if (v === null && !this.#nullables.has(k))
+            if (is.null(v) && !this.#nullables.has(k))
                 throw E.null_not_allowed(k);
         }
         const entries = Object.entries(set);
@@ -477,13 +537,13 @@ export class Store {
         const nulls = Object.fromEntries(entries
             .filter(([key, value]) => value === null && this.#nullables.has(key)));
         const parsed = {
-            ...this.#type.partial().parse(to_parse),
+            ...this.#schema.partial().parse(to_parse),
             ...nulls,
         };
         if (by_pk)
             return this.#update_1(arg0, parsed);
         const where = arg0.where;
-        if (where !== undefined)
+        if (is.defined(where))
             this.#parse_where(where, this.#types);
         return this.#update_n((where ?? {}), parsed);
     }
@@ -518,34 +578,30 @@ export class Store {
      *
      */
     async find(options) {
-        guard_options(options, ["where", "select", "sort", "limit", "with"]);
+        guard_options(options, ["where", "select", "sort", "limit", "offset", "with"]);
         this.#parse_query(options ?? {}, this.#types);
         const result = await this.db.read(this.#as, {
             where: options?.where ?? {},
             fields: options?.select !== undefined ? [...options.select] : undefined,
             limit: options?.limit,
+            offset: options?.offset,
             sort: options?.sort,
             with: this.#with(options?.with),
         });
         return result;
     }
     toJSON() {
-        return this.#type.toJSON();
+        return this.#schema.toJSON();
     }
     extend(extensor) {
         return new Store({
-            name: this.name,
-            db: this.db,
+            table: this.#table,
+            db: this.#db,
             schema: this.#input,
-            relations: this.#relations,
             migrate: this.#migrate,
             id: this.#id,
             extend: extensor(this),
         });
     }
 }
-function store(init) {
-    return new Store(init);
-}
-export default store;
-//# sourceMappingURL=store.js.map
+//# sourceMappingURL=Store.js.map

package/lib/private/store/StoreInput.d.ts

@@ -0,0 +1,11 @@
+import type ForeignKey from "#store/ForeignKey";
+import type { AllowedFKType } from "#store/ForeignKey";
+import type PrimaryKey from "#store/PrimaryKey";
+import type { AllowedPKType } from "#store/PrimaryKey";
+import type { Relation } from "#store/relation";
+import type { Dict } from "@rcompat/type";
+import type { DataKey, Storable } from "pema";
+type StoreField = Storable<DataKey> | PrimaryKey<AllowedPKType> | ForeignKey<AllowedFKType> | Relation;
+type StoreInput = Dict<StoreField>;
+export type { StoreInput as default };
+//# sourceMappingURL=StoreInput.d.ts.map

package/lib/private/store/key.d.ts

@@ -0,0 +1,8 @@
+import ForeignKey from "#store/ForeignKey";
+import PrimaryKey from "#store/PrimaryKey";
+declare const key: {
+    foreign: typeof ForeignKey.new;
+    primary: typeof PrimaryKey.new;
+};
+export default key;
+//# sourceMappingURL=key.d.ts.map

package/lib/private/store/key.js

@@ -0,0 +1,8 @@
+import ForeignKey from "#store/ForeignKey";
+import PrimaryKey from "#store/PrimaryKey";
+const key = {
+    foreign: ForeignKey.new,
+    primary: PrimaryKey.new,
+};
+export default key;
+//# sourceMappingURL=key.js.map

package/lib/private/{orm → store}/parse.d.ts

@@ -1,7 +1,7 @@
 import type PK from "#db/PK";
-import ForeignKey from "#orm/ForeignKey";
-import type { AllowedFKType } from "#orm/ForeignKey";
-import type StoreInput from "#orm/StoreInput";
+import type { AllowedFKType } from "#store/ForeignKey";
+import ForeignKey from "#store/ForeignKey";
+import type StoreInput from "#store/StoreInput";
 import type { Dict } from "@rcompat/type";
 import type { Storable } from "pema";
 export default function parse(input: StoreInput): {

package/lib/private/{orm → store}/parse.js

@@ -1,6 +1,7 @@
 import E from "#db/errors";
-import ForeignKey from "#orm/ForeignKey";
-import PrimaryKey from "#orm/PrimaryKey";
+import ForeignKey from "#store/ForeignKey";
+import PrimaryKey from "#store/PrimaryKey";
+import relation from "#store/relation";
 const is_pk = (x) => x instanceof PrimaryKey;
 const is_fk = (x) => x instanceof ForeignKey;
 export default function parse(input) {
@@ -20,6 +21,10 @@ export default function parse(input) {
             fks.set(key, value);
             schema[key] = value.type;
         }
+        else if (relation.is(value)) {
+            // skip — relations are extracted separately
+            continue;
+        }
         else {
             schema[key] = value;
         }

package/lib/private/store/relation.d.ts

@@ -0,0 +1,29 @@
+export type OneRelation<N extends string, FK extends string> = {
+    type: "one";
+    table: N;
+    fk: FK;
+    reverse: boolean;
+};
+export type ManyRelation<N extends string, FK extends string> = {
+    type: "many";
+    table: N;
+    fk: FK;
+};
+export type Relation = OneRelation<string, string> | ManyRelation<string, string>;
+declare function one<const N extends string, const FK extends string>(options: {
+    table: N;
+    by: FK;
+    reverse?: boolean;
+}): OneRelation<N, FK>;
+declare function many<const N extends string, const FK extends string>(options: {
+    table: N;
+    by: FK;
+}): ManyRelation<N, FK>;
+declare function is_relation(x: unknown): x is Relation;
+declare const relation: {
+    one: typeof one;
+    many: typeof many;
+    is: typeof is_relation;
+};
+export default relation;
+//# sourceMappingURL=relation.d.ts.map

package/lib/private/store/relation.js

@@ -0,0 +1,26 @@
+import is from "@rcompat/is";
+function one(options) {
+    return {
+        type: "one",
+        table: options.table,
+        fk: options.by,
+        reverse: options.reverse ?? false,
+    };
+}
+function many(options) {
+    return {
+        type: "many",
+        table: options.table,
+        fk: options.by,
+    };
+}
+function is_relation(x) {
+    return is.dict(x) && "type" in x && (x.type === "one" || x.type === "many");
+}
+const relation = {
+    one,
+    many,
+    is: is_relation,
+};
+export default relation;
+//# sourceMappingURL=relation.js.map

package/lib/private/store.d.ts

@@ -0,0 +1,24 @@
+import type Init from "#store/Init";
+import Store from "#store/Store";
+import type StoreInput from "#store/StoreInput";
+declare function store<T extends StoreInput, const N extends string = string>(init: Init<T, N>): Store<T, N>;
+declare namespace store {
+    var key: {
+        foreign: typeof import("./store/ForeignKey.js").default.new;
+        primary: typeof import("./store/PrimaryKey.js").default.new;
+    };
+    var relation: {
+        one: <const N extends string, const FK extends string>(options: {
+            table: N;
+            by: FK;
+            reverse?: boolean;
+        }) => import("#store/relation").OneRelation<N, FK>;
+        many: <const N extends string, const FK extends string>(options: {
+            table: N;
+            by: FK;
+        }) => import("#store/relation").ManyRelation<N, FK>;
+        is: (x: unknown) => x is import("#store/relation").Relation;
+    };
+}
+export default store;
+//# sourceMappingURL=store.d.ts.map