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

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

@@ -0,0 +1,471 @@
+import { afterAll, beforeAll, beforeEach, describe, expect, test, } from "vitest";
+import { $and, $eq, $gt, $gte, $ilike, $in, $is, $like, $lt, $lte, $ne, $not, $or, } from "../operators.js";
+import { createTestDB } from "./util/db.js";
+describe("findOne: where", () => {
+    const { db, logger, factory } = createTestDB();
+    beforeEach(() => {
+        logger.clear();
+    });
+    beforeAll(async () => {
+        await db.connect();
+    });
+    afterAll(async () => {
+        await db.close();
+    });
+    describe("basic operators", () => {
+        test("a value with no operator performs an equality check", async () => {
+            await db.transact(async (db) => {
+                await db.createMany("user", {
+                    values: [
+                        factory.user({ id: 1, name: "Alice" }),
+                        factory.user({ id: 2, name: "Bob" }),
+                    ],
+                });
+                const user = await db.findOne("user", {
+                    select: ["id", "name"],
+                    where: { name: "Alice" },
+                });
+                expect(user).toEqual({ id: 1, name: "Alice" });
+            }, { rollback: true });
+        });
+        test("$eq operator matches exact values", async () => {
+            await db.transact(async (db) => {
+                await db.createMany("user", {
+                    values: [
+                        factory.user({ id: 1, name: "Alice" }),
+                        factory.user({ id: 2, name: "Bob" }),
+                    ],
+                });
+                const user = await db.findOne("user", {
+                    select: ["id", "name"],
+                    where: { name: { [$eq]: "Alice" } },
+                });
+                expect(user).toEqual({ id: 1, name: "Alice" });
+            }, { rollback: true });
+        });
+        test("$ne operator excludes matching values", 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 user = await db.findOne("user", {
+                    select: ["id", "name"],
+                    where: {
+                        [$and]: [
+                            { name: { [$ne]: "Alice" } },
+                            { name: { [$ne]: "Charlie" } },
+                        ],
+                    },
+                });
+                expect(user).toEqual({ id: 2, name: "Bob" });
+            }, { rollback: true });
+        });
+        test("$gt operator compares values correctly", async () => {
+            await db.transact(async (db) => {
+                await db.createMany("user", {
+                    values: [
+                        factory.user({ id: 1 }),
+                        factory.user({ id: 2 }),
+                        factory.user({ id: 3 }),
+                    ],
+                });
+                const user = await db.findOne("user", {
+                    select: ["id"],
+                    where: {
+                        id: { [$gt]: 1, [$lt]: 3 },
+                    },
+                });
+                expect(user).toEqual({ id: 2 });
+            }, { rollback: true });
+        });
+        test("$gte operator compares values correctly", async () => {
+            await db.transact(async (db) => {
+                await db.createMany("user", {
+                    values: [
+                        factory.user({ id: 1 }),
+                        factory.user({ id: 2 }),
+                        factory.user({ id: 3 }),
+                    ],
+                });
+                const user = await db.findOne("user", {
+                    select: ["id"],
+                    where: {
+                        id: { [$gte]: 2, [$lt]: 3 },
+                    },
+                });
+                expect(user).toEqual({ id: 2 });
+            }, { rollback: true });
+        });
+        test("$lt operator compares values correctly", async () => {
+            await db.transact(async (db) => {
+                await db.createMany("user", {
+                    values: [
+                        factory.user({ id: 1 }),
+                        factory.user({ id: 2 }),
+                        factory.user({ id: 3 }),
+                    ],
+                });
+                const user = await db.findOne("user", {
+                    select: ["id"],
+                    where: {
+                        id: { [$lt]: 2 },
+                    },
+                });
+                expect(user).toEqual({ id: 1 });
+            }, { rollback: true });
+        });
+        test("$lte operator compares values correctly", async () => {
+            await db.transact(async (db) => {
+                await db.createMany("user", {
+                    values: [
+                        factory.user({ id: 1, role: "user" }),
+                        factory.user({ id: 2, role: "admin" }),
+                        factory.user({ id: 3 }),
+                    ],
+                });
+                const user = await db.findOne("user", {
+                    select: ["id"],
+                    where: {
+                        id: { [$lte]: 2 },
+                        role: "admin",
+                    },
+                });
+                expect(user).toEqual({ id: 2 });
+            }, { rollback: true });
+        });
+    });
+    describe("array operators", () => {
+        test("$in operator matches array of values", async () => {
+            await db.transact(async (db) => {
+                await db.createMany("user", {
+                    values: [
+                        factory.user({
+                            id: 1,
+                            name: "Alice",
+                            role: "admin",
+                        }),
+                        factory.user({ id: 2, name: "Bob", role: "user" }),
+                        factory.user({
+                            id: 3,
+                            name: "Charlie",
+                            role: "admin",
+                        }),
+                    ],
+                });
+                // Only Alice is in the name array and has the admin role
+                const user = await db.findOne("user", {
+                    select: ["id", "name"],
+                    where: {
+                        name: { [$in]: ["Alice", "David"] },
+                        role: "admin",
+                    },
+                });
+                expect(user).toEqual({ id: 1, name: "Alice" });
+            }, { rollback: true });
+        });
+        test("$in operator with matching single value returns a result", async () => {
+            await db.transact(async (db) => {
+                await db.createMany("user", {
+                    values: [
+                        factory.user({ id: 1 }),
+                        factory.user({ id: 2 }),
+                    ],
+                });
+                const user = await db.findOne("user", {
+                    select: ["id"],
+                    where: { id: { [$in]: [1] } },
+                });
+                expect(user).toEqual({ id: 1 });
+            }, { rollback: true });
+        });
+        test("$in operator with empty array throws 'expected one row but found none'", async () => {
+            await db.transact(async (db) => {
+                await db.createMany("user", {
+                    values: [
+                        factory.user({ id: 1 }),
+                        factory.user({ id: 2 }),
+                    ],
+                });
+                await expect(db.findOne("user", {
+                    select: ["id"],
+                    where: { id: { [$in]: [] } },
+                })).rejects.toThrow("Expected one row, but found none");
+            }, { rollback: true });
+        });
+    });
+    describe("string matching operators", () => {
+        test("$like operator matches pattern", async () => {
+            await db.transact(async (db) => {
+                await db.createMany("user", {
+                    values: [
+                        factory.user({ id: 1, name: "Alice" }),
+                        factory.user({ id: 2, name: "alex" }),
+                        factory.user({ id: 3, name: "Bob" }),
+                    ],
+                });
+                const user = await db.findOne("user", {
+                    select: ["id", "name"],
+                    where: { name: { [$like]: "A%" } },
+                });
+                expect(user).toEqual({ id: 1, name: "Alice" });
+            }, { rollback: true });
+        });
+        test("$ilike operator with specific pattern ensures single result", async () => {
+            await db.transact(async (db) => {
+                await db.createMany("user", {
+                    values: [
+                        factory.user({ id: 1, name: "Alice" }),
+                        factory.user({ id: 2, name: "alex" }),
+                        factory.user({ id: 3, name: "Bob" }),
+                    ],
+                });
+                const user = await db.findOne("user", {
+                    select: ["id", "name"],
+                    where: { name: { [$ilike]: "al_ce" } },
+                });
+                expect(user).toEqual({ id: 1, name: "Alice" });
+            }, { rollback: true });
+        });
+        test("$ilike operator with ambiguous pattern throws 'expected one row but found more'", async () => {
+            await db.transact(async (db) => {
+                await db.createMany("user", {
+                    values: [
+                        factory.user({ id: 1, name: "Alice" }),
+                        factory.user({ id: 2, name: "alex" }),
+                        factory.user({ id: 3, name: "Bob" }),
+                    ],
+                });
+                await expect(db.findOne("user", {
+                    select: ["id", "name"],
+                    where: { name: { [$ilike]: "a%" } },
+                })).rejects.toThrow("Expected one row, but found more");
+            }, { rollback: true });
+        });
+    });
+    describe("null handling operators", () => {
+        test("null as a value performs an IS NULL check", async () => {
+            await db.transact(async (db) => {
+                await db.createMany("user", {
+                    values: [
+                        factory.user({ id: 1, deletedAt: new Date() }),
+                        factory.user({ id: 2, deletedAt: null }),
+                    ],
+                });
+                const user = await db.findOne("user", {
+                    select: ["id"],
+                    where: { deletedAt: null },
+                });
+                expect(user).toEqual({ id: 2 });
+            }, { rollback: true });
+        });
+        test("$is operator handles null values", async () => {
+            await db.transact(async (db) => {
+                await db.createMany("user", {
+                    values: [
+                        factory.user({ id: 1, deletedAt: new Date() }),
+                        factory.user({ id: 2, deletedAt: null }),
+                    ],
+                });
+                const user = await db.findOne("user", {
+                    select: ["id"],
+                    where: { deletedAt: { [$is]: null } },
+                });
+                expect(user).toEqual({ id: 2 });
+            }, { rollback: true });
+        });
+        test("$not operator with null finds non-null value", async () => {
+            await db.transact(async (db) => {
+                await db.createMany("user", {
+                    values: [
+                        factory.user({ id: 1, deletedAt: new Date() }),
+                        factory.user({ id: 2, deletedAt: null }),
+                    ],
+                });
+                const user = await db.findOne("user", {
+                    select: ["id"],
+                    where: { deletedAt: { [$not]: null } },
+                });
+                expect(user).toEqual({ id: 1 });
+            }, { rollback: true });
+        });
+    });
+    describe("logical operators", () => {
+        test("$and operator combines conditions", async () => {
+            await db.transact(async (db) => {
+                await db.createMany("user", {
+                    values: [
+                        factory.user({
+                            id: 1,
+                            name: "Alice",
+                            role: "admin",
+                        }),
+                        factory.user({ id: 2, name: "Bob", role: "user" }),
+                        factory.user({
+                            id: 3,
+                            name: "Charlie",
+                            role: "admin",
+                        }),
+                    ],
+                });
+                const user = await db.findOne("user", {
+                    select: ["id", "name"],
+                    where: {
+                        [$and]: [
+                            { role: "admin" },
+                            { name: { [$like]: "A%" } },
+                        ],
+                    },
+                });
+                expect(user).toEqual({ id: 1, name: "Alice" });
+            }, { rollback: true });
+        });
+        test("$or operator with specific condition ensures single result", async () => {
+            await db.transact(async (db) => {
+                await db.createMany("user", {
+                    values: [
+                        factory.user({
+                            id: 1,
+                            name: "Alice",
+                            email: "alice@example.com",
+                            role: "admin",
+                        }),
+                        factory.user({
+                            id: 2,
+                            name: "Bob",
+                            email: "bob@example.com",
+                            role: "user",
+                        }),
+                        factory.user({
+                            id: 3,
+                            name: "Charlie",
+                            email: "charlie@example.com",
+                            role: "user",
+                        }),
+                    ],
+                });
+                // Only Alice matches this unique combination of criteria
+                const user = await db.findOne("user", {
+                    select: ["id", "name"],
+                    where: {
+                        [$or]: [
+                            // This combination only matches Alice
+                            { name: "Alice", role: "admin" },
+                            // This combination doesn't match any user
+                            {
+                                name: "David",
+                                email: "nonexistent@example.com",
+                            },
+                        ],
+                    },
+                });
+                expect(user).toEqual({ id: 1, name: "Alice" });
+            }, { rollback: true });
+        });
+        test("can combine $and and $or operators to find unique record", async () => {
+            await db.transact(async (db) => {
+                await db.createMany("user", {
+                    values: [
+                        factory.user({
+                            id: 1,
+                            name: "Alice",
+                            role: "admin",
+                            email: "alice@example.com",
+                        }),
+                        factory.user({
+                            id: 2,
+                            name: "Bob",
+                            role: "user",
+                            email: "bob@example.com",
+                        }),
+                        factory.user({
+                            id: 3,
+                            name: "Charlie",
+                            role: "admin",
+                            email: "charlie@example.com",
+                        }),
+                        factory.user({
+                            id: 4,
+                            name: "Charlie",
+                            role: "user",
+                            email: "charlie2@example.com",
+                        }),
+                        factory.user({
+                            id: 5,
+                            name: "David",
+                            role: "admin",
+                            email: "david@example.com",
+                        }),
+                    ],
+                });
+                // This combination of conditions should only match Alice
+                const user = await db.findOne("user", {
+                    select: ["id", "name"],
+                    where: {
+                        [$and]: [
+                            { role: "admin" },
+                            {
+                                [$or]: [
+                                    { name: "Alice" },
+                                    {
+                                        name: "David",
+                                        email: "not-david@example.com",
+                                    }, // Won't match
+                                ],
+                            },
+                        ],
+                    },
+                });
+                expect(user).toEqual({ id: 1, name: "Alice" });
+            }, { rollback: true });
+        });
+    });
+    describe("error cases", () => {
+        test("$in operator throws error with non-array value", async () => {
+            await db.transact(async (db) => {
+                await expect(db.findOne("user", {
+                    select: ["id"],
+                    // @ts-expect-error testing invalid value
+                    where: { id: { [$in]: "not-an-array" } },
+                })).rejects.toThrow("Non-array passed to IN clause");
+            }, { rollback: true });
+        });
+        test("$not operator throws error with invalid value", async () => {
+            await db.transact(async (db) => {
+                await expect(db.findOne("user", {
+                    select: ["id"],
+                    // @ts-expect-error testing invalid value
+                    where: { id: { [$not]: "invalid" } },
+                })).rejects.toThrow("Invalid value passed to $not operator");
+            }, { rollback: true });
+        });
+        test("throws error when no records match criteria", async () => {
+            await db.transact(async (db) => {
+                await db.createMany("user", {
+                    values: [factory.user({ id: 1, name: "Alice" })],
+                });
+                await expect(db.findOne("user", {
+                    select: ["id"],
+                    where: { id: 999 },
+                })).rejects.toThrow("Expected one row, but found none");
+            }, { rollback: true });
+        });
+        test("throws error when multiple records match criteria", async () => {
+            await db.transact(async (db) => {
+                await db.createMany("user", {
+                    values: [
+                        factory.user({ id: 1, name: "Alice" }),
+                        factory.user({ id: 2, name: "Alice" }),
+                    ],
+                });
+                await expect(db.findOne("user", {
+                    select: ["id"],
+                    where: { name: "Alice" },
+                })).rejects.toThrow("Expected one row, but found more");
+            }, { rollback: true });
+        });
+    });
+});

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

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

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

@@ -0,0 +1,132 @@
+import { afterAll, beforeAll, beforeEach, describe, expect, test, vi, } from "vitest";
+import { config } from "@casekit/orm-fixtures";
+import { orm } from "../orm.js";
+import { mockLogger } from "./util/logger.js";
+describe("orm.count: middleware", () => {
+    const logger = mockLogger();
+    let db;
+    beforeEach(() => {
+        logger.clear();
+    });
+    beforeAll(async () => {
+        db = orm({ ...config, logger });
+        await db.connect();
+    });
+    afterAll(async () => {
+        await db.close();
+    });
+    describe("count middleware", () => {
+        test("it allows overriding the orm's count method", async () => {
+            await db.transact(async (db) => {
+                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: "admin",
+                        },
+                        {
+                            id: 3,
+                            name: "Test User 3",
+                            email: "test3@example.com",
+                            role: "user",
+                        },
+                    ],
+                    returning: ["id"],
+                });
+                const stub = vi.fn();
+                const dbWithMiddleware = db.middleware([
+                    {
+                        count: (db, table, query) => {
+                            stub("called stub in middleware 1");
+                            return db.count(table, query);
+                        },
+                    },
+                    {
+                        count: (db, table, query) => {
+                            stub("called stub in middleware 2");
+                            return db.count(table, query);
+                        },
+                    },
+                ]);
+                const count = await dbWithMiddleware.count("user", {
+                    where: { role: "user" },
+                });
+                expect(count).toBe(2);
+                expect(stub.mock.calls).toEqual([
+                    ["called stub in middleware 1"],
+                    ["called stub in middleware 2"],
+                ]);
+            }, { rollback: true });
+        });
+        test("middleware can modify count behavior", async () => {
+            await db.transact(async (db) => {
+                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: "admin",
+                        },
+                    ],
+                    returning: ["id"],
+                });
+                const dbWithMiddleware = db.middleware([
+                    {
+                        count: () => {
+                            return Promise.resolve(42);
+                        },
+                    },
+                ]);
+                const count = await dbWithMiddleware.count("user", {});
+                expect(count).toBe(42);
+                const originalCount = await db.count("user", {});
+                expect(originalCount).toBe(2);
+            }, { rollback: true });
+        });
+        test("middleware executes in the correct order", async () => {
+            await db.transact(async (db) => {
+                const executionOrder = [];
+                const dbWithMiddleware = db.middleware([
+                    {
+                        count: (db, table, query) => {
+                            executionOrder.push("middleware 1 start");
+                            const result = db.count(table, query);
+                            executionOrder.push("middleware 1 end");
+                            return result;
+                        },
+                    },
+                    {
+                        count: (db, table, query) => {
+                            executionOrder.push("middleware 2 start");
+                            const result = db.count(table, query);
+                            executionOrder.push("middleware 2 end");
+                            return result;
+                        },
+                    },
+                ]);
+                await dbWithMiddleware.count("user", {});
+                expect(executionOrder).toEqual([
+                    "middleware 1 start",
+                    "middleware 2 start",
+                    "middleware 2 end",
+                    "middleware 1 end",
+                ]);
+            }, { rollback: true });
+        });
+    });
+});

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

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

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

@@ -0,0 +1,63 @@
+import { afterAll, beforeAll, beforeEach, describe, expect, test, vi, } from "vitest";
+import { config } from "@casekit/orm-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.middleware.createOne.test.d.ts

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