@casekit/orm2 0.0.0-20250331202540 → 1.0.0

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

@@ -0,0 +1,454 @@
+import { afterAll, beforeAll, beforeEach, describe, expect, test, } from "vitest";
+import { $not } from "../operators.js";
+import { createTestDB } from "./util/db.js";
+describe("findOne: 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.createMany("post", {
+                values: [
+                    factory.post({
+                        id: 1,
+                        authorId: 1,
+                        title: "Post 1",
+                    }),
+                    factory.post({
+                        id: 2,
+                        authorId: 1,
+                        title: "Post 2",
+                    }),
+                ],
+            });
+            const user = await db.findOne("user", {
+                select: ["id", "name"],
+                where: { id: 1 },
+                include: {
+                    posts: {
+                        select: ["id", "title"],
+                        orderBy: ["id"],
+                    },
+                },
+            });
+            expect(user).toEqual({
+                id: 1,
+                name: "User 1",
+                posts: [
+                    { id: 1, title: "Post 1" },
+                    { id: 2, title: "Post 2" },
+                ],
+            });
+        }, { rollback: true });
+    });
+    test("can filter included oneToMany relations", async () => {
+        await db.transact(async (db) => {
+            await db.createOne("user", {
+                values: factory.user({ id: 1 }),
+                returning: ["id"],
+            });
+            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: 1,
+                        publishedAt: new Date("2024-01-02"),
+                    }),
+                ],
+            });
+            const user = await db.findOne("user", {
+                select: ["id"],
+                where: { id: 1 },
+                include: {
+                    posts: {
+                        select: ["id", "publishedAt"],
+                        where: {
+                            publishedAt: { [$not]: null },
+                        },
+                        orderBy: ["id"],
+                    },
+                },
+            });
+            expect(user).toEqual({
+                id: 1,
+                posts: [
+                    { id: 1, publishedAt: new Date("2024-01-01") },
+                    { id: 3, publishedAt: new Date("2024-01-02") },
+                ],
+            });
+        }, { rollback: true });
+    });
+    test("can order included oneToMany relations", async () => {
+        await db.transact(async (db) => {
+            await db.createOne("user", {
+                values: factory.user({ id: 1 }),
+                returning: ["id"],
+            });
+            // Create posts with different 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: 1,
+                        createdAt: new Date("2024-01-02"),
+                    }),
+                ],
+            });
+            const user = await db.findOne("user", {
+                select: ["id"],
+                where: { id: 1 },
+                include: {
+                    posts: {
+                        select: ["id", "createdAt"],
+                        orderBy: [["createdAt", "desc"]],
+                    },
+                },
+            });
+            expect(user).toEqual({
+                id: 1,
+                posts: [
+                    { id: 2, createdAt: new Date("2024-01-03") },
+                    { id: 3, createdAt: new Date("2024-01-02") },
+                    { id: 1, createdAt: new Date("2024-01-01") },
+                ],
+            });
+        }, { rollback: true });
+    });
+    test("can limit and offset included oneToMany relations", async () => {
+        await db.transact(async (db) => {
+            await db.createOne("user", {
+                values: factory.user({ id: 1 }),
+                returning: ["id"],
+            });
+            // Create multiple posts
+            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: 1 }),
+                ],
+            });
+            const user = await db.findOne("user", {
+                select: ["id"],
+                where: { id: 1 },
+                include: {
+                    posts: {
+                        select: ["id"],
+                        orderBy: ["id"],
+                        limit: 2,
+                        offset: 1,
+                    },
+                },
+            });
+            expect(user).toEqual({
+                id: 1,
+                posts: [{ id: 2 }, { id: 3 }],
+            });
+        }, { rollback: true });
+    });
+    test("can include nested relations in oneToMany relations", async () => {
+        await db.transact(async (db) => {
+            // Create user and colors first
+            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("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 user = await db.findOne("user", {
+                select: ["id", "name"],
+                where: { id: 1 },
+                include: {
+                    posts: {
+                        select: ["id", "title"],
+                        include: {
+                            backgroundColor: {
+                                select: ["hex", "name"],
+                            },
+                            likes: {
+                                select: ["id"],
+                                include: {
+                                    user: {
+                                        select: ["id", "name"],
+                                    },
+                                },
+                            },
+                        },
+                        orderBy: ["id"],
+                    },
+                },
+            });
+            expect(user).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" },
+                            },
+                        ],
+                    },
+                ],
+            });
+        }, { rollback: true });
+    });
+    test("can filter and order deeply nested relations", async () => {
+        await db.transact(async (db) => {
+            await db.createOne("user", {
+                values: factory.user({ id: 1 }),
+                returning: ["id"],
+            });
+            await db.createOne("user", {
+                values: factory.user({ id: 2 }),
+                returning: ["id"],
+            });
+            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 user = await db.findOne("user", {
+                select: ["id"],
+                where: { id: 1 },
+                include: {
+                    posts: {
+                        select: ["id"],
+                        where: {},
+                        include: {
+                            backgroundColor: {
+                                select: ["name"],
+                                where: {
+                                    name: "Red",
+                                },
+                            },
+                            likes: {
+                                select: ["id", "createdAt"],
+                                orderBy: [["createdAt", "desc"]],
+                                include: {
+                                    user: {
+                                        select: ["id"],
+                                    },
+                                },
+                            },
+                        },
+                    },
+                },
+            });
+            expect(user).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 },
+                            },
+                        ],
+                    },
+                ],
+            });
+        }, { 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 user = await db.findOne("user", {
+                select: ["id"],
+                where: { id: 1 },
+                include: {
+                    friendships: {
+                        select: ["userId", "friendId"],
+                        include: {
+                            friend: {
+                                select: ["id", "name"],
+                            },
+                            stats: {
+                                select: ["messagesSent", "likesGiven"],
+                            },
+                        },
+                    },
+                },
+            });
+            expect(user).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 },
+                    },
+                ],
+            });
+        }, { rollback: true });
+    });
+});

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

@@ -0,0 +1,205 @@
+import { afterAll, beforeAll, beforeEach, describe, expect, test, } from "vitest";
+import { createTestDB } from "./util/db.js";
+describe("findOne: select", () => {
+    const { db, logger, factory } = createTestDB();
+    beforeEach(() => {
+        logger.clear();
+    });
+    beforeAll(async () => {
+        await db.connect();
+    });
+    afterAll(async () => {
+        await db.close();
+    });
+    test("selected fields are returned", async () => {
+        await db.transact(async (db) => {
+            await db.createOne("user", {
+                values: factory.user({ id: 1, name: "Lynne Tillman" }),
+            });
+            const user = await db.findOne("user", {
+                select: ["id", "name"],
+                where: { id: 1 },
+            });
+            expect(user).toEqual({ id: 1, name: "Lynne Tillman" });
+        }, { rollback: true });
+    });
+    test("primary key will not be returned if it is not selected", async () => {
+        await db.transact(async (db) => {
+            await db.createOne("user", {
+                values: factory.user({ id: 1, name: "Lynne Tillman" }),
+            });
+            const selectedUser = await db.findOne("user", {
+                select: ["name"],
+                where: { id: 1 },
+            });
+            expect(selectedUser).toEqual({ name: "Lynne Tillman" });
+        }, { rollback: true });
+    });
+    test("enum fields can be selected", async () => {
+        await db.transact(async (db) => {
+            await db.createOne("user", {
+                values: factory.user({ id: 1, role: "admin" }),
+            });
+            const user = await db.findOne("user", {
+                select: ["id", "role"],
+                where: { id: 1 },
+            });
+            expect(user).toEqual({ id: 1, role: "admin" });
+        }, { rollback: true });
+    });
+    test("array fields can be selected", async () => {
+        await db.transact(async (db) => {
+            await db.createOne("user", {
+                values: factory.user({ id: 1, role: "user" }),
+            });
+            await db.createOne("post", {
+                values: factory.post({
+                    id: 3,
+                    tags: ["foo", "bar"],
+                    authorId: 1,
+                }),
+            });
+            const post = await db.findOne("post", {
+                select: ["id", "tags"],
+                where: { id: 3 },
+            });
+            expect(post).toEqual({ id: 3, tags: ["foo", "bar"] });
+        }, { rollback: true });
+    });
+    test("json fields can be selected", async () => {
+        await db.transact(async (db) => {
+            await db.createOne("user", {
+                values: factory.user({ id: 1, role: "user" }),
+            });
+            await db.createOne("post", {
+                values: factory.post({
+                    id: 3,
+                    authorId: 1,
+                    metadata: {
+                        foo: "a",
+                        bar: [
+                            { baz: "good", quux: true },
+                            { baz: "bad", quux: false },
+                        ],
+                    },
+                }),
+            });
+            const post = await db.findOne("post", {
+                select: ["metadata"],
+                where: { id: 3 },
+            });
+            expect(post).toEqual({
+                metadata: {
+                    foo: "a",
+                    bar: [
+                        { baz: "good", quux: true },
+                        { baz: "bad", quux: false },
+                    ],
+                },
+            });
+        }, { rollback: true });
+    });
+    test("throws error when no records match criteria", async () => {
+        await db.transact(async (db) => {
+            await expect(db.findOne("user", {
+                select: ["id", "name"],
+                where: { id: 999 },
+            })).rejects.toThrow("Expected one row, but found none");
+        }, { rollback: true });
+    });
+    test("handles null values in selected fields correctly", async () => {
+        await db.transact(async (db) => {
+            await db.createOne("user", {
+                values: factory.user({
+                    id: 1,
+                    deletedAt: null,
+                }),
+            });
+            const user = await db.findOne("user", {
+                select: ["id", "deletedAt"],
+                where: { id: 1 },
+            });
+            expect(user).toEqual({
+                id: 1,
+                deletedAt: null,
+            });
+        }, { rollback: true });
+    });
+    test("can select all available fields", async () => {
+        await db.transact(async (db) => {
+            const userData = factory.user({
+                id: 1,
+                name: "Test User",
+                email: "test@example.com",
+                role: "user",
+                preferences: { theme: "dark" },
+                createdAt: new Date("2024-01-01"),
+                deletedAt: null,
+            });
+            await db.createOne("user", { values: userData });
+            const user = await db.findOne("user", {
+                select: [
+                    "id",
+                    "name",
+                    "email",
+                    "role",
+                    "preferences",
+                    "createdAt",
+                    "deletedAt",
+                ],
+                where: { id: 1 },
+            });
+            expect(user).toEqual(userData);
+        }, { rollback: true });
+    });
+    test("throws error when selecting from non-existent model", async () => {
+        await db.transact(async (db) => {
+            await expect(
+            // @ts-expect-error - Testing runtime behavior
+            db.findOne("invalid", {
+                select: ["id"],
+                where: { id: 1 },
+            })).rejects.toThrow(`Model "invalid" not found`);
+        }, { rollback: true });
+    });
+    test("throws error when selecting non-existent field", async () => {
+        await db.transact(async (db) => {
+            await expect(db.findOne("user", {
+                // @ts-expect-error - Testing runtime behavior
+                select: ["id", "nonexistentField"],
+                where: { id: 1 },
+            })).rejects.toThrow(`Field "nonexistentField" not found in model "user"`);
+        }, { rollback: true });
+    });
+    test("handles special characters in selected field values", async () => {
+        await db.transact(async (db) => {
+            await db.createOne("user", {
+                values: factory.user({
+                    id: 1,
+                    name: "O'Connor; DROP TABLE users;",
+                }),
+            });
+            const user = await db.findOne("user", {
+                select: ["id", "name"],
+                where: { id: 1 },
+            });
+            expect(user).toEqual({
+                id: 1,
+                name: "O'Connor; DROP TABLE users;",
+            });
+        }, { rollback: true });
+    });
+    test("handles large text values in selected fields", async () => {
+        await db.transact(async (db) => {
+            const longText = "a".repeat(10000);
+            await db.createOne("user", {
+                values: factory.user({ id: 1, name: longText }),
+            });
+            const user = await db.findOne("user", {
+                select: ["id", "name"],
+                where: { id: 1 },
+            });
+            expect(user).toEqual({ id: 1, name: longText });
+        }, { rollback: true });
+    });
+});