@casekit/orm2 0.0.0-20250322230249

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

@@ -0,0 +1,360 @@
+import { afterAll, beforeAll, beforeEach, describe, expect, test, } from "vitest";
+import { config } from "@casekit/orm2-fixtures";
+import { $and, $like } from "../operators.js";
+import { orm } from "../orm.js";
+import { mockLogger } from "./util/logger.js";
+describe("deleteOne", () => {
+    const logger = mockLogger();
+    let db;
+    beforeEach(() => {
+        logger.clear();
+    });
+    beforeAll(async () => {
+        db = orm({ ...config, logger });
+        await db.connect();
+    });
+    afterAll(async () => {
+        await db.close();
+    });
+    test("deletes single record and returns count when no returning clause specified", async () => {
+        await db.transact(async (db) => {
+            await db.createMany("user", {
+                values: [
+                    {
+                        id: 1,
+                        name: "Delete User",
+                        email: "delete@example.com",
+                        role: "user",
+                    },
+                    {
+                        id: 2,
+                        name: "Keep User 1",
+                        email: "keep1@example.com",
+                        role: "user",
+                    },
+                    {
+                        id: 3,
+                        name: "Keep User 2",
+                        email: "keep2@example.com",
+                        role: "admin",
+                    },
+                ],
+            });
+            const result = await db.deleteOne("user", {
+                where: { id: 1 },
+            });
+            expect(result).toBe(1);
+            const remainingUsers = await db.findMany("user", {
+                select: ["id", "name"],
+                orderBy: ["id"],
+            });
+            expect(remainingUsers).toHaveLength(2);
+            expect(remainingUsers).toEqual([
+                { id: 2, name: "Keep User 1" },
+                { id: 3, name: "Keep User 2" },
+            ]);
+        }, { rollback: true });
+    });
+    test("deletes single record and returns specified fields", async () => {
+        await db.transact(async (db) => {
+            await db.createMany("user", {
+                values: [
+                    {
+                        id: 1,
+                        name: "Delete User",
+                        email: "delete@example.com",
+                        role: "user",
+                    },
+                    {
+                        id: 2,
+                        name: "Keep User 1",
+                        email: "keep1@example.com",
+                        role: "admin",
+                    },
+                    {
+                        id: 3,
+                        name: "Keep User 2",
+                        email: "keep2@example.com",
+                        role: "user",
+                    },
+                ],
+            });
+            const deletedUser = await db.deleteOne("user", {
+                where: { id: 1 },
+                returning: ["id", "name", "email", "role"],
+            });
+            expect(deletedUser).toEqual({
+                id: 1,
+                name: "Delete User",
+                email: "delete@example.com",
+                role: "user",
+            });
+            const remainingUsers = await db.findMany("user", {
+                select: ["id", "name", "email", "role"],
+                orderBy: ["id"],
+            });
+            expect(remainingUsers).toHaveLength(2);
+            expect(remainingUsers).toEqual([
+                {
+                    id: 2,
+                    name: "Keep User 1",
+                    email: "keep1@example.com",
+                    role: "admin",
+                },
+                {
+                    id: 3,
+                    name: "Keep User 2",
+                    email: "keep2@example.com",
+                    role: "user",
+                },
+            ]);
+        }, { rollback: true });
+    });
+    test("throws error when no records match delete criteria", async () => {
+        await db.transact(async (db) => {
+            await db.createMany("user", {
+                values: [
+                    {
+                        id: 1,
+                        name: "Keep User 1",
+                        email: "keep1@example.com",
+                        role: "user",
+                    },
+                    {
+                        id: 2,
+                        name: "Keep User 2",
+                        email: "keep2@example.com",
+                        role: "admin",
+                    },
+                ],
+            });
+            await expect(db.deleteOne("user", {
+                where: { id: 999999 },
+                returning: ["id", "name"],
+            })).rejects.toThrow("Delete one failed to delete a row");
+            const remainingUsers = await db.findMany("user", {
+                select: ["id", "name"],
+                orderBy: ["id"],
+            });
+            expect(remainingUsers).toHaveLength(2);
+            expect(remainingUsers).toEqual([
+                { id: 1, name: "Keep User 1" },
+                { id: 2, name: "Keep User 2" },
+            ]);
+        }, { rollback: true });
+    });
+    test("throws error when multiple records would be deleted", async () => {
+        await db.transact(async (db) => {
+            await db.createMany("user", {
+                values: [
+                    {
+                        id: 1,
+                        name: "User 1",
+                        email: "user1@example.com",
+                        role: "user",
+                    },
+                    {
+                        id: 2,
+                        name: "User 2",
+                        email: "user2@example.com",
+                        role: "user",
+                    },
+                    {
+                        id: 3,
+                        name: "Admin",
+                        email: "admin@example.com",
+                        role: "admin",
+                    },
+                ],
+            });
+            await expect(db.deleteOne("user", {
+                where: { role: "user" },
+            })).rejects.toThrow("Delete one would have deleted more than one row");
+            const remainingUsers = await db.findMany("user", {
+                select: ["id"],
+            });
+            expect(remainingUsers).toHaveLength(3);
+        }, { rollback: true });
+    });
+    test("deletes record matching complex where clause including enum values", async () => {
+        await db.transact(async (db) => {
+            await db.createMany("user", {
+                values: [
+                    {
+                        id: 1,
+                        name: "Keep Regular User",
+                        email: "keep@example.com",
+                        role: "user",
+                    },
+                    {
+                        id: 2,
+                        name: "Delete Admin",
+                        email: "admin@example.com",
+                        role: "admin",
+                    },
+                    {
+                        id: 3,
+                        name: "Keep Another Admin",
+                        email: "keep-admin@example.com",
+                        role: "admin",
+                    },
+                ],
+            });
+            const result = await db.deleteOne("user", {
+                where: {
+                    [$and]: [
+                        { role: "admin" },
+                        { email: { [$like]: "%@example.com" } },
+                        { name: { [$like]: "%Delete%" } },
+                    ],
+                },
+                returning: ["id", "role", "email"],
+            });
+            expect(result).toEqual({
+                id: 2,
+                role: "admin",
+                email: "admin@example.com",
+            });
+            const remainingUsers = await db.findMany("user", {
+                select: ["id", "name", "role"],
+                orderBy: ["id"],
+            });
+            expect(remainingUsers).toHaveLength(2);
+            expect(remainingUsers).toEqual([
+                {
+                    id: 1,
+                    name: "Keep Regular User",
+                    role: "user",
+                },
+                {
+                    id: 3,
+                    name: "Keep Another Admin",
+                    role: "admin",
+                },
+            ]);
+        }, { rollback: true });
+    });
+    test("handles array and JSON fields in returning clause", 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.createMany("post", {
+                values: [
+                    {
+                        id: 1,
+                        title: "Delete Post",
+                        content: "Content 1",
+                        authorId: user.id,
+                        tags: ["delete", "test", "post1"],
+                        metadata: {
+                            foo: "a",
+                            bar: [{ baz: "good", quux: true }],
+                        },
+                    },
+                    {
+                        id: 2,
+                        title: "Keep Post 1",
+                        content: "Content 2",
+                        authorId: user.id,
+                        tags: ["keep", "test", "post2"],
+                        metadata: {
+                            foo: "b",
+                            bar: [{ baz: "bad", quux: false }],
+                        },
+                    },
+                    {
+                        id: 3,
+                        title: "Keep Post 2",
+                        content: "Content 3",
+                        authorId: user.id,
+                        tags: ["keep", "test"],
+                        metadata: {
+                            foo: "c",
+                            bar: [{ baz: "indifferent", quux: true }],
+                        },
+                    },
+                ],
+            });
+            const result = await db.deleteOne("post", {
+                where: { id: 1 },
+                returning: ["id", "tags", "metadata"],
+            });
+            expect(result).toEqual({
+                id: 1,
+                tags: ["delete", "test", "post1"],
+                metadata: {
+                    foo: "a",
+                    bar: [{ baz: "good", quux: true }],
+                },
+            });
+            const remainingPosts = await db.findMany("post", {
+                select: ["id", "title", "tags", "metadata"],
+                orderBy: ["id"],
+            });
+            expect(remainingPosts).toHaveLength(2);
+            expect(remainingPosts).toEqual([
+                {
+                    id: 2,
+                    title: "Keep Post 1",
+                    tags: ["keep", "test", "post2"],
+                    metadata: {
+                        foo: "b",
+                        bar: [{ baz: "bad", quux: false }],
+                    },
+                },
+                {
+                    id: 3,
+                    title: "Keep Post 2",
+                    tags: ["keep", "test"],
+                    metadata: {
+                        foo: "c",
+                        bar: [{ baz: "indifferent", quux: true }],
+                    },
+                },
+            ]);
+        }, { rollback: true });
+    });
+    test("throws error when deleting record would violate foreign key constraints", async () => {
+        await db.transact(async (db) => {
+            const users = await db.createMany("user", {
+                values: [
+                    {
+                        id: 1,
+                        name: "User with Posts",
+                        email: "posts@example.com",
+                        role: "user",
+                    },
+                    {
+                        id: 2,
+                        name: "Keep User",
+                        email: "keep@example.com",
+                        role: "admin",
+                    },
+                ],
+                returning: ["id"],
+            });
+            await db.createOne("post", {
+                values: {
+                    title: "Test Post",
+                    content: "Content",
+                    authorId: users[0].id,
+                },
+            });
+            await expect(db.deleteOne("user", {
+                where: { id: users[0].id },
+            })).rejects.toThrow();
+            const remainingUsers = await db.findMany("user", {
+                select: ["id"],
+                orderBy: ["id"],
+            });
+            expect(remainingUsers).toHaveLength(2);
+        }, { rollback: true });
+    });
+});

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

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

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

@@ -0,0 +1,335 @@
+import { afterAll, beforeAll, beforeEach, describe, expect, test, } from "vitest";
+import { createTestDB } from "./util/db.js";
+describe("findMany: 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 users = await db.findMany("user", {
+                select: ["id", "name"],
+                include: {
+                    friends: {
+                        select: ["id", "name"],
+                        orderBy: ["id"],
+                    },
+                },
+                orderBy: ["id"],
+            });
+            expect(users).toEqual([
+                {
+                    id: 1,
+                    name: "User 1",
+                    friends: [
+                        { id: 2, name: "User 2" },
+                        { id: 3, name: "User 3" },
+                    ],
+                },
+                {
+                    id: 2,
+                    name: "User 2",
+                    friends: [{ id: 3, name: "User 3" }],
+                },
+                {
+                    id: 3,
+                    name: "User 3",
+                    friends: [],
+                },
+            ]);
+        }, { 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 users = await db.findMany("user", {
+                select: ["id"],
+                include: {
+                    friends: {
+                        select: ["id", "role"],
+                        where: {
+                            role: "admin",
+                        },
+                        orderBy: ["id"],
+                    },
+                },
+                orderBy: ["id"],
+            });
+            expect(users).toEqual([
+                {
+                    id: 1,
+                    friends: [{ id: 3, role: "admin" }],
+                },
+                {
+                    id: 2,
+                    friends: [{ id: 3, role: "admin" }],
+                },
+                {
+                    id: 3,
+                    friends: [],
+                },
+            ]);
+        }, { 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"),
+                    }),
+                ],
+            });
+            // Make everyone friends with everyone
+            await db.createMany("friendship", {
+                values: [
+                    factory.friendship({ userId: 1, friendId: 2 }),
+                    factory.friendship({ userId: 1, friendId: 3 }),
+                    factory.friendship({ userId: 1, friendId: 4 }),
+                    factory.friendship({ userId: 2, friendId: 3 }),
+                    factory.friendship({ userId: 2, friendId: 4 }),
+                    factory.friendship({ userId: 3, friendId: 4 }),
+                ],
+            });
+            const users = await db.findMany("user", {
+                select: ["id"],
+                include: {
+                    friends: {
+                        select: ["id"],
+                        orderBy: ["id"],
+                        limit: 2,
+                        offset: 1,
+                    },
+                },
+                orderBy: ["id"],
+            });
+            expect(users).toEqual([
+                {
+                    id: 1,
+                    friends: [{ id: 3 }, { id: 4 }],
+                },
+                {
+                    id: 2,
+                    friends: [{ id: 4 }],
+                },
+                {
+                    id: 3,
+                    friends: [],
+                },
+                {
+                    id: 4,
+                    friends: [],
+                },
+            ]);
+        }, { 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 users = await db.findMany("user", {
+                select: ["id", "name"],
+                include: {
+                    friends: {
+                        select: ["id", "name"],
+                        include: {
+                            posts: {
+                                select: ["id", "title"],
+                                orderBy: ["id"],
+                            },
+                        },
+                        orderBy: ["id"],
+                    },
+                },
+                orderBy: ["id"],
+            });
+            expect(users).toEqual([
+                {
+                    id: 1,
+                    name: "User 1",
+                    friends: [
+                        {
+                            id: 2,
+                            name: "User 2",
+                            posts: [
+                                { id: 1, title: "Post 1" },
+                                { id: 2, title: "Post 2" },
+                            ],
+                        },
+                    ],
+                },
+                {
+                    id: 2,
+                    name: "User 2",
+                    friends: [],
+                },
+            ]);
+        }, { rollback: true });
+    });
+    test("can order, limit and offset N:N relations with overlapping values", async () => {
+        await db.transact(async (db) => {
+            // Create users
+            await db.createMany("user", {
+                values: [
+                    factory.user({
+                        id: 1,
+                        name: "Alice",
+                        createdAt: new Date("2024-01-01"),
+                    }),
+                    factory.user({
+                        id: 2,
+                        name: "Bob",
+                        createdAt: new Date("2024-01-02"),
+                    }),
+                    factory.user({
+                        id: 3,
+                        name: "Charlie",
+                        createdAt: new Date("2024-01-03"),
+                    }),
+                    factory.user({
+                        id: 4,
+                        name: "Dave",
+                        createdAt: new Date("2024-01-04"),
+                    }),
+                    factory.user({
+                        id: 5,
+                        name: "Eve",
+                        createdAt: new Date("2024-01-05"),
+                    }),
+                ],
+            });
+            // Create overlapping friendship groups:
+            // Group 1: Alice-Bob-Charlie
+            // Group 2: Bob-Charlie-Dave
+            // Group 3: Charlie-Dave-Eve
+            await db.createMany("friendship", {
+                values: [
+                    factory.friendship({ userId: 1, friendId: 2 }),
+                    factory.friendship({ userId: 1, friendId: 3 }),
+                    factory.friendship({ userId: 1, friendId: 4 }),
+                    factory.friendship({ userId: 2, friendId: 3 }),
+                    factory.friendship({ userId: 2, friendId: 4 }),
+                    factory.friendship({ userId: 2, friendId: 5 }),
+                    factory.friendship({ userId: 3, friendId: 4 }),
+                    factory.friendship({ userId: 3, friendId: 5 }),
+                    factory.friendship({ userId: 4, friendId: 5 }),
+                ],
+            });
+            const users = await db.findMany("user", {
+                select: ["id", "name"],
+                include: {
+                    friends: {
+                        select: ["id", "name"],
+                        orderBy: [["id", "desc"]],
+                        limit: 2,
+                    },
+                },
+                orderBy: [["createdAt", "desc"]],
+            });
+            expect(users).toEqual([
+                {
+                    id: 5,
+                    name: "Eve",
+                    friends: [],
+                },
+                {
+                    id: 4,
+                    name: "Dave",
+                    friends: [{ id: 5, name: "Eve" }],
+                },
+                {
+                    id: 3,
+                    name: "Charlie",
+                    friends: [
+                        { id: 5, name: "Eve" },
+                        { id: 4, name: "Dave" },
+                    ],
+                },
+                {
+                    id: 2,
+                    name: "Bob",
+                    friends: [
+                        { id: 5, name: "Eve" },
+                        { id: 4, name: "Dave" },
+                    ],
+                },
+                {
+                    id: 1,
+                    name: "Alice",
+                    friends: [
+                        { id: 4, name: "Dave" },
+                        { id: 3, name: "Charlie" },
+                    ],
+                },
+            ]);
+        }, { rollback: true });
+    });
+});

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

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