@casekit/orm 0.0.1-alpha.0

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"],
+                            },
+                        },
+                    },
+                },
+            }),
+        );
+    });
+});

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

@@ -0,0 +1,188 @@
+import { describe, expect, test } from "vitest";
+
+import { db } from "../../../test/db";
+import { seed } from "../../../test/seed";
+
+describe("findMany", () => {
+    test("it can select fields from the model", async () => {
+        await db.transact(
+            async (db) => {
+                const { posts } = await seed(db, {
+                    users: [
+                        {
+                            username: "Russell",
+                            tenants: [{ name: "WFMA", posts: 1 }],
+                        },
+                    ],
+                });
+                const results = await db.findMany("post", {
+                    select: ["id", "title"],
+                });
+
+                expect(results.find((r) => r.id === posts[0].id)).toEqual({
+                    id: posts[0].id,
+                    title: posts[0].title,
+                });
+            },
+            { rollback: true },
+        );
+    });
+
+    test("it can select fields from N:1 relations", async () => {
+        await db.transact(
+            async (db) => {
+                const { posts, users } = await seed(db, {
+                    users: [
+                        {
+                            username: "Russell",
+                            tenants: [{ name: "WFMA", posts: 1 }],
+                        },
+                    ],
+                });
+                const results = await db.findMany("post", {
+                    select: ["id", "title"],
+                    include: { author: { select: ["id", "username"] } },
+                });
+
+                expect(results.find((r) => r.id === posts[0].id)).toEqual({
+                    id: posts[0].id,
+                    title: posts[0].title,
+                    author: {
+                        id: users["Russell"].id,
+                        username: users["Russell"].username,
+                    },
+                });
+            },
+            { rollback: true },
+        );
+    });
+
+    test("it can select fields from 1:N relations", async () => {
+        await db.transact(
+            async (db) => {
+                const { posts, users } = await seed(db, {
+                    users: [
+                        {
+                            username: "Russell",
+                            tenants: [
+                                { name: "WFMA", posts: 1 },
+                                { name: "Popova Park", posts: 1 },
+                            ],
+                        },
+                    ],
+                });
+                const user = users["Russell"];
+
+                const results = await db.findMany("user", {
+                    select: ["id", "username"],
+                    include: {
+                        posts: {
+                            select: ["id", "title", "content"],
+                            orderBy: ["title"],
+                        },
+                    },
+                });
+
+                expect(results.find((r) => r.id === user.id)).toEqual({
+                    id: user.id,
+                    username: user.username,
+                    posts: [
+                        {
+                            id: posts[0].id,
+                            title: posts[0].title,
+                            content: posts[0].content,
+                        },
+                        {
+                            id: posts[1].id,
+                            title: posts[1].title,
+                            content: posts[1].content,
+                        },
+                    ],
+                });
+            },
+            { rollback: true },
+        );
+    });
+
+    test("it can select fields from N:N relations", async () => {
+        await db.transact(
+            async (db) => {
+                const { tenants, users } = await seed(db, {
+                    users: [
+                        {
+                            username: "Russell",
+                            tenants: [
+                                { name: "Popova Park", posts: 0 },
+                                { name: "WFMA", posts: 0 },
+                            ],
+                        },
+                    ],
+                });
+                const user = users["Russell"];
+                const result = await db.findMany("user", {
+                    select: ["id", "username"],
+                    include: {
+                        tenants: { select: ["id", "name"], orderBy: ["name"] },
+                    },
+                });
+
+                expect(result).toEqual([
+                    {
+                        id: user.id,
+                        username: user.username,
+                        tenants: [
+                            {
+                                id: tenants["Popova Park"].id,
+                                name: tenants["Popova Park"].name,
+                            },
+                            {
+                                id: tenants["WFMA"].id,
+                                name: tenants["WFMA"].name,
+                            },
+                        ],
+                    },
+                ]);
+            },
+            { rollback: true },
+        );
+    });
+
+    test("primary keys are not returned unless specified in the select clause", async () => {
+        await db.transact(
+            async (db) => {
+                const { tenants, users } = await seed(db, {
+                    users: [
+                        {
+                            username: "Russell",
+                            tenants: [
+                                { name: "Popova Park", posts: 0 },
+                                { name: "WFMA", posts: 0 },
+                            ],
+                        },
+                    ],
+                });
+                const user = users["Russell"];
+                const wfma = tenants["WFMA"];
+                const popovapark = tenants["Popova Park"];
+
+                const result = await db.findMany("user", {
+                    select: ["username"],
+                    include: {
+                        tenants: { select: ["name"], orderBy: ["name"] },
+                    },
+                });
+
+                expect(result).toEqual([
+                    {
+                        username: user.username,
+                        tenants: [
+                            { name: popovapark.name },
+                            { name: wfma.name },
+                        ],
+                    },
+                ]);
+            },
+            { rollback: true },
+        );
+    });
+});

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

@@ -0,0 +1,154 @@
+import { assertType, describe, test } from "vitest";
+
+import { db } from "../../../test/db";
+import { $and, $gt, $ilike, $not, $or } from "../../clauses/where/operators";
+
+describe("findMany", () => {
+    test("up to a point, deeply nested clauses don't cause type errors", async () => {
+        assertType(
+            await db.findMany("user", {
+                select: ["username"],
+                include: {
+                    tenants: {
+                        select: ["name"],
+                        orderBy: ["name"],
+                        include: {
+                            tenancies: {
+                                select: ["id"],
+                                where: { createdAt: { [$gt]: new Date() } },
+                            },
+                            users: {
+                                select: ["username", "id"],
+                                where: {
+                                    id: "abc",
+                                    deletedAt: { [$gt]: new Date() },
+                                },
+                                include: {
+                                    tenants: {
+                                        select: ["name"],
+                                        where: {
+                                            [$or]: [
+                                                { name: "a" },
+                                                { name: "b" },
+                                                {
+                                                    [$and]: [
+                                                        {
+                                                            [$or]: [
+                                                                { name: "c" },
+                                                                { name: "d" },
+                                                            ],
+                                                        },
+                                                        {
+                                                            [$or]: [
+                                                                { name: "e" },
+                                                                { name: "f" },
+                                                            ],
+                                                        },
+                                                    ],
+                                                },
+                                            ],
+                                        },
+                                        include: {
+                                            tenancies: {
+                                                select: ["id"],
+                                                where: {
+                                                    [$or]: [
+                                                        {
+                                                            createdAt: {
+                                                                [$gt]: new Date(),
+                                                            },
+                                                        },
+                                                        {
+                                                            [$and]: [
+                                                                {
+                                                                    createdAt: {
+                                                                        [$not]: null,
+                                                                    },
+                                                                },
+                                                            ],
+                                                        },
+                                                    ],
+                                                },
+                                                include: {
+                                                    tenant: {
+                                                        select: ["id"],
+                                                        where: {
+                                                            name: "abc",
+                                                        },
+                                                        include: {
+                                                            users: {
+                                                                select: [
+                                                                    "username",
+                                                                ],
+                                                                where: {
+                                                                    username: {
+                                                                        [$ilike]:
+                                                                            "Russell",
+                                                                    },
+                                                                },
+                                                            },
+                                                            posts: {
+                                                                select: [
+                                                                    "id",
+                                                                    "title",
+                                                                ],
+                                                                where: {
+                                                                    publishedAt:
+                                                                        {
+                                                                            [$not]: null,
+                                                                        },
+                                                                },
+                                                                include: {
+                                                                    author: {
+                                                                        select: [
+                                                                            "id",
+                                                                            "username",
+                                                                        ],
+                                                                        include:
+                                                                            {
+                                                                                posts: {
+                                                                                    select: [
+                                                                                        "id",
+                                                                                        "title",
+                                                                                    ],
+                                                                                    where: {
+                                                                                        publishedAt:
+                                                                                            {
+                                                                                                [$not]: null,
+                                                                                            },
+                                                                                    },
+                                                                                    include:
+                                                                                        {
+                                                                                            author: {
+                                                                                                select: [
+                                                                                                    "id",
+                                                                                                    "username",
+                                                                                                ],
+                                                                                            },
+                                                                                        },
+                                                                                },
+                                                                            },
+                                                                        where: {
+                                                                            username:
+                                                                                "Russell",
+                                                                        },
+                                                                    },
+                                                                },
+                                                            },
+                                                        },
+                                                    },
+                                                },
+                                            },
+                                        },
+                                        orderBy: ["name"],
+                                    },
+                                },
+                                orderBy: ["joinedAt"],
+                            },
+                        },
+                    },
+                },
+            }),
+        );
+    });
+});

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

@@ -0,0 +1,85 @@
+import { assertType, describe, test } from "vitest";
+
+import { db } from "../../../test/db";
+import { $gte, $ilike, $like, $not, $or } from "../../clauses/where/operators";
+
+describe("findMany", () => {
+    test("where clauses can only refer to fields that exist on the model", async () => {
+        assertType(
+            await db.findMany("post", {
+                select: ["id", "title", "content"],
+                where: {
+                    title: "I like cats",
+                    // @ts-expect-error 'wrong' is not a field on the post model
+                    wrong: 2,
+                },
+            }),
+        );
+    });
+
+    test("where clauses allow conditions to be grouped using logical operators", async () => {
+        assertType(
+            await db.findMany("post", {
+                select: ["id", "title", "content"],
+                where: {
+                    title: { [$like]: "I like %" },
+                    [$or]: [
+                        { title: { [$ilike]: "%dogs" } },
+                        { title: { [$ilike]: "%cats" } },
+                    ],
+                },
+            }),
+        );
+    });
+
+    test("where clauses can be applied to N:1 relations", async () => {
+        assertType(
+            await db.findMany("post", {
+                select: ["id", "title", "content"],
+                include: {
+                    author: {
+                        select: ["id", "username"],
+                        where: {
+                            username: "Russell",
+                            joinedAt: { [$gte]: new Date("2021-01-01") },
+                        },
+                    },
+                },
+            }),
+        );
+    });
+
+    test("where clauses can be applied to 1:N relations", async () => {
+        assertType(
+            await db.findMany("user", {
+                select: ["id", "username"],
+                include: {
+                    posts: {
+                        select: ["id", "title"],
+                        where: {
+                            publishedAt: { [$gte]: new Date("2021-01-01") },
+                        },
+                    },
+                },
+            }),
+        );
+    });
+
+    test("where clauses can be applied to N:N relations", async () => {
+        assertType(
+            await db.findMany("user", {
+                select: ["id", "username"],
+                include: {
+                    tenants: {
+                        select: ["id", "name"],
+                        where: {
+                            [$not]: {
+                                name: { [$like]: "% (Archived)" },
+                            },
+                        },
+                    },
+                },
+            }),
+        );
+    });
+});

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

@@ -0,0 +1,76 @@
+import { describe, expect, test } from "vitest";
+
+import { db } from "../../../test/db";
+import { seed } from "../../../test/seed";
+import { $in } from "../../clauses/where/operators";
+
+describe("findMany", () => {
+    test("it can apply where clauses to queries", async () => {
+        await db.transact(
+            async (db) => {
+                await seed(db, {
+                    users: [
+                        {
+                            username: "Russell",
+                            tenants: [{ name: "Popova Park", posts: 6 }],
+                        },
+                    ],
+                });
+                const result = await db.findMany("post", {
+                    select: ["title"],
+                    where: { title: { [$in]: ["Post a", "Post c"] } },
+                    orderBy: ["title"],
+                });
+                expect(result).toEqual([
+                    { title: "Post a" },
+                    { title: "Post c" },
+                ]);
+            },
+            { rollback: true },
+        );
+    });
+
+    test("clauses applied to N:1 models apply to the whole query", async () => {
+        await db.transact(
+            async (db) => {
+                await seed(db, {
+                    users: [
+                        {
+                            username: "Russell",
+                            tenants: [{ name: "Popova Park", posts: 2 }],
+                        },
+                    ],
+                });
+                expect(
+                    await db.findMany("post", {
+                        select: ["title"],
+                        include: {
+                            author: {
+                                select: ["username"],
+                                where: { username: "Fairooz" },
+                            },
+                        },
+                        orderBy: ["title"],
+                    }),
+                ).toEqual([]);
+
+                expect(
+                    await db.findMany("post", {
+                        select: ["title"],
+                        include: {
+                            author: {
+                                select: ["username"],
+                                where: { username: "Russell" },
+                            },
+                        },
+                        orderBy: ["title"],
+                    }),
+                ).toEqual([
+                    { title: "Post a", author: { username: "Russell" } },
+                    { title: "Post b", author: { username: "Russell" } },
+                ]);
+            },
+            { rollback: true },
+        );
+    });
+});