@casekit/orm2 0.0.0-20250322230249

package/build/sql/util.test.js

@@ -0,0 +1,163 @@
+import { describe, expect, test } from "vitest";
+import { sql } from "@casekit/sql";
+import { unindent } from "@casekit/unindent";
+import { columnName, joinClause, orderByColumn, selectColumn, setClause, sqlValue, tableName, unnestPk, } from "./util.js";
+describe("SQL utility functions", () => {
+    test("tableName should format table identifier correctly", () => {
+        const table = {
+            schema: "public",
+            name: "users",
+            alias: "u",
+            model: "user",
+        };
+        expect(tableName(table).text).toBe('"public"."users" AS "u"');
+    });
+    test("columnName should format column identifier correctly", () => {
+        const column = { table: "users", name: "id" };
+        expect(columnName(column).text).toBe('"users"."id"');
+    });
+    test("selectColumn should format column with alias", () => {
+        const column = {
+            table: "users",
+            name: "first_name",
+            alias: "name",
+            path: [],
+        };
+        expect(selectColumn(column).text).toBe('"users"."first_name" AS "name"');
+    });
+    test("sqlValue should create typed value", () => {
+        const typeValue = sqlValue("uuid");
+        expect(typeValue("123").text).toBe("$1::uuid");
+    });
+    test("unnestPk should format primary key array correctly", () => {
+        const pk = {
+            column: "id",
+            type: "uuid",
+            values: ["123", "456"],
+        };
+        expect(unnestPk(pk).text).toBe('UNNEST(ARRAY[$1::uuid, $2::uuid]) AS "id"');
+    });
+    test("joinClause should format INNER JOIN correctly for N:1 relation", () => {
+        const join = {
+            type: "INNER",
+            path: ["author"],
+            relation: "author",
+            table: {
+                schema: "public",
+                name: "users",
+                alias: "u",
+                model: "user",
+            },
+            columns: [
+                {
+                    from: { table: "p", name: "author_id" },
+                    to: { table: "u", name: "id" },
+                },
+            ],
+        };
+        expect(joinClause(join).pretty).toBe('JOIN "public"."users" AS "u" ON "p"."author_id" = "u"."id"');
+    });
+    test("joinClause should format LEFT JOIN correctly for N:1 relation", () => {
+        const join = {
+            type: "LEFT",
+            path: ["author"],
+            relation: "author",
+            table: {
+                schema: "public",
+                name: "users",
+                alias: "u",
+                model: "user",
+            },
+            columns: [
+                {
+                    from: { table: "p", name: "author_id" },
+                    to: { table: "u", name: "id" },
+                },
+            ],
+        };
+        expect(joinClause(join).pretty).toBe('LEFT JOIN "public"."users" AS "u" ON "p"."author_id" = "u"."id"');
+    });
+    test("joinClause should format LEFT JOIN correctly for N:1 relation with compound key", () => {
+        const join = {
+            type: "LEFT",
+            relation: "organization",
+            path: ["organization"],
+            table: {
+                schema: "public",
+                name: "organizations",
+                alias: "o",
+                model: "organization",
+            },
+            columns: [
+                {
+                    from: { table: "u", name: "org_id" },
+                    to: { table: "o", name: "id" },
+                },
+                {
+                    from: { table: "u", name: "org_type" },
+                    to: { table: "o", name: "type" },
+                },
+            ],
+        };
+        expect(joinClause(join).pretty).toBe(unindent `
+            LEFT JOIN "public"."organizations" AS "o" ON "u"."org_id" = "o"."id"
+            AND "u"."org_type" = "o"."type"
+        `);
+    });
+    test("joinClause should include where clause when provided for N:1 relation", () => {
+        const join = {
+            type: "LEFT",
+            relation: "author",
+            path: ["author"],
+            table: {
+                schema: "public",
+                name: "users",
+                alias: "u",
+                model: "user",
+            },
+            columns: [
+                {
+                    from: { table: "p", name: "author_id" },
+                    to: { table: "u", name: "id" },
+                },
+            ],
+            where: sql `"u"."deleted_at" IS NULL`,
+        };
+        expect(joinClause(join).pretty).toBe(unindent `
+                LEFT JOIN "public"."users" AS "u" ON "p"."author_id" = "u"."id"
+                AND "u"."deleted_at" IS NULL
+            `);
+    });
+    test("orderByColumn should format ASC order correctly", () => {
+        const orderBy = {
+            column: { table: "users", name: "created_at" },
+            direction: "ASC",
+        };
+        expect(orderByColumn(orderBy).pretty).toBe('"users"."created_at" ASC');
+    });
+    test("orderByColumn should format DESC order correctly", () => {
+        const orderBy = {
+            column: { table: "posts", name: "likes" },
+            direction: "DESC",
+        };
+        expect(orderByColumn(orderBy).pretty).toBe('"posts"."likes" DESC');
+    });
+});
+describe("setClause", () => {
+    test("setClause should format column and value correctly", () => {
+        const pair = ["first_name", "John"];
+        expect(setClause(pair).text).toBe('"first_name" = $1');
+    });
+    test("setClause should handle numbers", () => {
+        const pair = ["age", 25];
+        expect(setClause(pair).text).toBe('"age" = $1');
+    });
+    test("setClause should handle null values", () => {
+        const pair = ["deleted_at", null];
+        expect(setClause(pair).text).toBe('"deleted_at" = NULL');
+    });
+    test("setClause should handle boolean values", () => {
+        const pair = ["is_active", true];
+        expect(setClause(pair).text).toBe('"is_active" = TRUE');
+    });
+});

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

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

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/orm2-config";
+import { models } from "@casekit/orm2-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).toEqual("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).toEqual("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).toEqual("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 {};