@primate/core 0.6.2 → 0.7.0

package/lib/private/db/test.js

@@ -1,7 +1,8 @@
 import { Code } from "#db/errors";
-import key from "#orm/key";
-import relation from "#orm/relation";
-import store from "#orm/store";
+import store from "#store";
+import key from "#store/key";
+import relation from "#store/relation";
+import { CodeError } from "@rcompat/error";
 import test from "@rcompat/test";
 import any from "@rcompat/test/any";
 import p from "pema";
@@ -101,13 +102,15 @@ async function throws(assert, code, fn) {
         assert(false).true();
     }
     catch (error) {
-        assert(error.code).equals(code);
+        if (CodeError.is(error)) {
+            assert(error.code).equals(code);
+        }
     }
 }
 export default (db) => {
     test.ended(() => db.close());
     const Post = store({
-        name: "post",
+        table: "post",
         db,
         schema: {
             id: key.primary(p.uuid),
@@ -116,8 +119,11 @@ export default (db) => {
         },
     });
     Post.update;
+    test.case("#table typed from table name", assert => {
+        assert(Post.table).type();
+    });
     const User = store({
-        name: "user",
+        table: "user",
         db,
         schema: {
             id: key.primary(p.uuid),
@@ -127,7 +133,7 @@ export default (db) => {
         },
     });
     const UserN = store({
-        name: "user_n",
+        table: "user_n",
         db,
         schema: {
             id: key.primary(p.u32),
@@ -137,7 +143,7 @@ export default (db) => {
         },
     });
     const UserB = store({
-        name: "user_b",
+        table: "user_b",
         db,
         schema: {
             id: key.primary(p.u128),
@@ -148,10 +154,11 @@ export default (db) => {
     });
     const USER_STORES = [User, UserN, UserB];
     const Type = store({
-        name: "type",
+        table: "type",
         db,
         schema: {
             id: key.primary(p.uuid),
+            blob: p.blob.optional(),
             boolean: p.boolean.optional(),
             date: p.date.optional(),
             f32: p.f32.optional(),
@@ -173,7 +180,7 @@ export default (db) => {
     // this stresses identifier quoting in CREATE/INSERT/SELECT/UPDATE/DELETE
     const Reserved = store({
         // deliberately reserved-like table name
-        name: "select",
+        table: "select",
         db,
         schema: {
             id: key.primary(p.uuid),
@@ -182,28 +189,14 @@ export default (db) => {
             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({
+        table: "author",
         db,
-        name: "author",
-        schema: AuthorSchema,
-        relations: {
-            articles: relation.many(ArticleSchema, "author_id"),
-            profile: relation.one(ProfileSchema, "author_id"),
+        schema: {
+            id: key.primary(p.uuid),
+            name: p.string,
+            articles: relation.many({ table: "article", by: "author_id" }),
+            profile: relation.one({ table: "profile", by: "author_id" }),
         },
     });
     /*const AuthorWithJSON = store({
@@ -217,36 +210,41 @@ export default (db) => {
       },
     });*/
     const Article = store({
+        table: "article",
         db,
-        name: "article",
-        schema: ArticleSchema,
-        relations: {
-            author: relation.one(AuthorSchema, "author_id", { reverse: true }),
+        schema: {
+            id: key.primary(p.uuid),
+            title: p.string,
+            author_id: key.foreign(p.uuid),
+            author: relation.one({ table: "author", by: "author_id", reverse: true }),
         },
     });
     const Profile = store({
         db,
-        name: "profile",
-        schema: ProfileSchema,
-        relations: {
-            author: relation.one(AuthorSchema, "author_id", { reverse: true }),
+        table: "profile",
+        schema: {
+            id: key.primary(p.uuid),
+            bio: p.string,
+            url: p.url.optional(),
+            author_id: key.foreign(p.uuid),
+            author: relation.one({ table: "author", by: "author_id", reverse: true }),
         },
     });
     function $store(label, s, body) {
         test.case(label, async (assert) => {
-            await s.table.create();
+            await s.create();
             try {
                 await body(assert);
             }
             finally {
-                await s.table.delete();
+                await s.drop();
             }
         });
     }
     function $user(label, body) {
         test.case(label, async (assert) => {
             for (const S of USER_STORES)
-                await S.table.create();
+                await S.create();
             try {
                 for (const u of Object.values(USERS)) {
                     for (const S of USER_STORES)
@@ -256,7 +254,7 @@ export default (db) => {
             }
             finally {
                 for (const S of USER_STORES)
-                    await S.table.delete();
+                    await S.drop();
             }
         });
     }
@@ -268,9 +266,9 @@ export default (db) => {
     }
     function $rel(label, body) {
         test.case(`relation: ${label}`, async (assert) => {
-            await Author.table.create();
-            await Article.table.create();
-            await Profile.table.create();
+            await Author.create();
+            await Article.create();
+            await Profile.create();
             try {
                 const john = await Author.insert({ name: "John" });
                 const bob = await Author.insert({ name: "Bob" });
@@ -296,9 +294,9 @@ export default (db) => {
                 await body(assert);
             }
             finally {
-                await Profile.table.delete();
-                await Article.table.delete();
-                await Author.table.delete();
+                await Profile.drop();
+                await Article.drop();
+                await Author.drop();
             }
         });
     }
@@ -317,13 +315,13 @@ export default (db) => {
         });
     }
     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);
+        return security_pair("where", label, mk, base => User.find({ where: base }), w => Author.find({ with: { articles: { store: Article, 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);
+        return security_pair("find", label, mk, base => User.find({ select: base }), w => Author.find({ with: { articles: { store: Article, 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);
+        return security_pair("find", label, mk, base => User.find({ sort: base }), w => Author.find({ with: { articles: { store: Article, sort: w } } }), expected);
     }
     $store("insert", User, async (assert) => {
         const donald = await User.insert({ age: 30, name: "Donald" });
@@ -349,7 +347,7 @@ export default (db) => {
         assert(await UserB.has(user.id)).true();
     });
     const ManualUser = store({
-        name: "manual_user",
+        table: "manual_user",
         db,
         schema: {
             id: key.primary(p.uuid, { generate: false }),
@@ -377,6 +375,12 @@ export default (db) => {
             return User.insert({ name: "Nullman", lastname: null });
         });
     });
+    $store("insert: explicit undefined on optional field is allowed", User, async (assert) => {
+        const u = await User.insert({ name: "Test", lastname: undefined });
+        assert(await User.has(u.id)).true();
+        const [got] = await User.find({ where: { id: u.id } });
+        assert(got.lastname).undefined();
+    });
     $user("find: empty object equals no options", async (assert) => {
         const a = await User.find();
         const b = await User.find({});
@@ -853,7 +857,7 @@ export default (db) => {
         const articles = await Article.find();
         const article = await Article.get(articles[0].id, {
             with: {
-                author: true,
+                author: Author,
             },
         });
         assert(article).type();
@@ -862,7 +866,7 @@ export default (db) => {
     });
     $rel("get with many", async (assert) => {
         const [first] = await Author.find({ where: { name: "John" } });
-        const john = await Author.get(first.id, { with: { articles: true } });
+        const john = await Author.get(first.id, { with: { articles: Article } });
         assert(john.articles).type();
         const titles = john.articles.map(a => a.title);
         assert(titles.includes("John First Post")).true();
@@ -870,19 +874,19 @@ export default (db) => {
     });
     $rel("get by id", async (assert) => {
         const [first] = await Author.find({ where: { name: "John" } });
-        const john = await Author.get(first.id, { with: { profile: true } });
+        const john = await Author.get(first.id, { with: { profile: Profile } });
         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 } });
+        const bob = await Author.get(first.id, { with: { profile: Profile } });
         assert(bob.profile).null();
     });
     $rel("find", async (assert) => {
         const articles = await Article.find({
             where: { title: { $like: "% Post" } },
-            with: { author: true },
+            with: { author: Author },
             sort: { title: "asc" },
         });
         assert(articles.length).equals(3);
@@ -893,14 +897,14 @@ export default (db) => {
     });
     $rel("try", async (assert) => {
         const [first] = await Article.find();
-        const article = await Article.try(first.id, { with: { author: true } });
+        const article = await Article.try(first.id, { with: { author: Author } });
         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 } });
+        const author = await Author.get(lonely.id, { with: { articles: Article } });
         assert(author.articles).type();
         assert(author.articles.length).equals(0);
     });
@@ -908,8 +912,8 @@ export default (db) => {
         const authors = await Author.find({ where: { name: "John" } });
         const john = await Author.get(authors[0].id, {
             with: {
-                articles: true,
-                profile: true,
+                articles: Article,
+                profile: Profile,
             },
         });
         const titles = john.articles.map(a => a.title);
@@ -931,12 +935,13 @@ export default (db) => {
             limit: 20,
             with: {
                 articles: {
+                    store: Article,
                     where: { title: { $like: "%foo%" } },
                     select: ["id", "title"],
                     sort: { title: "asc" },
                     limit: SUBLIMIT,
                 },
-                profile: true,
+                profile: Profile,
             },
         });
         assert(authors).type();
@@ -1008,8 +1013,8 @@ export default (db) => {
         const rows = await Author.find({
             select: ["id"],
             with: {
-                profile: { select: ["bio"] },
-                articles: { select: ["title"] },
+                profile: { store: Profile, select: ["bio"] },
+                articles: { store: Article, select: ["title"] },
             },
         });
         assert(rows).type();
@@ -1031,15 +1036,15 @@ export default (db) => {
     $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();
+        await throws(assert, Code.record_not_found, () => Article.get(missing, { with: { author: Author } }));
+        assert(await Article.try(missing, { with: { author: Author } })).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 } }));
+        await throws(assert, Code.record_not_found, () => Author.get(missing, { with: { articles: Article, profile: Profile } }));
         assert(await Author.try(missing, {
-            with: { articles: true, profile: true },
+            with: { articles: Article, profile: Profile },
         })).undefined();
     });
     $user("try: does not swallow invalid options", async (assert) => {
@@ -1353,6 +1358,7 @@ export default (db) => {
             return Author.find({
                 with: {
                     articles: {
+                        store: Article,
                         select: {}, // must be array
                     },
                 },
@@ -1364,19 +1370,60 @@ export default (db) => {
             return Author.find({
                 with: {
                     articles: {
+                        store: Article,
                         limit: -1, // must be uint
                     },
                 },
             });
         });
     });
+    $rel$("with: rejects store with wrong table", async (assert) => {
+        // runtime check
+        await throws(assert, Code.relation_table_mismatch, () => {
+            return Author.find({
+                with: {
+                    // Profile.table === "profile", expected "article"
+                    articles: Profile,
+                },
+            });
+        });
+    });
+    $rel$("with: wrong table store is a type error", async (assert) => {
+        await throws(assert, Code.relation_table_mismatch, () => {
+            return Author.find({
+                with: {
+                    // @ts-expect-error — Profile.table === "profile", expected "article"
+                    articles: Profile,
+                },
+            });
+        });
+    });
+    test.case("with: missing store in query object is a type error", async (assert) => {
+        await throws(assert, Code.relation_store_required, () => {
+            return Author.find({
+                with: {
+                    // @ts-expect-error — store is required in WithQuery
+                    articles: { where: { title: "foo" } },
+                },
+            });
+        });
+    });
+    test.case("with: missing store throws at runtime", async (assert) => {
+        await throws(assert, Code.relation_store_required, () => {
+            return Author.find({
+                with: {
+                    articles: { where: { title: "foo" } },
+                },
+            });
+        });
+    });
     $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 } });
+        const got = await Article.get(orphan.id, { with: { author: Author } });
         assert(got.author).null();
     });
     $user("get/try: happy path", async (assert) => {
@@ -1426,7 +1473,7 @@ export default (db) => {
     $user$("inject invalid identifier (table name)", async (assert) => {
         await throws(assert, Code.identifier_invalid, () => {
             store({
-                name: "users; DROP TABLE users",
+                table: "users; DROP TABLE users",
                 db,
                 schema: {
                     id: key.primary(p.uuid),
@@ -1457,7 +1504,11 @@ export default (db) => {
     $rel("with + select (no id)", async (assert) => {
         const rows = await Author.find({
             select: ["name"],
-            with: { articles: { select: ["title"], sort: { title: "asc" } } },
+            with: {
+                articles: {
+                    store: Article, select: ["title"], sort: { title: "asc" }
+                },
+            },
             sort: { name: "asc" },
         });
         // no id leaked
@@ -1471,7 +1522,7 @@ export default (db) => {
     $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 },
+            with: { profile: Profile },
         });
         assert(john.profile).not.null();
         // this is the whole point: driver must unbind it
@@ -1483,40 +1534,34 @@ export default (db) => {
         const [row] = await Article.find({ select: ["id"] });
         const got = await Article.get(row.id, {
             select: ["title"], // intentionally omit author_id
-            with: { author: true },
+            with: { author: Author },
         });
         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",
+            table: "j_parent",
             db,
-            schema: ParentSchema,
-            relations: {
-                children: relation.many(ChildSchema, "parent_id"),
+            schema: {
+                id: key.primary(p.uuid),
+                name: p.string,
+                url: p.url.optional(),
+                children: relation.many({ table: "j_child", by: "parent_id" }),
             },
         });
         const Child = store({
             db,
-            name: "j_child",
-            schema: ChildSchema,
-            relations: {
-                parent: relation.one(ParentSchema, "parent_id", { reverse: true }),
+            table: "j_child",
+            schema: {
+                id: key.primary(p.uuid),
+                parent_id: key.foreign(p.uuid),
+                url: p.url.optional(),
+                parent: relation.one({ table: "j_parent", by: "parent_id", reverse: true }),
             },
         });
-        await Parent.table.create();
-        await Child.table.create();
+        await Parent.create();
+        await Child.create();
         try {
             const p0 = await Parent.insert({
                 name: "P0",
@@ -1530,7 +1575,7 @@ export default (db) => {
             const [got] = await Parent.find({
                 where: { id: p0.id },
                 select: ["url"],
-                with: { children: true },
+                with: { children: Child },
             });
             assert(got).defined();
             // pk must not leak
@@ -1548,15 +1593,15 @@ export default (db) => {
             assert(c0.url.href).equals("https://example.com/joined");
         }
         finally {
-            await Child.table.delete();
-            await Parent.table.delete();
+            await Child.drop();
+            await Parent.drop();
         }
     });
     $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 },
+            with: { articles: Article },
         });
         assert(authors.length).equals(2);
     });
@@ -1572,19 +1617,6 @@ 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();
@@ -1643,7 +1675,7 @@ export default (db) => {
     $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);
+        const types = await db.schema.introspect(User.table, User.pk);
         assert(types).not.null();
         if (types !== null) {
             assert(types.id).includes("uuid");
@@ -1658,7 +1690,7 @@ export default (db) => {
             add: { email: "string" }, drop: [], rename: [],
         });
         const MigratedUser = store({
-            name: "user",
+            table: "user",
             db,
             schema: {
                 id: key.primary(p.uuid),
@@ -1684,7 +1716,7 @@ export default (db) => {
             add: {}, drop: [], rename: [["lastname", "surname"]],
         });
         const MigratedUser = store({
-            name: "user",
+            table: "user",
             db,
             schema: {
                 id: key.primary(p.uuid),
@@ -1704,7 +1736,7 @@ export default (db) => {
             add: { email: "string" }, drop: ["lastname"], rename: [],
         });
         const MigratedUser = store({
-            name: "user",
+            table: "user",
             db,
             schema: {
                 id: key.primary(p.uuid),
@@ -1719,7 +1751,7 @@ export default (db) => {
         assert(types.lastname).undefined();
     });
     const UUIDTest = store({
-        name: "uuid_test",
+        table: "uuid_test",
         db,
         schema: {
             id: key.primary(p.uuid),
@@ -1746,5 +1778,114 @@ export default (db) => {
             add: { email: "string" }, drop: [], rename: [],
         }));
     });
+    $user("find: $in on string field", async (assert) => {
+        const rows = await User.find({
+            where: { name: { $in: ["Donald", "Ryan"] } },
+            sort: { name: "asc" },
+        });
+        assert(rows.length).equals(2);
+        assert(rows[0].name).equals("Donald");
+        assert(rows[1].name).equals("Ryan");
+    });
+    $user("find: $in on number field", async (assert) => {
+        const rows = await User.find({
+            where: { age: { $in: [30, 40] } },
+            sort: { age: "asc" },
+        });
+        assert(rows.length).equals(3);
+        assert(rows.map(r => r.age)).equals([30, 40, 40]);
+    });
+    $user("find: $in on uuid field", async (assert) => {
+        const [donald] = await User.find({ where: { name: "Donald" } });
+        const [ryan] = await User.find({ where: { name: "Ryan" } });
+        const rows = await User.find({
+            where: { id: { $in: [donald.id, ryan.id] } },
+            sort: { name: "asc" },
+        });
+        assert(rows.length).equals(2);
+        assert(rows.map(r => r.name)).equals(["Donald", "Ryan"]);
+    });
+    $user("find: $in with single value", async (assert) => {
+        const rows = await User.find({
+            where: { name: { $in: ["Donald"] } },
+        });
+        assert(rows.length).equals(1);
+        assert(rows[0].name).equals("Donald");
+    });
+    $user("find: $in with no matches returns empty", async (assert) => {
+        const rows = await User.find({
+            where: { name: { $in: ["Nobody", "Ghost"] } },
+        });
+        assert(rows.length).equals(0);
+    });
+    $user$("find: $in with empty array throws", async (assert) => {
+        await throws(assert, Code.operator_empty_in, () => {
+            return User.find({ where: { name: { $in: [] } } });
+        });
+    });
+    $user$("find: $in on boolean field throws", async (assert) => {
+        await throws(assert, Code.operator_unknown, () => {
+            return Type.find({ where: { boolean: { $in: [true, false] } } });
+        });
+    });
+    $user$("find: $in on blob field throws", async (assert) => {
+        await throws(assert, Code.operator_unknown, () => {
+            return Type.find({ where: { blob: { $in: [] } } });
+        });
+    });
+    $user("find: $in combined with other where criteria", async (assert) => {
+        const rows = await User.find({
+            where: {
+                name: { $in: ["Donald", "Ryan", "Ben"] },
+                age: { $lt: 40 },
+            },
+            sort: { name: "asc" },
+        });
+        assert(rows.length).equals(1);
+        assert(rows[0].name).equals("Donald");
+    });
+    $user("find: offset skips records", async (assert) => {
+        const all = await User.find({ sort: { name: "asc" } });
+        const offset = await User.find({
+            sort: { name: "asc" }, offset: 2, limit: all.length - 2
+        });
+        assert(offset.length).equals(all.length - 2);
+        assert(offset[0].name).equals(all[2].name);
+    });
+    $user("find: offset 0 is same as no offset", async (assert) => {
+        const without = await User.find({ sort: { name: "asc" } });
+        const with_zero = await User.find({
+            sort: { name: "asc" }, offset: 0, limit: without.length
+        });
+        assert(with_zero.length).equals(without.length);
+        assert(with_zero.map(r => r.name)).equals(without.map(r => r.name));
+    });
+    $user("find: offset with limit", async (assert) => {
+        const sort = { name: "asc" };
+        const all = await User.find({ sort });
+        const page = await User.find({ sort, offset: 1, limit: 2 });
+        assert(page.length).equals(2);
+        assert(page[0].name).equals(all[1].name);
+        assert(page[1].name).equals(all[2].name);
+    });
+    $user("find: offset beyond total returns empty", async (assert) => {
+        const rows = await User.find({ offset: 100, limit: 10 });
+        assert(rows.length).equals(0);
+    });
+    $user$("find: negative offset throws", async (assert) => {
+        await throws(assert, Code.offset_invalid, () => {
+            return User.find({ offset: -1 });
+        });
+    });
+    $user$("find: non-integer offset throws", async (assert) => {
+        await throws(assert, Code.offset_invalid, () => {
+            return User.find({ offset: 1.5 });
+        });
+    });
+    $user$("find: offset without limit throws", async (assert) => {
+        await throws(assert, Code.offset_requires_limit, () => {
+            return User.find({ offset: 1 });
+        });
+    });
 };
 //# sourceMappingURL=test.js.map