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

package/build/tests/connection.test.js

@@ -0,0 +1,304 @@
+import pg from "pg";
+import { afterEach, beforeEach, describe, expect, test } from "vitest";
+import { normalizeConfig } from "@casekit/orm-config";
+import { models } from "@casekit/orm-fixtures";
+import { sql } from "@casekit/sql";
+import { Connection, Transaction } from "../connection.js";
+import { mockLogger } from "./util/logger.js";
+describe("Connection", () => {
+    describe("without connection pooling", () => {
+        const logger = mockLogger();
+        let connection;
+        beforeEach(() => {
+            logger.clear();
+            connection = new Connection(normalizeConfig({
+                models: models,
+                pool: false,
+                logger: logger,
+            }));
+        });
+        afterEach(async () => {
+            if (connection.open) {
+                await connection.close();
+            }
+        });
+        test("opening and closing the connection", async () => {
+            await connection.connect();
+            expect(connection.open).toBe(true);
+            await connection.close();
+            expect(connection.open).toBe(false);
+        });
+        test("warning on trying to connect twice", async () => {
+            await connection.connect();
+            await connection.connect();
+            expect(logger.logs.warn[0]?.message).toEqual("Tried to connect, but connection is already open");
+        });
+        test("error on failing to connect", async () => {
+            const connection = new Connection(normalizeConfig({
+                models: models,
+                connection: {
+                    user: "nonexistent",
+                    password: "nonexistent",
+                    database: "nonexistent",
+                    host: "nonexistent",
+                    port: 54321,
+                },
+                pool: false,
+                logger,
+            }));
+            await expect(connection.connect()).rejects.toThrowError();
+            expect(logger.logs.error[0]?.message).toEqual("Error connecting to database");
+        });
+        test("warning on trying to close twice", async () => {
+            await connection.connect();
+            await connection.close();
+            await connection.close();
+            expect(logger.logs.warn[0]?.message).toEqual("Tried to close connection, but it is already closed");
+        });
+        test("running a query", async () => {
+            await connection.connect();
+            const result = await connection.query(sql `SELECT ${1}::int as num`);
+            expect(result.rows[0]["num"]).toBe(1);
+        });
+        test("error on trying to run query without connecting", async () => {
+            await expect(connection.query(sql `SELECT ${1}::int as num`)).rejects.toThrowError("Tried to run query but not connected");
+        });
+    });
+    describe("with connection pooling", () => {
+        const logger = mockLogger();
+        let connection;
+        beforeEach(() => {
+            logger.clear();
+            connection = new Connection(normalizeConfig({
+                models: models,
+                pool: true,
+                logger,
+            }));
+        });
+        afterEach(async () => {
+            if (connection.open) {
+                await connection.close();
+            }
+        });
+        test("opening and closing the connection", async () => {
+            await connection.connect();
+            expect(connection.open).toBe(true);
+            await connection.close();
+            expect(connection.open).toBe(false);
+        });
+        test("warning on trying to connect twice", async () => {
+            await connection.connect();
+            await connection.connect();
+            expect(logger.logs.warn[0]?.message).toEqual("Tried to connect, but connection is already open");
+        });
+        test("warning on trying to close twice", async () => {
+            await connection.connect();
+            await connection.close();
+            await connection.close();
+            expect(logger.logs.warn[0]?.message).toEqual("Tried to close connection, but it is already closed");
+        });
+        test("running a query", async () => {
+            await connection.connect();
+            const result = await connection.query(sql `SELECT ${1}::int as num`);
+            expect(result.rows[0]["num"]).toBe(1);
+        });
+    });
+});
+describe("Transaction", () => {
+    describe("without connection pooling", () => {
+        const logger = mockLogger();
+        let connection;
+        let transaction;
+        beforeEach(async () => {
+            logger.clear();
+            connection = new Connection(normalizeConfig({
+                models: models,
+                pool: false,
+                logger,
+            }));
+            await connection.connect();
+            await connection.query(sql `
+                        CREATE TABLE IF NOT EXISTS transaction_test_table (id int);
+                        TRUNCATE transaction_test_table
+                    `);
+            transaction = await connection.startTransaction();
+        });
+        afterEach(async () => {
+            await connection.query(sql `DROP TABLE IF EXISTS transaction_test_table`);
+            if (transaction.open) {
+                await transaction.rollback();
+            }
+            if (connection.open) {
+                await connection.close();
+            }
+        });
+        test("trying to start a transaction before connecting", async () => {
+            const connection = new Connection(normalizeConfig({
+                models: models,
+                pool: false,
+            }));
+            await expect(() => connection.startTransaction()).rejects.toThrowError("Tried to start transaction but not connected");
+        });
+        test("committing a transaction", async () => {
+            await transaction.query(sql `INSERT INTO transaction_test_table VALUES (1)`);
+            await transaction.commit();
+            const result = await connection.query(sql `SELECT * FROM transaction_test_table`);
+            expect(result.rows[0]["id"]).toBe(1);
+        });
+        test("trying to connect while in a transaction", async () => {
+            const tx = await connection.startTransaction();
+            await expect(() => tx.connect()).rejects.toThrowError("Cannot connect in transaction - already connected");
+        });
+        test("trying to close while in a transaction", async () => {
+            const tx = await connection.startTransaction();
+            await expect(() => tx.close()).rejects.toThrowError("Cannot close connection while in transaction");
+        });
+        test("trying to open a nested transaction before transaction has been opened", async () => {
+            const tx = new Transaction(normalizeConfig({
+                models: models,
+                pool: false,
+            }), new pg.Client());
+            await expect(tx.startTransaction()).rejects.toThrowError("Tried to open nested transaction but parent transaction is closed");
+        });
+        test("rolling back transaction", async () => {
+            await transaction.query(sql `INSERT INTO transaction_test_table VALUES (1)`);
+            await transaction.rollback();
+            const result = await connection.query(sql `SELECT * FROM transaction_test_table`);
+            expect(result.rows.length).toBe(0);
+        });
+        test("error on trying to commit twice", async () => {
+            await transaction.commit();
+            await expect(transaction.commit()).rejects.toThrowError("Tried to commit transaction but it is closed");
+        });
+        test("commiting a nested transaction then rolling back the parent transaction", async () => {
+            const nestedTx = await transaction.startTransaction();
+            await nestedTx.query(sql `INSERT INTO transaction_test_table VALUES (1)`);
+            await nestedTx.commit();
+            const innerResult = await transaction.query(sql `SELECT * FROM transaction_test_table`);
+            expect(innerResult.rows[0]["id"]).toBe(1);
+            await transaction.rollback();
+            const outerResult = await connection.query(sql `SELECT * FROM transaction_test_table`);
+            expect(outerResult.rows.length).toBe(0);
+        });
+        test("commiting a nested transaction then committing the parent transaction", async () => {
+            const nestedTx = await transaction.startTransaction();
+            await nestedTx.query(sql `INSERT INTO transaction_test_table VALUES (1)`);
+            await nestedTx.commit();
+            const innerResult = await transaction.query(sql `SELECT * FROM transaction_test_table`);
+            expect(innerResult.rows[0]["id"]).toBe(1);
+            await transaction.commit();
+            const outerResult = await connection.query(sql `SELECT * FROM transaction_test_table`);
+            expect(outerResult.rows[0]["id"]).toBe(1);
+        });
+        test("rolling back the nested transaction but committing the parent transaction", async () => {
+            const nestedTx = await transaction.startTransaction();
+            await nestedTx.query(sql `INSERT INTO transaction_test_table VALUES (1)`);
+            await nestedTx.rollback();
+            const innerResult = await transaction.query(sql `SELECT * FROM transaction_test_table`);
+            expect(innerResult.rows.length).toBe(0);
+            await transaction.commit();
+            const outerResult = await connection.query(sql `SELECT * FROM transaction_test_table`);
+            expect(outerResult.rows.length).toBe(0);
+        });
+        test("rolling back on error", async () => {
+            await transaction.query(sql `INSERT INTO transaction_test_table VALUES (2)`);
+            await expect(transaction.query(sql `SELECT * FROM non_existent_table`)).rejects.toThrowError('relation "non_existent_table" does not exist');
+            expect(logger.logs.error[0]?.message).toContain("Error running query");
+            expect(logger.logs.error[1]?.message).toEqual("Rolling back transaction due to error");
+            const result = await connection.query(sql `SELECT * FROM transaction_test_table`);
+            expect(result.rows.length).toBe(0);
+        });
+    });
+    describe("with connection pooling", () => {
+        const logger = mockLogger();
+        let connection;
+        let transaction;
+        beforeEach(async () => {
+            logger.clear();
+            connection = new Connection(normalizeConfig({
+                models: models,
+                pool: true,
+                logger,
+            }));
+            await connection.connect();
+            await connection.query(sql `
+                        CREATE TABLE IF NOT EXISTS transaction_test_table (id int);
+                        TRUNCATE transaction_test_table
+                    `);
+            transaction = await connection.startTransaction();
+        });
+        afterEach(async () => {
+            if (transaction.open) {
+                await transaction.rollback();
+            }
+            if (connection.open) {
+                await connection.query(sql `DROP TABLE IF EXISTS transaction_test_table`);
+                await connection.close();
+            }
+        });
+        test("committing a transaction", async () => {
+            await transaction.query(sql `INSERT INTO transaction_test_table VALUES (1)`);
+            await transaction.commit();
+            const result = await connection.query(sql `SELECT * FROM transaction_test_table`);
+            expect(result.rows[0]["id"]).toBe(1);
+        });
+        test("rolling back transaction", async () => {
+            await transaction.query(sql `INSERT INTO transaction_test_table VALUES (1)`);
+            await transaction.rollback();
+            const result = await connection.query(sql `SELECT * FROM transaction_test_table`);
+            expect(result.rows.length).toBe(0);
+        });
+        test("error on trying to commit twice", async () => {
+            await transaction.commit();
+            await expect(transaction.commit()).rejects.toThrowError("Tried to commit transaction but it is closed");
+        });
+        test("commiting a nested transaction then rolling back the parent transaction", async () => {
+            const nestedTx = await transaction.startTransaction();
+            await nestedTx.query(sql `INSERT INTO transaction_test_table VALUES (1)`);
+            await nestedTx.commit();
+            const innerResult = await transaction.query(sql `SELECT * FROM transaction_test_table`);
+            expect(innerResult.rows[0]["id"]).toBe(1);
+            await transaction.rollback();
+            const outerResult = await connection.query(sql `SELECT * FROM transaction_test_table`);
+            expect(outerResult.rows.length).toBe(0);
+        });
+        test("commiting a nested transaction then committing the parent transaction", async () => {
+            const nestedTx = await transaction.startTransaction();
+            await nestedTx.query(sql `INSERT INTO transaction_test_table VALUES (1)`);
+            await nestedTx.commit();
+            const innerResult = await transaction.query(sql `SELECT * FROM transaction_test_table`);
+            expect(innerResult.rows[0]["id"]).toBe(1);
+            await transaction.commit();
+            const outerResult = await connection.query(sql `SELECT * FROM transaction_test_table`);
+            expect(outerResult.rows[0]["id"]).toBe(1);
+        });
+        test("rolling back the nested transaction but committing the parent transaction", async () => {
+            const nestedTx = await transaction.startTransaction();
+            await nestedTx.query(sql `INSERT INTO transaction_test_table VALUES (1)`);
+            await nestedTx.rollback();
+            const innerResult = await transaction.query(sql `SELECT * FROM transaction_test_table`);
+            expect(innerResult.rows.length).toBe(0);
+            await transaction.commit();
+            const outerResult = await connection.query(sql `SELECT * FROM transaction_test_table`);
+            expect(outerResult.rows.length).toBe(0);
+        });
+        test("rolling back on error", async () => {
+            await transaction.query(sql `INSERT INTO transaction_test_table VALUES (2)`);
+            await expect(transaction.query(sql `SELECT * FROM non_existent_table`)).rejects.toThrowError('relation "non_existent_table" does not exist');
+            expect(logger.logs.error[0]?.message).toContain("Error running query");
+            const result = await connection.query(sql `SELECT * FROM transaction_test_table`);
+            expect(result.rows.length).toBe(0);
+        });
+        test("rolling back nested transaction on error", async () => {
+            const nestedTx = await transaction.startTransaction();
+            await nestedTx.query(sql `INSERT INTO transaction_test_table VALUES (2)`);
+            await expect(nestedTx.query(sql `SELECT * FROM non_existent_table`)).rejects.toThrowError('relation "non_existent_table" does not exist');
+            expect(logger.logs.error[0]?.message).toContain("Error running query");
+            expect(logger.logs.error[1]?.message).toEqual("Rolling back transaction due to error");
+            await transaction.query(sql `INSERT INTO transaction_test_table VALUES (7)`);
+            const result = await transaction.query(sql `SELECT * FROM transaction_test_table`);
+            expect(result.rows.length).toBe(1);
+            expect(result.rows[0]["id"]).toBe(7);
+        });
+    });
+});

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

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

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.test-d.d.ts

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