@casekit/orm2 0.0.0-20250322230249

package/build/tests/datatypes.test.js

@@ -0,0 +1,239 @@
+import { afterAll, beforeAll, beforeEach, describe, expect, test, } from "vitest";
+import { createTestDB } from "./util/db.js";
+describe("all supported data types", () => {
+    const { db, logger } = createTestDB();
+    beforeEach(() => {
+        logger.clear();
+    });
+    beforeAll(async () => {
+        await db.connect();
+    });
+    afterAll(async () => {
+        await db.close();
+    });
+    test("can insert and retrieve all field types", async () => {
+        await db.transact(async (db) => {
+            const created = await db.createOne("kitchenSink", {
+                values: {
+                    charField: "a",
+                    characterField: "b",
+                    characterNField: "abc",
+                    varcharField: "def",
+                    varcharNField: "ghi",
+                    textField: "hello world",
+                    bitField: "1",
+                    bitNField: "101",
+                    bitVaryingField: "101",
+                    bitVaryingNField: "101",
+                    numericField: "123",
+                    numericPrecisionField: "123.45",
+                    integerField: 42,
+                    bigintField: 9007199254740991n,
+                    smallintField: 32767,
+                    doublePrecisionField: 3.14159,
+                    realField: 3.14,
+                    moneyField: "19.99",
+                    booleanField: true,
+                    uuidField: "123e4567-e89b-12d3-a456-426614174000",
+                    dateField: new Date("2023-01-01"),
+                    timeField: "13:45:30",
+                    timeWithPrecisionField: "13:45:30",
+                    timetzField: "13:45:30+00",
+                    timeWithTzField: "13:45:30+00",
+                    timestampField: new Date("2023-01-01T13:45:30"),
+                    timestampWithPrecisionField: new Date("2023-01-01T13:45:30"),
+                    timestamptzField: new Date("2023-01-01T13:45:30Z"),
+                    timestampWithTzField: new Date("2023-01-01T13:45:30Z"),
+                    // intervalField: { years: 1, months: 2 },
+                    jsonField: { key: "value" },
+                    jsonbField: { key: "value" },
+                    // pointField: { x: 1, y: 2 },
+                    lineField: "{1,2,3}",
+                    lsegField: "[(1,2),(3,4)]",
+                    boxField: "(3,4),(1,2)",
+                    polygonField: "((1,2),(3,4),(5,6))",
+                    // circleField: { x: 1, y: 2, radius: 3 },
+                    cidrField: "192.168.100.128/25",
+                    inetField: "192.168.100.128",
+                    macaddrField: "08:00:2b:01:02:03",
+                    macaddr8Field: "08:00:2b:01:02:03:04:05",
+                    byteaField: Buffer.from("hello"),
+                    xmlField: "<root>test</root>",
+                    pathField: "((1,2),(3,4),(5,6))",
+                    tsqueryField: "'fat' & 'rat'",
+                    tsvectorField: "'a' 'cat' 'fat' 'mat' 'on' 'sat'",
+                    int4rangeField: "[1,4)",
+                    int8rangeField: "[1,9223372036854775807)",
+                    numrangeField: "[1.123,4.456)",
+                    tsrangeField: `["2023-01-01 00:00:00","2023-01-02 00:00:00")`,
+                    tstzrangeField: `["2023-01-01 00:00:00+00","2023-01-02 00:00:00+00")`,
+                    daterangeField: "[2023-01-01,2023-01-02)",
+                    int2vectorField: "1 2 3",
+                    oidField: 1234,
+                    pglsnField: "0/1234567",
+                    regclassField: "pg_class",
+                    regnamespaceField: "pg_catalog",
+                    regprocField: "now",
+                    regprocedureField: "sum(integer)",
+                    regroleField: "orm",
+                    regtypeField: "integer",
+                    tidField: "(0,1)",
+                    xidField: "1234",
+                    txidSnapshotField: "10:20:10,14,15",
+                    arrayField: ["a", "b", "c"],
+                    multiArrayField: [
+                        [
+                            ["a", "b"],
+                            ["c", "d"],
+                        ],
+                        [
+                            ["e", "f"],
+                            ["g", "h"],
+                        ],
+                    ],
+                },
+                returning: [
+                    "charField",
+                    "characterField",
+                    "characterNField",
+                    "varcharField",
+                    "varcharNField",
+                    "textField",
+                    "bitField",
+                    "bitNField",
+                    "bitVaryingField",
+                    "bitVaryingNField",
+                    "numericField",
+                    "numericPrecisionField",
+                    "integerField",
+                    "bigintField",
+                    "smallintField",
+                    "serialField",
+                    "bigserialField",
+                    "smallserialField",
+                    "doublePrecisionField",
+                    "realField",
+                    "moneyField",
+                    "booleanField",
+                    "uuidField",
+                    "dateField",
+                    "timeField",
+                    "timeWithPrecisionField",
+                    "timetzField",
+                    "timeWithTzField",
+                    "timestampField",
+                    "timestampWithPrecisionField",
+                    "timestamptzField",
+                    "timestampWithTzField",
+                    "jsonField",
+                    "jsonbField",
+                    "lineField",
+                    "lsegField",
+                    "boxField",
+                    "polygonField",
+                    "cidrField",
+                    "inetField",
+                    "macaddrField",
+                    "macaddr8Field",
+                    "byteaField",
+                    "xmlField",
+                    "pathField",
+                    "tsqueryField",
+                    "tsvectorField",
+                    "int4rangeField",
+                    "int8rangeField",
+                    "numrangeField",
+                    "tsrangeField",
+                    "tstzrangeField",
+                    "daterangeField",
+                    "int2vectorField",
+                    "oidField",
+                    "pglsnField",
+                    "regclassField",
+                    "regnamespaceField",
+                    "regprocField",
+                    "regprocedureField",
+                    "regroleField",
+                    "regtypeField",
+                    "tidField",
+                    "xidField",
+                    "txidSnapshotField",
+                    "arrayField",
+                    "multiArrayField",
+                ],
+            });
+            const retrieved = await db.findOne("kitchenSink", {
+                select: [
+                    "charField",
+                    "characterField",
+                    "characterNField",
+                    "varcharField",
+                    "varcharNField",
+                    "textField",
+                    "bitField",
+                    "bitNField",
+                    "bitVaryingField",
+                    "bitVaryingNField",
+                    "numericField",
+                    "numericPrecisionField",
+                    "integerField",
+                    "bigintField",
+                    "smallintField",
+                    "serialField",
+                    "bigserialField",
+                    "smallserialField",
+                    "doublePrecisionField",
+                    "realField",
+                    "moneyField",
+                    "booleanField",
+                    "uuidField",
+                    "dateField",
+                    "timeField",
+                    "timeWithPrecisionField",
+                    "timetzField",
+                    "timeWithTzField",
+                    "timestampField",
+                    "timestampWithPrecisionField",
+                    "timestamptzField",
+                    "timestampWithTzField",
+                    "jsonField",
+                    "jsonbField",
+                    "lineField",
+                    "lsegField",
+                    "boxField",
+                    "polygonField",
+                    "cidrField",
+                    "inetField",
+                    "macaddrField",
+                    "macaddr8Field",
+                    "byteaField",
+                    "xmlField",
+                    "pathField",
+                    "tsqueryField",
+                    "tsvectorField",
+                    "int4rangeField",
+                    "int8rangeField",
+                    "numrangeField",
+                    "tsrangeField",
+                    "tstzrangeField",
+                    "daterangeField",
+                    "int2vectorField",
+                    "oidField",
+                    "pglsnField",
+                    "regclassField",
+                    "regnamespaceField",
+                    "regprocField",
+                    "regprocedureField",
+                    "regroleField",
+                    "regtypeField",
+                    "tidField",
+                    "xidField",
+                    "txidSnapshotField",
+                    "arrayField",
+                    "multiArrayField",
+                ],
+            });
+            expect(retrieved).toEqual(created);
+        }, { rollback: true });
+    });
+});

package/build/tests/operators.test.d.ts

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

package/build/tests/operators.test.js

@@ -0,0 +1,125 @@
+import { describe, expect, test } from "vitest";
+import { sql } from "@casekit/sql";
+import { $eq, $gt, $gte, $ilike, $in, $is, $like, $lt, $lte, $ne, $not, defaultOperators, } from "../operators.js";
+describe("operators", () => {
+    const table = sql `a`;
+    const column = sql `a_0`;
+    describe("basic comparison operators", () => {
+        test("$eq", () => {
+            const fragment = defaultOperators[$eq]({ table, column }, 42);
+            expect(fragment.text).toBe("a.a_0 = $1");
+            expect(fragment.values).toEqual([42]);
+        });
+        test("$gt", () => {
+            const fragment = defaultOperators[$gt]({ table, column }, 42);
+            expect(fragment.text).toBe("a.a_0 > $1");
+            expect(fragment.values).toEqual([42]);
+        });
+        test("$gte", () => {
+            const fragment = defaultOperators[$gte]({ table, column }, 42);
+            expect(fragment.text).toBe("a.a_0 >= $1");
+            expect(fragment.values).toEqual([42]);
+        });
+        test("$lt", () => {
+            const fragment = defaultOperators[$lt]({ table, column }, 42);
+            expect(fragment.text).toBe("a.a_0 < $1");
+            expect(fragment.values).toEqual([42]);
+        });
+        test("$lte", () => {
+            const fragment = defaultOperators[$lte]({ table, column }, 42);
+            expect(fragment.text).toBe("a.a_0 <= $1");
+            expect(fragment.values).toEqual([42]);
+        });
+        test("$ne", () => {
+            const fragment = defaultOperators[$ne]({ table, column }, 42);
+            expect(fragment.text).toBe("a.a_0 != $1");
+            expect(fragment.values).toEqual([42]);
+        });
+        test("NULL, true and false are inserted directly rather than being used as parameters", () => {
+            const fragment = defaultOperators[$eq]({ table, column }, null);
+            expect(fragment.text).toBe("a.a_0 = NULL");
+            expect(fragment.values).toEqual([]);
+            const fragment2 = defaultOperators[$eq]({ table, column }, true);
+            expect(fragment2.text).toBe("a.a_0 = TRUE");
+            expect(fragment2.values).toEqual([]);
+            const fragment3 = defaultOperators[$eq]({ table, column }, false);
+            expect(fragment3.text).toBe("a.a_0 = FALSE");
+            expect(fragment3.values).toEqual([]);
+        });
+    });
+    describe("pattern matching operators", () => {
+        test("$like", () => {
+            const fragment = defaultOperators[$like]({ table, column }, "%test%");
+            expect(fragment.text).toBe("a.a_0 LIKE $1");
+            expect(fragment.values).toEqual(["%test%"]);
+        });
+        test("$ilike", () => {
+            const fragment = defaultOperators[$ilike]({ table, column }, "%TEST%");
+            expect(fragment.text).toBe("a.a_0 ILIKE $1");
+            expect(fragment.values).toEqual(["%TEST%"]);
+        });
+    });
+    describe("$is operator", () => {
+        test("with null", () => {
+            const fragment = defaultOperators[$is]({ table, column }, null);
+            expect(fragment.text).toBe("a.a_0 IS NULL");
+            expect(fragment.values).toEqual([]);
+        });
+        test("with true", () => {
+            const fragment = defaultOperators[$is]({ table, column }, true);
+            expect(fragment.text).toBe("a.a_0 IS TRUE");
+            expect(fragment.values).toEqual([]);
+        });
+        test("with false", () => {
+            const fragment = defaultOperators[$is]({ table, column }, false);
+            expect(fragment.text).toBe("a.a_0 IS FALSE");
+            expect(fragment.values).toEqual([]);
+        });
+    });
+    describe("$in operator", () => {
+        test("with array of values", () => {
+            const fragment = defaultOperators[$in]({ table, column }, [1, 2, 3]);
+            expect(fragment.text).toBe("a.a_0 IN ($1, $2, $3)");
+            expect(fragment.values).toEqual([1, 2, 3]);
+        });
+        test("with empty array", () => {
+            const fragment = defaultOperators[$in]({ table, column }, []);
+            expect(fragment.text).toBe("a.a_0 IN (NULL)");
+            expect(fragment.values).toEqual([]);
+        });
+        test("throws error with non-array value", () => {
+            expect(() => {
+                defaultOperators[$in]({ table, column }, "not-an-array");
+            }).toThrow("Non-array passed to IN clause");
+        });
+    });
+    describe("$not operator", () => {
+        test("with null", () => {
+            const fragment = defaultOperators[$not]({ table, column }, null);
+            expect(fragment.text).toBe("a.a_0 IS NOT NULL");
+            expect(fragment.values).toEqual([]);
+        });
+        test("with true", () => {
+            const fragment = defaultOperators[$not]({ table, column }, true);
+            expect(fragment.text).toBe("a.a_0 IS NOT TRUE");
+            expect(fragment.values).toEqual([]);
+        });
+        test("with false", () => {
+            const fragment = defaultOperators[$not]({ table, column }, false);
+            expect(fragment.text).toBe("a.a_0 IS NOT FALSE");
+            expect(fragment.values).toEqual([]);
+        });
+        test("throws error with invalid value", () => {
+            expect(() => {
+                defaultOperators[$not]({ table, column }, "invalid");
+            }).toThrow("Invalid value passed to $not operator");
+        });
+    });
+    describe("edge cases", () => {
+        test("handles special characters in values", () => {
+            const fragment = defaultOperators[$eq]({ table, column }, "value with 'quotes' and spaces");
+            expect(fragment.text).toBe("a.a_0 = $1");
+            expect(fragment.values).toEqual(["value with 'quotes' and spaces"]);
+        });
+    });
+});

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

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

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

@@ -0,0 +1,132 @@
+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.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.count.test-d.d.ts

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

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

@@ -0,0 +1,60 @@
+import { describe, expectTypeOf, test } from "vitest";
+import { $in, $like } from "../operators.js";
+import { createTestDB } from "./util/db.js";
+describe("orm.count", () => {
+    const { db } = createTestDB();
+    test("returns number type for basic count", () => {
+        expectTypeOf(db.count("post", {})).resolves.toBeNumber();
+    });
+    test("returns number type with where clause", () => {
+        expectTypeOf(db.count("post", {
+            where: {
+                title: "Test Post",
+            },
+        })).resolves.toBeNumber();
+    });
+    test("returns number type with complex where clause", () => {
+        expectTypeOf(db.count("post", {
+            where: {
+                title: { [$like]: "%Test%" },
+                id: { [$in]: [1, 2, 3] },
+            },
+        })).resolves.toBeNumber();
+    });
+    test("returns number type with include clause", () => {
+        expectTypeOf(db.count("post", {
+            include: {
+                author: {
+                    where: {
+                        name: { [$like]: "John%" },
+                    },
+                },
+            },
+        })).resolves.toBeNumber();
+    });
+    test("returns number type with for clause", () => {
+        expectTypeOf(db.count("post", {
+            for: "update",
+        })).resolves.toBeNumber();
+    });
+    test("type error for invalid model name", async () => {
+        // @ts-expect-error Invalid model name
+        await db.count("nonexistent", {});
+    });
+    test("type error for invalid field in where clause", async () => {
+        // @ts-expect-error Invalid field
+        await db.count("post", { where: { nonexistentField: "value" } });
+    });
+    test("type error for invalid relation in include", async () => {
+        // @ts-expect-error Invalid relation
+        await db.count("post", { include: { nonexistentRelation: {} } });
+    });
+    test("type error for non-N:1 relation in include", async () => {
+        // @ts-expect-error Only N:1 relations can be included
+        await db.count("post", { include: { likes: {} } });
+    });
+    test("type error for invalid value in for clause", async () => {
+        // @ts-expect-error Invalid for value
+        await db.count("post", { for: "invalid" });
+    });
+});

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

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