@casekit/orm2 0.0.0-20250322230249

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

@@ -0,0 +1,151 @@
+import { afterAll, beforeAll, beforeEach, describe, expect, test, } from "vitest";
+import { $ilike } from "../operators.js";
+import { createTestDB } from "./util/db.js";
+describe("count", () => {
+    const { db, logger, factory } = createTestDB();
+    beforeEach(() => {
+        logger.clear();
+    });
+    beforeAll(async () => {
+        await db.connect();
+    });
+    afterAll(async () => {
+        await db.close();
+    });
+    test("returns zero when no records match", async () => {
+        await db.transact(async (db) => {
+            const count = await db.count("post", {
+                where: { id: 999 },
+            });
+            expect(count).toBe(0);
+        }, { rollback: true });
+    });
+    test("counts all records when no filter is applied", async () => {
+        await db.transact(async (db) => {
+            await db.createMany("user", {
+                values: [
+                    factory.user({ id: 1, name: "Alice" }),
+                    factory.user({ id: 2, name: "Bob" }),
+                    factory.user({ id: 3, name: "Charlie" }),
+                ],
+            });
+            const count = await db.count("user", {});
+            expect(count).toBe(3);
+        }, { rollback: true });
+    });
+    test("counts filtered records when where clause is applied", async () => {
+        await db.transact(async (db) => {
+            await db.createMany("user", {
+                values: [
+                    factory.user({ id: 1, name: "Alice" }),
+                    factory.user({ id: 2, name: "Bob" }),
+                    factory.user({ id: 3, name: "Alice" }), // Same name
+                ],
+            });
+            const count = await db.count("user", {
+                where: { name: "Alice" },
+            });
+            expect(count).toBe(2);
+        }, { rollback: true });
+    });
+    test("counts respects N:1 relation filters", async () => {
+        await db.transact(async (db) => {
+            await db.createMany("user", {
+                values: [
+                    factory.user({ id: 1, name: "Author1" }),
+                    factory.user({ id: 2, name: "Author2" }),
+                ],
+            });
+            await db.createMany("post", {
+                values: [
+                    factory.post({ id: 1, title: "Post 1", authorId: 1 }),
+                    factory.post({ id: 2, title: "Post 2", authorId: 1 }),
+                    factory.post({ id: 3, title: "Post 3", authorId: 2 }),
+                ],
+            });
+            const count = await db.count("post", {
+                include: {
+                    author: {
+                        where: { name: "Author1" },
+                    },
+                },
+            });
+            expect(count).toBe(2);
+        }, { rollback: true });
+    });
+    test("handles deeply nested relation filters", async () => {
+        await db.transact(async (db) => {
+            await db.createMany("color", {
+                values: [
+                    factory.color({ hex: "#ff0000", name: "Red" }),
+                    factory.color({ hex: "#00ff00", name: "Green" }),
+                ],
+            });
+            await db.createMany("user", {
+                values: [factory.user({ id: 1, name: "Author1" })],
+            });
+            await db.createMany("post", {
+                values: [
+                    factory.post({
+                        id: 1,
+                        title: "Tech Post 1",
+                        authorId: 1,
+                        backgroundColorValue: "#ff0000",
+                    }),
+                    factory.post({
+                        id: 2,
+                        title: "Videogames Post 1",
+                        authorId: 1,
+                        backgroundColorValue: "#00ff00",
+                    }),
+                    factory.post({
+                        id: 3,
+                        title: "Science Post 1",
+                        authorId: 1,
+                        backgroundColorValue: "#ff0000",
+                    }),
+                    factory.post({
+                        id: 4,
+                        title: "Science Post 2",
+                        authorId: 1,
+                        backgroundColorValue: "#ff0000",
+                    }),
+                ],
+            });
+            const count = await db.count("post", {
+                where: {
+                    title: { [$ilike]: "%1" },
+                },
+                include: {
+                    author: {
+                        where: {
+                            name: "Author1",
+                        },
+                    },
+                    backgroundColor: {
+                        where: {
+                            name: "Red",
+                        },
+                    },
+                },
+            });
+            expect(count).toBe(2);
+        }, { rollback: true });
+    });
+    test("handles for update clause", async () => {
+        await db.transact(async (db) => {
+            await db.createMany("user", {
+                values: [
+                    factory.user({ id: 1, name: "Alice" }),
+                    factory.user({ id: 2, name: "Bob" }),
+                ],
+            });
+            // Not a great test, just makes sure the query actually runs
+            // with this clause
+            const count = await db.count("user", {
+                for: "update",
+            });
+            expect(count).toBe(2);
+        }, { rollback: true });
+    });
+});

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

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

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

@@ -0,0 +1,63 @@
+import { afterAll, beforeAll, beforeEach, describe, expect, test, vi, } from "vitest";
+import { config } from "@casekit/orm2-fixtures";
+import { orm } from "../orm.js";
+import { mockLogger } from "./util/logger.js";
+describe("orm.createMany: middleware", () => {
+    const logger = mockLogger();
+    let db;
+    beforeEach(() => {
+        logger.clear();
+    });
+    beforeAll(async () => {
+        db = orm({ ...config, logger });
+        await db.connect();
+    });
+    afterAll(async () => {
+        await db.close();
+    });
+    describe("createMany middleware", () => {
+        test("it allows overriding the orm's createMany method", async () => {
+            await db.transact(async (db) => {
+                const stub = vi.fn();
+                const dbWithMiddleware = db.middleware([
+                    {
+                        createMany: (db, table, query) => {
+                            stub("called stub in middleware 1");
+                            return db.createMany(table, query);
+                        },
+                    },
+                    {
+                        createMany: (db, table, query) => {
+                            stub("called stub in middleware 2");
+                            return db.createMany(table, query);
+                        },
+                    },
+                ]);
+                const result = await dbWithMiddleware.createMany("user", {
+                    values: [
+                        {
+                            name: "Test User 1",
+                            email: "test1@example.com",
+                            role: "user",
+                        },
+                        {
+                            name: "Test User 2",
+                            email: "test2@example.com",
+                            role: "user",
+                        },
+                    ],
+                    returning: ["id", "name"],
+                });
+                expect(result).toHaveLength(2);
+                expect(result).toEqual(expect.arrayContaining([
+                    expect.objectContaining({ name: "Test User 1" }),
+                    expect.objectContaining({ 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.createMany.test-d.d.ts

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

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

@@ -0,0 +1,131 @@
+import { assertType, describe, expectTypeOf, test } from "vitest";
+import { models } from "@casekit/orm2-fixtures";
+import { orm } from "../orm.js";
+const db = orm({ models });
+describe("createMany types", () => {
+    test("values is required", () => {
+        assertType(db.createMany("post", 
+        // @ts-expect-error - values is required
+        {}));
+    });
+    test("values must match model fields", () => {
+        assertType(db.createMany("post", {
+            values: [
+                {
+                    // @ts-expect-error - wrong is not a column
+                    wrong: "value",
+                },
+            ],
+        }));
+    });
+    test("returning fields must exist on model", () => {
+        assertType(db.createMany("post", {
+            values: [
+                {
+                    title: "test",
+                    content: "content",
+                    authorId: 123,
+                },
+            ],
+            returning: [
+                // @ts-expect-error - wrong is not a column
+                "wrong",
+            ],
+        }));
+    });
+    test("missing required fields", () => {
+        assertType(db.createMany("post", {
+            values: [
+                // @ts-expect-error - missing required fields
+                {
+                    title: "test",
+                },
+            ],
+        }));
+    });
+    test("valid create params with returning clause", async () => {
+        expectTypeOf(await db.createMany("post", {
+            values: [
+                {
+                    title: "test",
+                    content: "content",
+                    authorId: 123,
+                },
+            ],
+            returning: ["id", "title"],
+            onConflict: {
+                do: "nothing",
+            },
+        })).toEqualTypeOf();
+    });
+    test("valid create params without returning clause", async () => {
+        expectTypeOf(await db.createMany("user", {
+            values: [
+                {
+                    name: "test",
+                    email: "test@example.com",
+                    role: "user",
+                },
+            ],
+            onConflict: {
+                do: "nothing",
+            },
+        })).toEqualTypeOf();
+    });
+    test("works with enum fields", async () => {
+        expectTypeOf(await db.createMany("user", {
+            values: [
+                {
+                    name: "test",
+                    email: "test@example.com",
+                    role: "user",
+                },
+            ],
+            returning: ["id"],
+        })).toEqualTypeOf();
+    });
+    test("enum fields are returned as enum types", async () => {
+        expectTypeOf(await db.createMany("user", {
+            values: [
+                {
+                    name: "test",
+                    email: "test@example.com",
+                    role: "user",
+                },
+            ],
+            returning: ["id", "role", "deletedAt"],
+        })).toEqualTypeOf();
+    });
+    test("handles array fields", async () => {
+        expectTypeOf(await db.createMany("post", {
+            values: [
+                {
+                    title: "test",
+                    content: "test content",
+                    authorId: 123,
+                    tags: ["test", "example"],
+                },
+            ],
+            returning: ["id", "tags"],
+        })).toEqualTypeOf();
+    });
+    test("handles json fields", async () => {
+        expectTypeOf(await db.createMany("post", {
+            values: [
+                {
+                    title: "test",
+                    content: "test content",
+                    authorId: 123,
+                    metadata: {
+                        foo: "b",
+                        bar: [
+                            { baz: "good", quux: true },
+                            { baz: "bad", quux: false },
+                        ],
+                    },
+                },
+            ],
+            returning: ["id", "metadata"],
+        })).toEqualTypeOf();
+    });
+});

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

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