@casekit/orm 0.0.1-alpha.9 → 0.0.1-release-candidate.2

package/build/tests/orm.findOne.test-d.js

@@ -0,0 +1,377 @@
+import { describe, expectTypeOf, test } from "vitest";
+import { $and, $gt, $is, $like, $or } from "../operators.js";
+import { createTestDB } from "./util/db.js";
+describe("orm.findOne", () => {
+    const { db } = createTestDB();
+    test("handles basic select fields", () => {
+        expectTypeOf(db.findOne("post", {
+            select: ["id", "title", "content"],
+        })).resolves.toEqualTypeOf();
+    });
+    test("handles array fields in select and where clauses", async () => {
+        expectTypeOf(db.findOne("post", {
+            select: ["tags"],
+            where: {
+                tags: ["news", "tech"],
+            },
+        })).resolves.toEqualTypeOf();
+        await db.findOne("post", {
+            select: ["id"],
+            where: {
+                // @ts-expect-error tags must be string array
+                tags: "not-an-array",
+            },
+        });
+    });
+    test("handles enum fields in select and where clauses", async () => {
+        expectTypeOf(db.findOne("user", {
+            select: ["role"],
+            where: {
+                role: "admin",
+            },
+        })).resolves.toEqualTypeOf();
+        await db.findOne("user", {
+            select: ["id"],
+            where: {
+                // @ts-expect-error invalid enum value
+                role: "superadmin",
+            },
+        });
+    });
+    test("handles JSON fields in select and where clauses", async () => {
+        expectTypeOf(db.findOne("post", {
+            select: ["metadata"],
+            where: {
+                metadata: {
+                    foo: "a",
+                    bar: [
+                        {
+                            baz: "good",
+                            quux: true,
+                        },
+                    ],
+                },
+            },
+        })).resolves.toEqualTypeOf();
+        await db.findOne("post", {
+            select: ["id"],
+            where: {
+                metadata: {
+                    // @ts-expect-error invalid JSON structure
+                    foo: "invalid",
+                    bar: [
+                        {
+                            // @ts-expect-error invalid JSON structure
+                            baz: "invalid",
+                            // @ts-expect-error invalid JSON structure
+                            quux: "not-a-boolean",
+                        },
+                    ],
+                },
+            },
+        });
+    });
+    test("handles deeply nested where clauses with logical operators", () => {
+        expectTypeOf(db.findOne("post", {
+            select: ["id"],
+            where: {
+                [$and]: [
+                    {
+                        [$or]: [
+                            {
+                                [$and]: [
+                                    {
+                                        [$or]: [
+                                            {
+                                                [$and]: [
+                                                    {
+                                                        [$or]: [
+                                                            {
+                                                                [$and]: [
+                                                                    {
+                                                                        [$or]: [
+                                                                            {
+                                                                                [$and]: [
+                                                                                    {
+                                                                                        [$or]: [
+                                                                                            {
+                                                                                                [$and]: [
+                                                                                                    {
+                                                                                                        [$or]: [
+                                                                                                            {
+                                                                                                                [$and]: [
+                                                                                                                    {
+                                                                                                                        [$or]: [
+                                                                                                                            {
+                                                                                                                                [$and]: [
+                                                                                                                                    {
+                                                                                                                                        [$or]: [
+                                                                                                                                            {
+                                                                                                                                                title: {
+                                                                                                                                                    [$like]: "test%",
+                                                                                                                                                },
+                                                                                                                                                id: {
+                                                                                                                                                    [$gt]: 100,
+                                                                                                                                                },
+                                                                                                                                            },
+                                                                                                                                        ],
+                                                                                                                                    },
+                                                                                                                                ],
+                                                                                                                            },
+                                                                                                                        ],
+                                                                                                                    },
+                                                                                                                ],
+                                                                                                            },
+                                                                                                        ],
+                                                                                                    },
+                                                                                                ],
+                                                                                            },
+                                                                                        ],
+                                                                                    },
+                                                                                ],
+                                                                            },
+                                                                        ],
+                                                                    },
+                                                                ],
+                                                            },
+                                                        ],
+                                                    },
+                                                ],
+                                            },
+                                        ],
+                                    },
+                                ],
+                            },
+                        ],
+                    },
+                ],
+            },
+        })).resolves.toEqualTypeOf();
+    });
+    test("handles deeply nested includes", async () => {
+        const result = await db.findOne("user", {
+            select: ["id"],
+            include: {
+                // Level 1: user -> posts
+                posts: {
+                    select: ["id"],
+                    include: {
+                        // Level 2: posts -> author
+                        author: {
+                            select: ["id"],
+                            include: {
+                                // Level 3: author -> posts
+                                posts: {
+                                    select: ["id"],
+                                    include: {
+                                        // Level 4: posts -> author
+                                        author: {
+                                            select: ["id"],
+                                            include: {
+                                                // Level 5: author -> posts
+                                                posts: {
+                                                    select: ["id"],
+                                                    include: {
+                                                        // Level 6: posts -> author
+                                                        author: {
+                                                            select: ["id"],
+                                                            include: {
+                                                                // Level 7: author -> posts
+                                                                posts: {
+                                                                    select: [
+                                                                        "id",
+                                                                    ],
+                                                                    include: {
+                                                                        // Level 8: posts -> author
+                                                                        author: {
+                                                                            select: [
+                                                                                "id",
+                                                                            ],
+                                                                            include: {
+                                                                                // Level 9: author -> posts
+                                                                                posts: {
+                                                                                    select: [
+                                                                                        "id",
+                                                                                    ],
+                                                                                    include: {
+                                                                                        // Level 10: posts -> author
+                                                                                        author: {
+                                                                                            select: [
+                                                                                                "id",
+                                                                                            ],
+                                                                                            include: {
+                                                                                                // Level 11: author -> posts
+                                                                                                posts: {
+                                                                                                    select: [
+                                                                                                        "id",
+                                                                                                    ],
+                                                                                                    include: {
+                                                                                                        // Level 12: posts -> author
+                                                                                                        author: {
+                                                                                                            select: [
+                                                                                                                "id",
+                                                                                                            ],
+                                                                                                            include: {
+                                                                                                                // Level 13: author -> friends and author -> posts
+                                                                                                                friends: {
+                                                                                                                    select: [
+                                                                                                                        "id",
+                                                                                                                        "name",
+                                                                                                                    ],
+                                                                                                                    include: {
+                                                                                                                        posts: {
+                                                                                                                            select: [
+                                                                                                                                "id",
+                                                                                                                                "title",
+                                                                                                                                "tags",
+                                                                                                                            ],
+                                                                                                                            include: {
+                                                                                                                                // Level 14: posts -> backgroundColor
+                                                                                                                                backgroundColor: {
+                                                                                                                                    select: [
+                                                                                                                                        "hex",
+                                                                                                                                        "name",
+                                                                                                                                    ],
+                                                                                                                                },
+                                                                                                                            },
+                                                                                                                        },
+                                                                                                                    },
+                                                                                                                },
+                                                                                                                posts: {
+                                                                                                                    select: [
+                                                                                                                        "id",
+                                                                                                                        "title",
+                                                                                                                        "tags",
+                                                                                                                    ],
+                                                                                                                    include: {
+                                                                                                                        // Level 14: posts -> backgroundColor
+                                                                                                                        backgroundColor: {
+                                                                                                                            select: [
+                                                                                                                                "hex",
+                                                                                                                                "name",
+                                                                                                                            ],
+                                                                                                                        },
+                                                                                                                    },
+                                                                                                                },
+                                                                                                            },
+                                                                                                        },
+                                                                                                    },
+                                                                                                },
+                                                                                            },
+                                                                                        },
+                                                                                    },
+                                                                                },
+                                                                            },
+                                                                        },
+                                                                    },
+                                                                },
+                                                            },
+                                                        },
+                                                    },
+                                                },
+                                            },
+                                        },
+                                    },
+                                },
+                            },
+                        },
+                    },
+                },
+            },
+        });
+        const z = result.posts[0].author.posts[0].author.posts[0].author.posts[0]
+            .author.posts[0].author.posts[0].author.friends[0].posts[0]
+            .backgroundColor?.hex;
+        expectTypeOf(result.posts[0].author.posts[0].author.posts[0].author.posts[0]
+            .author.posts[0].author.posts[0].author.friends[0].posts[0]
+            .backgroundColor).toEqualTypeOf();
+        expectTypeOf(result.posts[0].author.posts[0].author.posts[0].author.posts[0]
+            .author.posts[0].author.posts[0].author.friends[0]).toEqualTypeOf();
+    });
+    test("handles complex combinations of fields, operators and includes", () => {
+        expectTypeOf(db.findOne("post", {
+            select: ["id", "title", "content", "tags", "metadata"],
+            where: {
+                [$or]: [
+                    {
+                        title: { [$like]: "test%" },
+                        tags: ["news"],
+                        metadata: {
+                            foo: "a",
+                            bar: [{ baz: "good", quux: true }],
+                        },
+                    },
+                    {
+                        publishedAt: { [$is]: null },
+                        authorId: { [$gt]: 100 },
+                    },
+                ],
+            },
+            include: {
+                author: {
+                    select: ["id", "role"],
+                    include: {
+                        posts: {
+                            select: ["id"],
+                        },
+                    },
+                },
+                backgroundColor: {
+                    select: ["hex", "name"],
+                },
+            },
+        })).resolves.toEqualTypeOf();
+    });
+    test("enforces select clause is required", async () => {
+        // @ts-expect-error select is required
+        await db.findOne("post", {
+            where: {
+                id: 1,
+            },
+        });
+    });
+    test("prevents invalid field names in select clause", async () => {
+        await db.findOne("post", {
+            // @ts-expect-error invalid field name
+            select: ["invalid"],
+            where: {
+                id: 1,
+            },
+        });
+    });
+    test("prevents invalid field names in where clause", async () => {
+        await db.findOne("post", {
+            select: ["id"],
+            where: {
+                // @ts-expect-error invalid field name
+                invalid: 1,
+            },
+        });
+    });
+    test("prevents invalid model names", async () => {
+        // @ts-expect-error invalid model name
+        await db.findOne("invalid", {
+            select: ["id"],
+        });
+    });
+    test("prevents invalid relation names in include", async () => {
+        await db.findOne("post", {
+            select: ["id"],
+            include: {
+                // @ts-expect-error invalid relation name
+                invalid: {
+                    select: ["id"],
+                },
+            },
+        });
+    });
+    test("prevents invalid operator usage", async () => {
+        await db.findOne("post", {
+            select: ["id"],
+            where: {
+                // @ts-expect-error $like cannot be used with number
+                id: { [$like]: 100 },
+            },
+        });
+    });
+});

package/build/tests/orm.findOne.test.d.ts

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

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

@@ -0,0 +1,247 @@
+import { afterAll, beforeAll, beforeEach, describe, expect, test, } from "vitest";
+import { config } from "@casekit/orm-fixtures";
+import { $like } from "../operators.js";
+import { orm } from "../orm.js";
+import { mockLogger } from "./util/logger.js";
+describe("findOne", () => {
+    const logger = mockLogger();
+    let db;
+    beforeEach(() => {
+        logger.clear();
+    });
+    beforeAll(async () => {
+        db = orm({ ...config, logger });
+        await db.connect();
+    });
+    afterAll(async () => {
+        await db.close();
+    });
+    test("finds a single record with basic select", async () => {
+        await db.transact(async (db) => {
+            const user = await db.createOne("user", {
+                values: {
+                    id: 1,
+                    name: "Test User",
+                    email: "test@example.com",
+                    role: "user",
+                },
+                returning: ["id"],
+            });
+            const foundUser = await db.findOne("user", {
+                select: ["id", "name", "email"],
+                where: { id: user.id },
+            });
+            expect(foundUser).toEqual({
+                id: 1,
+                name: "Test User",
+                email: "test@example.com",
+            });
+        }, { rollback: true });
+    });
+    test("finds a record with N:1 relation", async () => {
+        await db.transact(async (db) => {
+            const user = await db.createOne("user", {
+                values: {
+                    id: 1,
+                    name: "Test User",
+                    email: "test@example.com",
+                    role: "user",
+                },
+                returning: ["id"],
+            });
+            await db.createOne("post", {
+                values: {
+                    title: "Test Post",
+                    content: "Test Content",
+                    authorId: user.id,
+                },
+                returning: ["id"],
+            });
+            const post = await db.findOne("post", {
+                select: ["id", "title"],
+                include: {
+                    author: {
+                        select: ["id", "name"],
+                    },
+                },
+                where: { authorId: user.id },
+            });
+            expect(post).toEqual({
+                id: expect.any(Number),
+                title: "Test Post",
+                author: {
+                    id: 1,
+                    name: "Test User",
+                },
+            });
+        }, { rollback: true });
+    });
+    test("finds a record with optional N:1 relation", async () => {
+        await db.transact(async (db) => {
+            const user = await db.createOne("user", {
+                values: {
+                    id: 1,
+                    name: "Stewart Home",
+                    email: "stewart@example.com",
+                    role: "user",
+                },
+                returning: ["id"],
+            });
+            const color = await db.createOne("color", {
+                values: {
+                    name: "Red",
+                    hex: "#FF0000",
+                },
+                returning: ["hex"],
+            });
+            const posts = await db.createMany("post", {
+                values: [
+                    {
+                        title: "Test Post",
+                        content: "Test Content",
+                        authorId: user.id,
+                    },
+                    {
+                        title: "Test Post 2",
+                        content: "Test Content 2",
+                        authorId: user.id,
+                        backgroundColorValue: color.hex,
+                    },
+                ],
+                returning: ["id"],
+            });
+            const postWithoutBgColor = await db.findOne("post", {
+                select: ["id", "title"],
+                include: {
+                    backgroundColor: {
+                        select: ["hex", "name"],
+                    },
+                },
+                where: { id: posts[0].id },
+            });
+            expect(postWithoutBgColor).toEqual({
+                id: expect.any(Number),
+                title: "Test Post",
+                backgroundColor: null,
+            });
+            const postWithBgColor = await db.findOne("post", {
+                select: ["id", "title"],
+                include: {
+                    backgroundColor: {
+                        select: ["hex", "name"],
+                    },
+                },
+                where: { id: posts[1].id },
+            });
+            expect(postWithBgColor).toEqual({
+                id: expect.any(Number),
+                title: "Test Post 2",
+                backgroundColor: { hex: "#FF0000", name: "Red" },
+            });
+        }, { rollback: true });
+    });
+    test("throws error when no records match criteria", async () => {
+        await db.transact(async (db) => {
+            await expect(db.findOne("user", {
+                select: ["id"],
+                where: { id: 999999 },
+            })).rejects.toThrow("Expected one row, but found none");
+        }, { rollback: true });
+    });
+    test("throws error when multiple records match criteria", async () => {
+        await db.transact(async (db) => {
+            // Create multiple users with similar names
+            await db.createMany("user", {
+                values: [
+                    {
+                        id: 1,
+                        name: "John Doe",
+                        email: "john1@example.com",
+                        role: "user",
+                    },
+                    {
+                        id: 2,
+                        name: "John Doe",
+                        email: "john2@example.com",
+                        role: "user",
+                    },
+                ],
+            });
+            await expect(db.findOne("user", {
+                select: ["id", "name"],
+                where: {
+                    name: { [$like]: "John%" },
+                },
+            })).rejects.toThrow("Expected one row, but found more");
+        }, { rollback: true });
+    });
+    test("handles complex where clauses with array and JSON fields", async () => {
+        await db.transact(async (db) => {
+            const user = await db.createOne("user", {
+                values: {
+                    id: 1,
+                    name: "Test User",
+                    email: "test@example.com",
+                    role: "user",
+                },
+                returning: ["id"],
+            });
+            await db.createOne("post", {
+                values: {
+                    title: "Test Post",
+                    content: "Test Content",
+                    authorId: user.id,
+                    tags: ["test", "example"],
+                    metadata: {
+                        foo: "a",
+                        bar: [{ baz: "good", quux: true }],
+                    },
+                },
+            });
+            const post = await db.findOne("post", {
+                select: ["id", "title", "tags", "metadata"],
+                where: {
+                    tags: ["test", "example"],
+                    metadata: {
+                        foo: "a",
+                        bar: [{ baz: "good", quux: true }],
+                    },
+                },
+            });
+            expect(post).toEqual({
+                id: expect.any(Number),
+                title: "Test Post",
+                tags: ["test", "example"],
+                metadata: {
+                    foo: "a",
+                    bar: [{ baz: "good", quux: true }],
+                },
+            });
+        }, { rollback: true });
+    });
+    test("respects enum field types", async () => {
+        await db.transact(async (db) => {
+            await db.createOne("user", {
+                values: {
+                    id: 1,
+                    name: "Test Admin",
+                    email: "admin@example.com",
+                    role: "admin",
+                },
+            });
+            const admin = await db.findOne("user", {
+                select: ["id", "name", "role"],
+                where: { role: "admin" },
+            });
+            expect(admin.role).toBe("admin");
+            // TypeScript should prevent this, but we test at runtime too
+            await expect(db.findOne("user", {
+                select: ["id"],
+                where: {
+                    // @ts-expect-error - invalid role
+                    role: "superadmin",
+                },
+            })).rejects.toThrow();
+        }, { rollback: true });
+    });
+});

package/build/tests/orm.findOne.where.test.d.ts

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