@casekit/orm2 0.0.0-20250322230249

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

@@ -0,0 +1,268 @@
+import { afterAll, beforeAll, beforeEach, describe, expect, test, } from "vitest";
+import { config } from "@casekit/orm2-fixtures";
+import { orm } from "../orm.js";
+import { mockLogger } from "./util/logger.js";
+describe("createOne", () => {
+    const logger = mockLogger();
+    let db;
+    beforeEach(() => {
+        logger.clear();
+    });
+    beforeAll(async () => {
+        db = orm({ ...config, logger });
+        await db.connect();
+    });
+    afterAll(async () => {
+        await db.close();
+    });
+    test("creates a record with full values and returns specified fields", async () => {
+        await db.transact(async (db) => {
+            const user = await db.createOne("user", {
+                values: {
+                    id: 1,
+                    name: "Test User",
+                    email: "user@example.com",
+                    role: "user",
+                },
+                returning: ["id", "name", "role"],
+            });
+            expect(user).toEqual({
+                id: 1,
+                name: "Test User",
+                role: "user",
+            });
+            // Verify record was actually created
+            const foundUser = await db.findOne("user", {
+                select: ["id", "name", "role"],
+                where: { id: 1 },
+            });
+            expect(foundUser).toEqual(user);
+        }, { rollback: true });
+    });
+    test("creates record with minimal values using defaults", async () => {
+        await db.transact(async (db) => {
+            const user = await db.createOne("user", {
+                values: {
+                    id: 1,
+                    name: "Test User",
+                    email: "user@example.com",
+                    role: "user",
+                },
+                returning: ["id", "name", "deletedAt"],
+            });
+            expect(user.deletedAt).toBeNull();
+        }, { rollback: true });
+    });
+    test("returns row count when no returning clause specified", async () => {
+        await db.transact(async (db) => {
+            const result = await db.createOne("user", {
+                values: {
+                    id: 1,
+                    name: "Test User",
+                    email: "user@example.com",
+                    role: "user",
+                },
+            });
+            expect(result).toBe(1);
+            // Verify record was created
+            const user = await db.findOne("user", {
+                select: ["id"],
+                where: { id: 1 },
+            });
+            expect(user).toEqual({ id: 1 });
+        }, { rollback: true });
+    });
+    test("throws error on constraint violation", async () => {
+        await db.transact(async (db) => {
+            const email = "test@example.com";
+            // Create first user
+            await db.createOne("user", {
+                values: {
+                    id: 1,
+                    name: "First User",
+                    email,
+                    role: "user",
+                },
+            });
+            // Try to create another user with same email
+            await expect(db.createOne("user", {
+                values: {
+                    id: 2,
+                    name: "Second User",
+                    email, // Duplicate email with same deletedAt (null)
+                    role: "user",
+                },
+            })).rejects.toThrow(/duplicate key value/);
+        }, { rollback: true });
+    });
+    test("handles onConflict do nothing with returning clause", async () => {
+        await db.transact(async (db) => {
+            const email = "test@example.com";
+            const user1 = await db.createOne("user", {
+                values: {
+                    id: 1,
+                    name: "Original User",
+                    email,
+                    role: "user",
+                },
+                returning: ["id", "name"],
+            });
+            // Try to create user with same email
+            const user2 = await db.createOne("user", {
+                values: {
+                    id: 1, // Same ID
+                    name: "Duplicate User",
+                    email,
+                    role: "user",
+                },
+                onConflict: { do: "nothing" },
+                returning: ["id", "name"],
+            });
+            expect(user2).toBeNull();
+            const originalUser = await db.findOne("user", {
+                select: ["id", "name"],
+                where: { id: user1.id },
+            });
+            expect(originalUser.name).toBe("Original User");
+        }, { rollback: true });
+    });
+    test("handles onConflict do nothing without returning clause", async () => {
+        await db.transact(async (db) => {
+            const email = "test@example.com";
+            await db.createOne("user", {
+                values: {
+                    id: 1,
+                    name: "Original User",
+                    email,
+                    role: "user",
+                },
+            });
+            // Try to create user with same email
+            const result = await db.createOne("user", {
+                values: {
+                    id: 1,
+                    name: "Duplicate User",
+                    email,
+                    role: "user",
+                },
+                onConflict: { do: "nothing" },
+            });
+            expect(result).toBe(0);
+        }, { rollback: true });
+    });
+    test("handles enum fields in values", async () => {
+        await db.transact(async (db) => {
+            const user = await db.createOne("user", {
+                values: {
+                    id: 1,
+                    name: "Test User",
+                    email: "test@example.com",
+                    role: "admin",
+                },
+                returning: ["id", "name", "role"],
+            });
+            expect(user).toEqual({
+                id: 1,
+                name: "Test User",
+                role: "admin",
+            });
+            const foundUser = await db.findOne("user", {
+                select: ["id", "name", "role"],
+                where: { id: 1 },
+            });
+            expect(foundUser.role).toBe("admin");
+        }, { rollback: true });
+    });
+    test("handles array and JSON fields in values", 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 post = await db.createOne("post", {
+                values: {
+                    title: "Test Post",
+                    content: "Test Content",
+                    authorId: user.id,
+                    tags: ["test", "example", "tags"],
+                    metadata: {
+                        foo: "a",
+                        bar: [
+                            { baz: "good", quux: true },
+                            { baz: "bad", quux: false },
+                        ],
+                    },
+                },
+                returning: ["id", "title", "tags", "metadata"],
+            });
+            expect(post).toEqual({
+                id: expect.any(Number),
+                title: "Test Post",
+                tags: ["test", "example", "tags"],
+                metadata: {
+                    foo: "a",
+                    bar: [
+                        { baz: "good", quux: true },
+                        { baz: "bad", quux: false },
+                    ],
+                },
+            });
+            const foundPost = await db.findOne("post", {
+                select: ["id", "title", "tags", "metadata"],
+                where: { id: post.id },
+            });
+            expect(foundPost.tags).toEqual(["test", "example", "tags"]);
+            expect(foundPost.metadata).toEqual({
+                foo: "a",
+                bar: [
+                    { baz: "good", quux: true },
+                    { baz: "bad", quux: false },
+                ],
+            });
+        }, { rollback: true });
+    });
+    // TODO comment back in once relationships are implemented
+    test.skip("can create post with relationship to user", async () => {
+        await db.transact(async (db) => {
+            // Create a user first
+            const user = await db.createOne("user", {
+                values: {
+                    id: 1,
+                    name: "Test User",
+                    email: "test@example.com",
+                    role: "user",
+                },
+                returning: ["id"],
+            });
+            // Create a post for the user
+            const post = await db.createOne("post", {
+                values: {
+                    title: "First Post",
+                    content: "Hello World",
+                    authorId: user.id,
+                },
+                returning: ["id", "title", "authorId"],
+            });
+            expect(post.authorId).toBe(user.id);
+            expect(post).toHaveProperty("title");
+            expect(post).toHaveProperty("id");
+            // Verify the relationship works
+            const userWithPost = await db.findOne("user", {
+                select: ["id"],
+                include: {
+                    posts: {
+                        select: ["id", "title"],
+                    },
+                },
+                where: { id: user.id },
+            });
+            expect(userWithPost.posts).toHaveLength(1);
+            expect(userWithPost.posts[0].title).toBe("First Post");
+        }, { rollback: true });
+    });
+});

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

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

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

@@ -0,0 +1,77 @@
+import { afterAll, beforeAll, beforeEach, describe, expect, test, vi, } from "vitest";
+import { config } from "@casekit/orm2-fixtures";
+import { $in } from "../operators.js";
+import { orm } from "../orm.js";
+import { mockLogger } from "./util/logger.js";
+describe("orm.deleteMany: middleware", () => {
+    const logger = mockLogger();
+    let db;
+    beforeEach(() => {
+        logger.clear();
+    });
+    beforeAll(async () => {
+        db = orm({ ...config, logger });
+        await db.connect();
+    });
+    afterAll(async () => {
+        await db.close();
+    });
+    describe("deleteMany middleware", () => {
+        test("it allows overriding the orm's deleteMany method", async () => {
+            await db.transact(async (db) => {
+                // Create test users to delete
+                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: "user",
+                        },
+                    ],
+                    returning: ["id"],
+                });
+                const stub = vi.fn();
+                const dbWithMiddleware = db.middleware([
+                    {
+                        deleteMany: (db, table, query) => {
+                            stub("called stub in middleware 1");
+                            return db.deleteMany(table, query);
+                        },
+                    },
+                    {
+                        deleteMany: (db, table, query) => {
+                            stub("called stub in middleware 2");
+                            return db.deleteMany(table, query);
+                        },
+                    },
+                ]);
+                const result = await dbWithMiddleware.deleteMany("user", {
+                    where: { id: { [$in]: [1, 2] } },
+                    returning: ["id", "name"],
+                });
+                expect(result).toHaveLength(2);
+                expect(result).toEqual(expect.arrayContaining([
+                    expect.objectContaining({
+                        id: 1,
+                        name: "Test User 1",
+                    }),
+                    expect.objectContaining({
+                        id: 2,
+                        name: "Test User 2",
+                    }),
+                ]));
+                expect(stub.mock.calls).toEqual([
+                    ["called stub in middleware 1"],
+                    ["called stub in middleware 2"],
+                ]);
+            }, { rollback: true });
+        });
+    });
+});

package/build/tests/orm.deleteMany.test-d.d.ts

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

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

@@ -0,0 +1,179 @@
+import { describe, expectTypeOf, test } from "vitest";
+import { $gt, $is, $like, $or } from "../operators.js";
+import { createTestDB } from "./util/db.js";
+describe("deleteMany", () => {
+    const { db } = createTestDB();
+    test("returns array of records when returning clause is specified", () => {
+        expectTypeOf(db.deleteMany("post", {
+            where: { id: 1 },
+            returning: ["id", "title", "content"],
+        })).resolves.toEqualTypeOf();
+    });
+    test("returns number when no returning clause specified", () => {
+        expectTypeOf(db.deleteMany("post", {
+            where: { id: 1 },
+        })).resolves.toEqualTypeOf();
+    });
+    test("handles nullable fields in returning clause", () => {
+        expectTypeOf(db.deleteMany("post", {
+            where: { id: 1 },
+            returning: ["deletedAt"],
+        })).resolves.toEqualTypeOf();
+    });
+    test("handles array fields in where and returning clauses", () => {
+        expectTypeOf(db.deleteMany("post", {
+            where: {
+                tags: ["news", "tech"],
+                id: 1,
+            },
+            returning: ["tags", "id"],
+        })).resolves.toEqualTypeOf();
+    });
+    test("handles JSON fields in where and returning clauses", async () => {
+        // Test returning JSON fields
+        expectTypeOf(db.deleteMany("post", {
+            where: { id: 1 },
+            returning: ["metadata"],
+        })).resolves.toEqualTypeOf();
+        // Test user preferences JSON field
+        expectTypeOf(db.deleteMany("user", {
+            where: { id: 1 },
+            returning: ["preferences"],
+        })).resolves.toEqualTypeOf();
+        expectTypeOf(db.deleteMany("post", {
+            where: {
+                metadata: {
+                    foo: "a",
+                    bar: [
+                        {
+                            baz: "good",
+                            quux: true,
+                        },
+                    ],
+                },
+            },
+            returning: ["metadata"],
+        })).resolves.toEqualTypeOf();
+        await db.deleteMany("post", {
+            where: {
+                metadata: {
+                    // @ts-expect-error invalid enum value in JSON
+                    foo: "invalid",
+                    bar: [],
+                },
+            },
+        });
+    });
+    test("handles complex where clauses", () => {
+        expectTypeOf(db.deleteMany("post", {
+            where: {
+                id: { [$gt]: 100 },
+                [$or]: [
+                    { title: { [$like]: "test%" } },
+                    { tags: ["news", "tech"] },
+                ],
+                publishedAt: { [$is]: null },
+            },
+            returning: ["id"],
+        })).resolves.toEqualTypeOf();
+    });
+    test("enforces where clause is required", async () => {
+        // @ts-expect-error where clause is required
+        await db.deleteMany("post", {
+            returning: ["id"],
+        });
+    });
+    test("prevents invalid field names in where clause", async () => {
+        await db.deleteMany("post", {
+            where: {
+                // @ts-expect-error invalid field name
+                invalid: 1,
+            },
+        });
+    });
+    test("prevents invalid field names in returning clause", async () => {
+        await db.deleteMany("post", {
+            where: { id: 1 },
+            // @ts-expect-error invalid field name
+            returning: ["invalid"],
+        });
+    });
+    test("prevents invalid model names", async () => {
+        // @ts-expect-error invalid model name
+        await db.deleteMany("invalid", {
+            where: { id: 1 },
+        });
+    });
+    test("prevents invalid operator usage", async () => {
+        await db.deleteMany("post", {
+            where: {
+                // @ts-expect-error $like cannot be used with number
+                id: { [$like]: 100 },
+            },
+        });
+    });
+    test("handles enum fields in where and returning clauses", async () => {
+        // Test enum in where clause
+        expectTypeOf(db.deleteMany("user", {
+            where: { role: "admin" },
+            returning: ["role", "id"],
+        })).resolves.toEqualTypeOf();
+        // Test enum in JSON structure
+        expectTypeOf(db.deleteMany("post", {
+            where: {
+                metadata: {
+                    foo: "a",
+                    bar: [
+                        {
+                            baz: "good",
+                            quux: true,
+                        },
+                    ],
+                },
+            },
+            returning: ["metadata"],
+        })).resolves.toEqualTypeOf();
+        await db.deleteMany("user", {
+            where: {
+                // @ts-expect-error invalid enum value for role
+                role: "superadmin",
+            },
+        });
+        await db.deleteMany("post", {
+            where: {
+                metadata: {
+                    // @ts-expect-error invalid enum value in JSON metadata
+                    foo: "invalid",
+                    bar: [],
+                },
+            },
+        });
+    });
+    test("enforces field type constraints in where clause", async () => {
+        await db.deleteMany("post", {
+            where: {
+                // @ts-expect-error id must be number
+                id: "1",
+            },
+        });
+        await db.deleteMany("post", {
+            where: {
+                // @ts-expect-error tags must be string[]
+                tags: "tag1",
+            },
+        });
+        await db.deleteMany("user", {
+            where: {
+                // @ts-expect-error role must be "user" | "admin"
+                role: "superuser",
+            },
+        });
+    });
+    test("returned arrays contain deeply readonly objects", async () => {
+        const result = await db.deleteMany("post", {
+            where: { id: 1 },
+            returning: ["metadata"],
+        });
+        expectTypeOf(result).toEqualTypeOf();
+    });
+});

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

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