@casekit/orm2 0.0.0-20250322230249

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

@@ -0,0 +1,530 @@
+import { afterAll, beforeAll, beforeEach, describe, expect, test, } from "vitest";
+import { $not } from "../operators.js";
+import { createTestDB } from "./util/db.js";
+describe("findMany: include oneToMany", () => {
+    const { db, logger, factory } = createTestDB();
+    beforeEach(() => {
+        logger.clear();
+    });
+    beforeAll(async () => {
+        await db.connect();
+    });
+    afterAll(async () => {
+        await db.close();
+    });
+    test("can include oneToMany relations", async () => {
+        await db.transact(async (db) => {
+            await db.createOne("user", {
+                values: factory.user({ id: 1, name: "User 1" }),
+                returning: ["id"],
+            });
+            await db.createOne("user", {
+                values: factory.user({ id: 2, name: "User 2" }),
+                returning: ["id"],
+            });
+            await db.createMany("post", {
+                values: [
+                    factory.post({
+                        id: 1,
+                        authorId: 1,
+                        title: "Post 1",
+                    }),
+                    factory.post({
+                        id: 2,
+                        authorId: 1,
+                        title: "Post 2",
+                    }),
+                    factory.post({
+                        id: 3,
+                        authorId: 2,
+                        title: "Post 3",
+                    }),
+                ],
+            });
+            const users = await db.findMany("user", {
+                select: ["id", "name"],
+                include: {
+                    posts: {
+                        select: ["id", "title"],
+                        orderBy: ["id"],
+                    },
+                },
+                orderBy: ["id"],
+            });
+            expect(users).toEqual([
+                {
+                    id: 1,
+                    name: "User 1",
+                    posts: [
+                        { id: 1, title: "Post 1" },
+                        { id: 2, title: "Post 2" },
+                    ],
+                },
+                {
+                    id: 2,
+                    name: "User 2",
+                    posts: [{ id: 3, title: "Post 3" }],
+                },
+            ]);
+        }, { rollback: true });
+    });
+    test("can filter included oneToMany relations", async () => {
+        await db.transact(async (db) => {
+            await db.createMany("user", {
+                values: [factory.user({ id: 1 }), factory.user({ id: 2 })],
+            });
+            await db.createMany("post", {
+                values: [
+                    factory.post({
+                        id: 1,
+                        authorId: 1,
+                        publishedAt: new Date("2024-01-01"),
+                    }),
+                    factory.post({
+                        id: 2,
+                        authorId: 1,
+                        publishedAt: null,
+                    }),
+                    factory.post({
+                        id: 3,
+                        authorId: 2,
+                        publishedAt: new Date("2024-01-02"),
+                    }),
+                    factory.post({
+                        id: 4,
+                        authorId: 1,
+                        publishedAt: null,
+                    }),
+                ],
+            });
+            const users = await db.findMany("user", {
+                select: ["id"],
+                include: {
+                    posts: {
+                        select: ["id", "publishedAt"],
+                        where: {
+                            publishedAt: { [$not]: null },
+                        },
+                        orderBy: ["id"],
+                    },
+                },
+                orderBy: ["id"],
+            });
+            expect(users).toEqual([
+                {
+                    id: 1,
+                    posts: [{ id: 1, publishedAt: new Date("2024-01-01") }],
+                },
+                {
+                    id: 2,
+                    posts: [{ id: 3, publishedAt: new Date("2024-01-02") }],
+                },
+            ]);
+        }, { rollback: true });
+    });
+    test("can order included oneToMany relations", async () => {
+        await db.transact(async (db) => {
+            await db.createMany("user", {
+                values: [factory.user({ id: 1 }), factory.user({ id: 2 })],
+            });
+            // Create posts with overlapping creation dates
+            await db.createMany("post", {
+                values: [
+                    factory.post({
+                        id: 1,
+                        authorId: 1,
+                        createdAt: new Date("2024-01-01"),
+                    }),
+                    factory.post({
+                        id: 2,
+                        authorId: 1,
+                        createdAt: new Date("2024-01-03"),
+                    }),
+                    factory.post({
+                        id: 3,
+                        authorId: 2,
+                        createdAt: new Date("2024-01-02"),
+                    }),
+                    factory.post({
+                        id: 4,
+                        authorId: 2,
+                        createdAt: new Date("2024-01-04"),
+                    }),
+                ],
+            });
+            const users = await db.findMany("user", {
+                select: ["id"],
+                include: {
+                    posts: {
+                        select: ["id", "createdAt"],
+                        orderBy: [["createdAt", "desc"]],
+                    },
+                },
+                orderBy: ["id"],
+            });
+            expect(users).toEqual([
+                {
+                    id: 1,
+                    posts: [
+                        { id: 2, createdAt: new Date("2024-01-03") },
+                        { id: 1, createdAt: new Date("2024-01-01") },
+                    ],
+                },
+                {
+                    id: 2,
+                    posts: [
+                        { id: 4, createdAt: new Date("2024-01-04") },
+                        { id: 3, createdAt: new Date("2024-01-02") },
+                    ],
+                },
+            ]);
+        }, { rollback: true });
+    });
+    test("can limit and offset included oneToMany relations", async () => {
+        await db.transact(async (db) => {
+            await db.createMany("user", {
+                values: [factory.user({ id: 1 }), factory.user({ id: 2 })],
+            });
+            // Create multiple posts for each user
+            await db.createMany("post", {
+                values: [
+                    factory.post({
+                        id: 1,
+                        authorId: 1,
+                    }),
+                    factory.post({
+                        id: 2,
+                        authorId: 1,
+                    }),
+                    factory.post({
+                        id: 3,
+                        authorId: 1,
+                    }),
+                    factory.post({
+                        id: 4,
+                        authorId: 2,
+                    }),
+                    factory.post({
+                        id: 5,
+                        authorId: 2,
+                    }),
+                    factory.post({
+                        id: 6,
+                        authorId: 2,
+                    }),
+                ],
+            });
+            const users = await db.findMany("user", {
+                select: ["id"],
+                include: {
+                    posts: {
+                        select: ["id"],
+                        orderBy: ["id"],
+                        limit: 2,
+                        offset: 1,
+                    },
+                },
+                orderBy: ["id"],
+            });
+            expect(users).toEqual([
+                {
+                    id: 1,
+                    posts: [{ id: 2 }, { id: 3 }],
+                },
+                {
+                    id: 2,
+                    posts: [{ id: 5 }, { id: 6 }],
+                },
+            ]);
+        }, { rollback: true });
+    });
+    test("can include nested relations in oneToMany relations", async () => {
+        await db.transact(async (db) => {
+            // Create users and colors first
+            await db.createMany("user", {
+                values: [
+                    factory.user({ id: 1, name: "User 1" }),
+                    factory.user({ id: 2, name: "User 2" }),
+                ],
+            });
+            await db.createMany("color", {
+                values: [
+                    factory.color({ hex: "#FF0000", name: "Red" }),
+                    factory.color({ hex: "#00FF00", name: "Green" }),
+                ],
+            });
+            // Create posts with N:1 relations to colors
+            await db.createMany("post", {
+                values: [
+                    factory.post({
+                        id: 1,
+                        authorId: 1,
+                        title: "Post 1",
+                        backgroundColorValue: "#FF0000",
+                    }),
+                    factory.post({
+                        id: 2,
+                        authorId: 1,
+                        title: "Post 2",
+                        backgroundColorValue: "#00FF00",
+                    }),
+                ],
+            });
+            // Create likes (N:N relation via post -> likes <- user)
+            await db.createMany("like", {
+                values: [
+                    factory.like({ id: 1, userId: 2, postId: 1 }),
+                    factory.like({ id: 2, userId: 2, postId: 2 }),
+                ],
+            });
+            const users = await db.findMany("user", {
+                select: ["id", "name"],
+                include: {
+                    posts: {
+                        select: ["id", "title"],
+                        include: {
+                            backgroundColor: {
+                                select: ["hex", "name"],
+                            },
+                            likes: {
+                                select: ["id"],
+                                include: {
+                                    user: {
+                                        select: ["id", "name"],
+                                    },
+                                },
+                            },
+                        },
+                        orderBy: ["id"],
+                    },
+                },
+                orderBy: ["id"],
+            });
+            expect(users).toEqual([
+                {
+                    id: 1,
+                    name: "User 1",
+                    posts: [
+                        {
+                            id: 1,
+                            title: "Post 1",
+                            backgroundColor: {
+                                hex: "#FF0000",
+                                name: "Red",
+                            },
+                            likes: [
+                                {
+                                    id: 1,
+                                    user: { id: 2, name: "User 2" },
+                                },
+                            ],
+                        },
+                        {
+                            id: 2,
+                            title: "Post 2",
+                            backgroundColor: {
+                                hex: "#00FF00",
+                                name: "Green",
+                            },
+                            likes: [
+                                {
+                                    id: 2,
+                                    user: { id: 2, name: "User 2" },
+                                },
+                            ],
+                        },
+                    ],
+                },
+                {
+                    id: 2,
+                    name: "User 2",
+                    posts: [],
+                },
+            ]);
+        }, { rollback: true });
+    });
+    test("can filter and order deeply nested relations", async () => {
+        await db.transact(async (db) => {
+            await db.createMany("user", {
+                values: [factory.user({ id: 1 }), factory.user({ id: 2 })],
+            });
+            await db.createMany("color", {
+                values: [
+                    factory.color({ hex: "#FF0000", name: "Red" }),
+                    factory.color({ hex: "#00FF00", name: "Green" }),
+                ],
+            });
+            await db.createMany("post", {
+                values: [
+                    factory.post({
+                        id: 1,
+                        authorId: 1,
+                        backgroundColorValue: "#FF0000",
+                        createdAt: new Date("2024-01-01"),
+                    }),
+                    factory.post({
+                        id: 2,
+                        authorId: 1,
+                        backgroundColorValue: "#00FF00",
+                        createdAt: new Date("2024-01-02"),
+                    }),
+                ],
+            });
+            await db.createMany("like", {
+                values: [
+                    factory.like({
+                        id: 1,
+                        userId: 2,
+                        postId: 1,
+                        createdAt: new Date("2024-01-03"),
+                    }),
+                    factory.like({
+                        id: 2,
+                        userId: 1,
+                        postId: 1,
+                        createdAt: new Date("2024-01-04"),
+                    }),
+                    factory.like({
+                        id: 3,
+                        userId: 2,
+                        postId: 2,
+                        createdAt: new Date("2024-01-04"),
+                    }),
+                ],
+            });
+            const users = await db.findMany("user", {
+                select: ["id"],
+                include: {
+                    posts: {
+                        select: ["id"],
+                        where: {},
+                        include: {
+                            backgroundColor: {
+                                select: ["name"],
+                                where: {
+                                    name: "Red",
+                                },
+                            },
+                            likes: {
+                                select: ["id", "createdAt"],
+                                orderBy: [["createdAt", "desc"]],
+                                include: {
+                                    user: {
+                                        select: ["id"],
+                                    },
+                                },
+                            },
+                        },
+                    },
+                },
+                orderBy: ["id"],
+            });
+            expect(users).toEqual([
+                {
+                    id: 1,
+                    posts: [
+                        {
+                            id: 1,
+                            backgroundColor: { name: "Red" },
+                            likes: [
+                                {
+                                    id: 2,
+                                    createdAt: new Date("2024-01-04"),
+                                    user: { id: 1 },
+                                },
+                                {
+                                    id: 1,
+                                    createdAt: new Date("2024-01-03"),
+                                    user: { id: 2 },
+                                },
+                            ],
+                        },
+                    ],
+                },
+                {
+                    id: 2,
+                    posts: [],
+                },
+            ]);
+        }, { rollback: true });
+    });
+    test("can include oneToMany relations with multi-field joins", async () => {
+        await db.transact(async (db) => {
+            await db.createMany("user", {
+                values: [
+                    factory.user({ id: 1, name: "Lynne Tillman" }),
+                    factory.user({ id: 2, name: "Stewart Home" }),
+                    factory.user({ id: 3, name: "Judith Butler" }),
+                ],
+            });
+            await db.createMany("friendship", {
+                values: [
+                    factory.friendship({ userId: 1, friendId: 2 }),
+                    factory.friendship({ userId: 1, friendId: 3 }),
+                ],
+            });
+            await db.createMany("friendshipStats", {
+                values: [
+                    factory.friendshipStats({
+                        id: 1,
+                        userId: 1,
+                        friendId: 2,
+                        messagesSent: 100,
+                        likesGiven: 50,
+                    }),
+                    factory.friendshipStats({
+                        id: 2,
+                        userId: 1,
+                        friendId: 3,
+                        messagesSent: 200,
+                        likesGiven: 75,
+                    }),
+                ],
+            });
+            const users = await db.findMany("user", {
+                select: ["id"],
+                include: {
+                    friendships: {
+                        select: ["userId", "friendId"],
+                        include: {
+                            friend: {
+                                select: ["id", "name"],
+                            },
+                            stats: {
+                                select: ["messagesSent", "likesGiven"],
+                            },
+                        },
+                    },
+                },
+                orderBy: ["id"],
+            });
+            expect(users).toEqual([
+                {
+                    id: 1,
+                    friendships: [
+                        {
+                            userId: 1,
+                            friendId: 2,
+                            friend: { id: 2, name: "Stewart Home" },
+                            stats: { messagesSent: 100, likesGiven: 50 },
+                        },
+                        {
+                            userId: 1,
+                            friendId: 3,
+                            friend: { id: 3, name: "Judith Butler" },
+                            stats: { messagesSent: 200, likesGiven: 75 },
+                        },
+                    ],
+                },
+                {
+                    id: 2,
+                    friendships: [],
+                },
+                {
+                    id: 3,
+                    friendships: [],
+                },
+            ]);
+        }, { rollback: true });
+    });
+});

package/build/tests/orm.findMany.middleware.test.d.ts

@@ -0,0 +1 @@
+export {};

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

@@ -0,0 +1,66 @@
+import { afterAll, beforeAll, beforeEach, describe, expect, test, vi, } from "vitest";
+import { config } from "@casekit/orm2-fixtures";
+import { orm } from "../orm.js";
+import { mockLogger } from "./util/logger.js";
+describe("orm.findMany: middleware", () => {
+    const logger = mockLogger();
+    let db;
+    beforeEach(() => {
+        logger.clear();
+    });
+    beforeAll(async () => {
+        db = orm({ ...config, logger });
+        await db.connect();
+    });
+    afterAll(async () => {
+        await db.close();
+    });
+    describe("findMany middleware", () => {
+        test("it allows overriding the orm's findMany method", async () => {
+            await db.transact(async (db) => {
+                // Create multiple test users
+                await db.createMany("user", {
+                    values: [
+                        {
+                            id: 1,
+                            name: "Test User 1",
+                            email: "test1@example.com",
+                            role: "user",
+                        },
+                        {
+                            id: 2,
+                            name: "Test User 2",
+                            email: "test2@example.com",
+                            role: "admin",
+                        },
+                    ],
+                    returning: ["id"],
+                });
+                const stub = vi.fn();
+                const dbWithMiddleware = db.middleware([
+                    {
+                        findMany: (db, table, query) => {
+                            stub("called stub in middleware 1");
+                            return db.findMany(table, query);
+                        },
+                    },
+                    {
+                        findMany: (db, table, query) => {
+                            stub("called stub in middleware 2");
+                            return db.findMany(table, query);
+                        },
+                    },
+                ]);
+                const results = await dbWithMiddleware.findMany("user", {
+                    select: ["id", "name"],
+                    where: { role: "user" },
+                });
+                expect(results).toEqual([{ id: 1, name: "Test User 1" }]);
+                expect(stub.mock.calls).toEqual([
+                    ["called stub in middleware 1"],
+                    ["called stub in middleware 2"],
+                ]);
+            }, { rollback: true });
+        });
+    });
+});

package/build/tests/orm.findMany.offsetLimit.test.d.ts

@@ -0,0 +1 @@
+export {};