@casekit/orm 0.0.1-alpha.8 → 0.0.1-release-candidate

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

@@ -1,176 +0,0 @@
-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

@@ -1,127 +0,0 @@
-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 },
-                    values: {
-                        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

@@ -1,84 +0,0 @@
-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

@@ -1,184 +0,0 @@
-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

@@ -1,117 +0,0 @@
-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"],
-                            },
-                        },
-                    },
-                },
-            }),
-        );
-    });
-});