@geekmidas/testkit 0.0.11 → 0.0.13

package/dist/__tests__/PostgresKyselyMigrator.spec.mjs

@@ -0,0 +1,396 @@
+import { PostgresMigrator } from "../PostgresMigrator-DxPC_gGu.mjs";
+import { PostgresKyselyMigrator } from "../PostgresKyselyMigrator-Bdhl251C.mjs";
+import { createTestDatabase } from "../helpers-B4TXg3Wp.mjs";
+import { Kysely, PostgresDialect, sql } from "kysely";
+import { Client, Pool } from "pg";
+import { afterAll, afterEach, beforeAll, beforeEach, describe, expect, it, vi } from "vitest";
+
+//#region src/__tests__/PostgresKyselyMigrator.spec.ts
+var TestMigrationProvider = class {
+	migrations = {};
+	shouldError = false;
+	addMigration(name, migration) {
+		this.migrations[name] = migration;
+	}
+	setError(shouldError) {
+		this.shouldError = shouldError;
+	}
+	async getMigrations() {
+		if (this.shouldError) throw new Error("Failed to load migrations");
+		return this.migrations;
+	}
+};
+describe("PostgresKyselyMigrator", () => {
+	let testDbName;
+	let cleanupDb;
+	let consoleSpy;
+	let consoleErrorSpy;
+	beforeAll(async () => {
+		testDbName = `test_kysely_migrator_${Date.now()}`;
+		cleanupDb = await createTestDatabase(testDbName);
+	});
+	beforeEach(() => {
+		consoleSpy = vi.spyOn(console, "log").mockImplementation(() => {});
+		consoleErrorSpy = vi.spyOn(console, "error").mockImplementation(() => {});
+	});
+	afterEach(() => {
+		consoleSpy.mockRestore();
+		consoleErrorSpy.mockRestore();
+	});
+	afterAll(async () => {
+		await cleanupDb();
+	});
+	describe("constructor", () => {
+		it("should create a PostgresKyselyMigrator instance", () => {
+			const db = new Kysely({ dialect: new PostgresDialect({ pool: new Pool({
+				host: "localhost",
+				port: 5432,
+				user: "geekmidas",
+				password: "geekmidas",
+				database: testDbName
+			}) }) });
+			const provider = new TestMigrationProvider();
+			const migrator = new PostgresKyselyMigrator({
+				uri: `postgresql://geekmidas:geekmidas@localhost:5432/${testDbName}`,
+				db,
+				provider
+			});
+			expect(migrator).toBeInstanceOf(PostgresKyselyMigrator);
+			expect(migrator).toBeInstanceOf(PostgresMigrator);
+		});
+	});
+	describe("migrate method", () => {
+		it("should apply migrations successfully", async () => {
+			const newDbName = `test_migrate_${Date.now()}`;
+			const uri = `postgresql://geekmidas:geekmidas@localhost:5432/${newDbName}`;
+			const db = new Kysely({ dialect: new PostgresDialect({ pool: new Pool({
+				host: "localhost",
+				port: 5432,
+				user: "geekmidas",
+				password: "geekmidas",
+				database: newDbName
+			}) }) });
+			const provider = new TestMigrationProvider();
+			provider.addMigration("001_create_users", {
+				up: async (db$1) => {
+					await db$1.schema.createTable("users").addColumn("id", "serial", (col) => col.primaryKey()).addColumn("name", "varchar", (col) => col.notNull()).addColumn("email", "varchar", (col) => col.notNull().unique()).addColumn("created_at", "timestamp", (col) => col.defaultTo(sql`now()`).notNull()).execute();
+				},
+				down: async (db$1) => {
+					await db$1.schema.dropTable("users").execute();
+				}
+			});
+			provider.addMigration("002_create_posts", {
+				up: async (db$1) => {
+					await db$1.schema.createTable("posts").addColumn("id", "serial", (col) => col.primaryKey()).addColumn("title", "varchar", (col) => col.notNull()).addColumn("content", "text", (col) => col.notNull()).addColumn("user_id", "integer", (col) => col.notNull().references("users.id").onDelete("cascade")).addColumn("created_at", "timestamp", (col) => col.defaultTo(sql`now()`).notNull()).execute();
+				},
+				down: async (db$1) => {
+					await db$1.schema.dropTable("posts").execute();
+				}
+			});
+			const migrator = new PostgresKyselyMigrator({
+				uri,
+				db,
+				provider
+			});
+			const cleanup = await migrator.start();
+			expect(consoleSpy).toHaveBeenCalledWith(expect.stringContaining("Applied 2 migrations successfully"));
+			const client = new Client({
+				host: "localhost",
+				port: 5432,
+				user: "geekmidas",
+				password: "geekmidas",
+				database: newDbName
+			});
+			try {
+				await client.connect();
+				const tablesResult = await client.query(`
+          SELECT table_name FROM information_schema.tables
+          WHERE table_schema = 'public' 
+          AND table_name IN ('users', 'posts')
+          ORDER BY table_name
+        `);
+				expect(tablesResult.rowCount).toBe(2);
+				expect(tablesResult.rows).toEqual([{ table_name: "posts" }, { table_name: "users" }]);
+			} finally {
+				await client.end();
+			}
+			await cleanup();
+		});
+		it("should handle migration errors", async () => {
+			const errorDbName = `test_migrate_error_${Date.now()}`;
+			const uri = `postgresql://geekmidas:geekmidas@localhost:5432/${errorDbName}`;
+			const db = new Kysely({ dialect: new PostgresDialect({ pool: new Pool({
+				host: "localhost",
+				port: 5432,
+				user: "geekmidas",
+				password: "geekmidas",
+				database: errorDbName
+			}) }) });
+			const provider = new TestMigrationProvider();
+			provider.addMigration("001_failing_migration", { up: async () => {
+				throw new Error("Migration failed intentionally");
+			} });
+			const migrator = new PostgresKyselyMigrator({
+				uri,
+				db,
+				provider
+			});
+			await expect(migrator.start()).rejects.toThrow("Migration failed intentionally");
+			expect(consoleErrorSpy).toHaveBeenCalledWith(expect.any(Error), "Failed to apply migrations");
+			await db.destroy();
+			const cleanupClient = new Client({
+				host: "localhost",
+				port: 5432,
+				user: "geekmidas",
+				password: "geekmidas",
+				database: "postgres"
+			});
+			try {
+				await cleanupClient.connect();
+				await cleanupClient.query(`
+          SELECT pg_terminate_backend(pg_stat_activity.pid)
+          FROM pg_stat_activity
+          WHERE pg_stat_activity.datname = '${errorDbName}'
+            AND pid <> pg_backend_pid()
+        `);
+				await cleanupClient.query(`DROP DATABASE IF EXISTS "${errorDbName}"`);
+			} finally {
+				await cleanupClient.end();
+			}
+		});
+		it("should destroy database connection after migrations", async () => {
+			const destroyDbName = `test_destroy_${Date.now()}`;
+			const uri = `postgresql://geekmidas:geekmidas@localhost:5432/${destroyDbName}`;
+			const db = new Kysely({ dialect: new PostgresDialect({ pool: new Pool({
+				host: "localhost",
+				port: 5432,
+				user: "geekmidas",
+				password: "geekmidas",
+				database: destroyDbName
+			}) }) });
+			const destroySpy = vi.spyOn(db, "destroy");
+			const provider = new TestMigrationProvider();
+			provider.addMigration("001_simple", { up: async (db$1) => {
+				await db$1.schema.createTable("test").addColumn("id", "serial", (col) => col.primaryKey()).execute();
+			} });
+			const migrator = new PostgresKyselyMigrator({
+				uri,
+				db,
+				provider
+			});
+			const cleanup = await migrator.start();
+			expect(destroySpy).toHaveBeenCalled();
+			await cleanup();
+		});
+	});
+	describe("integration with PostgresMigrator", () => {
+		it("should work with complete workflow", async () => {
+			const integrationDbName = `test_integration_${Date.now()}`;
+			const uri = `postgresql://geekmidas:geekmidas@localhost:5432/${integrationDbName}`;
+			const db = new Kysely({ dialect: new PostgresDialect({ pool: new Pool({
+				host: "localhost",
+				port: 5432,
+				user: "geekmidas",
+				password: "geekmidas",
+				database: integrationDbName
+			}) }) });
+			const provider = new TestMigrationProvider();
+			provider.addMigration("001_initial_schema", { up: async (db$1) => {
+				await db$1.schema.createTable("users").addColumn("id", "serial", (col) => col.primaryKey()).addColumn("name", "varchar", (col) => col.notNull()).addColumn("email", "varchar", (col) => col.notNull().unique()).addColumn("created_at", "timestamp", (col) => col.defaultTo(sql`now()`).notNull()).execute();
+				await db$1.schema.createTable("posts").addColumn("id", "serial", (col) => col.primaryKey()).addColumn("title", "varchar", (col) => col.notNull()).addColumn("content", "text", (col) => col.notNull()).addColumn("user_id", "integer", (col) => col.notNull().references("users.id").onDelete("cascade")).addColumn("created_at", "timestamp", (col) => col.defaultTo(sql`now()`).notNull()).execute();
+				await db$1.schema.createIndex("idx_posts_user_id").on("posts").column("user_id").execute();
+			} });
+			provider.addMigration("002_add_updated_at", { up: async (db$1) => {
+				await db$1.schema.alterTable("users").addColumn("updated_at", "timestamp", (col) => col.defaultTo(sql`now()`).notNull()).execute();
+				await db$1.schema.alterTable("posts").addColumn("updated_at", "timestamp", (col) => col.defaultTo(sql`now()`).notNull()).execute();
+			} });
+			const migrator = new PostgresKyselyMigrator({
+				uri,
+				db,
+				provider
+			});
+			const cleanup = await migrator.start();
+			expect(consoleSpy).toHaveBeenCalledWith(`Migrating database: ${integrationDbName}`);
+			expect(consoleSpy).toHaveBeenCalledWith("Applied 2 migrations successfully");
+			const verifyClient = new Client({
+				host: "localhost",
+				port: 5432,
+				user: "geekmidas",
+				password: "geekmidas",
+				database: integrationDbName
+			});
+			try {
+				await verifyClient.connect();
+				const columnsResult = await verifyClient.query(`
+          SELECT table_name, column_name 
+          FROM information_schema.columns
+          WHERE table_schema = 'public' 
+          AND table_name IN ('users', 'posts')
+          AND column_name = 'updated_at'
+          ORDER BY table_name
+        `);
+				expect(columnsResult.rowCount).toBe(2);
+				const indexResult = await verifyClient.query(`
+          SELECT indexname FROM pg_indexes
+          WHERE schemaname = 'public'
+          AND indexname = 'idx_posts_user_id'
+        `);
+				expect(indexResult.rowCount).toBe(1);
+			} finally {
+				await verifyClient.end();
+			}
+			await cleanup();
+		});
+		it("should handle empty migrations", async () => {
+			const emptyDbName = `test_empty_${Date.now()}`;
+			const uri = `postgresql://geekmidas:geekmidas@localhost:5432/${emptyDbName}`;
+			const db = new Kysely({ dialect: new PostgresDialect({ pool: new Pool({
+				host: "localhost",
+				port: 5432,
+				user: "geekmidas",
+				password: "geekmidas",
+				database: emptyDbName
+			}) }) });
+			const provider = new TestMigrationProvider();
+			const migrator = new PostgresKyselyMigrator({
+				uri,
+				db,
+				provider
+			});
+			const cleanup = await migrator.start();
+			expect(consoleSpy).toHaveBeenCalledWith("Applied 0 migrations successfully");
+			await cleanup();
+		});
+		it("should work with FileMigrationProvider pattern", async () => {
+			const fileProviderDbName = `test_file_provider_${Date.now()}`;
+			const uri = `postgresql://geekmidas:geekmidas@localhost:5432/${fileProviderDbName}`;
+			const db = new Kysely({ dialect: new PostgresDialect({ pool: new Pool({
+				host: "localhost",
+				port: 5432,
+				user: "geekmidas",
+				password: "geekmidas",
+				database: fileProviderDbName
+			}) }) });
+			const migrations = {
+				"2024_01_01_000001_create_users": {
+					up: async (db$1) => {
+						await db$1.schema.createTable("users").addColumn("id", "serial", (col) => col.primaryKey()).addColumn("username", "varchar", (col) => col.notNull().unique()).execute();
+					},
+					down: async (db$1) => {
+						await db$1.schema.dropTable("users").execute();
+					}
+				},
+				"2024_01_02_000001_create_sessions": {
+					up: async (db$1) => {
+						await db$1.schema.createTable("sessions").addColumn("id", "serial", (col) => col.primaryKey()).addColumn("user_id", "integer", (col) => col.notNull().references("users.id")).addColumn("token", "varchar", (col) => col.notNull()).execute();
+					},
+					down: async (db$1) => {
+						await db$1.schema.dropTable("sessions").execute();
+					}
+				}
+			};
+			const provider = { async getMigrations() {
+				return migrations;
+			} };
+			const migrator = new PostgresKyselyMigrator({
+				uri,
+				db,
+				provider
+			});
+			const cleanup = await migrator.start();
+			expect(consoleSpy).toHaveBeenCalledWith("Applied 2 migrations successfully");
+			const verifyClient = new Client({
+				host: "localhost",
+				port: 5432,
+				user: "geekmidas",
+				password: "geekmidas",
+				database: fileProviderDbName
+			});
+			try {
+				await verifyClient.connect();
+				const tablesResult = await verifyClient.query(`
+          SELECT table_name FROM information_schema.tables
+          WHERE table_schema = 'public' 
+          AND table_name IN ('users', 'sessions')
+          ORDER BY table_name
+        `);
+				expect(tablesResult.rowCount).toBe(2);
+			} finally {
+				await verifyClient.end();
+			}
+			await cleanup();
+		});
+	});
+	describe("error scenarios", () => {
+		it("should handle provider errors", async () => {
+			const providerErrorDbName = `test_provider_error_${Date.now()}`;
+			const uri = `postgresql://geekmidas:geekmidas@localhost:5432/${providerErrorDbName}`;
+			const db = new Kysely({ dialect: new PostgresDialect({ pool: new Pool({
+				host: "localhost",
+				port: 5432,
+				user: "geekmidas",
+				password: "geekmidas",
+				database: providerErrorDbName
+			}) }) });
+			const provider = new TestMigrationProvider();
+			provider.setError(true);
+			const migrator = new PostgresKyselyMigrator({
+				uri,
+				db,
+				provider
+			});
+			await expect(migrator.start()).rejects.toThrow("Failed to load migrations");
+			await db.destroy();
+			const cleanupClient = new Client({
+				host: "localhost",
+				port: 5432,
+				user: "geekmidas",
+				password: "geekmidas",
+				database: "postgres"
+			});
+			try {
+				await cleanupClient.connect();
+				await cleanupClient.query(`DROP DATABASE IF EXISTS "${providerErrorDbName}"`);
+			} finally {
+				await cleanupClient.end();
+			}
+		}, 1e4);
+		it("should handle invalid SQL in migrations", async () => {
+			const invalidSqlDbName = `test_invalid_sql_${Date.now()}`;
+			const uri = `postgresql://geekmidas:geekmidas@localhost:5432/${invalidSqlDbName}`;
+			const db = new Kysely({ dialect: new PostgresDialect({ pool: new Pool({
+				host: "localhost",
+				port: 5432,
+				user: "geekmidas",
+				password: "geekmidas",
+				database: invalidSqlDbName
+			}) }) });
+			const provider = new TestMigrationProvider();
+			provider.addMigration("001_invalid_sql", { up: async (db$1) => {
+				await db$1.schema.createTable("posts").addColumn("id", "serial", (col) => col.primaryKey()).addColumn("user_id", "integer", (col) => col.notNull().references("non_existent_table.id")).execute();
+			} });
+			const migrator = new PostgresKyselyMigrator({
+				uri,
+				db,
+				provider
+			});
+			await expect(migrator.start()).rejects.toThrow();
+			await db.destroy();
+			const cleanupClient = new Client({
+				host: "localhost",
+				port: 5432,
+				user: "geekmidas",
+				password: "geekmidas",
+				database: "postgres"
+			});
+			try {
+				await cleanupClient.connect();
+				await cleanupClient.query(`DROP DATABASE IF EXISTS "${invalidSqlDbName}"`);
+			} finally {
+				await cleanupClient.end();
+			}
+		}, 1e4);
+	});
+});
+
+//#endregion

package/dist/__tests__/PostgresMigrator.spec.cjs

@@ -1,6 +1,6 @@
 const require_chunk = require('../chunk-CUT6urMc.cjs');
 const require_PostgresMigrator = require('../PostgresMigrator-DFcNdCvD.cjs');
-const require_helpers = require('../helpers-CNMBePuj.cjs');
+const require_helpers = require('../helpers-Bf0nXhbu.cjs');
 const pg = require_chunk.__toESM(require("pg"));
 const vitest = require_chunk.__toESM(require("vitest"));
 

package/dist/__tests__/PostgresMigrator.spec.mjs

@@ -1,5 +1,5 @@
 import { PostgresMigrator } from "../PostgresMigrator-DxPC_gGu.mjs";
-import { createTestDatabase } from "../helpers-BEmjyUVE.mjs";
+import { createTestDatabase } from "../helpers-B4TXg3Wp.mjs";
 import { Client } from "pg";
 import { afterAll, afterEach, beforeAll, beforeEach, describe, expect, it, vi } from "vitest";
 

package/dist/__tests__/PostgresObjectionMigrator.spec.cjs

@@ -1,7 +1,7 @@
 const require_chunk = require('../chunk-CUT6urMc.cjs');
 require('../PostgresMigrator-DFcNdCvD.cjs');
 const require_PostgresObjectionMigrator = require('../PostgresObjectionMigrator-BG6ymgnt.cjs');
-const require_helpers = require('../helpers-CNMBePuj.cjs');
+const require_helpers = require('../helpers-Bf0nXhbu.cjs');
 const pg = require_chunk.__toESM(require("pg"));
 const vitest = require_chunk.__toESM(require("vitest"));
 const knex = require_chunk.__toESM(require("knex"));

package/dist/__tests__/PostgresObjectionMigrator.spec.mjs

@@ -1,6 +1,6 @@
 import "../PostgresMigrator-DxPC_gGu.mjs";
 import { PostgresObjectionMigrator } from "../PostgresObjectionMigrator-G4h5FLvU.mjs";
-import { createTestDatabase } from "../helpers-BEmjyUVE.mjs";
+import { createTestDatabase } from "../helpers-B4TXg3Wp.mjs";
 import { Client } from "pg";
 import { afterAll, afterEach, beforeAll, beforeEach, describe, expect, it, vi } from "vitest";
 import knex from "knex";

package/dist/__tests__/VitestObjectionTransactionIsolator.spec.cjs

@@ -1,13 +1,13 @@
 const require_chunk = require('../chunk-CUT6urMc.cjs');
 require('../Factory-WMhTNZ9S.cjs');
-require('../faker-SMN4ira4.cjs');
-require('../ObjectionFactory-Wq80ypMM.cjs');
+require('../faker-B14IEMIN.cjs');
+require('../ObjectionFactory-CDriunkS.cjs');
 require('../PostgresMigrator-DFcNdCvD.cjs');
 require('../PostgresObjectionMigrator-BG6ymgnt.cjs');
 require('../VitestTransactionIsolator-CruLTRRi.cjs');
 require('../VitestObjectionTransactionIsolator-DyqLp_in.cjs');
 const require_objection = require('../objection-CCD8fMLj.cjs');
-const require_helpers = require('../helpers-CNMBePuj.cjs');
+const require_helpers = require('../helpers-Bf0nXhbu.cjs');
 const vitest = require_chunk.__toESM(require("vitest"));
 const objection = require_chunk.__toESM(require("objection"));
 
@@ -18,8 +18,6 @@ var User = class extends objection.Model {
 	}
 	id;
 	name;
-	email;
-	role;
 	createdAt;
 	updatedAt;
 	static get relationMappings() {
@@ -106,24 +104,18 @@ var Comment = class extends objection.Model {
 	}
 };
 const knex = require_helpers.createKnexDb();
-objection.Model.knex(knex);
 const it = require_objection.wrapVitestObjectionTransaction(vitest.it, knex, async (trx) => {
 	await require_helpers.createTestTablesKnex(trx);
 });
 (0, vitest.describe)("VitestObjectionTransactionIsolator", () => {
 	(0, vitest.describe)("Transaction Isolation", () => {
 		it("should rollback data after test completes", async ({ trx }) => {
-			const user = await User.query(trx).insert({
-				name: "Test User",
-				email: "test@example.com",
-				role: "user"
-			});
+			const user = await User.query(trx).insert({ name: "Test User" });
 			(0, vitest.expect)(user).toBeDefined();
 			(0, vitest.expect)(user.id).toBeDefined();
 			(0, vitest.expect)(user.name).toBe("Test User");
 			const foundUser = await User.query(trx).findById(user.id);
 			(0, vitest.expect)(foundUser).toBeDefined();
-			(0, vitest.expect)(foundUser?.email).toBe(user.email);
 		});
 	});
 });

package/dist/__tests__/VitestObjectionTransactionIsolator.spec.mjs

@@ -1,12 +1,12 @@
 import "../Factory-z2m01hMj.mjs";
-import "../faker-CxKkEeYi.mjs";
-import "../ObjectionFactory-aqM0dDW7.mjs";
+import "../faker-BGKYFoCT.mjs";
+import "../ObjectionFactory-8hebmnai.mjs";
 import "../PostgresMigrator-DxPC_gGu.mjs";
 import "../PostgresObjectionMigrator-G4h5FLvU.mjs";
 import "../VitestTransactionIsolator-BWwK-ca6.mjs";
 import "../VitestObjectionTransactionIsolator-BPoLUFop.mjs";
 import { wrapVitestObjectionTransaction } from "../objection-lsMgM5gP.mjs";
-import { createKnexDb, createTestTablesKnex } from "../helpers-BEmjyUVE.mjs";
+import { createKnexDb, createTestTablesKnex } from "../helpers-B4TXg3Wp.mjs";
 import { describe, expect, it } from "vitest";
 import { Model } from "objection";
 
@@ -17,8 +17,6 @@ var User = class extends Model {
 	}
 	id;
 	name;
-	email;
-	role;
 	createdAt;
 	updatedAt;
 	static get relationMappings() {
@@ -105,24 +103,18 @@ var Comment = class extends Model {
 	}
 };
 const knex = createKnexDb();
-Model.knex(knex);
 const it$1 = wrapVitestObjectionTransaction(it, knex, async (trx) => {
 	await createTestTablesKnex(trx);
 });
 describe("VitestObjectionTransactionIsolator", () => {
 	describe("Transaction Isolation", () => {
 		it$1("should rollback data after test completes", async ({ trx }) => {
-			const user = await User.query(trx).insert({
-				name: "Test User",
-				email: "test@example.com",
-				role: "user"
-			});
+			const user = await User.query(trx).insert({ name: "Test User" });
 			expect(user).toBeDefined();
 			expect(user.id).toBeDefined();
 			expect(user.name).toBe("Test User");
 			const foundUser = await User.query(trx).findById(user.id);
 			expect(foundUser).toBeDefined();
-			expect(foundUser?.email).toBe(user.email);
 		});
 	});
 });

package/dist/__tests__/faker.spec.cjs

@@ -1,5 +1,5 @@
 const require_chunk = require('../chunk-CUT6urMc.cjs');
-const require_faker = require('../faker-SMN4ira4.cjs');
+const require_faker = require('../faker-B14IEMIN.cjs');
 const vitest = require_chunk.__toESM(require("vitest"));
 
 //#region src/__tests__/faker.spec.ts

package/dist/__tests__/faker.spec.mjs

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

package/dist/__tests__/integration.spec.cjs

@@ -1,14 +1,14 @@
 const require_chunk = require('../chunk-CUT6urMc.cjs');
 require('../Factory-WMhTNZ9S.cjs');
-require('../faker-SMN4ira4.cjs');
-const require_KyselyFactory = require('../KyselyFactory-Bdq1s1Go.cjs');
+require('../faker-B14IEMIN.cjs');
+const require_KyselyFactory = require('../KyselyFactory-Cf0o2YxO.cjs');
 require('../PostgresMigrator-DFcNdCvD.cjs');
 require('../PostgresKyselyMigrator-CfytARcA.cjs');
 require('../VitestTransactionIsolator-CruLTRRi.cjs');
 require('../VitestKyselyTransactionIsolator-CIlpIO78.cjs');
 const require_helpers = require('../helpers-nEUtQ7eo.cjs');
 const require_kysely = require('../kysely-CBfCXxUn.cjs');
-const require_helpers$1 = require('../helpers-CNMBePuj.cjs');
+const require_helpers$1 = require('../helpers-Bf0nXhbu.cjs');
 const vitest = require_chunk.__toESM(require("vitest"));
 
 //#region src/__tests__/integration.spec.ts

package/dist/__tests__/integration.spec.mjs

@@ -1,13 +1,13 @@
 import "../Factory-z2m01hMj.mjs";
-import "../faker-CxKkEeYi.mjs";
-import { KyselyFactory } from "../KyselyFactory-ELiHgHVv.mjs";
+import "../faker-BGKYFoCT.mjs";
+import { KyselyFactory } from "../KyselyFactory-BcYkC0t2.mjs";
 import "../PostgresMigrator-DxPC_gGu.mjs";
 import "../PostgresKyselyMigrator-Bdhl251C.mjs";
 import "../VitestTransactionIsolator-BWwK-ca6.mjs";
 import "../VitestKyselyTransactionIsolator-BKGT9nEG.mjs";
 import { createKyselyDb } from "../helpers-BuPmgzyQ.mjs";
 import { wrapVitestKyselyTransaction } from "../kysely-Cx_1pZYc.mjs";
-import { TEST_DATABASE_CONFIG, createTestTables } from "../helpers-BEmjyUVE.mjs";
+import { TEST_DATABASE_CONFIG, createTestTables } from "../helpers-B4TXg3Wp.mjs";
 import { beforeAll, describe, expect, it } from "vitest";
 
 //#region src/__tests__/integration.spec.ts

package/dist/{faker-SMN4ira4.cjs → faker-B14IEMIN.cjs}

@@ -196,6 +196,36 @@ function resetAllSequences() {
 function price() {
 	return +faker.commerce.price();
 }
+function coordinateInRadius(center, radius) {
+	const earth = 6378137;
+	const d = radius / earth;
+	const theta = 2 * Math.PI * Math.random();
+	const r = d * Math.sqrt(Math.random());
+	const lat1 = center.lat * Math.PI / 180;
+	const lng1 = center.lng * Math.PI / 180;
+	const lat2 = Math.asin(Math.sin(lat1) * Math.cos(r) + Math.cos(lat1) * Math.sin(r) * Math.cos(theta));
+	const lng2 = lng1 + Math.atan2(Math.sin(theta) * Math.sin(r) * Math.cos(lat1), Math.cos(r) - Math.sin(lat1) * Math.sin(lat2));
+	return {
+		lat: lat2 * 180 / Math.PI,
+		lng: lng2 * 180 / Math.PI
+	};
+}
+function coordinateOutsideRadius(center, minRadiusMeters, maxRadiusMeters) {
+	const earth = 6378137;
+	const minD = minRadiusMeters / earth;
+	const maxD = maxRadiusMeters / earth;
+	const theta = 2 * Math.PI * Math.random();
+	const r = Math.sqrt(minD * minD + (maxD * maxD - minD * minD) * Math.random());
+	const lat1 = center.lat * Math.PI / 180;
+	const lng1 = center.lng * Math.PI / 180;
+	const lat2 = Math.asin(Math.sin(lat1) * Math.cos(r) + Math.cos(lat1) * Math.sin(r) * Math.cos(theta));
+	const lng2 = lng1 + Math.atan2(Math.sin(theta) * Math.sin(r) * Math.cos(lat1), Math.cos(r) - Math.sin(lat1) * Math.sin(lat2));
+	const normalizedLng = (lng2 * 180 / Math.PI + 540) % 360 - 180;
+	return {
+		lat: lat2 * 180 / Math.PI,
+		lng: normalizedLng
+	};
+}
 /**
 * Enhanced faker instance with additional utility methods for testing.
 * Extends @faker-js/faker with custom methods for common test data generation patterns.
@@ -221,10 +251,20 @@ const faker = Object.freeze(Object.assign({}, __faker_js_faker.faker, {
 	sequence,
 	resetSequence,
 	resetAllSequences,
-	price
+	price,
+	coordinates: {
+		within: coordinateInRadius,
+		outside: coordinateOutsideRadius
+	}
 }));
 
 //#endregion
+Object.defineProperty(exports, 'coordinateInRadius', {
+  enumerable: true,
+  get: function () {
+    return coordinateInRadius;
+  }
+});
 Object.defineProperty(exports, 'faker', {
   enumerable: true,
   get: function () {