@primate/core 0.4.6 → 0.6.0

package/lib/private/db/test.js

@@ -0,0 +1,1750 @@
+import { Code } from "#db/errors";
+import key from "#orm/key";
+import relation from "#orm/relation";
+import store from "#orm/store";
+import test from "@rcompat/test";
+import any from "@rcompat/test/any";
+import p from "pema";
+const BAD_WHERE = [
+    {
+        label: "reject array where value",
+        base: { name: ["Donald"] },
+        with: { title: ["foo a"] },
+        expected: Code.where_invalid_value,
+    },
+    {
+        label: "reject empty operator object",
+        base: { name: {} },
+        with: { title: {} },
+        expected: Code.operator_empty,
+    },
+    {
+        label: "reject undefined where value",
+        base: { age: undefined },
+        with: { title: undefined },
+        expected: Code.field_undefined,
+    },
+    {
+        label: "reject unknown operator",
+        base: { name: { $nope: "x" } },
+        with: { title: { $nope: "x" } },
+        expected: Code.operator_unknown,
+    },
+];
+const BAD_SELECT = [
+    {
+        label: "reject empty select",
+        base: [],
+        with: [],
+        expected: Code.select_empty,
+    },
+    {
+        label: "reject unknown select column",
+        base: ["nope"],
+        with: ["nope"],
+        expected: Code.field_unknown,
+    },
+    {
+        label: "reject duplicate select fields",
+        base: ["id", "id"],
+        with: ["id", "id"],
+        expected: Code.field_duplicate,
+    },
+];
+const BAD_SORT = [
+    {
+        label: "reject empty sort",
+        base: {},
+        with: {},
+        expected: Code.sort_empty,
+    },
+    {
+        label: "reject unknown sort column",
+        base: { nope: "asc" },
+        with: { nope: "asc" },
+        expected: Code.field_unknown,
+    },
+    {
+        label: "reject invalid direction",
+        base: { age: "ascending" },
+        with: { title: "ascending" },
+        expected: Code.sort_invalid_value,
+    },
+    {
+        label: "reject undefined direction",
+        base: { age: undefined },
+        with: { title: undefined },
+        expected: Code.sort_invalid_value,
+    },
+];
+const BAD_WHERE_COLUMN = [
+    {
+        label: "reject unknown criteria column",
+        base: { nope: "x" },
+        with: { nope: "x" },
+        expected: Code.field_unknown,
+    },
+];
+const USERS = {
+    ben: { age: 60, lastname: "Miller", name: "Ben" },
+    donald: { age: 30, lastname: "Duck", name: "Donald" },
+    jeremy: { age: 20, name: "Just Jeremy" },
+    paul: { age: 40, lastname: "Miller", name: "Paul" },
+    ryan: { age: 40, lastname: "Wilson", name: "Ryan" },
+};
+function pick(record, ...projection) {
+    return Object.fromEntries(Object.entries(record).filter(([k]) => projection.includes(k)));
+}
+async function throws(assert, code, fn) {
+    try {
+        await fn();
+        assert(false).true();
+    }
+    catch (error) {
+        assert(error.code).equals(code);
+    }
+}
+export default (db) => {
+    test.ended(() => db.close());
+    const Post = store({
+        name: "post",
+        db,
+        schema: {
+            id: key.primary(p.uuid),
+            title: p.string,
+            user_id: p.uint,
+        },
+    });
+    Post.update;
+    const User = store({
+        name: "user",
+        db,
+        schema: {
+            id: key.primary(p.uuid),
+            age: p.u8.optional(),
+            lastname: p.string.optional(),
+            name: p.string.default("Donald"),
+        },
+    });
+    const UserN = store({
+        name: "user_n",
+        db,
+        schema: {
+            id: key.primary(p.u32),
+            age: p.u8.optional(),
+            lastname: p.string.optional(),
+            name: p.string.default("Donald"),
+        },
+    });
+    const UserB = store({
+        name: "user_b",
+        db,
+        schema: {
+            id: key.primary(p.u128),
+            age: p.u8.optional(),
+            lastname: p.string.optional(),
+            name: p.string.default("Donald"),
+        },
+    });
+    const USER_STORES = [User, UserN, UserB];
+    const Type = store({
+        name: "type",
+        db,
+        schema: {
+            id: key.primary(p.uuid),
+            boolean: p.boolean.optional(),
+            date: p.date.optional(),
+            f32: p.f32.optional(),
+            f64: p.f64.optional(),
+            i128: p.i128.optional(),
+            i16: p.i16.optional(),
+            i32: p.i32.optional(),
+            i64: p.i64.optional(),
+            i8: p.i8.optional(),
+            string: p.string.optional(),
+            u128: p.u128.optional(),
+            u16: p.u16.optional(),
+            u32: p.u32.optional(),
+            u64: p.u64.optional(),
+            u8: p.u8.optional(),
+            json: p.json().optional(),
+        },
+    });
+    // this stresses identifier quoting in CREATE/INSERT/SELECT/UPDATE/DELETE
+    const Reserved = store({
+        // deliberately reserved-like table name
+        name: "select",
+        db,
+        schema: {
+            id: key.primary(p.uuid),
+            // deliberately reserved-looking column name
+            order: p.u8.optional(),
+            name: p.string,
+        },
+    });
+    const AuthorSchema = {
+        id: key.primary(p.uuid),
+        name: p.string,
+    };
+    const ArticleSchema = {
+        id: key.primary(p.uuid),
+        title: p.string,
+        author_id: key.foreign(p.uuid),
+    };
+    const ProfileSchema = {
+        id: key.primary(p.uuid),
+        bio: p.string,
+        url: p.url.optional(),
+        author_id: key.foreign(p.uuid),
+    };
+    const Author = store({
+        db,
+        name: "author",
+        schema: AuthorSchema,
+        relations: {
+            articles: relation.many(ArticleSchema, "author_id"),
+            profile: relation.one(ProfileSchema, "author_id"),
+        },
+    });
+    /*const AuthorWithJSON = store({
+      name: "author_json",
+      db,
+      schema: {
+        id: key.primary(p.uuid),
+        name: p.string,
+        meta: p.json(p({ views: p.u32, tags: p.array(p.string) })),
+        notes: p.json(),  // untyped
+      },
+    });*/
+    const Article = store({
+        db,
+        name: "article",
+        schema: ArticleSchema,
+        relations: {
+            author: relation.one(AuthorSchema, "author_id", { reverse: true }),
+        },
+    });
+    const Profile = store({
+        db,
+        name: "profile",
+        schema: ProfileSchema,
+        relations: {
+            author: relation.one(AuthorSchema, "author_id", { reverse: true }),
+        },
+    });
+    function $store(label, s, body) {
+        test.case(label, async (assert) => {
+            await s.table.create();
+            try {
+                await body(assert);
+            }
+            finally {
+                await s.table.delete();
+            }
+        });
+    }
+    function $user(label, body) {
+        test.case(label, async (assert) => {
+            for (const S of USER_STORES)
+                await S.table.create();
+            try {
+                for (const u of Object.values(USERS)) {
+                    for (const S of USER_STORES)
+                        await S.insert(u);
+                }
+                await body(assert);
+            }
+            finally {
+                for (const S of USER_STORES)
+                    await S.table.delete();
+            }
+        });
+    }
+    function $user$(label, body) {
+        $user(`security: ${label}`, body);
+    }
+    function $type(label, body) {
+        $store(`type: ${label}`, Type, body);
+    }
+    function $rel(label, body) {
+        test.case(`relation: ${label}`, async (assert) => {
+            await Author.table.create();
+            await Article.table.create();
+            await Profile.table.create();
+            try {
+                const john = await Author.insert({ name: "John" });
+                const bob = await Author.insert({ name: "Bob" });
+                const ned = await Author.insert({ name: "Ned" });
+                const jid = john.id;
+                const bid = bob.id;
+                const nid = ned.id;
+                await Article.insert({ title: "John First Post", author_id: jid });
+                await Article.insert({ title: "John Second Post", author_id: jid });
+                await Article.insert({ title: "Bob Only Post", author_id: bid });
+                await Profile.insert({
+                    bio: "John is a writer",
+                    url: new URL("https://example.com/john"),
+                    author_id: jid,
+                });
+                const ts = ["foo a", "foo c", "foo d", "foo e", "foo f", "foo g"];
+                for (const title of ts)
+                    await Article.insert({ title, author_id: jid });
+                await Article.insert({ title: "bar x", author_id: jid });
+                await Article.insert({ title: "foo b", author_id: bid });
+                await Article.insert({ title: "bar y", author_id: bid });
+                await Article.insert({ title: "bar z", author_id: nid });
+                await body(assert);
+            }
+            finally {
+                await Profile.table.delete();
+                await Article.table.delete();
+                await Author.table.delete();
+            }
+        });
+    }
+    function $rel$(label, body) {
+        $rel(`security: ${label}`, body);
+    }
+    function security_pair(base_prefix, label, mk, run_base, run_with, expected) {
+        const run = throws;
+        $user$(`${base_prefix}: ${label}`, async (assert) => {
+            const { base } = mk();
+            await run(assert, expected, () => run_base(base));
+        });
+        $rel$(`with: ${base_prefix}: ${label}`, async (assert) => {
+            const { with: w } = mk();
+            await run(assert, expected, () => run_with(w));
+        });
+    }
+    function bad_where(label, mk, expected) {
+        return security_pair("where", label, mk, base => User.find({ where: base }), w => Author.find({ with: { articles: { where: w } } }), expected);
+    }
+    function bad_select(label, mk, expected) {
+        return security_pair("find", label, mk, base => User.find({ select: base }), w => Author.find({ with: { articles: { select: w } } }), expected);
+    }
+    function bad_sort(label, mk, expected) {
+        return security_pair("find", label, mk, base => User.find({ sort: base }), w => Author.find({ with: { articles: { sort: w } } }), expected);
+    }
+    $store("insert", User, async (assert) => {
+        const donald = await User.insert({ age: 30, name: "Donald" });
+        assert(donald).type();
+        assert(await User.has(donald.id)).true();
+        const ryan = await User.insert({ age: 40, name: "Ryan" });
+        assert(await User.has(donald.id)).true();
+        assert(await User.has(ryan.id)).true();
+    });
+    $store("insert: primary key is optional (string)", User, async (assert) => {
+        const user = await User.insert({ name: "Test" });
+        assert(user.id).type();
+        assert(await User.has(user.id)).true();
+    });
+    $store("insert: primary key is optional (number)", UserN, async (assert) => {
+        const user = await UserN.insert({ name: "Test" });
+        assert(user.id).type();
+        assert(await UserN.has(user.id)).true();
+    });
+    $store("insert: primary key is optional (bigint)", UserB, async (assert) => {
+        const user = await UserB.insert({ name: "Test" });
+        assert(user.id).type();
+        assert(await UserB.has(user.id)).true();
+    });
+    const ManualUser = store({
+        name: "manual_user",
+        db,
+        schema: {
+            id: key.primary(p.uuid, { generate: false }),
+            name: p.string,
+        },
+    });
+    $store("insert: generate=false requires PK", ManualUser, async (assert) => {
+        await throws(assert, Code.pk_required, () => {
+            return ManualUser.insert({ name: "Test" });
+        });
+    });
+    $store("insert: generate=false accepts provided PK", ManualUser, async (assert) => {
+        const id = "4d0996db-bda9-4f95-ad7c-7075b10d4ba6";
+        const user = await ManualUser.insert({ id, name: "Test" });
+        assert(user.id).equals(id);
+        assert(await ManualUser.has(id)).true();
+    });
+    $store("insert: defaults apply", User, async (assert) => {
+        const u = await User.insert({});
+        assert(u.name).equals("Donald");
+    });
+    $store("insert: reject null values", User, async (assert) => {
+        await throws(assert, Code.null_not_allowed, () => {
+            // lastname is optional, but null is forbidden on insert
+            return User.insert({ name: "Nullman", lastname: null });
+        });
+    });
+    $user("find: empty object equals no options", async (assert) => {
+        const a = await User.find();
+        const b = await User.find({});
+        assert(a.length).equals(b.length);
+    });
+    $user("find: $like: handles regex metacharacters", async (assert) => {
+        await User.insert({ name: "A[1]" });
+        const got = await User.find({
+            where: { name: { $like: "A[1]" } },
+            select: ["name"],
+        });
+        assert(got.length).equals(1);
+        assert(got[0].name).equals("A[1]");
+    });
+    $user("find: types", async (assert) => {
+        const where = { name: "Ryan" };
+        assert(await User.find({ where })).type();
+        assert(await UserN.find({ where })).type();
+        assert(await UserB.find({ where })).type();
+    });
+    $user("find: select narrows type", async (assert) => {
+        const select = ["id", "name"];
+        const users = await User.find({ select });
+        assert(users).type();
+        const users_n = await UserN.find({ select });
+        assert(users_n).type();
+        const users_b = await UserB.find({ select });
+        assert(users_b).type();
+    });
+    $user("find: basic query", async (assert) => {
+        const result = await User.find({ where: { name: "Ryan" } });
+        assert(result.length).equals(1);
+    });
+    $user("find: sorting by multiple fields", async (assert) => {
+        // sorting by multiple fields: age descending, then Lastname ascending
+        const sorted = await User.find({
+            select: ["age", "name"],
+            sort: { age: "desc", lastname: "asc" },
+        });
+        assert(sorted.length).equals(5);
+        ["ben", "paul", "ryan", "donald", "jeremy"].forEach((user, i) => {
+            assert(sorted[i]).equals(pick(USERS[user], "name", "age"));
+        });
+        const descending = await User.find({
+            select: ["age", "name"],
+            sort: { age: "desc", lastname: "desc" },
+        });
+        const descended = ["ben", "ryan", "paul", "donald", "jeremy"];
+        descended.forEach((user, i) => {
+            assert(descending[i]).equals(pick(USERS[user], "name", "age"));
+        });
+    });
+    $user("find: sorting ascending and descending", async (assert) => {
+        const ascending = await User.find({
+            select: ["age", "name"],
+            sort: { age: "asc" },
+            limit: 2,
+        });
+        const ascended = ["jeremy", "donald"];
+        ascended.forEach((user, i) => {
+            assert(ascending[i]).equals(pick(USERS[user], "name", "age"));
+        });
+        const descending = await User.find({
+            select: ["age", "name"],
+            sort: { age: "desc" },
+            limit: 1,
+        });
+        assert(descending[0]).equals(pick(USERS.ben, "name", "age"));
+    });
+    $user("find: null criteria uses IS NULL semantics", async (assert) => {
+        // inserted fixtures include Jeremy without a lastname (NULL in DB)
+        // querying with { lastname: null } should find him
+        const rows = await User.find({
+            select: ["name", "lastname"],
+            where: { lastname: null },
+            sort: { name: "asc" },
+        });
+        assert(rows.length).equals(1);
+        if (rows.length > 0) {
+            assert(rows[0].name).equals("Just Jeremy");
+        }
+    });
+    $user("find: $like operator for strings", async (assert) => {
+        const prefix = await User.find({ where: { name: { $like: "J%" } } });
+        assert(prefix.length).equals(1);
+        if (prefix.length > 0)
+            assert(prefix[0].name).equals("Just Jeremy");
+        const suffix = await User.find({ where: { lastname: { $like: "%er" } } });
+        assert(suffix.length).equals(2);
+        const lastnames = suffix.map(u => u.lastname).sort();
+        assert(lastnames).equals(["Miller", "Miller"]);
+        const contains = await User.find({ where: { name: { $like: "%on%" } } });
+        assert(contains.length).equals(1);
+        if (contains.length > 0)
+            assert(contains[0].name).equals("Donald");
+        const exact = await User.find({ where: { name: { $like: "Ryan" } } });
+        assert(exact.length).equals(1);
+        if (exact.length > 0)
+            assert(exact[0].name).equals("Ryan");
+        const none = await User.find({ where: { name: { $like: "xyz%" } } });
+        assert(none.length).equals(0);
+    });
+    $user("find: $like with null/undefined fields", async (assert) => {
+        // Jeremy has no lastname (null), should not match ANY $like patterns
+        const results = await User.find({
+            where: { lastname: { $like: "%ll%" } },
+        });
+        assert(results.length).equals(2); // Ben, Paul
+        const names = results.map(u => u.name).sort();
+        assert(names).equals(["Ben", "Paul"]);
+    });
+    $user("find: $like: reject non-string types", async (assert) => {
+        await throws(assert, Code.operator_unknown, () => {
+            // age is u8, should not accept $like
+            return User.find({ where: { age: { $like: "30%" } } });
+        });
+    });
+    $user("update: single record", async (assert) => {
+        const [donald] = (await User.find({ where: { name: "Donald" } }));
+        await User.update(donald.id, { set: { age: 35 } });
+        const [updated] = (await User.find({ where: { name: "Donald" } }));
+        assert(updated.age).equals(35);
+        assert(updated).equals({ ...USERS.donald, age: 35, id: donald.id });
+    });
+    $user("update: unset fields", async (assert) => {
+        const [donald] = (await User.find({ where: { name: "Donald" } }));
+        assert(donald.age).equals(30);
+        await User.update(donald.id, { set: { age: null } });
+        const [updated] = (await User.find({ where: { name: "Donald" } }));
+        assert(updated.age).undefined();
+        const [paul] = (await User.find({ where: { name: "Paul" } }));
+        await User.update(paul.id, { set: { age: null, lastname: null } });
+        const [updated_paul] = (await User.find({ where: { name: "Paul" } }));
+        assert(updated_paul).equals({ id: updated_paul.id, name: "Paul" });
+    });
+    $user("update: cannot unset required fields", async (assert) => {
+        const [donald] = await User.find({ where: { name: "Donald" } });
+        await throws(assert, Code.null_not_allowed, () => {
+            // name is required (non-nullable) -> cannot be unset
+            return User.update(donald.id, { set: { name: null } });
+        });
+    });
+    $user("update: cannot unset required fields (multi-update)", async (assert) => {
+        await throws(assert, Code.null_not_allowed, () => {
+            return User.update({
+                where: { name: { $like: "D%" } },
+                set: { name: null },
+            });
+        });
+    });
+    $user("update: multiple records", async (assert) => {
+        const n_updated = await User.update({
+            where: { age: 40 },
+            set: { age: 45 },
+        });
+        assert(n_updated).equals(2);
+        const updated = await User.find({ where: { age: 45 } });
+        assert(updated.length).equals(2);
+    });
+    $user("update: where and changeset share a column", async (assert) => {
+        // Donald has age 30; update age using criteria on the same column
+        const n = await User.update({ where: { age: 30 }, set: { age: 31 } });
+        assert(n).equals(1);
+        assert(await User.count({ where: { age: 30 } })).equals(0);
+        assert(await User.count({ where: { age: 31 } })).equals(1);
+        const [donald] = await User.find({ where: { name: "Donald" } });
+        assert(donald.age).equals(31);
+    });
+    $rel("count: no with", async (assert) => {
+        await throws(assert, Code.count_with_invalid, async () => {
+            await Author.count({ with: { articles: true } });
+        });
+    });
+    $user("update: update all", async (assert) => {
+        await User.update({ set: { age: 99 } });
+        const users = await User.find();
+        for (const user of users)
+            assert(user.age).equals(99);
+    });
+    $user("update: $like criteria", async (assert) => {
+        // update all users whose names start with "J"
+        const updated = await User.update({
+            where: { name: { $like: "J%" } },
+            set: { age: 25 },
+        });
+        assert(updated).equals(1);
+        const jeremy = await User.find({ where: { name: "Just Jeremy" } });
+        assert(jeremy[0].age).equals(25);
+    });
+    $user("delete: single record", async (assert) => {
+        const [donald] = await User.find({ where: { name: "Donald" } });
+        await User.delete(donald.id);
+        const deleted = await User.find({ where: { name: "Donald" } });
+        assert(deleted.length).equals(0);
+    });
+    $user("delete: multiple records", async (assert) => {
+        const n = await User.delete({ where: { age: 40 } });
+        assert(n).equals(2);
+        const remaining = await User.find({ sort: { age: "asc" } });
+        assert(remaining.length).equals(3);
+        assert(remaining[0].name).equals("Just Jeremy");
+    });
+    $user("delete: $like criteria", async (assert) => {
+        // delete all users with "Miller" lastname
+        const deleted = await User.delete({
+            where: { lastname: { $like: "%Miller%" } },
+        });
+        assert(deleted).equals(2);
+        const remaining = await User.find();
+        assert(remaining.length).equals(3);
+        const remainingNames = remaining.map(u => u.name).sort();
+        assert(remainingNames).equals(["Donald", "Just Jeremy", "Ryan"]);
+    });
+    $user("count", async (assert) => {
+        assert(await User.count()).equals(5);
+        assert(await User.count({ where: { name: "Ryan" } })).equals(1);
+        assert(await User.count({ where: { age: 40 } })).equals(2);
+        assert(await User.count({ where: { age: 30 } })).equals(1);
+        assert(await User.count({ where: { age: 35 } })).equals(0);
+    });
+    $user("count: $like operator", async (assert) => {
+        assert(await User.count({ where: { name: { $like: "J%" } } })).equals(1);
+        assert(await User.count({ where: { lastname: { $like: "%er" } } }))
+            .equals(2);
+        assert(await User.count({ where: { name: { $like: "%xyz%" } } }))
+            .equals(0);
+    });
+    $user("has", async (assert) => {
+        const [donald] = await User.find({ where: { name: "Donald" } });
+        assert(await User.has(donald.id)).true();
+        await User.delete(donald.id);
+        assert(await User.has(donald.id)).false();
+    });
+    $type("boolean", async (assert) => {
+        const t = await Type.insert({ boolean: true });
+        assert(t.boolean).equals(true);
+        assert((await Type.get(t.id)).boolean).equals(true);
+        await Type.update(t.id, { set: { boolean: false } });
+        assert((await Type.get(t.id)).boolean).equals(false);
+    });
+    $type("string", async (assert) => {
+        const t = await Type.insert({ string: "foo" });
+        assert(t.string).equals("foo");
+        assert((await Type.get(t.id)).string).equals("foo");
+        await Type.update(t.id, { set: { string: "bar" } });
+        assert((await Type.get(t.id)).string).equals("bar");
+    });
+    $type("date", async (assert) => {
+        const now = new Date();
+        const t = await Type.insert({ date: now });
+        assert(t.date?.getTime()).equals(now.getTime());
+        assert((await Type.get(t.id)).date?.getTime()).equals(now.getTime());
+        const next = new Date();
+        await Type.update(t.id, { set: { date: next } });
+        assert((await Type.get(t.id)).date).equals(next);
+    });
+    $type("f32", async (assert) => {
+        const t = await Type.insert({ f32: 1.5 });
+        assert(t.f32).equals(1.5);
+        assert((await Type.get(t.id)).f32).equals(1.5);
+        await Type.update(t.id, { set: { f32: 123456.75 } });
+        assert((await Type.get(t.id)).f32).equals(123456.75);
+    });
+    $type("f64", async (assert) => {
+        const f1 = 123456.78901;
+        const t = await Type.insert({ f64: f1 });
+        assert(t.f64).equals(f1);
+        assert((await Type.get(t.id)).f64).equals(f1);
+        await Type.update(t.id, { set: { f32: 1.5 } });
+        assert((await Type.get(t.id)).f32).equals(1.5);
+    });
+    [8, 16, 32].forEach(n => {
+        $type(`i${n}`, async (assert) => {
+            const k = `i${n}`;
+            // lower bound
+            const lb = -(2 ** (n - 1));
+            const t = await Type.insert({ [k]: lb });
+            assert(t[any(k)]).equals(lb);
+            assert((await Type.get(t.id))[any(k)]).equals(lb);
+            // upper bound
+            const ub = 2 ** (n - 1) - 1;
+            await Type.update(t.id, { set: { [k]: ub } });
+            assert((await Type.get(t.id))[any(k)]).equals(ub);
+        });
+        $type(`u${n}`, async (assert) => {
+            const k = `u${n}`;
+            // lower bound
+            const lb = 0;
+            const t = await Type.insert({ [k]: lb });
+            assert(t[any(k)]).equals(lb);
+            assert((await Type.get(t.id))[any(k)]).equals(lb);
+            // upper bound
+            const ub = 2 ** n - 1;
+            await Type.update(t.id, { set: { [k]: ub } });
+            assert((await Type.get(t.id))[any(k)]).equals(ub);
+        });
+    });
+    [64n, 128n].forEach(i => {
+        $type(`i${i}`, async (assert) => {
+            const k = `i${i}`;
+            // lower bound
+            const lb = -(2n ** (i - 1n));
+            const t = await Type.insert({ [k]: lb });
+            assert(t[any(k)]).equals(lb);
+            assert((await Type.get(t.id))[any(k)]).equals(lb);
+            // upper bound
+            const ub = 2n ** (i - 1n) - 1n;
+            const tu = await Type.insert({ [k]: ub });
+            assert(tu[any(k)]).equals(ub);
+            assert((await Type.get(tu.id))[any(k)]).equals(ub);
+        });
+        $type(`u${i}`, async (assert) => {
+            const k = `u${i}`;
+            // lower bound
+            const lb = 0n;
+            const t = await Type.insert({ [k]: lb });
+            assert(t[any(k)]).equals(lb);
+            assert((await Type.get(t.id))[any(k)]).equals(lb);
+            // upper bound
+            const ub = 2n ** i - 1n;
+            const tu = await Type.insert({ [k]: ub });
+            assert(tu[any(k)]).equals(ub);
+            assert((await Type.get(tu.id))[any(k)]).equals(ub);
+        });
+    });
+    $user$("find: reject non-array select", async (assert) => {
+        await throws(assert, Code.select_invalid, () => {
+            return User.find({ select: {} });
+        });
+    });
+    $user$("find: projection limits fields", async (assert) => {
+        const records = await User.find({ select: ["id", "name"] });
+        assert(records.length).equals(5);
+        for (const r of records) {
+            // only id + name must be present
+            assert(Object.keys(r).toSorted()).equals(["id", "name"].toSorted());
+        }
+    });
+    $user$("update: reject unknown field on set", async (assert) => {
+        const [donald] = await User.find({ where: { name: "Donald" } });
+        await throws(assert, Code.field_unknown, () => {
+            return User.update(donald.id, { set: { nope: 1 } });
+        });
+    });
+    $user$("update: reject empty set object", async (assert) => {
+        const [donald] = await User.find({ where: { name: "Donald" } });
+        await throws(assert, Code.set_empty, () => {
+            return User.update(donald.id, { set: {} });
+        });
+    });
+    $user$("update: reject updating primary key", async (assert) => {
+        const [donald] = await User.find({ where: { name: "Donald" } });
+        await throws(assert, Code.pk_immutable, () => {
+            return User.update(donald.id, { set: { id: "nope" } });
+        });
+    });
+    $user$("update: reject missing set", async (assert) => {
+        await throws(assert, Code.set_empty, () => {
+            return User.update({ where: { name: "Donald" } });
+        });
+    });
+    $user$("delete: reject missing where", async (assert) => {
+        await throws(assert, Code.where_required, () => {
+            return User.delete({});
+        });
+    });
+    $user$("inject invalid identifier (where)", async (assert) => {
+        // attempted injection via bogus key
+        await throws(assert, Code.identifier_invalid, () => {
+            return User.find({ where: { "name; DROP TABLE user;": "x" } });
+        });
+    });
+    $user$("inject invalid identifier (select)", async (assert) => {
+        await throws(assert, Code.identifier_invalid, () => {
+            return User.find({ select: ["name; DROP TABLE user;"] });
+        });
+    });
+    $user$("value safety: does not interpolate values", async (assert) => {
+        const evil = "x' ; DROP TABLE user; --";
+        // should just behave like a normal string compare (0 matches), not explode
+        const rows = await User.find({ where: { name: evil } });
+        assert(rows.length).equals(0);
+        // table should still exist / be queryable
+        assert(await User.count()).equals(5);
+    });
+    $user$("update respects unset / binding map", async (assert) => {
+        const [paul] = await User.find({ where: { name: "Paul" } });
+        // allowed, lastname is optional
+        await User.update(paul.id, { set: { lastname: null } });
+        const [after] = await User.find({
+            select: ["id", "name", "lastname"],
+            where: { id: paul.id },
+        });
+        assert(after.lastname).undefined();
+    });
+    $user$("count: reject unknown where column", async (assert) => {
+        await throws(assert, Code.field_unknown, () => {
+            return User.count({ where: { nope: 1 } });
+        });
+    });
+    $user$("$like: reject unknown field", async (assert) => {
+        await throws(assert, Code.field_unknown, () => {
+            return User.find({ where: { unknown: { $like: "test%" } } });
+        });
+    });
+    $user$("insert: reject unknown column", async (assert) => {
+        await throws(assert, Code.field_unknown, () => {
+            return User.insert({ name: "X", nope: 1 });
+        });
+    });
+    $user$("update: reject unknown where column", async (assert) => {
+        await throws(assert, Code.field_unknown, () => User.update({
+            where: { nope: 1 },
+            set: { age: 1 },
+        }));
+    });
+    $user$("delete: reject unknown where column", async (assert) => {
+        await throws(assert, Code.field_unknown, () => User.delete({ where: { nope: 1 } }));
+    });
+    $user$("number operators: reject on non-number fields", async (assert) => {
+        await throws(assert, Code.operator_unknown, () => {
+            // name is string, should not accept $gte
+            return User.find({ where: { name: { $gte: 10 } } });
+        });
+    });
+    $user$("mixed operators: reject invalid combinations", async (assert) => {
+        await throws(assert, Code.operator_unknown, () => {
+            // can't mix string and number operators
+            return User.find({ where: { name: { $like: "test%", $gte: 5 } } });
+        });
+    });
+    $store("insert: reject null on required fields", User, async (assert) => {
+        await throws(assert, Code.null_not_allowed, () => {
+            // name is required, but passing null explicitly is still forbidden
+            return User.insert({ name: null });
+        });
+    });
+    $store("insert: omission stores NULL", User, async (assert) => {
+        const u = await User.insert({ name: "NoLast" });
+        const [got] = await User.find({
+            where: { id: u.id },
+            select: ["id", "name", "lastname"],
+        });
+        assert(got.id).equals(u.id);
+        assert(got.name).equals("NoLast");
+        // returned shape must not contain null
+        assert(got.lastname).undefined();
+    });
+    $store("insert: default fields can be omitted", User, async (assert) => {
+        // User has name: p.string.default("Donald")
+        // should be insertable without providing name
+        const user = await User.insert({ age: 30 });
+        assert(user.name).equals("Donald");
+    });
+    $store("reserved table / column names", Reserved, async (assert) => {
+        const a = await Reserved.insert({ name: "alpha", order: 1 });
+        const b = await Reserved.insert({ name: "beta", order: 2 });
+        const got = await Reserved.find({ where: { name: "alpha" } });
+        assert(got.length).equals(1);
+        assert(got[0]).equals({ id: a.id, name: "alpha", order: 1 });
+        // update using the reserved column
+        const n = await Reserved.update({
+            where: { name: "beta" },
+            set: { order: 9 },
+        });
+        assert(n).equals(1);
+        const [after] = await Reserved.find({ where: { id: b.id } });
+        assert(after.order).equals(9);
+        // and delete to complete the cycle
+        await Reserved.delete(a.id);
+        assert(await Reserved.has(a.id)).false();
+    });
+    $rel("get with one (reverse)", async (assert) => {
+        const articles = await Article.find();
+        const article = await Article.get(articles[0].id, {
+            with: {
+                author: true,
+            },
+        });
+        assert(article).type();
+        assert(article.author).not.null();
+        assert(article.author?.name).defined();
+    });
+    $rel("get with many", async (assert) => {
+        const [first] = await Author.find({ where: { name: "John" } });
+        const john = await Author.get(first.id, { with: { articles: true } });
+        assert(john.articles).type();
+        const titles = john.articles.map(a => a.title);
+        assert(titles.includes("John First Post")).true();
+        assert(titles.includes("John Second Post")).true();
+    });
+    $rel("get by id", async (assert) => {
+        const [first] = await Author.find({ where: { name: "John" } });
+        const john = await Author.get(first.id, { with: { profile: true } });
+        assert(john.profile).not.null();
+        assert(john.profile?.bio).equals("John is a writer");
+    });
+    $rel("get by id returns null when missing", async (assert) => {
+        const [first] = await Author.find({ where: { name: "Bob" } });
+        const bob = await Author.get(first.id, { with: { profile: true } });
+        assert(bob.profile).null();
+    });
+    $rel("find", async (assert) => {
+        const articles = await Article.find({
+            where: { title: { $like: "% Post" } },
+            with: { author: true },
+            sort: { title: "asc" },
+        });
+        assert(articles.length).equals(3);
+        for (const article of articles) {
+            assert(article.author).not.null();
+            assert(article.author?.name).defined();
+        }
+    });
+    $rel("try", async (assert) => {
+        const [first] = await Article.find();
+        const article = await Article.try(first.id, { with: { author: true } });
+        assert(article).defined();
+        assert(article?.author).not.null();
+    });
+    $rel("many returns empty array when no matches", async (assert) => {
+        // insert author with no articles
+        const lonely = await Author.insert({ name: "Lonely" });
+        const author = await Author.get(lonely.id, { with: { articles: true } });
+        assert(author.articles).type();
+        assert(author.articles.length).equals(0);
+    });
+    $rel("multiple relations in one query", async (assert) => {
+        const authors = await Author.find({ where: { name: "John" } });
+        const john = await Author.get(authors[0].id, {
+            with: {
+                articles: true,
+                profile: true,
+            },
+        });
+        const titles = john.articles.map(a => a.title);
+        assert(titles.includes("John First Post")).true();
+        assert(titles.includes("John Second Post")).true();
+        assert(john.profile).not.null();
+        assert(john.profile?.bio).equals("John is a writer");
+    });
+    $rel("no fields without 'with'", async (assert) => {
+        const articles = await Article.find();
+        const article = await Article.get(articles[0].id);
+        assert("author" in article).false();
+    });
+    $rel("find: complex relation subqueries", async (assert) => {
+        const SUBLIMIT = 5;
+        const authors = await Author.find({
+            select: ["id", "name"],
+            sort: { name: "asc" },
+            limit: 20,
+            with: {
+                articles: {
+                    where: { title: { $like: "%foo%" } },
+                    select: ["id", "title"],
+                    sort: { title: "asc" },
+                    limit: SUBLIMIT,
+                },
+                profile: true,
+            },
+        });
+        assert(authors).type();
+        // parents must *not* be filtered by relation where
+        const base = await Author.find({
+            select: ["id", "name"],
+            sort: { name: "asc" },
+            limit: 20,
+        });
+        assert(authors.map(r => r.name)).equals(base.map(r => r.name));
+        // base projection is respected (only id/name + relation keys)
+        for (const author of authors) {
+            assert(Object.keys(author).toSorted()).equals(["articles", "id", "name", "profile"].toSorted());
+        }
+        // per-parent relation correctness (filter + sort + limit)
+        for (const author of authors) {
+            // many => always array
+            assert(Array.isArray(author.articles)).true();
+            // projection + filter enforcement on returned relation rows
+            for (const article of author.articles) {
+                assert(Object.keys(article).toSorted()).equals(["id", "title"]
+                    .toSorted());
+                assert(article.title.includes("foo")).true();
+            }
+            // relation sort asc by title
+            const titles = author.articles.map(a => a.title);
+            assert([...titles].toSorted()).equals(titles);
+            // relation limit is per-parent
+            assert(author.articles.length <= SUBLIMIT).true();
+            // compare against base query (same semantics, explicit per-parent)
+            const expected = await Article.find({
+                where: { author_id: author.id, title: { $like: "%foo%" } },
+                select: ["id", "title"],
+                sort: { title: "asc" },
+            });
+            const expected_titles = expected.slice(0, SUBLIMIT).map(a => a.title);
+            assert(titles).equals(expected_titles);
+            // profile: one => null or full record, FK must point back
+            if (author.profile !== null) {
+                assert(Object.keys(author.profile).toSorted()).equals(["author_id", "bio", "id", "url"].toSorted());
+                assert(author.profile.author_id).equals(author.id);
+            }
+        }
+        // ensure the inner limit was actually used (needs > SUBLIMIT matches)
+        let used = false;
+        for (const author of authors) {
+            const n_foo = await Article.count({
+                where: { author_id: author.id, title: { $like: "%foo%" } },
+            });
+            if (n_foo > SUBLIMIT)
+                used = true;
+        }
+        assert(used).true();
+        const john = authors.find(r => r.name === "John");
+        if (john !== undefined) {
+            assert(john.profile).not.null();
+            assert(john.profile?.bio).equals("John is a writer");
+        }
+        // parent with *zero* matching related rows must still be present,
+        // and the many-relation must be [] (not missing / not null)
+        const ned = authors.find(a => a.name === "Ned");
+        assert(ned).defined();
+        assert(ned.articles).type();
+        assert(ned.articles.length).equals(0);
+        // and one-relation should be null when missing
+        assert(ned.profile).null();
+    });
+    $rel("type: select narrows nested types", async (assert) => {
+        const rows = await Author.find({
+            select: ["id"],
+            with: {
+                profile: { select: ["bio"] },
+                articles: { select: ["title"] },
+            },
+        });
+        assert(rows).type();
+        // runtime: selected base only has id (plus relation keys)
+        for (const r of rows)
+            assert("name" in r).false();
+    });
+    $rel$("with: reject unknown relation name", async (assert) => {
+        await throws(assert, Code.relation_unknown, () => {
+            return Author.find({ with: { nope: true } });
+        });
+    });
+    $user("get/try: missing id", async (assert) => {
+        const missing = "00000000-0000-4000-8000-000000000000";
+        // const missing = `missing-${Date.now()}-${Math.random()}`;
+        await throws(assert, Code.record_not_found, () => User.get(missing));
+        assert(await User.try(missing)).undefined();
+    });
+    $rel("get/try: missing id (with relations)", async (assert) => {
+        //const missing = `missing-${Date.now()}-${Math.random()}`;
+        const missing = "00000000-0000-4000-8000-000000000000";
+        await throws(assert, Code.record_not_found, () => Article.get(missing, { with: { author: true } }));
+        assert(await Article.try(missing, { with: { author: true } })).undefined();
+    });
+    $rel("get/try: missing id (+ parent)", async (assert) => {
+        const missing = "00000000-0000-4000-8000-000000000000";
+        //const missing = `missing-${Date.now()}-${Math.random()}`;
+        await throws(assert, Code.record_not_found, () => Author.get(missing, { with: { articles: true, profile: true } }));
+        assert(await Author.try(missing, {
+            with: { articles: true, profile: true },
+        })).undefined();
+    });
+    $user("try: does not swallow invalid options", async (assert) => {
+        const [u] = await User.find({ select: ["id"] });
+        await throws(assert, Code.select_empty, () => {
+            return User.try(u.id, { select: [] });
+        });
+    });
+    $type("where: treat date as literal value (not operator)", async (assert) => {
+        const d = new Date();
+        const inserted = await Type.insert({ date: d });
+        // to be treated as equality, not operator parsing.
+        const got = await Type.find({ where: { date: new Date(d.getTime()) } });
+        assert(got.length).equals(1);
+        assert(got[0].id).equals(inserted.id);
+    });
+    $type("where: number operators ($gt/$gte/$lt/$lte/$ne)", async (assert) => {
+        // use a marker to avoid cross-test interference if the DB isn't reset
+        await Type.insert({ string: "ops-num", u8: 201 });
+        await Type.insert({ string: "ops-num", u8: 202 });
+        await Type.insert({ string: "ops-num", u8: 203 });
+        const gt = await Type.find({
+            where: { string: "ops-num", u8: { $gt: 201 } },
+            sort: { u8: "asc" },
+        });
+        assert(gt.map(r => r.u8)).equals([202, 203]);
+        const between = await Type.find({
+            where: { string: "ops-num", u8: { $gte: 202, $lt: 203 } },
+        });
+        assert(between.length).equals(1);
+        assert(between[0].u8).equals(202);
+        const ne = await Type.find({
+            where: { string: "ops-num", u8: { $ne: 202 } },
+            sort: { u8: "asc" },
+        });
+        assert(ne.map(r => r.u8)).equals([201, 203]);
+        const lte = await Type.find({
+            where: { string: "ops-num", u8: { $lte: 202 } },
+            sort: { u8: "asc" },
+        });
+        assert(lte.map(r => r.u8)).equals([201, 202]);
+    });
+    $type("where: bigint operators ($gt/$gte/$lt/$lte/$ne)", async (assert) => {
+        await Type.insert({ string: "ops-big", u64: 201n });
+        await Type.insert({ string: "ops-big", u64: 202n });
+        await Type.insert({ string: "ops-big", u64: 203n });
+        const gt = await Type.find({
+            where: { string: "ops-big", u64: { $gt: 201n } },
+            sort: { u64: "asc" },
+        });
+        assert(gt.map(r => r.u64)).equals([202n, 203n]);
+        const between = await Type.find({
+            where: { string: "ops-big", u64: { $gte: 202n, $lt: 203n } },
+        });
+        assert(between.length).equals(1);
+        assert(between[0].u64).equals(202n);
+        const ne = await Type.find({
+            where: { string: "ops-big", u64: { $ne: 202n } },
+            sort: { u64: "asc" },
+        });
+        assert(ne.map(r => r.u64)).equals([201n, 203n]);
+    });
+    $type("where: datetime operators ($before/$after/$ne)", async (assert) => {
+        const d1 = new Date("2020-01-01T00:00:00.000Z");
+        const d2 = new Date("2020-01-02T00:00:00.000Z");
+        const d3 = new Date("2020-01-03T00:00:00.000Z");
+        await Type.insert({ string: "ops-date", date: d1 });
+        await Type.insert({ string: "ops-date", date: d2 });
+        await Type.insert({ string: "ops-date", date: d3 });
+        const before = await Type.find({
+            where: { string: "ops-date", date: { $before: d2 } },
+            sort: { date: "asc" },
+        });
+        assert(before.map(r => r.date.getTime())).equals([d1.getTime()]);
+        const after = await Type.find({
+            where: { string: "ops-date", date: { $after: d2 } },
+            sort: { date: "asc" },
+        });
+        assert(after.map(r => r.date.getTime())).equals([d3.getTime()]);
+        const ne = await Type.find({
+            where: { string: "ops-date", date: { $ne: d2 } },
+            sort: { date: "asc" },
+        });
+        assert(ne.map(r => r.date.getTime()))
+            .equals([d1.getTime(), d3.getTime()]);
+    });
+    $type("where: operator validation errors", async (assert) => {
+        await throws(assert, Code.operator_empty, () => {
+            return Type.find({ where: { u8: {} } });
+        });
+        // string/time: only $like
+        await throws(assert, Code.operator_unknown, () => {
+            return Type.find({ where: { string: { $gt: 1 } } });
+        });
+        // number: no $like
+        await throws(assert, Code.operator_unknown, () => {
+            return Type.find({ where: { u8: { $like: "x" } } });
+        });
+        // datetime: no $gt
+        await throws(assert, Code.operator_unknown, () => {
+            return Type.find({ where: { date: { $gt: new Date() } } });
+        });
+        await throws(assert, Code.wrong_type, () => {
+            return Type.find({ where: { u8: { $gt: "nope" } } });
+        });
+        await throws(assert, Code.wrong_type, () => {
+            return Type.find({ where: { date: { $before: "nope" } } });
+        });
+    });
+    $type("where: combined operators on same field", async (assert) => {
+        await Type.insert({ string: "combo", u8: 100 });
+        await Type.insert({ string: "combo", u8: 150 });
+        await Type.insert({ string: "combo", u8: 200 });
+        const results = await Type.find({
+            where: {
+                string: "combo",
+                u8: { $gte: 150, $ne: 200 },
+            },
+            sort: { u8: "asc" },
+        });
+        assert(results.map(r => r.u8)).equals([150]);
+    });
+    $type("json: opaque roundtrip", async (assert) => {
+        const json = { a: 1, b: [true, "x"], c: null };
+        const t = await Type.insert({ json });
+        assert(t.json).equals(json);
+        assert((await Type.get(t.id)).json).equals(json);
+    });
+    $type("json: update", async (assert) => {
+        const t = await Type.insert({ json: { x: 1 } });
+        await Type.update(t.id, { set: { json: { x: 2, y: "hello" } } });
+        assert((await Type.get(t.id)).json).equals({ x: 2, y: "hello" });
+    });
+    $type("json: nested object", async (assert) => {
+        const value = { outer: { inner: { deep: true } } };
+        const t = await Type.insert({ json: value });
+        assert((await Type.get(t.id)).json).equals(value);
+    });
+    $type("json: array at root", async (assert) => {
+        const value = [1, "two", false, null];
+        const t = await Type.insert({ json: value });
+        assert((await Type.get(t.id)).json).equals(value);
+    });
+    $type("json: null value unsets field", async (assert) => {
+        const t = await Type.insert({ json: { x: 1 } });
+        await Type.update(t.id, { set: { json: null } });
+        assert((await Type.get(t.id)).json).undefined();
+    });
+    $type("json: empty object", async (assert) => {
+        const t = await Type.insert({ json: {} });
+        assert((await Type.get(t.id)).json).equals({});
+    });
+    $type("json: empty array", async (assert) => {
+        const t = await Type.insert({ json: [] });
+        assert((await Type.get(t.id)).json).equals([]);
+    });
+    $type("json: primitive string", async (assert) => {
+        const t = await Type.insert({ json: "hello" });
+        assert((await Type.get(t.id)).json).equals("hello");
+    });
+    $type("json: primitive number", async (assert) => {
+        const t = await Type.insert({ json: 42 });
+        assert((await Type.get(t.id)).json).equals(42);
+    });
+    $type("json: primitive float", async (assert) => {
+        const t = await Type.insert({ json: 3.14 });
+        assert((await Type.get(t.id)).json).equals(3.14);
+    });
+    $type("json: primitive boolean true", async (assert) => {
+        const t = await Type.insert({ json: true });
+        assert((await Type.get(t.id)).json).equals(true);
+    });
+    $type("json: primitive boolean false", async (assert) => {
+        const t = await Type.insert({ json: false });
+        assert((await Type.get(t.id)).json).equals(false);
+    });
+    $type("json: null inside object survives roundtrip", async (assert) => {
+        const value = { a: 1, b: null };
+        const t = await Type.insert({ json: value });
+        assert((await Type.get(t.id)).json).equals({ a: 1, b: null });
+    });
+    $type("json: null inside array survives roundtrip", async (assert) => {
+        const value = [1, null, "three"];
+        const t = await Type.insert({ json: value });
+        assert((await Type.get(t.id)).json).equals([1, null, "three"]);
+    });
+    $store("where: null matches omitted optional field", User, async (assert) => {
+        const u = await User.insert({ name: "NoLast" });
+        const rows = await User.find({
+            where: { id: u.id, lastname: null },
+            select: ["id"],
+        });
+        assert(rows.length).equals(1);
+        assert(rows[0].id).equals(u.id);
+    });
+    /*$store("json column: inferred type on insert", AuthorWithJSON, async assert => {
+      const author = await AuthorWithJSON.insert({
+        name: "John",
+        articles: [{ title: "First", published: new Date() }],
+        meta: { views: 0, tags: ["typescript"] },
+      });
+  
+      assert(author).type<{
+        id: string;
+        name: string;
+        articles?: { title: string; published: Date }[];
+        meta?: { views: number; tags: string[] };
+        notes?: JSONValue;
+      }>();
+    });
+  
+    $store("json column: inferred type on find", AuthorWithJSON, async assert => {
+      const authors = await AuthorWithJSON.find();
+      assert(authors).type<{
+        id: string;
+        name: string;
+        articles?: { title: string; published: Date }[];
+        meta?: { views: number; tags: string[] };
+        notes?: JSONValue;
+      }[]>();
+    });
+  
+    $store("json column: inferred type on get", AuthorWithJSON, async assert => {
+      const a = await AuthorWithJSON.insert({
+        name: "John",
+        articles: [{ title: "First", published: new Date() }],
+        meta: { views: 0, tags: ["typescript"] },
+      });
+      const author = await AuthorWithJSON.get(a.id);
+  
+      assert(author.articles).type<{ title: string; published: Date }[] | undefined>();
+      assert(author.meta).type<{ views: number; tags: string[] } | undefined>();
+      assert(author.notes).type<JSONValue | undefined>();
+  
+      // inner field access fully typed
+      assert(author.articles?.[0].title).type<string | undefined>();
+      assert(author.articles?.[0].published).type<Date | undefined>();
+    });
+  
+    $store("json column: roundtrip preserves types", AuthorWithJSON, async assert => {
+      const now = new Date();
+      const a = await AuthorWithJSON.insert({
+        name: "John",
+        articles: [{ title: "First", published: now }],
+        meta: { views: 42, tags: ["ts", "primate"] },
+      });
+  
+      const author = await AuthorWithJSON.get(a.id);
+  
+      assert(author.articles?.[0].title).equals("First");
+      assert(author.articles?.[0].published?.getTime()).equals(now.getTime());
+      assert(author.meta?.views).equals(42);
+      assert(author.meta?.tags).equals(["ts", "primate"]);
+    });
+  
+    $store("json column: nested where is typed", AuthorWithJSON, async assert => {
+      // these should compile
+      await AuthorWithJSON.find({ where: { articles: { title: "First" } } });
+      await AuthorWithJSON.find({ where: { meta: { views: { $gt: 10 } } } });
+      await AuthorWithJSON.find({ where: { meta: { tags: { $like: "%ts%" } } } });
+  
+      // $contains always available, untyped
+      await AuthorWithJSON.find({ where: { articles: { $contains: { title: "First" } } } });
+    });*/
+    $user("where: null matches unset via update", async (assert) => {
+        const [paul] = await User.find({ where: { name: "Paul" } });
+        await User.update(paul.id, { set: { lastname: null } });
+        const rows = await User.find({
+            where: { id: paul.id, lastname: null },
+            select: ["id"],
+        });
+        assert(rows.length).equals(1);
+        assert(rows[0].id).equals(paul.id);
+    });
+    $user("find: $like: underscore is single-character *", async (assert) => {
+        await User.insert({ name: "A1" });
+        await User.insert({ name: "A12" });
+        const one = await User.find({
+            where: { name: { $like: "A_" } },
+            select: ["name"],
+            sort: { name: "asc" },
+        });
+        assert(one.map(r => r.name)).equals(["A1"]);
+        const two = await User.find({
+            where: { name: { $like: "A__" } },
+            select: ["name"],
+            sort: { name: "asc" },
+        });
+        assert(two.map(r => r.name)).equals(["A12"]);
+    });
+    $user("find: $like: question mark is literal", async (assert) => {
+        await User.insert({ name: "A?" });
+        await User.insert({ name: "A1" });
+        const got = await User.find({
+            where: { name: { $like: "A?" } },
+            select: ["name"],
+            sort: { name: "asc" },
+        });
+        // '?' means only one character
+        assert(got.map(r => r.name)).equals(["A?"]);
+    });
+    $rel("try: does not swallow invalid relation name", async (assert) => {
+        const [row] = await Article.find({ select: ["id"] });
+        await throws(assert, Code.relation_unknown, () => {
+            // programmer error: should throw, not return undefined
+            return Article.try(row.id, { with: { nope: true } });
+        });
+    });
+    $rel$("with: reject non-array relation select", async (assert) => {
+        await throws(assert, Code.select_invalid, () => {
+            return Author.find({
+                with: {
+                    articles: {
+                        select: {}, // must be array
+                    },
+                },
+            });
+        });
+    });
+    $rel$("with: reject non-uint relation limit", async (assert) => {
+        await throws(assert, Code.limit_invalid, () => {
+            return Author.find({
+                with: {
+                    articles: {
+                        limit: -1, // must be uint
+                    },
+                },
+            });
+        });
+    });
+    $rel("one relation returns null when FK missing", async (assert) => {
+        const author_id = "4d0996db-bda9-4f95-ad7c-7075b10d4ba6";
+        const orphan = await Article.insert({
+            title: "Orphan",
+            author_id,
+        });
+        const got = await Article.get(orphan.id, { with: { author: true } });
+        assert(got.author).null();
+    });
+    $user("get/try: happy path", async (assert) => {
+        const [u] = await User.find({ where: { name: "Donald" } });
+        const got = await User.get(u.id);
+        assert(got.id).equals(u.id);
+        const tried = await User.try(u.id);
+        assert(tried?.id).equals(u.id);
+    });
+    $user$("find: unknown option keys throw", async (assert) => {
+        await throws(assert, Code.option_unknown, () => {
+            // wrong call-shape (looks like where but isn't nested)
+            return User.find({ name: "John" });
+        });
+        await throws(assert, Code.option_unknown, () => {
+            // totally unknown option
+            return User.find({ banana: true });
+        });
+    });
+    $user("find: $like is case-sensitive", async (assert) => {
+        await User.insert({ name: "MiXeDCase" });
+        const no = await User.find({ where: { name: { $like: "mixed%" } } });
+        assert(no.length).equals(0);
+        const yes = await User.find({ where: { name: { $like: "MiXeD%" } } });
+        assert(yes.length).equals(1);
+        assert(yes[0].name).equals("MiXeDCase");
+    });
+    $user("find: $ilike is case-insensitive", async (assert) => {
+        await User.insert({ name: "MiXeDCase2" });
+        const rows = await User.find({ where: { name: { $ilike: "mixed%" } } });
+        assert(rows.length).equals(1);
+        assert(rows[0].name).equals("MiXeDCase2");
+    });
+    $user$("get: unknown option keys throw", async (assert) => {
+        const u = await User.insert({ name: "Guard", age: 1 });
+        await throws(assert, Code.option_unknown, () => {
+            // get only accepts { select?, with? }
+            return User.get(u.id, { where: { name: "Guard" } });
+        });
+        await throws(assert, Code.option_unknown, () => {
+            return User.get(u.id, { sort: { name: "asc" } });
+        });
+        await throws(assert, Code.option_unknown, () => {
+            return User.get(u.id, { banana: true });
+        });
+    });
+    $user$("inject invalid identifier (table name)", async (assert) => {
+        await throws(assert, Code.identifier_invalid, () => {
+            store({
+                name: "users; DROP TABLE users",
+                db,
+                schema: {
+                    id: key.primary(p.uuid),
+                },
+            });
+        });
+    });
+    $user("find: $like: literal percent sign", async (assert) => {
+        await User.insert({ name: "100% complete" });
+        await User.insert({ name: "100 complete" });
+        const got = await User.find({
+            where: { name: { $like: "100\\% complete" } },
+            select: ["name"],
+        });
+        assert(got.length).equals(1);
+        assert(got[0].name).equals("100% complete");
+    });
+    $user("find: $like: literal underscore", async (assert) => {
+        await User.insert({ name: "file_name" });
+        await User.insert({ name: "file1name" });
+        const got = await User.find({
+            where: { name: { $like: "file\\_name" } },
+            select: ["name"],
+        });
+        assert(got.length).equals(1);
+        assert(got[0].name).equals("file_name");
+    });
+    $rel("with + select (no id)", async (assert) => {
+        const rows = await Author.find({
+            select: ["name"],
+            with: { articles: { select: ["title"], sort: { title: "asc" } } },
+            sort: { name: "asc" },
+        });
+        // no id leaked
+        for (const r of rows)
+            assert("id" in r).false();
+        // but relations are loaded
+        const john = rows.find(r => r.name === "John");
+        assert(Array.isArray(john.articles)).true();
+        assert(john.articles.length).nequals(0);
+    });
+    $rel("with: relation fields are decoded (URL)", async (assert) => {
+        const [first] = await Author.find({ where: { name: "John" } });
+        const john = await Author.get(first.id, {
+            with: { profile: true },
+        });
+        assert(john.profile).not.null();
+        // this is the whole point: driver must unbind it
+        assert(john.profile.url).type();
+        assert(john.profile.url instanceof URL).true();
+        assert(john.profile.url?.href).equals("https://example.com/john");
+    });
+    $rel("reverse one: with + select (no author_id) still loads relation", async (assert) => {
+        const [row] = await Article.find({ select: ["id"] });
+        const got = await Article.get(row.id, {
+            select: ["title"], // intentionally omit author_id
+            with: { author: true },
+        });
+        assert("author_id" in got).false(); // stripped
+        assert(got.author).not.null();
+    });
+    $rel("with: joined relations decode URL fields (base + rel)", async (assert) => {
+        const ParentSchema = {
+            id: key.primary(p.uuid),
+            name: p.string,
+            url: p.url.optional(),
+        };
+        const ChildSchema = {
+            id: key.primary(p.uuid),
+            parent_id: key.foreign(p.uuid),
+            url: p.url.optional(),
+        };
+        const Parent = store({
+            name: "j_parent",
+            db,
+            schema: ParentSchema,
+            relations: {
+                children: relation.many(ChildSchema, "parent_id"),
+            },
+        });
+        const Child = store({
+            db,
+            name: "j_child",
+            schema: ChildSchema,
+            relations: {
+                parent: relation.one(ParentSchema, "parent_id", { reverse: true }),
+            },
+        });
+        await Parent.table.create();
+        await Child.table.create();
+        try {
+            const p0 = await Parent.insert({
+                name: "P0",
+                url: new URL("https://example.com/parent"),
+            });
+            await Child.insert({
+                parent_id: p0.id,
+                url: new URL("https://example.com/joined"),
+            });
+            // IMPORTANT: force joined path + projection that omits pk, but still must join.
+            const [got] = await Parent.find({
+                where: { id: p0.id },
+                select: ["url"],
+                with: { children: true },
+            });
+            assert(got).defined();
+            // pk must not leak
+            assert("id" in got).false();
+            // ---- base assertion (should fail if joined base isn't unbound/decoded)
+            assert(got.url).type();
+            assert(got.url instanceof URL).true();
+            assert(got.url.href).equals("https://example.com/parent");
+            // ---- relation assertion (should fail if joined relation isn't unbound/decoded)
+            assert(Array.isArray(got.children)).true();
+            assert(got.children.length).equals(1);
+            const c0 = got.children[0];
+            assert(c0.url).type();
+            assert(c0.url instanceof URL).true();
+            assert(c0.url.href).equals("https://example.com/joined");
+        }
+        finally {
+            await Child.table.delete();
+            await Parent.table.delete();
+        }
+    });
+    $rel("find: limit applies to parent rows, not joined rows", async (assert) => {
+        const authors = await Author.find({
+            limit: 2,
+            sort: { name: "asc" },
+            with: { articles: true },
+        });
+        assert(authors.length).equals(2);
+    });
+    for (const c of BAD_WHERE) {
+        bad_where(c.label, () => ({ base: c.base, with: c.with }), c.expected);
+    }
+    for (const c of BAD_SELECT) {
+        bad_select(c.label, () => ({ base: c.base, with: c.with }), c.expected);
+    }
+    for (const c of BAD_SORT) {
+        bad_sort(c.label, () => ({ base: c.base, with: c.with }), c.expected);
+    }
+    for (const c of BAD_WHERE_COLUMN) {
+        bad_where(c.label, () => ({ base: c.base, with: c.with }), c.expected);
+    }
+    test.case("store: relation name conflicts with field throws", async (assert) => {
+        await throws(assert, Code.relation_conflicts_with_field, async () => store({
+            name: "conflict",
+            db,
+            schema: {
+                id: key.primary(p.uuid),
+                articles: p.string,
+            },
+            relations: {
+                articles: relation.many(ArticleSchema, "author_id"),
+            },
+        }));
+    });
+    // introspect: returns null for non-existent table
+    test.case("schema: introspect non-existent", async (assert) => {
+        assert(await db.schema.introspect("no_such_table")).null();
+    });
+    // UUID pk (User): wrong JS type
+    $store("pk: get rejects non-string for uuid pk", User, async (assert) => {
+        await throws(assert, Code.pk_invalid, () => User.get(123));
+    });
+    $store("pk: has rejects non-string for uuid pk", User, async (assert) => {
+        await throws(assert, Code.pk_invalid, () => User.has(123));
+    });
+    $store("pk: delete rejects non-string for uuid pk", User, async (assert) => {
+        await throws(assert, Code.pk_invalid, () => User.delete(123));
+    });
+    $store("pk: update rejects non-string for uuid pk", User, async (assert) => {
+        await throws(assert, Code.pk_invalid, () => User.update(123, { set: { name: "x" } }));
+    });
+    // UUID pk (User): valid JS type but malformed UUID
+    $store("pk: get rejects malformed uuid", User, async (assert) => {
+        await throws(assert, Code.pk_invalid, () => User.get("not-a-uuid"));
+    });
+    $store("pk: has rejects malformed uuid", User, async (assert) => {
+        await throws(assert, Code.pk_invalid, () => User.has("not-a-uuid"));
+    });
+    $store("pk: delete rejects malformed uuid", User, async (assert) => {
+        await throws(assert, Code.pk_invalid, () => User.delete("not-a-uuid"));
+    });
+    $store("pk: update rejects malformed uuid", User, async (assert) => {
+        await throws(assert, Code.pk_invalid, () => User.update("not-a-uuid", { set: { name: "x" } }));
+    });
+    // Numeric pk (UserN u32): wrong JS type
+    $store("pk: get rejects string for numeric pk", UserN, async (assert) => {
+        await throws(assert, Code.pk_invalid, () => UserN.get("abc"));
+    });
+    $store("pk: has rejects string for numeric pk", UserN, async (assert) => {
+        await throws(assert, Code.pk_invalid, () => UserN.has("abc"));
+    });
+    $store("pk: delete rejects string for numeric pk", UserN, async (assert) => {
+        await throws(assert, Code.pk_invalid, () => UserN.delete("abc"));
+    });
+    $store("pk: update rejects string for numeric pk", UserN, async (assert) => {
+        await throws(assert, Code.pk_invalid, () => UserN.update("abc", { set: { name: "x" } }));
+    });
+    // Numeric pk (UserN u32): negative value
+    $store("pk: get rejects negative for unsigned pk", UserN, async (assert) => {
+        await throws(assert, Code.pk_invalid, () => UserN.get(-1));
+    });
+    // Bigint pk (UserB u128): wrong JS type
+    $store("pk: get rejects string for bigint pk", UserB, async (assert) => {
+        await throws(assert, Code.pk_invalid, () => UserB.get("abc"));
+    });
+    $store("pk: get rejects negative for unsigned bigint pk", UserB, async (assert) => {
+        await throws(assert, Code.pk_invalid, () => UserB.get(-1n));
+    });
+    // introspect: returns correct types after create
+    $store("schema: introspect after create", User, async (assert) => {
+        // insert a record so MongoDB has something to sample
+        await User.insert({ name: "test", age: 1, lastname: "test" });
+        const types = await db.schema.introspect(User.name, User.pk);
+        assert(types).not.null();
+        if (types !== null) {
+            assert(types.id).includes("uuid");
+            assert(types.name).includes("string");
+            assert(types.age).includes("u8");
+            assert(types.lastname).includes("string");
+        }
+    });
+    // alter: add a field
+    $store("schema: alter add", User, async (assert) => {
+        await db.schema.alter("user", {
+            add: { email: "string" }, drop: [], rename: [],
+        });
+        const MigratedUser = store({
+            name: "user",
+            db,
+            schema: {
+                id: key.primary(p.uuid),
+                age: p.u8.optional(),
+                lastname: p.string.optional(),
+                name: p.string.default("Donald"),
+                email: p.string.email(),
+            },
+        });
+        await MigratedUser.insert({ name: "test", age: 1, email: "test@test.com" });
+        const types = await db.schema.introspect("user");
+        assert(types.email).includes("string");
+    });
+    // alter: drop a field
+    $store("schema: alter drop", User, async (assert) => {
+        await db.schema.alter("user", { add: {}, drop: ["lastname"], rename: [] });
+        const types = await db.schema.introspect("user");
+        assert(types.lastname).undefined();
+    });
+    // alter: rename a field
+    $store("schema: alter rename", User, async (assert) => {
+        await db.schema.alter("user", {
+            add: {}, drop: [], rename: [["lastname", "surname"]],
+        });
+        const MigratedUser = store({
+            name: "user",
+            db,
+            schema: {
+                id: key.primary(p.uuid),
+                age: p.u8.optional(),
+                surname: p.string.optional(),
+                name: p.string.default("Donald"),
+            },
+        });
+        await MigratedUser.insert({ name: "Donald", surname: "Adams" });
+        const types = await db.schema.introspect("user");
+        assert(types.lastname).undefined();
+        assert(types.surname).includes("string");
+    });
+    // alter: combined add + drop
+    $store("schema: alter add and drop", User, async (assert) => {
+        await db.schema.alter("user", {
+            add: { email: "string" }, drop: ["lastname"], rename: [],
+        });
+        const MigratedUser = store({
+            name: "user",
+            db,
+            schema: {
+                id: key.primary(p.uuid),
+                age: p.u8.optional(),
+                name: p.string.default("Donald"),
+                email: p.string.email(),
+            },
+        });
+        await MigratedUser.insert({ name: "Donald", email: "test@test.com" });
+        const types = await db.schema.introspect("user");
+        assert(types.email).includes("string");
+        assert(types.lastname).undefined();
+    });
+    const UUIDTest = store({
+        name: "uuid_test",
+        db,
+        schema: {
+            id: key.primary(p.uuid),
+            uuid: p.uuid,
+            uuid_v4: p.uuid.v4(),
+            uuid_v7: p.uuid.v7(),
+        },
+    });
+    $store("uuid: round-trips uuid column", UUIDTest, async (assert) => {
+        const uuid = "4d0996db-bda9-4f95-ad7c-7075b10d4ba6"; // any valid uuid
+        const uuid_v4 = "7c9e6679-7425-40de-944b-e07fc1f90ae7"; // distinct v4
+        const uuid_v7 = "01932b6e-5a2f-7e4f-9a3b-4f6d2c8b1a0e"; // v7
+        const row = await UUIDTest.insert({ uuid, uuid_v4, uuid_v7 });
+        assert(row.uuid).equals(uuid).type();
+        assert(row.uuid_v4).equals(uuid_v4).type();
+        assert(row.uuid_v7).equals(uuid_v7).type();
+        const fetched = await UUIDTest.get(row.id);
+        assert(fetched.uuid).equals(uuid);
+        assert(fetched.uuid_v4).equals(uuid_v4);
+        assert(fetched.uuid_v7).equals(uuid_v7);
+    });
+    test.case("schema: alter non-existent throws", async (assert) => {
+        await throws(assert, Code.table_not_found, () => db.schema.alter("no_such_table", {
+            add: { email: "string" }, drop: [], rename: [],
+        }));
+    });
+};
+//# sourceMappingURL=test.js.map