@geekmidas/testkit 0.0.5 → 0.0.7

package/dist/VitestTransactionIsolator-DcOz0LZF.cjs

@@ -0,0 +1,129 @@
+
+//#region src/VitestTransactionIsolator.ts
+/**
+* PostgreSQL transaction isolation levels.
+* Controls the visibility of concurrent transactions.
+*
+* @see https://www.postgresql.org/docs/current/transaction-iso.html
+*/
+let IsolationLevel = /* @__PURE__ */ function(IsolationLevel$1) {
+	/**
+	* Lowest isolation level. Allows dirty reads.
+	* Not recommended for testing.
+	*/
+	IsolationLevel$1["READ_UNCOMMITTED"] = "READ UNCOMMITTED";
+	/**
+	* Default PostgreSQL isolation level.
+	* Prevents dirty reads but allows non-repeatable reads.
+	*/
+	IsolationLevel$1["READ_COMMITTED"] = "READ COMMITTED";
+	/**
+	* Prevents dirty reads and non-repeatable reads.
+	* Recommended for most test scenarios.
+	*/
+	IsolationLevel$1["REPEATABLE_READ"] = "REPEATABLE READ";
+	/**
+	* Highest isolation level. Prevents all phenomena.
+	* May cause performance overhead in tests.
+	*/
+	IsolationLevel$1["SERIALIZABLE"] = "SERIALIZABLE";
+	return IsolationLevel$1;
+}({});
+/**
+* Abstract base class for implementing database transaction isolation in Vitest tests.
+* Provides automatic transaction rollback after each test to maintain test isolation.
+* Subclasses must implement the transact() method for their specific database driver.
+*
+* @template Connection - The database connection type
+* @template Transaction - The transaction type
+*
+* @example
+* ```typescript
+* // Implement for your database driver
+* class MyDatabaseIsolator extends VitestPostgresTransactionIsolator<MyDB, MyTx> {
+*   async transact(conn: MyDB, level: IsolationLevel, fn: (tx: MyTx) => Promise<void>) {
+*     await conn.transaction(level, fn);
+*   }
+* }
+*
+* // Use in tests
+* const isolator = new MyDatabaseIsolator(test);
+* const isolatedTest = isolator.wrapVitestWithTransaction(db);
+*
+* isolatedTest('should create user', async ({ trx }) => {
+*   await trx.insert('users', { name: 'Test' });
+*   // Data is automatically rolled back after test
+* });
+* ```
+*/
+var VitestPostgresTransactionIsolator = class {
+	/**
+	* Creates a new VitestPostgresTransactionIsolator instance.
+	*
+	* @param api - The Vitest test API (usually the `test` export from vitest)
+	*/
+	constructor(api) {
+		this.api = api;
+	}
+	/**
+	* Creates a wrapped version of Vitest's test API that provides transaction isolation.
+	* Each test will run within a database transaction that is automatically rolled back.
+	*
+	* @param conn - The database connection to use
+	* @param setup - Optional setup function to run within the transaction before each test
+	* @param level - The transaction isolation level (defaults to REPEATABLE_READ)
+	* @returns A wrapped test API with transaction support
+	*
+	* @example
+	* ```typescript
+	* const isolatedTest = isolator.wrapVitestWithTransaction(db, async (trx) => {
+	*   // Optional setup: create common test data
+	*   await trx.insert('settings', { key: 'test', value: 'true' });
+	* });
+	*
+	* isolatedTest('test with transaction', async ({ trx }) => {
+	*   const user = await trx.insert('users', { name: 'Test' });
+	*   expect(user).toBeDefined();
+	* });
+	* ```
+	*/
+	wrapVitestWithTransaction(conn, setup, level = IsolationLevel.REPEATABLE_READ) {
+		return this.api.extend({ trx: async ({}, use) => {
+			class TestRollback extends Error {
+				constructor() {
+					super("Test rollback");
+					this.name = "TestRollback";
+				}
+			}
+			let testError;
+			try {
+				await this.transact(conn, level, async (transaction) => {
+					try {
+						await setup?.(transaction);
+						await use(transaction);
+					} catch (error) {
+						testError = error;
+					}
+					throw new TestRollback();
+				});
+			} catch (error) {
+				if (!(error instanceof TestRollback)) throw error;
+				if (testError) throw testError;
+			}
+		} });
+	}
+};
+
+//#endregion
+Object.defineProperty(exports, 'IsolationLevel', {
+  enumerable: true,
+  get: function () {
+    return IsolationLevel;
+  }
+});
+Object.defineProperty(exports, 'VitestPostgresTransactionIsolator', {
+  enumerable: true,
+  get: function () {
+    return VitestPostgresTransactionIsolator;
+  }
+});

package/dist/VitestTransactionIsolator-kFL36T8x.mjs

@@ -0,0 +1,117 @@
+//#region src/VitestTransactionIsolator.ts
+/**
+* PostgreSQL transaction isolation levels.
+* Controls the visibility of concurrent transactions.
+*
+* @see https://www.postgresql.org/docs/current/transaction-iso.html
+*/
+let IsolationLevel = /* @__PURE__ */ function(IsolationLevel$1) {
+	/**
+	* Lowest isolation level. Allows dirty reads.
+	* Not recommended for testing.
+	*/
+	IsolationLevel$1["READ_UNCOMMITTED"] = "READ UNCOMMITTED";
+	/**
+	* Default PostgreSQL isolation level.
+	* Prevents dirty reads but allows non-repeatable reads.
+	*/
+	IsolationLevel$1["READ_COMMITTED"] = "READ COMMITTED";
+	/**
+	* Prevents dirty reads and non-repeatable reads.
+	* Recommended for most test scenarios.
+	*/
+	IsolationLevel$1["REPEATABLE_READ"] = "REPEATABLE READ";
+	/**
+	* Highest isolation level. Prevents all phenomena.
+	* May cause performance overhead in tests.
+	*/
+	IsolationLevel$1["SERIALIZABLE"] = "SERIALIZABLE";
+	return IsolationLevel$1;
+}({});
+/**
+* Abstract base class for implementing database transaction isolation in Vitest tests.
+* Provides automatic transaction rollback after each test to maintain test isolation.
+* Subclasses must implement the transact() method for their specific database driver.
+*
+* @template Connection - The database connection type
+* @template Transaction - The transaction type
+*
+* @example
+* ```typescript
+* // Implement for your database driver
+* class MyDatabaseIsolator extends VitestPostgresTransactionIsolator<MyDB, MyTx> {
+*   async transact(conn: MyDB, level: IsolationLevel, fn: (tx: MyTx) => Promise<void>) {
+*     await conn.transaction(level, fn);
+*   }
+* }
+*
+* // Use in tests
+* const isolator = new MyDatabaseIsolator(test);
+* const isolatedTest = isolator.wrapVitestWithTransaction(db);
+*
+* isolatedTest('should create user', async ({ trx }) => {
+*   await trx.insert('users', { name: 'Test' });
+*   // Data is automatically rolled back after test
+* });
+* ```
+*/
+var VitestPostgresTransactionIsolator = class {
+	/**
+	* Creates a new VitestPostgresTransactionIsolator instance.
+	*
+	* @param api - The Vitest test API (usually the `test` export from vitest)
+	*/
+	constructor(api) {
+		this.api = api;
+	}
+	/**
+	* Creates a wrapped version of Vitest's test API that provides transaction isolation.
+	* Each test will run within a database transaction that is automatically rolled back.
+	*
+	* @param conn - The database connection to use
+	* @param setup - Optional setup function to run within the transaction before each test
+	* @param level - The transaction isolation level (defaults to REPEATABLE_READ)
+	* @returns A wrapped test API with transaction support
+	*
+	* @example
+	* ```typescript
+	* const isolatedTest = isolator.wrapVitestWithTransaction(db, async (trx) => {
+	*   // Optional setup: create common test data
+	*   await trx.insert('settings', { key: 'test', value: 'true' });
+	* });
+	*
+	* isolatedTest('test with transaction', async ({ trx }) => {
+	*   const user = await trx.insert('users', { name: 'Test' });
+	*   expect(user).toBeDefined();
+	* });
+	* ```
+	*/
+	wrapVitestWithTransaction(conn, setup, level = IsolationLevel.REPEATABLE_READ) {
+		return this.api.extend({ trx: async ({}, use) => {
+			class TestRollback extends Error {
+				constructor() {
+					super("Test rollback");
+					this.name = "TestRollback";
+				}
+			}
+			let testError;
+			try {
+				await this.transact(conn, level, async (transaction) => {
+					try {
+						await setup?.(transaction);
+						await use(transaction);
+					} catch (error) {
+						testError = error;
+					}
+					throw new TestRollback();
+				});
+			} catch (error) {
+				if (!(error instanceof TestRollback)) throw error;
+				if (testError) throw testError;
+			}
+		} });
+	}
+};
+
+//#endregion
+export { IsolationLevel, VitestPostgresTransactionIsolator };

package/dist/VitestTransactionIsolator.cjs

@@ -1,4 +1,4 @@
-const require_VitestTransactionIsolator = require('./VitestTransactionIsolator-Bx2c4OzK.cjs');
+const require_VitestTransactionIsolator = require('./VitestTransactionIsolator-DcOz0LZF.cjs');
 
 exports.IsolationLevel = require_VitestTransactionIsolator.IsolationLevel;
 exports.VitestPostgresTransactionIsolator = require_VitestTransactionIsolator.VitestPostgresTransactionIsolator;

package/dist/VitestTransactionIsolator.mjs

@@ -1,3 +1,3 @@
-import { IsolationLevel, VitestPostgresTransactionIsolator } from "./VitestTransactionIsolator-BjVXqFs6.mjs";
+import { IsolationLevel, VitestPostgresTransactionIsolator } from "./VitestTransactionIsolator-kFL36T8x.mjs";
 
 export { IsolationLevel, VitestPostgresTransactionIsolator };

package/dist/__tests__/Factory.spec.cjs

@@ -1,5 +1,5 @@
 const require_chunk = require('../chunk-CUT6urMc.cjs');
-const require_Factory = require('../Factory-DREHoms3.cjs');
+const require_Factory = require('../Factory-WMhTNZ9S.cjs');
 const vitest = require_chunk.__toESM(require("vitest"));
 
 //#region src/__tests__/Factory.spec.ts

package/dist/__tests__/Factory.spec.mjs

@@ -1,4 +1,4 @@
-import { Factory } from "../Factory-DlzMkMzb.mjs";
+import { Factory } from "../Factory-z2m01hMj.mjs";
 import { beforeEach, describe, expect, it } from "vitest";
 
 //#region src/__tests__/Factory.spec.ts

package/dist/__tests__/KyselyFactory.spec.cjs

@@ -1,33 +1,34 @@
 const require_chunk = require('../chunk-CUT6urMc.cjs');
-require('../Factory-DREHoms3.cjs');
-require('../faker-caz-8zt8.cjs');
-const require_KyselyFactory = require('../KyselyFactory-BX7Kv2uP.cjs');
-require('../VitestTransactionIsolator-Bx2c4OzK.cjs');
-require('../VitestKyselyTransactionIsolator-DWSTKIe3.cjs');
-const require_helpers = require('../helpers-B9Jdk_C7.cjs');
-const require_helpers$1 = require('../helpers-DKEBHABj.cjs');
+require('../Factory-WMhTNZ9S.cjs');
+require('../faker-SMN4ira4.cjs');
+const require_KyselyFactory = require('../KyselyFactory-Bdq1s1Go.cjs');
+require('../PostgresMigrator-BtAWdLss.cjs');
+require('../PostgresKyselyMigrator-Bs31emFd.cjs');
+require('../VitestTransactionIsolator-DcOz0LZF.cjs');
+require('../VitestKyselyTransactionIsolator-YWnSJiIH.cjs');
+const require_helpers = require('../helpers-H4hO5SZR.cjs');
+const require_kysely = require('../kysely-B-GOhABm.cjs');
+const require_helpers$1 = require('../helpers-Bnm3Jy9X.cjs');
 const pg = require_chunk.__toESM(require("pg"));
 const vitest = require_chunk.__toESM(require("vitest"));
 
 //#region src/__tests__/KyselyFactory.spec.ts
 const db = require_helpers.createKyselyDb(require_helpers$1.TEST_DATABASE_CONFIG);
-const itWithTransaction = require_helpers.wrapVitestKyselyTransaction(db, require_helpers$1.createTestTables);
+const itWithTransaction = require_kysely.wrapVitestKyselyTransaction(vitest.it, db, require_helpers$1.createTestTables);
 const int8TypeId = 20;
 pg.default.types.setTypeParser(int8TypeId, (val) => {
 	return parseInt(val, 10);
 });
 (0, vitest.describe)("KyselyFactory", () => {
-	let db$1;
-	let trx;
 	(0, vitest.describe)("KyselyFactory.insert", () => {
-		itWithTransaction("should insert a record with defaults", async ({ trx: trx$1 }) => {
+		itWithTransaction("should insert a record with defaults", async ({ trx }) => {
 			const userBuilder = require_KyselyFactory.KyselyFactory.createBuilder("users", async (attrs) => ({
 				name: "John Doe",
 				email: `user${Date.now()}@example.com`,
 				createdAt: /* @__PURE__ */ new Date()
 			}));
 			const builders = { user: userBuilder };
-			const factory = new require_KyselyFactory.KyselyFactory(builders, {}, trx$1);
+			const factory = new require_KyselyFactory.KyselyFactory(builders, {}, trx);
 			const user = await factory.insert("user");
 			(0, vitest.expect)(user).toBeDefined();
 			(0, vitest.expect)(user.id).toBeDefined();
@@ -36,14 +37,14 @@ pg.default.types.setTypeParser(int8TypeId, (val) => {
 			(0, vitest.expect)(user.email).toContain("@example.com");
 			(0, vitest.expect)(user.createdAt).toBeInstanceOf(Date);
 		});
-		itWithTransaction("should override defaults with provided attributes", async ({ trx: trx$1 }) => {
+		itWithTransaction("should override defaults with provided attributes", async ({ trx }) => {
 			const userBuilder = require_KyselyFactory.KyselyFactory.createBuilder("users", async (attrs) => ({
 				name: "John Doe",
 				email: `user${Date.now()}@example.com`,
 				createdAt: /* @__PURE__ */ new Date()
 			}));
 			const builders = { user: userBuilder };
-			const factory = new require_KyselyFactory.KyselyFactory(builders, {}, trx$1);
+			const factory = new require_KyselyFactory.KyselyFactory(builders, {}, trx);
 			const customEmail = "custom@test.com";
 			const customName = "Jane Smith";
 			const user = await factory.insert("user", {
@@ -53,7 +54,7 @@ pg.default.types.setTypeParser(int8TypeId, (val) => {
 			(0, vitest.expect)(user.name).toBe(customName);
 			(0, vitest.expect)(user.email).toBe(customEmail);
 		});
-		itWithTransaction("should handle relations", async ({ trx: trx$1 }) => {
+		itWithTransaction("should handle relations", async ({ trx }) => {
 			const userBuilder = require_KyselyFactory.KyselyFactory.createBuilder("users", async (attrs) => ({
 				name: "John Doe",
 				email: `user${Date.now()}@example.com`,
@@ -79,27 +80,27 @@ pg.default.types.setTypeParser(int8TypeId, (val) => {
 				user: userBuilder,
 				post: postBuilder
 			};
-			const factory = new require_KyselyFactory.KyselyFactory(builders, {}, trx$1);
+			const factory = new require_KyselyFactory.KyselyFactory(builders, {}, trx);
 			const post = await factory.insert("post", { title: "Test Post" });
 			(0, vitest.expect)(post).toBeDefined();
 			(0, vitest.expect)(post.title).toBe("Test Post");
 			(0, vitest.expect)(post.userId).toBeDefined();
 			(0, vitest.expect)(typeof post.userId).toBe("number");
 		});
-		itWithTransaction("should throw error for non-existent builder", async ({ trx: trx$1 }) => {
-			const factory = new require_KyselyFactory.KyselyFactory({}, {}, trx$1);
+		itWithTransaction("should throw error for non-existent builder", async ({ trx }) => {
+			const factory = new require_KyselyFactory.KyselyFactory({}, {}, trx);
 			await (0, vitest.expect)(factory.insert("nonExistent")).rejects.toThrow("Factory \"nonExistent\" does not exist");
 		});
 	});
 	(0, vitest.describe)("KyselyFactory.insertMany", () => {
-		itWithTransaction("should insert multiple records with same attributes", async ({ trx: trx$1 }) => {
+		itWithTransaction("should insert multiple records with same attributes", async ({ trx }) => {
 			const userBuilder = require_KyselyFactory.KyselyFactory.createBuilder("users", async (attrs) => ({
 				name: "John Doe",
 				email: `user${Date.now()}-${Math.random()}@example.com`,
 				createdAt: /* @__PURE__ */ new Date()
 			}));
 			const builders = { user: userBuilder };
-			const factory = new require_KyselyFactory.KyselyFactory(builders, {}, trx$1);
+			const factory = new require_KyselyFactory.KyselyFactory(builders, {}, trx);
 			const users = await factory.insertMany(3, "user");
 			(0, vitest.expect)(users).toHaveLength(3);
 			users.forEach((user, index) => {
@@ -108,26 +109,26 @@ pg.default.types.setTypeParser(int8TypeId, (val) => {
 				(0, vitest.expect)(user.email).toContain("@example.com");
 			});
 		});
-		itWithTransaction("should insert multiple records with dynamic attributes", async ({ trx: trx$1 }) => {
+		itWithTransaction("should insert multiple records with dynamic attributes", async ({ trx }) => {
 			const userBuilder = require_KyselyFactory.KyselyFactory.createBuilder("users", async (attrs) => ({
 				email: `user${Date.now()}-${Math.random()}@example.com`,
 				createdAt: /* @__PURE__ */ new Date()
 			}));
 			const builders = { user: userBuilder };
-			const factory = new require_KyselyFactory.KyselyFactory(builders, {}, trx$1);
+			const factory = new require_KyselyFactory.KyselyFactory(builders, {}, trx);
 			const users = await factory.insertMany(3, "user", (idx) => ({ name: `User ${idx}` }));
 			(0, vitest.expect)(users).toHaveLength(3);
 			users.forEach((user, index) => {
 				(0, vitest.expect)(user.name).toBe(`User ${index}`);
 			});
 		});
-		itWithTransaction("should throw error for non-existent builder", async ({ trx: trx$1 }) => {
-			const factory = new require_KyselyFactory.KyselyFactory({}, {}, trx$1);
+		itWithTransaction("should throw error for non-existent builder", async ({ trx }) => {
+			const factory = new require_KyselyFactory.KyselyFactory({}, {}, trx);
 			await (0, vitest.expect)(factory.insertMany(2, "nonExistent")).rejects.toThrow("Builder \"nonExistent\" is not registered");
 		});
 	});
 	(0, vitest.describe)("KyselyFactory.createBuilder", () => {
-		itWithTransaction("should work with async defaults", async ({ trx: trx$1 }) => {
+		itWithTransaction("should work with async defaults", async ({ trx }) => {
 			let counter = 0;
 			const userBuilder = require_KyselyFactory.KyselyFactory.createBuilder("users", async (attrs) => {
 				await new Promise((resolve) => setTimeout(resolve, 10));
@@ -139,7 +140,7 @@ pg.default.types.setTypeParser(int8TypeId, (val) => {
 				};
 			});
 			const builders = { user: userBuilder };
-			const factory = new require_KyselyFactory.KyselyFactory(builders, {}, trx$1);
+			const factory = new require_KyselyFactory.KyselyFactory(builders, {}, trx);
 			const user1 = await factory.insert("user");
 			const user2 = await factory.insert("user");
 			(0, vitest.expect)(user1.name).toBe("Async User 1");
@@ -147,36 +148,36 @@ pg.default.types.setTypeParser(int8TypeId, (val) => {
 		});
 	});
 	(0, vitest.describe)("KyselyFactory.seed", () => {
-		itWithTransaction("should execute seed functions", async ({ trx: trx$1 }) => {
+		itWithTransaction("should execute seed functions", async ({ trx }) => {
 			const userBuilder = require_KyselyFactory.KyselyFactory.createBuilder("users", async (attrs) => ({
 				name: "John Doe",
 				email: `user${Date.now()}@example.com`,
 				createdAt: /* @__PURE__ */ new Date()
 			}));
 			const builders = { user: userBuilder };
-			const seeds = { createAdminUser: require_KyselyFactory.KyselyFactory.createSeed(async (attrs, factory$1, db$2) => {
+			const seeds = { createAdminUser: require_KyselyFactory.KyselyFactory.createSeed(async (attrs, factory$1, db$1) => {
 				return await factory$1.insert("user", {
 					name: attrs.name || "Admin User",
 					email: "admin@example.com"
 				});
 			}) };
-			const factory = new require_KyselyFactory.KyselyFactory(builders, seeds, trx$1);
+			const factory = new require_KyselyFactory.KyselyFactory(builders, seeds, trx);
 			const adminUser = await factory.seed("createAdminUser");
 			(0, vitest.expect)(adminUser).toBeDefined();
 			(0, vitest.expect)(adminUser.name).toBe("Admin User");
 			(0, vitest.expect)(adminUser.email).toBe("admin@example.com");
 		});
-		itWithTransaction("should pass attributes to seed functions", async ({ trx: trx$1 }) => {
+		itWithTransaction("should pass attributes to seed functions", async ({ trx }) => {
 			const userBuilder = require_KyselyFactory.KyselyFactory.createBuilder("users", async (attrs) => ({
 				name: "John Doe",
 				email: `user${Date.now()}@example.com`,
 				createdAt: /* @__PURE__ */ new Date()
 			}));
 			const builders = { user: userBuilder };
-			const seeds = { createCustomUser: require_KyselyFactory.KyselyFactory.createSeed(async (attrs, factory$1, db$2) => {
+			const seeds = { createCustomUser: require_KyselyFactory.KyselyFactory.createSeed(async (attrs, factory$1, db$1) => {
 				return await factory$1.insert("user", attrs);
 			}) };
-			const factory = new require_KyselyFactory.KyselyFactory(builders, seeds, trx$1);
+			const factory = new require_KyselyFactory.KyselyFactory(builders, seeds, trx);
 			const customUser = await factory.seed("createCustomUser", {
 				name: "Custom User",
 				email: "custom@test.com"
@@ -184,26 +185,26 @@ pg.default.types.setTypeParser(int8TypeId, (val) => {
 			(0, vitest.expect)(customUser.name).toBe("Custom User");
 			(0, vitest.expect)(customUser.email).toBe("custom@test.com");
 		});
-		itWithTransaction("should throw error for non-existent seed", async ({ trx: trx$1 }) => {
-			const factory = new require_KyselyFactory.KyselyFactory({}, {}, trx$1);
+		itWithTransaction("should throw error for non-existent seed", async ({ trx }) => {
+			const factory = new require_KyselyFactory.KyselyFactory({}, {}, trx);
 			(0, vitest.expect)(() => factory.seed("nonExistent")).toThrow("Seed \"nonExistent\" is not registered");
 		});
 	});
 	(0, vitest.describe)("Factory integration", () => {
-		itWithTransaction("should work with controlled transactions", async ({ trx: trx$1 }) => {
+		itWithTransaction("should work with controlled transactions", async ({ trx }) => {
 			const userBuilder = require_KyselyFactory.KyselyFactory.createBuilder("users", async (attrs) => ({
 				name: "John Doe",
 				email: `user${Date.now()}@example.com`,
 				createdAt: /* @__PURE__ */ new Date()
 			}));
 			const builders = { user: userBuilder };
-			const factory = new require_KyselyFactory.KyselyFactory(builders, {}, trx$1);
+			const factory = new require_KyselyFactory.KyselyFactory(builders, {}, trx);
 			const user = await factory.insert("user");
-			const foundUser = await trx$1.selectFrom("users").selectAll().where("id", "=", user.id).executeTakeFirst();
+			const foundUser = await trx.selectFrom("users").selectAll().where("id", "=", user.id).executeTakeFirst();
 			(0, vitest.expect)(foundUser).toBeDefined();
 			(0, vitest.expect)(foundUser?.id).toBe(user.id);
 		});
-		itWithTransaction("should work with factory passed to defaults", async ({ trx: trx$1 }) => {
+		itWithTransaction("should work with factory passed to defaults", async ({ trx }) => {
 			const userBuilder = require_KyselyFactory.KyselyFactory.createBuilder("users", async (attrs) => ({
 				name: "John Doe",
 				email: `user${Date.now()}@example.com`,
@@ -222,10 +223,10 @@ pg.default.types.setTypeParser(int8TypeId, (val) => {
 				user: userBuilder,
 				post: postBuilder
 			};
-			const factory = new require_KyselyFactory.KyselyFactory(builders, {}, trx$1);
+			const factory = new require_KyselyFactory.KyselyFactory(builders, {}, trx);
 			const post = await factory.insert("post");
 			(0, vitest.expect)(post.userId).toBeDefined();
-			const relatedUser = await trx$1.selectFrom("users").selectAll().where("id", "=", post.userId).executeTakeFirst();
+			const relatedUser = await trx.selectFrom("users").selectAll().where("id", "=", post.userId).executeTakeFirst();
 			(0, vitest.expect)(relatedUser).toBeDefined();
 		});
 	});