@geekmidas/testkit 0.4.0 → 1.0.0

package/test/globalSetup.ts

@@ -3,52 +3,52 @@ import { Client } from 'pg';
 const TEST_DATABASE_NAME = 'geekmidas_test';
 
 export const TEST_DATABASE_CONFIG = {
-  host: 'localhost',
-  port: 5432,
-  user: 'geekmidas',
-  password: 'geekmidas',
-  database: TEST_DATABASE_NAME,
+	host: 'localhost',
+	port: 5432,
+	user: 'geekmidas',
+	password: 'geekmidas',
+	database: TEST_DATABASE_NAME,
 };
 
 export default async function globalSetup() {
-  const adminConfig = {
-    host: TEST_DATABASE_CONFIG.host,
-    port: TEST_DATABASE_CONFIG.port,
-    user: TEST_DATABASE_CONFIG.user,
-    password: TEST_DATABASE_CONFIG.password,
-    database: 'postgres', // Connect to default postgres database
-  };
-
-  const client = new Client(adminConfig);
-
-  try {
-    await client.connect();
-
-    // Check if test database exists
-    const result = await client.query(
-      `SELECT * FROM pg_catalog.pg_database WHERE datname = $1`,
-      [TEST_DATABASE_NAME],
-    );
-
-    // Create test database if it doesn't exist
-    if (result.rowCount === 0) {
-      await client.query(`CREATE DATABASE "${TEST_DATABASE_NAME}"`);
-    } else {
-    }
-  } finally {
-    await client.end();
-  }
-
-  // Return cleanup function that drops the database
-  return async () => {
-    const cleanupClient = new Client(adminConfig);
-    try {
-      await cleanupClient.connect();
-      await cleanupClient.query(
-        `DROP DATABASE IF EXISTS "${TEST_DATABASE_NAME}"`,
-      );
-    } finally {
-      await cleanupClient.end();
-    }
-  };
+	const adminConfig = {
+		host: TEST_DATABASE_CONFIG.host,
+		port: TEST_DATABASE_CONFIG.port,
+		user: TEST_DATABASE_CONFIG.user,
+		password: TEST_DATABASE_CONFIG.password,
+		database: 'postgres', // Connect to default postgres database
+	};
+
+	const client = new Client(adminConfig);
+
+	try {
+		await client.connect();
+
+		// Check if test database exists
+		const result = await client.query(
+			`SELECT * FROM pg_catalog.pg_database WHERE datname = $1`,
+			[TEST_DATABASE_NAME],
+		);
+
+		// Create test database if it doesn't exist
+		if (result.rowCount === 0) {
+			await client.query(`CREATE DATABASE "${TEST_DATABASE_NAME}"`);
+		} else {
+		}
+	} finally {
+		await client.end();
+	}
+
+	// Return cleanup function that drops the database
+	return async () => {
+		const cleanupClient = new Client(adminConfig);
+		try {
+			await cleanupClient.connect();
+			await cleanupClient.query(
+				`DROP DATABASE IF EXISTS "${TEST_DATABASE_NAME}"`,
+			);
+		} finally {
+			await cleanupClient.end();
+		}
+	};
 }

package/test/helpers.ts

@@ -1,267 +1,267 @@
 import type { Knex } from 'knex';
 import knex from 'knex';
 import {
-  CamelCasePlugin,
-  type ControlledTransaction,
-  Kysely,
-  type Migrator,
-  PostgresDialect,
-  sql,
+	CamelCasePlugin,
+	type ControlledTransaction,
+	Kysely,
+	type Migrator,
+	PostgresDialect,
+	sql,
 } from 'kysely';
 import pg from 'pg';
 import { TEST_DATABASE_CONFIG } from './globalSetup';
 
 export interface TestDatabase {
-  users: {
-    id: number;
-    name: string;
-    email: string;
-    role?: 'admin' | 'user';
-    createdAt: Date;
-    updatedAt?: Date;
-  };
-  posts: {
-    id: number;
-    title: string;
-    content: string;
-    userId: number;
-    published?: boolean;
-    createdAt: Date;
-    updatedAt?: Date;
-  };
-  comments: {
-    id: number;
-    content: string;
-    postId: number;
-    userId: number;
-    createdAt: Date;
-  };
+	users: {
+		id: number;
+		name: string;
+		email: string;
+		role?: 'admin' | 'user';
+		createdAt: Date;
+		updatedAt?: Date;
+	};
+	posts: {
+		id: number;
+		title: string;
+		content: string;
+		userId: number;
+		published?: boolean;
+		createdAt: Date;
+		updatedAt?: Date;
+	};
+	comments: {
+		id: number;
+		content: string;
+		postId: number;
+		userId: number;
+		createdAt: Date;
+	};
 }
 
 /**
  * Creates a Kysely database instance for testing
  */
 export function createKyselyDb(): Kysely<TestDatabase> {
-  return new Kysely({
-    dialect: new PostgresDialect({
-      pool: new pg.Pool(TEST_DATABASE_CONFIG),
-    }),
-    plugins: [new CamelCasePlugin()],
-  });
+	return new Kysely({
+		dialect: new PostgresDialect({
+			pool: new pg.Pool(TEST_DATABASE_CONFIG),
+		}),
+		plugins: [new CamelCasePlugin()],
+	});
 }
 
 /**
  * Creates a Knex database instance for testing
  */
 export function createKnexDb(): Knex {
-  return knex({
-    client: 'pg',
-    connection: TEST_DATABASE_CONFIG,
-  });
+	return knex({
+		client: 'pg',
+		connection: TEST_DATABASE_CONFIG,
+	});
 }
 
 /**
  * Test setup helper that creates tables within a transaction and returns cleanup
  */
 export async function setupKyselyTest(db: Kysely<TestDatabase>): Promise<{
-  db: Kysely<TestDatabase>;
-  trx: ControlledTransaction<TestDatabase, []>;
-  cleanup: () => Promise<void>;
+	db: Kysely<TestDatabase>;
+	trx: ControlledTransaction<TestDatabase, []>;
+	cleanup: () => Promise<void>;
 }> {
-  const trx = await db.startTransaction().execute();
+	const trx = await db.startTransaction().execute();
 
-  // Create tables within the transaction
-  await createTestTables(db);
+	// Create tables within the transaction
+	await createTestTables(db);
 
-  const cleanup = async () => {
-    await trx.rollback().execute();
-    await db.destroy();
-  };
+	const cleanup = async () => {
+		await trx.rollback().execute();
+		await db.destroy();
+	};
 
-  return { db, trx, cleanup };
+	return { db, trx, cleanup };
 }
 
 /**
  * Test setup helper for Knex/Objection that creates tables within a transaction
  */
 export async function setupKnexTest(): Promise<{
-  db: Knex;
-  trx: Knex.Transaction;
-  cleanup: () => Promise<void>;
+	db: Knex;
+	trx: Knex.Transaction;
+	cleanup: () => Promise<void>;
 }> {
-  const db = createKnexDb();
-  const trx = await db.transaction();
+	const db = createKnexDb();
+	const trx = await db.transaction();
 
-  // Create tables within the transaction
-  await createTestTablesKnex(trx);
+	// Create tables within the transaction
+	await createTestTablesKnex(trx);
 
-  const cleanup = async () => {
-    await trx.rollback();
-    await db.destroy();
-  };
+	const cleanup = async () => {
+		await trx.rollback();
+		await db.destroy();
+	};
 
-  return { db, trx, cleanup };
+	return { db, trx, cleanup };
 }
 
 /**
  * Creates test tables using Kysely
  */
 export async function createTestTables(
-  db: Kysely<TestDatabase> | ControlledTransaction<TestDatabase, []>,
+	db: Kysely<TestDatabase> | ControlledTransaction<TestDatabase, []>,
 ): Promise<void> {
-  // Create users table
-  await db.schema
-    .createTable('users')
-    .addColumn('id', 'bigserial', (col) => col.primaryKey())
-    .addColumn('name', 'varchar', (col) => col.notNull())
-    .addColumn('email', 'varchar', (col) => col.notNull().unique())
-    .addColumn('role', 'varchar', (col) => col.defaultTo('user'))
-    .addColumn('created_at', 'timestamp', (col) =>
-      col.defaultTo(sql`now()`).notNull(),
-    )
-    .addColumn('updated_at', 'timestamp', (col) =>
-      col.defaultTo(sql`now()`).notNull(),
-    )
-    .execute();
+	// Create users table
+	await db.schema
+		.createTable('users')
+		.addColumn('id', 'bigserial', (col) => col.primaryKey())
+		.addColumn('name', 'varchar', (col) => col.notNull())
+		.addColumn('email', 'varchar', (col) => col.notNull().unique())
+		.addColumn('role', 'varchar', (col) => col.defaultTo('user'))
+		.addColumn('created_at', 'timestamp', (col) =>
+			col.defaultTo(sql`now()`).notNull(),
+		)
+		.addColumn('updated_at', 'timestamp', (col) =>
+			col.defaultTo(sql`now()`).notNull(),
+		)
+		.execute();
 
-  // Create posts table
-  await db.schema
-    .createTable('posts')
-    .addColumn('id', 'bigserial', (col) => col.primaryKey())
-    .addColumn('title', 'varchar', (col) => col.notNull())
-    .addColumn('content', 'text', (col) => col.notNull())
-    .addColumn('user_id', 'bigint', (col) =>
-      col.notNull().references('users.id').onDelete('cascade'),
-    )
-    .addColumn('published', 'boolean', (col) => col.defaultTo(false))
-    .addColumn('created_at', 'timestamp', (col) =>
-      col.defaultTo(sql`now()`).notNull(),
-    )
-    .addColumn('updated_at', 'timestamp', (col) =>
-      col.defaultTo(sql`now()`).notNull(),
-    )
-    .execute();
+	// Create posts table
+	await db.schema
+		.createTable('posts')
+		.addColumn('id', 'bigserial', (col) => col.primaryKey())
+		.addColumn('title', 'varchar', (col) => col.notNull())
+		.addColumn('content', 'text', (col) => col.notNull())
+		.addColumn('user_id', 'bigint', (col) =>
+			col.notNull().references('users.id').onDelete('cascade'),
+		)
+		.addColumn('published', 'boolean', (col) => col.defaultTo(false))
+		.addColumn('created_at', 'timestamp', (col) =>
+			col.defaultTo(sql`now()`).notNull(),
+		)
+		.addColumn('updated_at', 'timestamp', (col) =>
+			col.defaultTo(sql`now()`).notNull(),
+		)
+		.execute();
 
-  // Create comments table
-  await db.schema
-    .createTable('comments')
-    .addColumn('id', 'bigserial', (col) => col.primaryKey())
-    .addColumn('content', 'text', (col) => col.notNull())
-    .addColumn('post_id', 'bigint', (col) =>
-      col.notNull().references('posts.id').onDelete('cascade'),
-    )
-    .addColumn('user_id', 'bigint', (col) =>
-      col.notNull().references('users.id').onDelete('cascade'),
-    )
-    .addColumn('created_at', 'timestamp', (col) =>
-      col.defaultTo(sql`now()`).notNull(),
-    )
-    .execute();
+	// Create comments table
+	await db.schema
+		.createTable('comments')
+		.addColumn('id', 'bigserial', (col) => col.primaryKey())
+		.addColumn('content', 'text', (col) => col.notNull())
+		.addColumn('post_id', 'bigint', (col) =>
+			col.notNull().references('posts.id').onDelete('cascade'),
+		)
+		.addColumn('user_id', 'bigint', (col) =>
+			col.notNull().references('users.id').onDelete('cascade'),
+		)
+		.addColumn('created_at', 'timestamp', (col) =>
+			col.defaultTo(sql`now()`).notNull(),
+		)
+		.execute();
 }
 
 /**
  * Creates test tables using Knex
  */
 export async function createTestTablesKnex(
-  trx: Knex.Transaction,
+	trx: Knex.Transaction,
 ): Promise<void> {
-  // Create simple users table for testing factory
-  await trx.raw(`CREATE EXTENSION IF NOT EXISTS "uuid-ossp"`);
-  await trx.schema.createTableIfNotExists('users', (table) => {
-    table.uuid('id').primary().defaultTo(trx.raw('uuid_generate_v4()'));
-    table.string('name').notNullable();
-  });
+	// Create simple users table for testing factory
+	await trx.raw(`CREATE EXTENSION IF NOT EXISTS "uuid-ossp"`);
+	await trx.schema.createTableIfNotExists('users', (table) => {
+		table.uuid('id').primary().defaultTo(trx.raw('uuid_generate_v4()'));
+		table.string('name').notNullable();
+	});
 
-  // Create simple posts table for testing factory
-  await trx.schema.createTableIfNotExists('posts', (table) => {
-    table.uuid('id').primary().defaultTo(trx.raw('uuid_generate_v4()'));
-    table.string('title').notNullable();
-    table
-      .uuid('user_id')
-      .notNullable()
-      .references('id')
-      .inTable('users')
-      .onDelete('cascade');
-  });
+	// Create simple posts table for testing factory
+	await trx.schema.createTableIfNotExists('posts', (table) => {
+		table.uuid('id').primary().defaultTo(trx.raw('uuid_generate_v4()'));
+		table.string('title').notNullable();
+		table
+			.uuid('user_id')
+			.notNullable()
+			.references('id')
+			.inTable('users')
+			.onDelete('cascade');
+	});
 
-  // Create simple comments table for testing factory
-  await trx.schema.createTableIfNotExists('comments', (table) => {
-    table.uuid('id').primary().defaultTo(trx.raw('uuid_generate_v4()'));
-    table.text('content').notNullable();
-    table
-      .uuid('post_id')
-      .notNullable()
-      .references('id')
-      .inTable('posts')
-      .onDelete('cascade');
-    table
-      .uuid('user_id')
-      .notNullable()
-      .references('id')
-      .inTable('users')
-      .onDelete('cascade');
-  });
+	// Create simple comments table for testing factory
+	await trx.schema.createTableIfNotExists('comments', (table) => {
+		table.uuid('id').primary().defaultTo(trx.raw('uuid_generate_v4()'));
+		table.text('content').notNullable();
+		table
+			.uuid('post_id')
+			.notNullable()
+			.references('id')
+			.inTable('posts')
+			.onDelete('cascade');
+		table
+			.uuid('user_id')
+			.notNullable()
+			.references('id')
+			.inTable('users')
+			.onDelete('cascade');
+	});
 }
 
 /**
  * Helper for PostgresMigrator tests - creates a separate test database
  */
 export async function createTestDatabase(
-  dbName: string,
+	dbName: string,
 ): Promise<() => Promise<void>> {
-  const adminConfig = {
-    host: TEST_DATABASE_CONFIG.host,
-    port: TEST_DATABASE_CONFIG.port,
-    user: TEST_DATABASE_CONFIG.user,
-    password: TEST_DATABASE_CONFIG.password,
-    database: 'postgres',
-  };
+	const adminConfig = {
+		host: TEST_DATABASE_CONFIG.host,
+		port: TEST_DATABASE_CONFIG.port,
+		user: TEST_DATABASE_CONFIG.user,
+		password: TEST_DATABASE_CONFIG.password,
+		database: 'postgres',
+	};
 
-  const client = new pg.Client(adminConfig);
+	const client = new pg.Client(adminConfig);
 
-  try {
-    await client.connect();
+	try {
+		await client.connect();
 
-    // Drop database if it exists, then create it
-    await client.query(`DROP DATABASE IF EXISTS "${dbName}"`);
-    await client.query(`CREATE DATABASE "${dbName}"`);
-  } finally {
-    await client.end();
-  }
+		// Drop database if it exists, then create it
+		await client.query(`DROP DATABASE IF EXISTS "${dbName}"`);
+		await client.query(`CREATE DATABASE "${dbName}"`);
+	} finally {
+		await client.end();
+	}
 
-  // Return cleanup function
-  return async () => {
-    const cleanupClient = new pg.Client(adminConfig);
-    try {
-      await cleanupClient.connect();
-      await cleanupClient.query(`DROP DATABASE IF EXISTS "${dbName}"`);
-    } finally {
-      await cleanupClient.end();
-    }
-  };
+	// Return cleanup function
+	return async () => {
+		const cleanupClient = new pg.Client(adminConfig);
+		try {
+			await cleanupClient.connect();
+			await cleanupClient.query(`DROP DATABASE IF EXISTS "${dbName}"`);
+		} finally {
+			await cleanupClient.end();
+		}
+	};
 }
 
 /**
  * Creates a Kysely migrator for testing
  */
 export function createTestMigrator(
-  db: Kysely<any>,
-  migrations: Record<
-    string,
-    {
-      up: (db: Kysely<any>) => Promise<void>;
-      down: (db: Kysely<any>) => Promise<void>;
-    }
-  >,
+	db: Kysely<any>,
+	migrations: Record<
+		string,
+		{
+			up: (db: Kysely<any>) => Promise<void>;
+			down: (db: Kysely<any>) => Promise<void>;
+		}
+	>,
 ): Migrator {
-  const { Migrator } = require('kysely');
+	const { Migrator } = require('kysely');
 
-  return new Migrator({
-    db,
-    provider: {
-      async getMigrations() {
-        return migrations;
-      },
-    },
-  });
+	return new Migrator({
+		db,
+		provider: {
+			async getMigrations() {
+				return migrations;
+			},
+		},
+	});
 }

package/test/migrations/1749664623372_user.ts

@@ -2,21 +2,21 @@ import { type Kysely, sql } from 'kysely';
 
 // `any` is required here since migrations should be frozen in time. alternatively, keep a "snapshot" db interface.
 export async function up(db: Kysely<any>): Promise<void> {
-  await db.schema
-    .createTable('users')
-    .addColumn('id', 'bigserial', (col) => col.primaryKey())
-    .addColumn('email', 'varchar', (col) => col.notNull().unique())
-    .addColumn('name', 'varchar', (col) => col.notNull())
-    .addColumn('created_at', 'timestamp', (col) =>
-      col.defaultTo(sql`now()`).notNull(),
-    )
-    .addColumn('updated_at', 'timestamp', (col) =>
-      col.defaultTo(sql`now()`).notNull(),
-    )
-    .execute();
+	await db.schema
+		.createTable('users')
+		.addColumn('id', 'bigserial', (col) => col.primaryKey())
+		.addColumn('email', 'varchar', (col) => col.notNull().unique())
+		.addColumn('name', 'varchar', (col) => col.notNull())
+		.addColumn('created_at', 'timestamp', (col) =>
+			col.defaultTo(sql`now()`).notNull(),
+		)
+		.addColumn('updated_at', 'timestamp', (col) =>
+			col.defaultTo(sql`now()`).notNull(),
+		)
+		.execute();
 }
 
 // `any` is required here since migrations should be frozen in time. alternatively, keep a "snapshot" db interface.
 export async function down(db: Kysely<any>): Promise<void> {
-  await db.schema.dropTable('users').execute();
+	await db.schema.dropTable('users').execute();
 }

package/tsconfig.json

@@ -0,0 +1,9 @@
+{
+  "extends": "../../tsconfig.base.json",
+  "compilerOptions": {
+    "outDir": "./dist",
+    "rootDir": "./src",
+    "composite": true
+  },
+  "include": ["src/**/*"]
+}

package/vitest.config.ts

@@ -1,8 +1,8 @@
 import { defineProject } from 'vitest/config';
 
 export default defineProject({
-  test: {
-    globalSetup: ['test/globalSetup.ts'],
-    pool: 'forks',
-  },
+	test: {
+		globalSetup: ['test/globalSetup.ts'],
+		pool: 'forks',
+	},
 });

package/dist/PostgresKyselyMigrator-CfytARcA.cjs.map

@@ -1 +0,0 @@
-{"version":3,"file":"PostgresKyselyMigrator-CfytARcA.cjs","names":["PostgresMigrator","options: {\n      uri: string;\n      db: Kysely<any>;\n      provider: MigrationProvider;\n    }","Migrator"],"sources":["../src/PostgresKyselyMigrator.ts"],"sourcesContent":["import { type Kysely, type MigrationProvider, Migrator } from 'kysely';\nimport { PostgresMigrator } from './PostgresMigrator';\n\n/**\n * Default logger instance for migration operations.\n */\nconst logger = console;\n\n/**\n * PostgreSQL migrator implementation for Kysely ORM.\n * Extends PostgresMigrator to provide Kysely-specific migration functionality.\n * Automatically creates test databases and applies migrations for testing environments.\n *\n * @example\n * ```typescript\n * import { FileMigrationProvider } from 'kysely';\n * import { PostgresKyselyMigrator } from '@geekmidas/testkit';\n *\n * // Create migration provider\n * const provider = new FileMigrationProvider({\n *   fs: require('fs'),\n *   path: require('path'),\n *   migrationFolder: path.join(__dirname, 'migrations')\n * });\n *\n * // Create Kysely instance\n * const db = new Kysely<Database>({\n *   dialect: new PostgresDialect({\n *     pool: new Pool({ connectionString: uri })\n *   })\n * });\n *\n * // Create and use migrator\n * const migrator = new PostgresKyselyMigrator({\n *   uri: 'postgresql://localhost:5432/test_db',\n *   db,\n *   provider\n * });\n *\n * const cleanup = await migrator.start();\n * // Run tests...\n * await cleanup();\n * ```\n */\nexport class PostgresKyselyMigrator extends PostgresMigrator {\n  /**\n   * Creates a new PostgresKyselyMigrator instance.\n   *\n   * @param options - Configuration options\n   * @param options.uri - PostgreSQL connection URI\n   * @param options.db - Kysely database instance\n   * @param options.provider - Migration provider for locating migration files\n   */\n  constructor(\n    private options: {\n      uri: string;\n      db: Kysely<any>;\n      provider: MigrationProvider;\n    },\n  ) {\n    super(options.uri);\n  }\n\n  /**\n   * Executes Kysely migrations to the latest version.\n   * Implements the abstract migrate() method from PostgresMigrator.\n   *\n   * @throws Error if migrations fail to apply\n   * @returns Promise that resolves when all migrations are applied\n   */\n  async migrate(): Promise<void> {\n    const migrator = new Migrator({\n      db: this.options.db,\n      provider: this.options.provider,\n    });\n    const migrations = await migrator.migrateToLatest();\n\n    if (migrations.error) {\n      logger.error(migrations.error, `Failed to apply migrations`);\n      throw migrations.error;\n    }\n\n    await this.options.db.destroy();\n\n    logger.log(`Applied ${migrations.results?.length} migrations successfully`);\n  }\n}\n"],"mappings":";;;;;;;;AAMA,MAAM,SAAS;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAsCf,IAAa,yBAAb,cAA4CA,0CAAiB;;;;;;;;;CAS3D,YACUC,SAKR;AACA,QAAM,QAAQ,IAAI;EANV;CAOT;;;;;;;;CASD,MAAM,UAAyB;EAC7B,MAAM,WAAW,IAAIC,gBAAS;GAC5B,IAAI,KAAK,QAAQ;GACjB,UAAU,KAAK,QAAQ;EACxB;EACD,MAAM,aAAa,MAAM,SAAS,iBAAiB;AAEnD,MAAI,WAAW,OAAO;AACpB,UAAO,MAAM,WAAW,QAAQ,4BAA4B;AAC5D,SAAM,WAAW;EAClB;AAED,QAAM,KAAK,QAAQ,GAAG,SAAS;AAE/B,SAAO,KAAK,UAAU,WAAW,SAAS,OAAO,0BAA0B;CAC5E;AACF"}

package/dist/PostgresKyselyMigrator-upT-hmrz.mjs.map

@@ -1 +0,0 @@
-{"version":3,"file":"PostgresKyselyMigrator-upT-hmrz.mjs","names":["options: {\n      uri: string;\n      db: Kysely<any>;\n      provider: MigrationProvider;\n    }"],"sources":["../src/PostgresKyselyMigrator.ts"],"sourcesContent":["import { type Kysely, type MigrationProvider, Migrator } from 'kysely';\nimport { PostgresMigrator } from './PostgresMigrator';\n\n/**\n * Default logger instance for migration operations.\n */\nconst logger = console;\n\n/**\n * PostgreSQL migrator implementation for Kysely ORM.\n * Extends PostgresMigrator to provide Kysely-specific migration functionality.\n * Automatically creates test databases and applies migrations for testing environments.\n *\n * @example\n * ```typescript\n * import { FileMigrationProvider } from 'kysely';\n * import { PostgresKyselyMigrator } from '@geekmidas/testkit';\n *\n * // Create migration provider\n * const provider = new FileMigrationProvider({\n *   fs: require('fs'),\n *   path: require('path'),\n *   migrationFolder: path.join(__dirname, 'migrations')\n * });\n *\n * // Create Kysely instance\n * const db = new Kysely<Database>({\n *   dialect: new PostgresDialect({\n *     pool: new Pool({ connectionString: uri })\n *   })\n * });\n *\n * // Create and use migrator\n * const migrator = new PostgresKyselyMigrator({\n *   uri: 'postgresql://localhost:5432/test_db',\n *   db,\n *   provider\n * });\n *\n * const cleanup = await migrator.start();\n * // Run tests...\n * await cleanup();\n * ```\n */\nexport class PostgresKyselyMigrator extends PostgresMigrator {\n  /**\n   * Creates a new PostgresKyselyMigrator instance.\n   *\n   * @param options - Configuration options\n   * @param options.uri - PostgreSQL connection URI\n   * @param options.db - Kysely database instance\n   * @param options.provider - Migration provider for locating migration files\n   */\n  constructor(\n    private options: {\n      uri: string;\n      db: Kysely<any>;\n      provider: MigrationProvider;\n    },\n  ) {\n    super(options.uri);\n  }\n\n  /**\n   * Executes Kysely migrations to the latest version.\n   * Implements the abstract migrate() method from PostgresMigrator.\n   *\n   * @throws Error if migrations fail to apply\n   * @returns Promise that resolves when all migrations are applied\n   */\n  async migrate(): Promise<void> {\n    const migrator = new Migrator({\n      db: this.options.db,\n      provider: this.options.provider,\n    });\n    const migrations = await migrator.migrateToLatest();\n\n    if (migrations.error) {\n      logger.error(migrations.error, `Failed to apply migrations`);\n      throw migrations.error;\n    }\n\n    await this.options.db.destroy();\n\n    logger.log(`Applied ${migrations.results?.length} migrations successfully`);\n  }\n}\n"],"mappings":";;;;;;;AAMA,MAAM,SAAS;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAsCf,IAAa,yBAAb,cAA4C,iBAAiB;;;;;;;;;CAS3D,YACUA,SAKR;AACA,QAAM,QAAQ,IAAI;EANV;CAOT;;;;;;;;CASD,MAAM,UAAyB;EAC7B,MAAM,WAAW,IAAI,SAAS;GAC5B,IAAI,KAAK,QAAQ;GACjB,UAAU,KAAK,QAAQ;EACxB;EACD,MAAM,aAAa,MAAM,SAAS,iBAAiB;AAEnD,MAAI,WAAW,OAAO;AACpB,UAAO,MAAM,WAAW,QAAQ,4BAA4B;AAC5D,SAAM,WAAW;EAClB;AAED,QAAM,KAAK,QAAQ,GAAG,SAAS;AAE/B,SAAO,KAAK,UAAU,WAAW,SAAS,OAAO,0BAA0B;CAC5E;AACF"}

package/dist/PostgresMigrator-DFcNdCvD.cjs.map

@@ -1 +0,0 @@
-{"version":3,"file":"PostgresMigrator-DFcNdCvD.cjs","names":["uri: string"],"sources":["../src/PostgresMigrator.ts"],"sourcesContent":["import pg from 'pg';\n\nconst { Client } = pg;\n\n/**\n * Creates a PostgreSQL client connected to the 'postgres' database.\n * Extracts connection details from the provided URI.\n *\n * @param uri - PostgreSQL connection URI\n * @returns Object containing the target database name and client instance\n *\n * @example\n * ```typescript\n * const { database, db } = await setupClient('postgresql://user:pass@localhost:5432/mydb');\n * // database = 'mydb'\n * // db = Client instance connected to 'postgres' database\n * ```\n */\nasync function setupClient(uri: string) {\n  const url = new URL(uri);\n\n  const db = new Client({\n    user: url.username,\n    password: url.password,\n    host: url.hostname,\n    port: parseInt(url.port),\n    database: 'postgres',\n  });\n\n  let database = url.pathname.slice(1);\n  if (database.includes('?')) {\n    database = database.substring(0, database.indexOf('?'));\n  }\n  return { database, db };\n}\n\n/**\n * Default logger instance for migration operations.\n */\nconst logger = console;\n\n/**\n * Abstract base class for PostgreSQL database migration utilities.\n * Provides database creation, migration, and cleanup functionality for testing.\n * Subclasses must implement the migrate() method to define migration logic.\n *\n * @example\n * ```typescript\n * class MyMigrator extends PostgresMigrator {\n *   async migrate(): Promise<void> {\n *     // Run your migrations here\n *     await this.runMigrations();\n *   }\n * }\n *\n * // Use in tests\n * const migrator = new MyMigrator('postgresql://localhost:5432/test_db');\n * const cleanup = await migrator.start();\n *\n * // Run tests...\n *\n * // Clean up\n * await cleanup();\n * ```\n */\nexport abstract class PostgresMigrator {\n  /**\n   * Creates a new PostgresMigrator instance.\n   *\n   * @param uri - PostgreSQL connection URI\n   */\n  constructor(private uri: string) {}\n\n  /**\n   * Abstract method to be implemented by subclasses.\n   * Should contain the migration logic for setting up database schema.\n   *\n   * @returns Promise that resolves when migrations are complete\n   */\n  abstract migrate(): Promise<void>;\n\n  /**\n   * Creates a PostgreSQL database if it doesn't already exist.\n   * Connects to the 'postgres' database to check and create the target database.\n   *\n   * @param uri - PostgreSQL connection URI\n   * @returns Object indicating whether the database already existed\n   * @private\n   */\n  private static async create(\n    uri: string,\n  ): Promise<{ alreadyExisted: boolean }> {\n    const { database, db } = await setupClient(uri);\n    try {\n      await db.connect();\n      const result = await db.query(\n        `SELECT * FROM pg_catalog.pg_database WHERE datname = '${database}'`,\n      );\n\n      if (result.rowCount === 0) {\n        await db.query(`CREATE DATABASE \"${database}\"`);\n      }\n\n      return {\n        alreadyExisted: result.rowCount ? result.rowCount > 0 : false,\n      };\n    } finally {\n      await db.end();\n    }\n  }\n\n  /**\n   * Drops a PostgreSQL database.\n   * Used for cleanup after tests are complete.\n   *\n   * @param uri - PostgreSQL connection URI\n   * @throws Error if database cannot be dropped\n   * @private\n   */\n  private static async drop(uri: string): Promise<void> {\n    const { database, db } = await setupClient(uri);\n    try {\n      await db.connect();\n      await db.query(`DROP DATABASE \"${database}\"`);\n    } finally {\n      await db.end();\n    }\n  }\n\n  /**\n   * Starts the migration process by creating the database and running migrations.\n   * Returns a cleanup function that will drop the database when called.\n   *\n   * @returns Async cleanup function that drops the created database\n   *\n   * @example\n   * ```typescript\n   * const migrator = new MyMigrator('postgresql://localhost:5432/test_db');\n   *\n   * // Start migrations and get cleanup function\n   * const cleanup = await migrator.start();\n   *\n   * try {\n   *   // Run your tests here\n   *   await runTests();\n   * } finally {\n   *   // Always clean up\n   *   await cleanup();\n   * }\n   * ```\n   */\n  async start() {\n    const { database, db } = await setupClient(this.uri);\n    try {\n      await PostgresMigrator.create(this.uri);\n      // Implement migration logic here\n      await this.migrate();\n      logger.log(`Migrating database: ${database}`);\n      // Example: await db.query('CREATE TABLE example (id SERIAL PRIMARY KEY)');\n    } finally {\n      await db.end();\n    }\n\n    return async () => {\n      await PostgresMigrator.drop(this.uri);\n    };\n  }\n}\n"],"mappings":";;;;AAEA,MAAM,EAAE,QAAQ,GAAG;;;;;;;;;;;;;;;AAgBnB,eAAe,YAAYA,KAAa;CACtC,MAAM,MAAM,IAAI,IAAI;CAEpB,MAAM,KAAK,IAAI,OAAO;EACpB,MAAM,IAAI;EACV,UAAU,IAAI;EACd,MAAM,IAAI;EACV,MAAM,SAAS,IAAI,KAAK;EACxB,UAAU;CACX;CAED,IAAI,WAAW,IAAI,SAAS,MAAM,EAAE;AACpC,KAAI,SAAS,SAAS,IAAI,CACxB,YAAW,SAAS,UAAU,GAAG,SAAS,QAAQ,IAAI,CAAC;AAEzD,QAAO;EAAE;EAAU;CAAI;AACxB;;;;AAKD,MAAM,SAAS;;;;;;;;;;;;;;;;;;;;;;;;;AA0Bf,IAAsB,mBAAtB,MAAsB,iBAAiB;;;;;;CAMrC,YAAoBA,KAAa;EAAb;CAAe;;;;;;;;;CAkBnC,aAAqB,OACnBA,KACsC;EACtC,MAAM,EAAE,UAAU,IAAI,GAAG,MAAM,YAAY,IAAI;AAC/C,MAAI;AACF,SAAM,GAAG,SAAS;GAClB,MAAM,SAAS,MAAM,GAAG,OACrB,wDAAwD,SAAS,GACnE;AAED,OAAI,OAAO,aAAa,EACtB,OAAM,GAAG,OAAO,mBAAmB,SAAS,GAAG;AAGjD,UAAO,EACL,gBAAgB,OAAO,WAAW,OAAO,WAAW,IAAI,MACzD;EACF,UAAS;AACR,SAAM,GAAG,KAAK;EACf;CACF;;;;;;;;;CAUD,aAAqB,KAAKA,KAA4B;EACpD,MAAM,EAAE,UAAU,IAAI,GAAG,MAAM,YAAY,IAAI;AAC/C,MAAI;AACF,SAAM,GAAG,SAAS;AAClB,SAAM,GAAG,OAAO,iBAAiB,SAAS,GAAG;EAC9C,UAAS;AACR,SAAM,GAAG,KAAK;EACf;CACF;;;;;;;;;;;;;;;;;;;;;;;CAwBD,MAAM,QAAQ;EACZ,MAAM,EAAE,UAAU,IAAI,GAAG,MAAM,YAAY,KAAK,IAAI;AACpD,MAAI;AACF,SAAM,iBAAiB,OAAO,KAAK,IAAI;AAEvC,SAAM,KAAK,SAAS;AACpB,UAAO,KAAK,sBAAsB,SAAS,EAAE;EAE9C,UAAS;AACR,SAAM,GAAG,KAAK;EACf;AAED,SAAO,YAAY;AACjB,SAAM,iBAAiB,KAAK,KAAK,IAAI;EACtC;CACF;AACF"}