@primate/core 0.5.0 → 0.6.0

package/lib/private/db/test.js

@@ -1,7 +1,7 @@
-import { Code } from "#db/error";
+import { Code } from "#db/errors";
 import key from "#orm/key";
 import relation from "#orm/relation";
-import Store from "#orm/Store";
+import store from "#orm/store";
 import test from "@rcompat/test";
 import any from "@rcompat/test/any";
 import p from "pema";
@@ -106,108 +106,147 @@ async function throws(assert, code, fn) {
 }
 export default (db) => {
     test.ended(() => db.close());
-    const Post = new Store({
-        id: key.primary(p.string),
-        title: p.string,
-        user_id: p.uint,
-    }, { db, name: "post" });
+    const Post = store({
+        name: "post",
+        db,
+        schema: {
+            id: key.primary(p.uuid),
+            title: p.string,
+            user_id: p.uint,
+        },
+    });
     Post.update;
-    const User = new Store({
-        id: key.primary(p.string),
-        age: p.u8.optional(),
-        lastname: p.string.optional(),
-        name: p.string.default("Donald"),
-    }, { db: db, name: "user" });
-    const UserN = new Store({
-        id: key.primary(p.u32),
-        age: p.u8.optional(),
-        lastname: p.string.optional(),
-        name: p.string.default("Donald"),
-    }, { db: db, name: "user_n" });
-    const UserB = new Store({
-        id: key.primary(p.u128),
-        age: p.u8.optional(),
-        lastname: p.string.optional(),
-        name: p.string.default("Donald"),
-    }, { db: db, name: "user_b" });
+    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 = new Store({
-        id: key.primary(p.string),
-        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(),
-    }, { db: db, name: "type" });
+    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 = new Store({
-        id: key.primary(p.string),
-        // deliberately reserved-looking column name
-        order: p.u8.optional(),
-        name: p.string,
-    }, { db: db, name: "select" }); // deliberately reserved-like table name
+    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.string),
+        id: key.primary(p.uuid),
         name: p.string,
     };
     const ArticleSchema = {
-        id: key.primary(p.string),
+        id: key.primary(p.uuid),
         title: p.string,
-        author_id: key.foreign(p.string),
+        author_id: key.foreign(p.uuid),
     };
     const ProfileSchema = {
-        id: key.primary(p.string),
+        id: key.primary(p.uuid),
         bio: p.string,
         url: p.url.optional(),
-        author_id: key.foreign(p.string),
+        author_id: key.foreign(p.uuid),
     };
-    const Author = new Store(AuthorSchema, {
+    const Author = store({
         db,
         name: "author",
+        schema: AuthorSchema,
         relations: {
             articles: relation.many(ArticleSchema, "author_id"),
             profile: relation.one(ProfileSchema, "author_id"),
         },
     });
-    const Article = new Store(ArticleSchema, {
+    /*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 = new Store(ProfileSchema, {
+    const Profile = store({
         db,
         name: "profile",
+        schema: ProfileSchema,
         relations: {
             author: relation.one(AuthorSchema, "author_id", { reverse: true }),
         },
     });
-    function $store(label, store, body) {
+    function $store(label, s, body) {
         test.case(label, async (assert) => {
-            await store.collection.create();
+            await s.table.create();
             try {
                 await body(assert);
             }
             finally {
-                await store.collection.delete();
+                await s.table.delete();
             }
         });
     }
     function $user(label, body) {
         test.case(label, async (assert) => {
             for (const S of USER_STORES)
-                await S.collection.create();
+                await S.table.create();
             try {
                 for (const u of Object.values(USERS)) {
                     for (const S of USER_STORES)
@@ -217,7 +256,7 @@ export default (db) => {
             }
             finally {
                 for (const S of USER_STORES)
-                    await S.collection.delete();
+                    await S.table.delete();
             }
         });
     }
@@ -229,9 +268,9 @@ export default (db) => {
     }
     function $rel(label, body) {
         test.case(`relation: ${label}`, async (assert) => {
-            await Author.collection.create();
-            await Article.collection.create();
-            await Profile.collection.create();
+            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" });
@@ -257,9 +296,9 @@ export default (db) => {
                 await body(assert);
             }
             finally {
-                await Profile.collection.delete();
-                await Article.collection.delete();
-                await Author.collection.delete();
+                await Profile.table.delete();
+                await Article.table.delete();
+                await Author.table.delete();
             }
         });
     }
@@ -309,19 +348,24 @@ export default (db) => {
         assert(user.id).type();
         assert(await UserB.has(user.id)).true();
     });
-    const ManualUser = new Store({
-        id: key.primary(p.string, { generate: false }),
-        name: p.string,
-    }, { db, name: "manual_user" });
+    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 user = await ManualUser.insert({ id: "manual-id", name: "Test" });
-        assert(user.id).equals("manual-id");
-        assert(await ManualUser.has("manual-id")).true();
+        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({});
@@ -781,6 +825,12 @@ export default (db) => {
         // 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 });
@@ -973,17 +1023,20 @@ export default (db) => {
         });
     });
     $user("get/try: missing id", async (assert) => {
-        const missing = `missing-${Date.now()}-${Math.random()}`;
+        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 = `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 = `missing-${Date.now()}-${Math.random()}`;
+        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 },
@@ -1103,12 +1156,76 @@ export default (db) => {
         const results = await Type.find({
             where: {
                 string: "combo",
-                u8: { $gte: 150, $ne: 200 }
+                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({
@@ -1118,6 +1235,75 @@ export default (db) => {
         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 } });
@@ -1185,9 +1371,10 @@ export default (db) => {
         });
     });
     $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: "missing-author",
+            author_id,
         });
         const got = await Article.get(orphan.id, { with: { author: true } });
         assert(got.author).null();
@@ -1237,11 +1424,14 @@ export default (db) => {
         });
     });
     $user$("inject invalid identifier (table name)", async (assert) => {
-        const BadStore = new Store({
-            id: key.primary(p.string),
-        }, { db, name: "users; DROP TABLE users" });
-        await throws(assert, Code.identifier_invalid, async () => {
-            await BadStore.collection.create();
+        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) => {
@@ -1300,31 +1490,33 @@ export default (db) => {
     });
     $rel("with: joined relations decode URL fields (base + rel)", async (assert) => {
         const ParentSchema = {
-            id: key.primary(p.string),
+            id: key.primary(p.uuid),
             name: p.string,
             url: p.url.optional(),
         };
         const ChildSchema = {
-            id: key.primary(p.string),
-            parent_id: key.foreign(p.string),
+            id: key.primary(p.uuid),
+            parent_id: key.foreign(p.uuid),
             url: p.url.optional(),
         };
-        const Parent = new Store(ParentSchema, {
-            db,
+        const Parent = store({
             name: "j_parent",
+            db,
+            schema: ParentSchema,
             relations: {
                 children: relation.many(ChildSchema, "parent_id"),
             },
         });
-        const Child = new Store(ChildSchema, {
+        const Child = store({
             db,
             name: "j_child",
+            schema: ChildSchema,
             relations: {
                 parent: relation.one(ParentSchema, "parent_id", { reverse: true }),
             },
         });
-        await Parent.collection.create();
-        await Child.collection.create();
+        await Parent.table.create();
+        await Child.table.create();
         try {
             const p0 = await Parent.insert({
                 name: "P0",
@@ -1356,8 +1548,8 @@ export default (db) => {
             assert(c0.url.href).equals("https://example.com/joined");
         }
         finally {
-            await Child.collection.delete();
-            await Parent.collection.delete();
+            await Child.table.delete();
+            await Parent.table.delete();
         }
     });
     $rel("find: limit applies to parent rows, not joined rows", async (assert) => {
@@ -1380,5 +1572,179 @@ export default (db) => {
     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