@casekit/orm 0.0.1-alpha.14 → 0.0.1-alpha.16

package/src/queries/find/tests/findMany.limit.test.ts

@@ -0,0 +1,176 @@
+import { describe, expect, test } from "vitest";
+
+import { db } from "../../../test/db";
+import { seed } from "../../../test/seed";
+
+describe("findMany", () => {
+    test("it can limit the number of rows returned", async () => {
+        await db.transact(
+            async (db) => {
+                await seed(db, {
+                    users: [
+                        {
+                            username: "Russell",
+                            tenants: [{ name: "WFMA", posts: 0 }],
+                        },
+                        {
+                            username: "Dan",
+                            tenants: [{ name: "WFMA", posts: 0 }],
+                        },
+                        {
+                            username: "Fairooz",
+                            tenants: [{ name: "WFMA", posts: 0 }],
+                        },
+                    ],
+                });
+                const results = await db.findMany("user", {
+                    select: ["id", "username"],
+                    orderBy: ["username"],
+                    limit: 2,
+                });
+
+                expect(results.map((r) => r.username)).toEqual([
+                    "Dan",
+                    "Fairooz",
+                ]);
+            },
+            { rollback: true },
+        );
+    });
+
+    test("offsets can be applied", async () => {
+        await db.transact(
+            async (db) => {
+                await seed(db, {
+                    users: [
+                        {
+                            username: "Russell",
+                            tenants: [{ name: "WFMA", posts: 0 }],
+                        },
+                        {
+                            username: "Dan",
+                            tenants: [{ name: "WFMA", posts: 0 }],
+                        },
+                        {
+                            username: "Fairooz",
+                            tenants: [{ name: "WFMA", posts: 0 }],
+                        },
+                    ],
+                });
+                const results = await db.findMany("user", {
+                    select: ["id", "username"],
+                    orderBy: ["username"],
+                    limit: 1,
+                    offset: 2,
+                });
+
+                expect(results.map((r) => r.username)).toEqual(["Russell"]);
+            },
+            { rollback: true },
+        );
+    });
+
+    test("1:N relations can have limits and offsets applied", async () => {
+        await db.transact(
+            async (db) => {
+                await seed(db, {
+                    users: [
+                        {
+                            username: "Russell",
+                            tenants: [{ name: "WFMA", posts: 3 }],
+                        },
+                        {
+                            username: "Dan",
+                            tenants: [{ name: "WFMA", posts: 5 }],
+                        },
+                        {
+                            username: "Fairooz",
+                            tenants: [{ name: "WFMA", posts: 2 }],
+                        },
+                    ],
+                });
+                const results = await db.findMany("user", {
+                    select: ["id", "username"],
+                    orderBy: ["username"],
+                    include: {
+                        posts: {
+                            select: ["title"],
+                            orderBy: ["title"],
+                            limit: 2,
+                            offset: 1,
+                        },
+                    },
+                });
+
+                expect(
+                    results.map((r) => [
+                        r.username,
+                        r.posts.map((p) => p.title),
+                    ]),
+                ).toEqual([
+                    ["Dan", ["Post e", "Post f"]],
+                    ["Fairooz", ["Post j"]],
+                    ["Russell", ["Post b", "Post c"]],
+                ]);
+            },
+            { rollback: true },
+        );
+    });
+
+    test("N:N relations can have limits and offsets applied", async () => {
+        await db.transact(
+            async (db) => {
+                await seed(db, {
+                    users: [
+                        {
+                            username: "Russell",
+                            tenants: [
+                                { name: "WFMA", posts: 0 },
+                                { name: "Popova Park", posts: 0 },
+                                { name: "LRF", posts: 0 },
+                            ],
+                        },
+                        {
+                            username: "Dan",
+                            tenants: [
+                                { name: "Popova Park", posts: 0 },
+                                { name: "LRF", posts: 0 },
+                            ],
+                        },
+                        {
+                            username: "Fairooz",
+                            tenants: [
+                                { name: "WFMA", posts: 0 },
+                                { name: "LRF", posts: 0 },
+                            ],
+                        },
+                    ],
+                });
+                const results = await db.findMany("user", {
+                    select: ["id", "username"],
+                    orderBy: ["username"],
+                    include: {
+                        tenants: {
+                            select: ["name"],
+                            orderBy: ["name"],
+                            limit: 2,
+                            offset: 1,
+                        },
+                    },
+                });
+
+                expect(
+                    results.map((r) => [
+                        r.username,
+                        r.tenants.map((p) => p.name),
+                    ]),
+                ).toEqual([
+                    ["Dan", ["Popova Park"]],
+                    ["Fairooz", ["WFMA"]],
+                    ["Russell", ["Popova Park", "WFMA"]],
+                ]);
+            },
+            { rollback: true },
+        );
+    });
+});

package/src/queries/find/tests/findMany.nullable-relations.test.ts

@@ -0,0 +1,127 @@
+import { describe, expect, test } from "vitest";
+
+import { db } from "../../../test/db";
+import { seed } from "../../../test/seed";
+
+describe("findMany", () => {
+    test("optional N:1 relations don't prevent records being returned", async () => {
+        await db.transact(
+            async (db) => {
+                await seed(db, {
+                    users: [
+                        {
+                            username: "Russell",
+                            tenants: [
+                                { name: "WFMA", posts: 1 },
+                                { name: "Popova Park", posts: 0 },
+                            ],
+                        },
+                        {
+                            username: "Dan",
+                            tenants: [{ name: "WFMA", posts: 2 }],
+                        },
+                        {
+                            username: "Fairooz",
+                            tenants: [{ name: "WFMA", posts: 0 }],
+                        },
+                    ],
+                });
+                const results = await db.findMany("post", {
+                    select: ["id", "title"],
+                    include: {
+                        reviewedBy: {
+                            select: ["id", "username"],
+                            include: {
+                                posts: { select: ["id", "title"] },
+                                invitedBy: { select: ["id", "username"] },
+                            },
+                        },
+                    },
+                    orderBy: ["title"],
+                    limit: 2,
+                });
+
+                expect(results.map((p) => [p.title, p.reviewedBy])).toEqual([
+                    ["Post a", null],
+                    ["Post b", null],
+                ]);
+            },
+            { rollback: true },
+        );
+    });
+
+    test("optional N:1 relations are returned if they exist", async () => {
+        await db.transact(
+            async (db) => {
+                const { users } = await seed(db, {
+                    users: [
+                        {
+                            username: "Russell",
+                            tenants: [
+                                { name: "WFMA", posts: 1 },
+                                { name: "Popova Park", posts: 0 },
+                            ],
+                        },
+                        {
+                            username: "Dan",
+                            tenants: [{ name: "WFMA", posts: 2 }],
+                        },
+                        {
+                            username: "Fairooz",
+                            tenants: [{ name: "WFMA", posts: 0 }],
+                        },
+                    ],
+                });
+                await db.updateOne("user", {
+                    where: { id: users["Dan"].id },
+                    set: {
+                        invitedById: users["Russell"].id,
+                    },
+                });
+                const results = await db.findMany("user", {
+                    select: ["username"],
+                    include: {
+                        invitedBy: {
+                            select: ["username"],
+                        },
+                        tenants: {
+                            select: ["name"],
+                            orderBy: ["name"],
+                        },
+                        reviewedPosts: {
+                            select: ["title"],
+                        },
+                        invitedUsers: {
+                            select: ["username"],
+                        },
+                    },
+                    orderBy: ["username"],
+                });
+                expect(results).toEqual([
+                    {
+                        username: "Dan",
+                        invitedBy: { username: "Russell" },
+                        tenants: [{ name: "WFMA" }],
+                        reviewedPosts: [],
+                        invitedUsers: [],
+                    },
+                    {
+                        username: "Fairooz",
+                        invitedBy: null,
+                        tenants: [{ name: "WFMA" }],
+                        reviewedPosts: [],
+                        invitedUsers: [],
+                    },
+                    {
+                        username: "Russell",
+                        invitedBy: null,
+                        tenants: [{ name: "Popova Park" }, { name: "WFMA" }],
+                        reviewedPosts: [],
+                        invitedUsers: [{ username: "Dan" }],
+                    },
+                ]);
+            },
+            { rollback: true },
+        );
+    });
+});

package/src/queries/find/tests/findMany.orderBy.test-d.ts

@@ -0,0 +1,84 @@
+import { assertType, describe, test } from "vitest";
+
+import { db } from "../../../test/db";
+
+describe("findMany", () => {
+    test("queries can only be ordered by columns that exist", () => {
+        assertType(
+            db.findMany("post", {
+                select: ["id", "content"],
+                orderBy: [
+                    "title",
+                    // @ts-expect-error "wrong" is not a column on the post model
+                    "wrong",
+                ],
+            }),
+        );
+    });
+
+    test("queries can be ordered by columns ascending, descending, or implicitly ascending", () => {
+        assertType(
+            db.findMany("post", {
+                select: ["id", "content"],
+                orderBy: ["title", ["content", "asc"], ["id", "desc"]],
+            }),
+        );
+    });
+
+    test("anything other than asc or desc as a sort order gives a type error", () => {
+        assertType(
+            db.findMany("post", {
+                select: ["id", "content"],
+                orderBy: [
+                    "title",
+                    ["content", "asc"],
+                    // @ts-expect-error "wrong" is not a valid sort order
+                    ["id", "wrong"],
+                ],
+            }),
+        );
+    });
+
+    test("included N:1 relations cannot be ordered", () => {
+        assertType(
+            db.findMany("post", {
+                select: ["id", "content"],
+                include: {
+                    author: {
+                        select: ["username"],
+                        // @ts-expect-error N:1 relations cannot be ordered
+                        orderBy: ["username"],
+                    },
+                },
+            }),
+        );
+    });
+
+    test("included 1:N relations can be ordered", () => {
+        assertType(
+            db.findMany("user", {
+                select: ["id", "username"],
+                include: {
+                    posts: {
+                        select: ["title"],
+                        orderBy: ["title"],
+                    },
+                },
+            }),
+        );
+    });
+
+    test("included N:N relations can be ordered", () => {
+        assertType(
+            db.findMany("user", {
+                select: ["id", "username"],
+                include: {
+                    tenants: {
+                        select: ["name"],
+                        orderBy: ["name"],
+                    },
+                },
+            }),
+        );
+    });
+});

package/src/queries/find/tests/findMany.orderBy.test.ts

@@ -0,0 +1,184 @@
+import { describe, expect, test } from "vitest";
+
+import { db } from "../../../test/db";
+import { seed } from "../../../test/seed";
+
+describe("findMany", () => {
+    test("it can return data in the specified order", async () => {
+        await db.transact(
+            async (db) => {
+                await seed(db, {
+                    users: [
+                        {
+                            username: "Russell",
+                            tenants: [{ name: "WFMA", posts: 0 }],
+                        },
+                        {
+                            username: "Dan",
+                            tenants: [{ name: "WFMA", posts: 0 }],
+                        },
+                        {
+                            username: "Fairooz",
+                            tenants: [{ name: "WFMA", posts: 0 }],
+                        },
+                    ],
+                });
+                const results = await db.findMany("user", {
+                    select: ["id", "username"],
+                    orderBy: ["username"],
+                });
+
+                expect(results.map((r) => r.username)).toEqual([
+                    "Dan",
+                    "Fairooz",
+                    "Russell",
+                ]);
+            },
+            { rollback: true },
+        );
+    });
+
+    test("it can return data in the reverse order", async () => {
+        await db.transact(
+            async (db) => {
+                await seed(db, {
+                    users: [
+                        {
+                            username: "Russell",
+                            tenants: [{ name: "WFMA", posts: 0 }],
+                        },
+                        {
+                            username: "Dan",
+                            tenants: [{ name: "WFMA", posts: 0 }],
+                        },
+                        {
+                            username: "Fairooz",
+                            tenants: [{ name: "WFMA", posts: 0 }],
+                        },
+                    ],
+                });
+                const results = await db.findMany("user", {
+                    select: ["id", "username"],
+                    orderBy: [["username", "desc"]],
+                });
+
+                expect(results.map((r) => r.username)).toEqual([
+                    "Russell",
+                    "Fairooz",
+                    "Dan",
+                ]);
+            },
+            { rollback: true },
+        );
+    });
+
+    test("it can return 1:N relations in order", async () => {
+        await db.transact(
+            async (db) => {
+                await seed(db, {
+                    users: [
+                        {
+                            username: "Russell",
+                            tenants: [{ name: "WFMA", posts: 3 }],
+                        },
+                        {
+                            username: "Dan",
+                            tenants: [{ name: "WFMA", posts: 2 }],
+                        },
+                        {
+                            username: "Fairooz",
+                            tenants: [{ name: "WFMA", posts: 6 }],
+                        },
+                    ],
+                });
+                const results = await db.findMany("user", {
+                    select: ["id", "username"],
+                    include: {
+                        posts: {
+                            select: ["id", "title"],
+                            orderBy: [["title", "desc"]],
+                        },
+                    },
+                    orderBy: ["username"],
+                });
+
+                expect(
+                    results.map((r) => [
+                        r.username,
+                        r.posts.map((p) => p.title),
+                    ]),
+                ).toEqual([
+                    ["Dan", ["Post e", "Post d"]],
+                    [
+                        "Fairooz",
+                        [
+                            "Post k",
+                            "Post j",
+                            "Post i",
+                            "Post h",
+                            "Post g",
+                            "Post f",
+                        ],
+                    ],
+                    ["Russell", ["Post c", "Post b", "Post a"]],
+                ]);
+            },
+            { rollback: true },
+        );
+    });
+
+    test("it can return N:N relations in order", async () => {
+        await db.transact(
+            async (db) => {
+                await seed(db, {
+                    users: [
+                        {
+                            username: "Russell",
+                            tenants: [
+                                { name: "WFMA", posts: 0 },
+                                { name: "Popova Park", posts: 0 },
+                                { name: "LRF", posts: 0 },
+                            ],
+                        },
+                        {
+                            username: "Dan",
+                            tenants: [
+                                { name: "Popova Park", posts: 0 },
+                                { name: "LRF", posts: 0 },
+                            ],
+                        },
+                        {
+                            username: "Fairooz",
+                            tenants: [
+                                { name: "WFMA", posts: 0 },
+                                { name: "LRF", posts: 0 },
+                            ],
+                        },
+                    ],
+                });
+                const results = await db.findMany("user", {
+                    select: ["id", "username"],
+                    include: {
+                        tenants: {
+                            select: ["id", "name"],
+                            orderBy: ["name"],
+                        },
+                    },
+                    orderBy: [["username", "desc"]],
+                });
+
+                expect(
+                    results.map((r) => [
+                        r.username,
+                        r.tenants.map((t) => t.name),
+                    ]),
+                ).toEqual([
+                    ["Russell", ["LRF", "Popova Park", "WFMA"]],
+                    ["Fairooz", ["LRF", "WFMA"]],
+                    ["Dan", ["LRF", "Popova Park"]],
+                ]);
+            },
+            { rollback: true },
+        );
+    });
+});

package/src/queries/find/tests/findMany.select.test-d.ts

@@ -0,0 +1,117 @@
+import { assertType, describe, expectTypeOf, test } from "vitest";
+
+import { db } from "../../../test/db";
+
+describe("findMany", () => {
+    test("only models that exist can be queried", () => {
+        assertType(
+            db.findMany(
+                // @ts-expect-error model does not exist
+                "wrong",
+                {},
+            ),
+        );
+    });
+
+    test("a select clause must be included in the query", () => {
+        assertType(
+            db.findMany(
+                "post",
+                // @ts-expect-error query is empty
+                {},
+            ),
+        );
+    });
+
+    test("at least one field must be selected", () => {
+        assertType(
+            db.findMany("post", {
+                // @ts-expect-error select clause is empty
+                select: [],
+            }),
+        );
+    });
+
+    test("only fields on the model can be selected", () => {
+        assertType(
+            db.findMany("post", {
+                // @ts-expect-error name is not a field on the post model
+                select: ["id", "name", "content"],
+            }),
+        );
+    });
+
+    test("the return type is an array of objects including the selected fields", async () => {
+        expectTypeOf(
+            await db.findMany("post", {
+                select: ["id", "title", "content", "publishedAt"],
+            }),
+        ).toMatchTypeOf<
+            {
+                id: string;
+                title: string;
+                content: string;
+                publishedAt: Date | null;
+            }[]
+        >();
+    });
+
+    test("non-selected fields are not included in the result type", async () => {
+        expectTypeOf(
+            await db.findMany("post", {
+                select: ["id", "title"],
+            }),
+        ).not.toMatchTypeOf<{ id: number; title: string; content: string }[]>();
+    });
+
+    test("a model's relations can be included", async () => {
+        expectTypeOf(
+            await db.findMany("post", {
+                select: ["id", "title", "content"],
+                include: {
+                    author: {
+                        select: ["id", "username", "joinedAt"],
+                        include: {
+                            tenants: {
+                                select: ["id", "name"],
+                            },
+                        },
+                    },
+                },
+            }),
+        ).toMatchTypeOf<
+            Readonly<
+                {
+                    id: string;
+                    title: string;
+                    content: string;
+                    author: {
+                        id: string;
+                        username: string;
+                        joinedAt: Date | null;
+                        tenants: { id: string; name: string }[];
+                    };
+                }[]
+            >
+        >();
+    });
+
+    test("only fields that exist can be selected from included models", async () => {
+        assertType(
+            await db.findMany("post", {
+                select: ["id", "title", "content"],
+                include: {
+                    author: {
+                        // @ts-expect-error wrong is not a field on the user model
+                        select: ["id", "username", "joinedAt", "wrong"],
+                        include: {
+                            tenants: {
+                                select: ["id", "name"],
+                            },
+                        },
+                    },
+                },
+            }),
+        );
+    });
+});