@casekit/orm2 0.0.0-20250331181319 → 0.0.0

package/build/tests/orm.findMany.includeManyToOne.test.js

@@ -69,6 +69,7 @@ describe("findMany: N:1 relations", () => {
                 values: [
                     factory.post({
                         id: 2,
+                        title: "Post 2",
                         authorId: 1,
                         backgroundColorValue: "#ff0000",
                     }),
@@ -79,17 +80,32 @@ describe("findMany: N:1 relations", () => {
                 include: {
                     author: {
                         select: ["name"],
-                    },
-                    backgroundColor: {
-                        select: ["name"],
+                        include: {
+                            posts: {
+                                select: ["id", "title"],
+                                include: {
+                                    backgroundColor: {
+                                        select: ["name"],
+                                    },
+                                },
+                            },
+                        },
                     },
                 },
             });
             expect(posts).toEqual([
                 {
                     id: 2,
-                    author: { name: "Author" },
-                    backgroundColor: { name: "Red" },
+                    author: {
+                        name: "Author",
+                        posts: [
+                            {
+                                id: 2,
+                                title: "Post 2",
+                                backgroundColor: { name: "Red" },
+                            },
+                        ],
+                    },
                 },
             ]);
         }, { rollback: true });

package/build/tests/orm.findOne.includeManyToMany.test.js

@@ -0,0 +1,270 @@
+import { afterAll, beforeAll, beforeEach, describe, expect, test, } from "vitest";
+import { createTestDB } from "./util/db.js";
+describe("findOne: include manyToMany", () => {
+    const { db, logger, factory } = createTestDB();
+    beforeEach(() => {
+        logger.clear();
+    });
+    beforeAll(async () => {
+        await db.connect();
+    });
+    afterAll(async () => {
+        await db.close();
+    });
+    test("can include manyToMany relations", async () => {
+        await db.transact(async (db) => {
+            await db.createMany("user", {
+                values: [
+                    factory.user({ id: 1, name: "User 1" }),
+                    factory.user({ id: 2, name: "User 2" }),
+                    factory.user({ id: 3, name: "User 3" }),
+                ],
+            });
+            await db.createMany("friendship", {
+                values: [
+                    factory.friendship({ userId: 1, friendId: 2 }),
+                    factory.friendship({ userId: 1, friendId: 3 }),
+                    factory.friendship({ userId: 2, friendId: 3 }),
+                ],
+            });
+            const user = await db.findOne("user", {
+                select: ["id", "name"],
+                where: { id: 1 },
+                include: {
+                    friends: {
+                        select: ["id", "name"],
+                        orderBy: ["id"],
+                    },
+                },
+            });
+            expect(user).toEqual({
+                id: 1,
+                name: "User 1",
+                friends: [
+                    { id: 2, name: "User 2" },
+                    { id: 3, name: "User 3" },
+                ],
+            });
+        }, { rollback: true });
+    });
+    test("can filter included manyToMany relations", async () => {
+        await db.transact(async (db) => {
+            await db.createMany("user", {
+                values: [
+                    factory.user({ id: 1, role: "admin" }),
+                    factory.user({ id: 2, role: "user" }),
+                    factory.user({ id: 3, role: "admin" }),
+                ],
+            });
+            await db.createMany("friendship", {
+                values: [
+                    factory.friendship({ userId: 1, friendId: 2 }),
+                    factory.friendship({ userId: 1, friendId: 3 }),
+                    factory.friendship({ userId: 2, friendId: 3 }),
+                ],
+            });
+            const user = await db.findOne("user", {
+                select: ["id"],
+                where: { id: 1 },
+                include: {
+                    friends: {
+                        select: ["id", "role"],
+                        where: {
+                            role: "admin",
+                        },
+                        orderBy: ["id"],
+                    },
+                },
+            });
+            expect(user).toEqual({
+                id: 1,
+                friends: [{ id: 3, role: "admin" }],
+            });
+        }, { rollback: true });
+    });
+    test("can limit and offset included manyToMany relations", async () => {
+        await db.transact(async (db) => {
+            // Create users with ascending creation dates
+            await db.createMany("user", {
+                values: [
+                    factory.user({
+                        id: 1,
+                        createdAt: new Date("2024-01-01"),
+                    }),
+                    factory.user({
+                        id: 2,
+                        createdAt: new Date("2024-01-02"),
+                    }),
+                    factory.user({
+                        id: 3,
+                        createdAt: new Date("2024-01-03"),
+                    }),
+                    factory.user({
+                        id: 4,
+                        createdAt: new Date("2024-01-04"),
+                    }),
+                ],
+            });
+            // Create friendships
+            await db.createMany("friendship", {
+                values: [
+                    factory.friendship({ userId: 1, friendId: 2 }),
+                    factory.friendship({ userId: 1, friendId: 3 }),
+                    factory.friendship({ userId: 1, friendId: 4 }),
+                ],
+            });
+            const user = await db.findOne("user", {
+                select: ["id"],
+                where: { id: 1 },
+                include: {
+                    friends: {
+                        select: ["id"],
+                        orderBy: ["id"],
+                        limit: 2,
+                        offset: 1,
+                    },
+                },
+            });
+            expect(user).toEqual({
+                id: 1,
+                friends: [{ id: 3 }, { id: 4 }],
+            });
+        }, { rollback: true });
+    });
+    test("can include nested relations through manyToMany", async () => {
+        await db.transact(async (db) => {
+            await db.createMany("user", {
+                values: [
+                    factory.user({ id: 1, name: "User 1" }),
+                    factory.user({ id: 2, name: "User 2" }),
+                ],
+            });
+            await db.createMany("friendship", {
+                values: [factory.friendship({ userId: 1, friendId: 2 })],
+            });
+            await db.createMany("post", {
+                values: [
+                    factory.post({
+                        id: 1,
+                        authorId: 2,
+                        title: "Post 1",
+                    }),
+                    factory.post({
+                        id: 2,
+                        authorId: 2,
+                        title: "Post 2",
+                    }),
+                ],
+            });
+            const user = await db.findOne("user", {
+                select: ["id", "name"],
+                where: { id: 1 },
+                include: {
+                    friends: {
+                        select: ["id", "name"],
+                        include: {
+                            posts: {
+                                select: ["id", "title"],
+                                orderBy: ["id"],
+                            },
+                        },
+                        orderBy: ["id"],
+                    },
+                },
+            });
+            expect(user).toEqual({
+                id: 1,
+                name: "User 1",
+                friends: [
+                    {
+                        id: 2,
+                        name: "User 2",
+                        posts: [
+                            { id: 1, title: "Post 1" },
+                            { id: 2, title: "Post 2" },
+                        ],
+                    },
+                ],
+            });
+        }, { rollback: true });
+    });
+    test("handles not found case appropriately", async () => {
+        await db.transact(async (db) => {
+            await db.createMany("user", {
+                values: [
+                    factory.user({ id: 1, name: "User 1" }),
+                    factory.user({ id: 2, name: "User 2" }),
+                ],
+            });
+            await db.createMany("friendship", {
+                values: [factory.friendship({ userId: 1, friendId: 2 })],
+            });
+            // Should throw when user doesn't exist
+            await expect(db.findOne("user", {
+                select: ["id"],
+                where: { id: 999 },
+                include: {
+                    friends: {
+                        select: ["id"],
+                    },
+                },
+            })).rejects.toThrow();
+        }, { rollback: true });
+    });
+    test("can include manyToMany relations with complex ordering", async () => {
+        await db.transact(async (db) => {
+            await db.createMany("user", {
+                values: [
+                    factory.user({
+                        id: 1,
+                        name: "User 1",
+                        createdAt: new Date("2024-01-01"),
+                    }),
+                    factory.user({
+                        id: 2,
+                        name: "User 2",
+                        createdAt: new Date("2024-01-03"),
+                    }),
+                    factory.user({
+                        id: 3,
+                        name: "User 3",
+                        createdAt: new Date("2024-01-02"),
+                    }),
+                ],
+            });
+            await db.createMany("friendship", {
+                values: [
+                    factory.friendship({ userId: 1, friendId: 2 }),
+                    factory.friendship({ userId: 1, friendId: 3 }),
+                ],
+            });
+            const user = await db.findOne("user", {
+                select: ["id", "name"],
+                where: { id: 1 },
+                include: {
+                    friends: {
+                        select: ["id", "name", "createdAt"],
+                        orderBy: [["createdAt", "desc"]],
+                    },
+                },
+            });
+            // Use toEqual with a complete object that specifies the exact expected order
+            expect(user).toEqual({
+                id: 1,
+                name: "User 1",
+                friends: [
+                    {
+                        id: 2,
+                        name: "User 2",
+                        createdAt: expect.any(Date),
+                    },
+                    {
+                        id: 3,
+                        name: "User 3",
+                        createdAt: expect.any(Date),
+                    },
+                ],
+            });
+        }, { rollback: true });
+    });
+});

package/build/tests/orm.findOne.includeManyToOne.test.js

@@ -0,0 +1,280 @@
+import { afterAll, beforeAll, beforeEach, describe, expect, test, } from "vitest";
+import { $not } from "../operators.js";
+import { createTestDB } from "./util/db.js";
+describe("findOne: N:1 relations", () => {
+    const { db, logger, factory } = createTestDB();
+    beforeEach(() => {
+        logger.clear();
+    });
+    beforeAll(async () => {
+        await db.connect();
+    });
+    afterAll(async () => {
+        await db.close();
+    });
+    test("can select N:1 relations", async () => {
+        await db.transact(async (db) => {
+            await db.createMany("user", {
+                values: [
+                    factory.user({ id: 1, name: "Author 1" }),
+                    factory.user({ id: 2, name: "Author 2" }),
+                ],
+            });
+            await db.createMany("post", {
+                values: [
+                    factory.post({
+                        id: 3,
+                        title: "Post 1",
+                        authorId: 1,
+                    }),
+                    factory.post({
+                        id: 4,
+                        title: "Post 2",
+                        authorId: 2,
+                    }),
+                ],
+            });
+            const post = await db.findOne("post", {
+                select: ["id", "title"],
+                where: { id: 3 },
+                include: {
+                    author: {
+                        select: ["id", "name"],
+                    },
+                },
+            });
+            expect(post).toEqual({
+                id: 3,
+                title: "Post 1",
+                author: { id: 1, name: "Author 1" },
+            });
+        }, { rollback: true });
+    });
+    test("can select nested N:1 relations", async () => {
+        await db.transact(async (db) => {
+            await db.createOne("color", {
+                values: factory.color({ hex: "#ff0000", name: "Red" }),
+            });
+            const user = await db.createOne("user", {
+                values: factory.user({ id: 1, name: "Author" }),
+            });
+            await db.createOne("post", {
+                values: factory.post({
+                    id: 2,
+                    title: "Post 2",
+                    authorId: 1,
+                    backgroundColorValue: "#ff0000",
+                }),
+            });
+            const post = await db.findOne("post", {
+                select: ["id"],
+                include: {
+                    author: {
+                        select: ["name"],
+                        include: {
+                            posts: {
+                                select: ["id", "title"],
+                                include: {
+                                    backgroundColor: {
+                                        select: ["name"],
+                                    },
+                                },
+                            },
+                        },
+                    },
+                },
+            });
+            expect(post).toEqual({
+                id: 2,
+                author: {
+                    name: "Author",
+                    posts: [
+                        {
+                            id: 2,
+                            title: "Post 2",
+                            backgroundColor: { name: "Red" },
+                        },
+                    ],
+                },
+            });
+        }, { rollback: true });
+    });
+    test("filters by N:1 relation where clause", async () => {
+        await db.transact(async (db) => {
+            await db.createMany("user", {
+                values: [
+                    factory.user({
+                        id: 1,
+                        name: "Active",
+                        deletedAt: null,
+                    }),
+                    factory.user({
+                        id: 2,
+                        name: "Deleted",
+                        deletedAt: new Date(),
+                    }),
+                ],
+            });
+            await db.createMany("post", {
+                values: [
+                    factory.post({
+                        id: 1,
+                        authorId: 1,
+                    }),
+                    factory.post({
+                        id: 2,
+                        authorId: 2,
+                    }),
+                ],
+            });
+            const post = await db.findOne("post", {
+                select: ["id"],
+                where: { id: 1 },
+                include: {
+                    author: {
+                        select: ["name"],
+                        where: { deletedAt: null },
+                    },
+                },
+            });
+            expect(post).toEqual({ id: 1, author: { name: "Active" } });
+            // Test that filtering works - this post's author doesn't match the where clause
+            await expect(async () => {
+                await db.findOne("post", {
+                    select: ["id"],
+                    where: { id: 2 },
+                    include: {
+                        author: {
+                            select: ["name"],
+                            where: { deletedAt: null },
+                        },
+                    },
+                });
+            }).rejects.toThrow();
+        }, { rollback: true });
+    });
+    test("enforces where clause even on optional N:1 relation", async () => {
+        await db.transact(async (db) => {
+            await db.createMany("color", {
+                values: [
+                    factory.color({ hex: "#ff0000", name: "Red" }),
+                    factory.color({ hex: "#0000ff", name: "Blue" }),
+                ],
+            });
+            await db.createOne("user", {
+                values: factory.user({ id: 1 }),
+            });
+            await db.createMany("post", {
+                values: [
+                    factory.post({
+                        id: 1,
+                        authorId: 1,
+                        backgroundColorValue: "#ff0000",
+                    }),
+                    factory.post({
+                        id: 2,
+                        authorId: 1,
+                    }),
+                    factory.post({
+                        id: 3,
+                        authorId: 1,
+                        backgroundColorValue: "#0000ff",
+                    }),
+                ],
+            });
+            const post = await db.findOne("post", {
+                select: ["id"],
+                where: { id: 3 },
+                include: {
+                    backgroundColor: {
+                        select: ["name"],
+                        where: { name: "Blue" },
+                    },
+                },
+            });
+            expect(post).toEqual({
+                id: 3,
+                backgroundColor: {
+                    name: "Blue",
+                },
+            });
+            // Test that post without backgroundColor matching the filter will exclude the record
+            await expect(db.findOne("post", {
+                select: ["id"],
+                where: { id: 1 },
+                include: {
+                    backgroundColor: {
+                        select: ["name"],
+                        where: { name: "Blue" },
+                    },
+                },
+            })).rejects.toThrowError("Expected one row, but found none");
+        }, { rollback: true });
+    });
+    test("combines where clauses across multiple levels", async () => {
+        await db.transact(async (db) => {
+            await db.createMany("color", {
+                values: [
+                    factory.color({ hex: "#ff0000", name: "Red" }),
+                    factory.color({ hex: "#0000ff", name: "Blue" }),
+                ],
+            });
+            await db.createMany("user", {
+                values: [
+                    factory.user({ id: 1, role: "admin" }),
+                    factory.user({ id: 2, role: "user" }),
+                ],
+            });
+            await db.createMany("post", {
+                values: [
+                    factory.post({
+                        id: 1,
+                        authorId: 1,
+                        backgroundColorValue: "#ff0000",
+                        publishedAt: new Date(),
+                    }),
+                    factory.post({
+                        id: 2,
+                        authorId: 1,
+                        backgroundColorValue: "#ff0000",
+                        publishedAt: null,
+                    }),
+                    factory.post({
+                        id: 3,
+                        authorId: 2,
+                        backgroundColorValue: "#ff0000",
+                        publishedAt: new Date(),
+                    }),
+                    factory.post({
+                        id: 4,
+                        authorId: 1,
+                        backgroundColorValue: "#0000ff",
+                        publishedAt: new Date(),
+                    }),
+                ],
+            });
+            const post = await db.findOne("post", {
+                select: ["id"],
+                where: {
+                    id: 1,
+                    publishedAt: { [$not]: null },
+                },
+                include: {
+                    author: {
+                        select: ["id"],
+                        where: { role: "admin" },
+                    },
+                    backgroundColor: {
+                        select: ["name"],
+                        where: { name: "Red" },
+                    },
+                },
+            });
+            expect(post).toEqual({
+                id: 1,
+                author: { id: 1 },
+                backgroundColor: { name: "Red" },
+            });
+        }, { rollback: true });
+    });
+});