@geekmidas/testkit 0.0.3 → 0.0.5

package/PostgresKyselyMigrator.spec

@@ -0,0 +1,471 @@
+import {
+  type Kysely,
+  type MigrationProvider,
+  type Transaction,
+  sql,
+} from 'kysely';
+import {
+  type TestAPI,
+  afterEach,
+  beforeAll,
+  beforeEach,
+  describe,
+  expect,
+  vi,
+} from 'vitest';
+import { createTestDatabase } from '../../test/helpers';
+import { PostgresKyselyMigrator } from '../PostgresKyselyMigrator';
+import { PostgresMigrator } from '../PostgresMigrator';
+import { createKyselyDb, wrapVitestKyselyTransaction } from '../helpers';
+
+describe.skip('PostgresKyselyMigrator', () => {
+  let testDbName: string;
+  let cleanupDb: () => Promise<void>;
+
+  let consoleSpy: any;
+  let consoleErrorSpy: any;
+  let it: TestAPI<{
+    trx: Transaction<any>;
+  }>;
+
+  beforeAll(async () => {
+    testDbName = `test_kysely_migrator_${Date.now()}`;
+    cleanupDb = await createTestDatabase(testDbName);
+    const db = createKyselyDb<any>({
+      host: 'localhost',
+      port: 5432,
+      user: 'geekmidas',
+      password: 'geekmidas',
+      database: testDbName,
+    });
+    it = wrapVitestKyselyTransaction(db);
+  });
+
+  beforeEach(() => {
+    consoleSpy = vi.spyOn(console, 'log').mockImplementation(() => {});
+    consoleErrorSpy = vi.spyOn(console, 'error').mockImplementation(() => {});
+  });
+
+  afterEach(() => {
+    consoleSpy.mockRestore();
+    consoleErrorSpy.mockRestore();
+  });
+
+  describe.skip('constructor', () => {
+    it('should create a PostgresKyselyMigrator instance', ({ trx }) => {
+      const provider: MigrationProvider = {
+        getMigrations: async () => ({}),
+      };
+
+      const options = {
+        uri: `postgresql://geekmidas:geekmidas@localhost:5432/${testDbName}`,
+        db: trx,
+        provider,
+      };
+
+      const migrator = new PostgresKyselyMigrator(options);
+
+      expect(migrator).toBeInstanceOf(PostgresKyselyMigrator);
+      expect(migrator).toBeInstanceOf(PostgresMigrator);
+    });
+  });
+
+  describe.skip('migrate method', () => {
+    it('should run migrations successfully', async ({ trx }) => {
+      const migrations = {
+        '001_initial': {
+          up: async (db: Kysely<any>) => {
+            await db.schema
+              .createTable('test_table')
+              .addColumn('id', 'serial', (col) => col.primaryKey())
+              .addColumn('name', 'varchar', (col) => col.notNull())
+              .execute();
+          },
+          down: async (db: Kysely<any>) => {
+            await db.schema.dropTable('test_table').execute();
+          },
+        },
+        '002_add_column': {
+          up: async (db: Kysely<any>) => {
+            await db.schema
+              .alterTable('test_table')
+              .addColumn('email', 'varchar')
+              .execute();
+          },
+          down: async (db: Kysely<any>) => {
+            await db.schema
+              .alterTable('test_table')
+              .dropColumn('email')
+              .execute();
+          },
+        },
+      };
+
+      const provider: MigrationProvider = {
+        getMigrations: async () => migrations,
+      };
+
+      const options = {
+        uri: `postgresql://geekmidas:geekmidas@localhost:5432/${testDbName}`,
+        db: trx,
+        provider,
+      };
+
+      const migrator = new PostgresKyselyMigrator(options);
+
+      await migrator.migrate();
+
+      expect(consoleSpy).toHaveBeenCalledWith(
+        'Applied 2 migrations successfully',
+      );
+
+      // Verify the table was created
+      const tableResult = await trx
+        .selectFrom('information_schema.tables')
+        .selectAll()
+        .where('table_name', '=', 'test_table')
+        .where('table_schema', '=', 'public')
+        .execute();
+
+      expect(tableResult.length).toBe(1);
+
+      // Verify the column was added
+      const columnResult = await trx
+        .selectFrom('information_schema.columns')
+        .selectAll()
+        .where('table_name', '=', 'test_table')
+        .where('column_name', '=', 'email')
+        .execute();
+
+      expect(columnResult.length).toBe(1);
+    });
+
+    it('should handle migration errors', async ({ trx }) => {
+      const migrations = {
+        '001_bad_migration': {
+          up: async (db: Kysely<any>) => {
+            // This will fail due to invalid SQL
+            await db.executeQuery(sql`INVALID SQL SYNTAX`.compile(trx));
+          },
+          down: async (db: Kysely<any>) => {
+            // No-op
+          },
+        },
+      };
+
+      const provider: MigrationProvider = {
+        getMigrations: async () => migrations,
+      };
+
+      const options = {
+        uri: `postgresql://geekmidas:geekmidas@localhost:5432/${testDbName}`,
+        db: trx,
+        provider,
+      };
+
+      const migrator = new PostgresKyselyMigrator(options);
+
+      await expect(migrator.migrate()).rejects.toThrow();
+
+      expect(consoleErrorSpy).toHaveBeenCalledWith(
+        expect.any(Error),
+        'Failed to apply migrations',
+      );
+    });
+
+    it('should handle no migrations to apply', async ({ trx }) => {
+      const provider: MigrationProvider = {
+        getMigrations: async () => ({}), // No migrations
+      };
+
+      const options = {
+        uri: `postgresql://geekmidas:geekmidas@localhost:5432/${testDbName}`,
+        db: trx,
+        provider,
+      };
+
+      const migrator = new PostgresKyselyMigrator(options);
+
+      await migrator.migrate();
+
+      expect(consoleSpy).toHaveBeenCalledWith(
+        'Applied 0 migrations successfully',
+      );
+    });
+
+    it('should handle provider that returns undefined results', async ({
+      trx,
+    }) => {
+      // Create a provider that returns migrations but Kysely reports undefined results
+      const provider: MigrationProvider = {
+        getMigrations: async () => ({
+          '001_test': {
+            up: async (db: Kysely<any>) => {
+              // Simple migration that should succeed but might return undefined results
+              await db.schema
+                .createTable('temp_table')
+                .addColumn('id', 'serial')
+                .ifNotExists()
+                .execute();
+              await db.schema.dropTable('temp_table').ifExists().execute();
+            },
+            down: async () => {},
+          },
+        }),
+      };
+
+      const options = {
+        uri: `postgresql://geekmidas:geekmidas@localhost:5432/${testDbName}`,
+        db: trx,
+        provider,
+      };
+
+      const migrator = new PostgresKyselyMigrator(options);
+
+      await migrator.migrate();
+
+      // Should handle the case gracefully
+      expect(consoleSpy).toHaveBeenCalled();
+    });
+
+    it('should cleanup database connection even if migration throws', async ({
+      trx,
+    }) => {
+      const destroySpy = vi.spyOn(trx, 'destroy');
+
+      const provider: MigrationProvider = {
+        getMigrations: async () => {
+          throw new Error('Provider failed');
+        },
+      };
+
+      const options = {
+        uri: `postgresql://geekmidas:geekmidas@localhost:5432/${testDbName}`,
+        db: trx,
+        provider,
+      };
+
+      const migrator = new PostgresKyselyMigrator(options);
+
+      await expect(migrator.migrate()).rejects.toThrow('Provider failed');
+
+      expect(destroySpy).toHaveBeenCalled();
+    });
+
+    it('should handle database destroy errors gracefully', async () => {
+      // Create a mock db that will fail on destroy
+      const failingDb = {
+        destroy: vi
+          .fn()
+          .mockRejectedValue(new Error('Failed to close connection')),
+      } as any;
+
+      const provider: MigrationProvider = {
+        getMigrations: async () => ({}),
+      };
+
+      const options = {
+        uri: `postgresql://geekmidas:geekmidas@localhost:5432/${testDbName}`,
+        db: failingDb,
+        provider,
+      };
+
+      const migrator = new PostgresKyselyMigrator(options);
+
+      // The migrate method should propagate the destroy error
+      await expect(migrator.migrate()).rejects.toThrow(
+        'Failed to close connection',
+      );
+    });
+  });
+
+  describe.skip('integration with Kysely types', () => {
+    it('should work with typed database interface', ({ trx }) => {
+      interface Database {
+        users: {
+          id: number;
+          name: string;
+          email: string;
+        };
+        posts: {
+          id: number;
+          title: string;
+          userId: number;
+        };
+      }
+
+      const typedDb = trx as Kysely<Database>;
+      const typedProvider: MigrationProvider = {
+        getMigrations: async () => ({}),
+      };
+
+      const options = {
+        uri: `postgresql://geekmidas:geekmidas@localhost:5432/${testDbName}`,
+        db: typedDb,
+        provider: typedProvider,
+      };
+
+      const migrator = new PostgresKyselyMigrator(options);
+
+      expect(migrator).toBeInstanceOf(PostgresKyselyMigrator);
+    });
+  });
+
+  describe.skip('logging', () => {
+    it('should log correct number of applied migrations', async ({ trx }) => {
+      const migrations = {};
+      // Create 5 simple migrations
+      for (let i = 1; i <= 5; i++) {
+        migrations[`00${i}_migration`] = {
+          up: async (db: Kysely<any>) => {
+            // Simple operation that won't conflict
+            await db.executeQuery(
+              sql`CREATE TABLE IF NOT EXISTS temp_${sql.raw(`migration_${i}`)} (id SERIAL)`.compile(
+                db,
+              ),
+            );
+            await db.executeQuery(
+              sql`DROP TABLE IF EXISTS temp_${sql.raw(`migration_${i}`)}`.compile(
+                db,
+              ),
+            );
+          },
+          down: async () => {},
+        };
+      }
+
+      const provider: MigrationProvider = {
+        getMigrations: async () => migrations,
+      };
+
+      const options = {
+        uri: `postgresql://geekmidas:geekmidas@localhost:5432/${testDbName}`,
+        db: trx,
+        provider,
+      };
+
+      const migrator = new PostgresKyselyMigrator(options);
+
+      await migrator.migrate();
+
+      expect(consoleSpy).toHaveBeenCalledWith(
+        'Applied 5 migrations successfully',
+      );
+    });
+
+    it('should log errors with context', async ({ trx }) => {
+      const migrations = {
+        '001_invalid_column': {
+          up: async (db: Kysely<any>) => {
+            // This will fail with a specific error
+            await db.executeQuery(
+              sql`SELECT invalid_column FROM non_existent_table`.compile(db),
+            );
+          },
+          down: async () => {},
+        },
+      };
+
+      const provider: MigrationProvider = {
+        getMigrations: async () => migrations,
+      };
+
+      const options = {
+        uri: `postgresql://geekmidas:geekmidas@localhost:5432/${testDbName}`,
+        db: trx,
+        provider,
+      };
+
+      const migrator = new PostgresKyselyMigrator(options);
+
+      await expect(migrator.migrate()).rejects.toThrow();
+
+      expect(consoleErrorSpy).toHaveBeenCalledWith(
+        expect.any(Error),
+        'Failed to apply migrations',
+      );
+    });
+  });
+
+  describe.skip('error scenarios', () => {
+    it('should handle invalid migration provider', async ({ trx }) => {
+      const invalidProvider: MigrationProvider = {
+        getMigrations: async () => {
+          throw new Error('Invalid migration configuration');
+        },
+      };
+
+      const options = {
+        uri: `postgresql://geekmidas:geekmidas@localhost:5432/${testDbName}`,
+        db: trx,
+        provider: invalidProvider,
+      };
+
+      const migrator = new PostgresKyselyMigrator(options);
+
+      await expect(migrator.migrate()).rejects.toThrow(
+        'Invalid migration configuration',
+      );
+    });
+
+    it('should handle migration execution errors', async ({ trx }) => {
+      const migrations = {
+        '001_failing_migration': {
+          up: async (db: Kysely<any>) => {
+            throw new Error('Migration execution failed');
+          },
+          down: async () => {},
+        },
+      };
+
+      const provider: MigrationProvider = {
+        getMigrations: async () => migrations,
+      };
+
+      const options = {
+        uri: `postgresql://geekmidas:geekmidas@localhost:5432/${testDbName}`,
+        db: trx,
+        provider,
+      };
+
+      const migrator = new PostgresKyselyMigrator(options);
+
+      await expect(migrator.migrate()).rejects.toThrow();
+    });
+  });
+
+  describe('inheritance', () => {
+    it('should properly extend PostgresMigrator', ({ trx }) => {
+      const provider: MigrationProvider = {
+        getMigrations: async () => ({}),
+      };
+
+      const options = {
+        uri: `postgresql://geekmidas:geekmidas@localhost:5432/${testDbName}`,
+        db: trx,
+        provider,
+      };
+
+      const migrator = new PostgresKyselyMigrator(options);
+
+      expect(migrator).toBeInstanceOf(PostgresMigrator);
+      expect(migrator).toBeInstanceOf(PostgresKyselyMigrator);
+    });
+
+    it('should implement the abstract migrate method', ({ trx }) => {
+      const provider: MigrationProvider = {
+        getMigrations: async () => ({}),
+      };
+
+      const options = {
+        uri: `postgresql://geekmidas:geekmidas@localhost:5432/${testDbName}`,
+        db: trx,
+        provider,
+      };
+
+      const migrator = new PostgresKyselyMigrator(options);
+
+      expect(typeof migrator.migrate).toBe('function');
+    });
+  });
+});

package/dist/{KyselyFactory-DiiWtMYe.cjs → KyselyFactory-BX7Kv2uP.cjs}

@@ -1,4 +1,5 @@
 const require_Factory = require('./Factory-DREHoms3.cjs');
+const require_faker = require('./faker-caz-8zt8.cjs');
 
 //#region src/KyselyFactory.ts
 var KyselyFactory = class extends require_Factory.Factory {
@@ -11,31 +12,29 @@ var KyselyFactory = class extends require_Factory.Factory {
 		this.seeds = seeds;
 		this.db = db;
 	}
-	static createBuilder(config) {
-		return async (attrs, factory, db) => {
+	static createBuilder(table, item, autoInsert) {
+		return async (attrs, factory, db, faker$1) => {
 			let data = { ...attrs };
-			if (config.defaults) {
-				const defaults = await config.defaults(attrs, factory, db);
+			if (item) {
+				const defaults = await item(attrs, factory, db, faker$1);
 				data = {
 					...defaults,
 					...data
 				};
 			}
-			if (config.transform) data = await config.transform(data, factory, db);
-			if (config.autoInsert !== false) {
-				const result = await db.insertInto(config.table).values(data).returningAll().executeTakeFirst();
-				if (!result) throw new Error(`Failed to insert into ${config.table}`);
-				if (config.relations) await config.relations(result, attrs, factory, db);
+			if (autoInsert !== false) {
+				const result = await db.insertInto(table).values(data).returningAll().executeTakeFirst();
+				if (!result) throw new Error(`Failed to insert into ${table}`);
 				return result;
 			} else return {
-				table: config.table,
+				table,
 				data
 			};
 		};
 	}
 	async insert(builderName, attrs) {
 		if (!(builderName in this.builders)) throw new Error(`Factory "${builderName}" does not exist. Make sure it is correct and registered in src/test/setup.ts`);
-		const result = await this.builders[builderName](attrs || {}, this, this.db);
+		const result = await this.builders[builderName](attrs || {}, this, this.db, require_faker.faker);
 		if (result && typeof result === "object" && "table" in result && "data" in result) {
 			const inserted = await this.db.insertInto(result.table).values(result.data).returningAll().executeTakeFirst();
 			return inserted;
@@ -46,7 +45,7 @@ var KyselyFactory = class extends require_Factory.Factory {
 		if (!(builderName in this.builders)) throw new Error(`Builder "${builderName}" is not registered in this factory. Make sure it is correct and registered in src/test/setup.ts`);
 		const promises = [];
 		for (let i = 0; i < count; i++) {
-			const newAttrs = typeof attrs === "function" ? attrs(i) : attrs;
+			const newAttrs = typeof attrs === "function" ? attrs(i, require_faker.faker) : attrs;
 			promises.push(this.insert(builderName, newAttrs));
 		}
 		return Promise.all(promises);

package/dist/{KyselyFactory-DZewtWtJ.mjs → KyselyFactory-pOMOFQWE.mjs}

@@ -1,4 +1,5 @@
 import { Factory } from "./Factory-DlzMkMzb.mjs";
+import { faker } from "./faker-BwaXA_RF.mjs";
 
 //#region src/KyselyFactory.ts
 var KyselyFactory = class extends Factory {
@@ -11,31 +12,29 @@ var KyselyFactory = class extends Factory {
 		this.seeds = seeds;
 		this.db = db;
 	}
-	static createBuilder(config) {
-		return async (attrs, factory, db) => {
+	static createBuilder(table, item, autoInsert) {
+		return async (attrs, factory, db, faker$1) => {
 			let data = { ...attrs };
-			if (config.defaults) {
-				const defaults = await config.defaults(attrs, factory, db);
+			if (item) {
+				const defaults = await item(attrs, factory, db, faker$1);
 				data = {
 					...defaults,
 					...data
 				};
 			}
-			if (config.transform) data = await config.transform(data, factory, db);
-			if (config.autoInsert !== false) {
-				const result = await db.insertInto(config.table).values(data).returningAll().executeTakeFirst();
-				if (!result) throw new Error(`Failed to insert into ${config.table}`);
-				if (config.relations) await config.relations(result, attrs, factory, db);
+			if (autoInsert !== false) {
+				const result = await db.insertInto(table).values(data).returningAll().executeTakeFirst();
+				if (!result) throw new Error(`Failed to insert into ${table}`);
 				return result;
 			} else return {
-				table: config.table,
+				table,
 				data
 			};
 		};
 	}
 	async insert(builderName, attrs) {
 		if (!(builderName in this.builders)) throw new Error(`Factory "${builderName}" does not exist. Make sure it is correct and registered in src/test/setup.ts`);
-		const result = await this.builders[builderName](attrs || {}, this, this.db);
+		const result = await this.builders[builderName](attrs || {}, this, this.db, faker);
 		if (result && typeof result === "object" && "table" in result && "data" in result) {
 			const inserted = await this.db.insertInto(result.table).values(result.data).returningAll().executeTakeFirst();
 			return inserted;
@@ -46,7 +45,7 @@ var KyselyFactory = class extends Factory {
 		if (!(builderName in this.builders)) throw new Error(`Builder "${builderName}" is not registered in this factory. Make sure it is correct and registered in src/test/setup.ts`);
 		const promises = [];
 		for (let i = 0; i < count; i++) {
-			const newAttrs = typeof attrs === "function" ? attrs(i) : attrs;
+			const newAttrs = typeof attrs === "function" ? attrs(i, faker) : attrs;
 			promises.push(this.insert(builderName, newAttrs));
 		}
 		return Promise.all(promises);

package/dist/KyselyFactory.cjs

@@ -1,4 +1,5 @@
 require('./Factory-DREHoms3.cjs');
-const require_KyselyFactory = require('./KyselyFactory-DiiWtMYe.cjs');
+require('./faker-caz-8zt8.cjs');
+const require_KyselyFactory = require('./KyselyFactory-BX7Kv2uP.cjs');
 
 exports.KyselyFactory = require_KyselyFactory.KyselyFactory;

package/dist/KyselyFactory.mjs

@@ -1,4 +1,5 @@
 import "./Factory-DlzMkMzb.mjs";
-import { KyselyFactory } from "./KyselyFactory-DZewtWtJ.mjs";
+import "./faker-BwaXA_RF.mjs";
+import { KyselyFactory } from "./KyselyFactory-pOMOFQWE.mjs";
 
 export { KyselyFactory };

package/dist/ObjectionFactory.cjs

@@ -1,4 +1,4 @@
 require('./Factory-DREHoms3.cjs');
-const require_ObjectionFactory = require('./ObjectionFactory-DeFYWbzt.cjs');
+const require_ObjectionFactory = require('./ObjectionFactory-BlkzSEqo.cjs');
 
 exports.ObjectionFactory = require_ObjectionFactory.ObjectionFactory;

package/dist/ObjectionFactory.mjs

@@ -1,4 +1,4 @@
 import "./Factory-DlzMkMzb.mjs";
-import { ObjectionFactory } from "./ObjectionFactory-MAf2m8LI.mjs";
+import { ObjectionFactory } from "./ObjectionFactory-ChuX8sZN.mjs";
 
 export { ObjectionFactory };

package/dist/{PostgresKyselyMigrator-ChMJpPrQ.mjs → PostgresKyselyMigrator-D8fm35-s.mjs}

@@ -1,4 +1,4 @@
-import { PostgresMigrator } from "./PostgresMigrator-BKaNTth5.mjs";
+import { PostgresMigrator } from "./PostgresMigrator-CEoRKTdq.mjs";
 import { Migrator } from "kysely";
 
 //#region src/PostgresKyselyMigrator.ts

package/dist/{PostgresKyselyMigrator-rY3hO_-1.cjs → PostgresKyselyMigrator-JTY2LfwD.cjs}

@@ -1,5 +1,6 @@
-const require_PostgresMigrator = require('./PostgresMigrator-BJ2-5A_b.cjs');
-const kysely = require_PostgresMigrator.__toESM(require("kysely"));
+const require_chunk = require('./chunk-CUT6urMc.cjs');
+const require_PostgresMigrator = require('./PostgresMigrator-Bz-tnjB6.cjs');
+const kysely = require_chunk.__toESM(require("kysely"));
 
 //#region src/PostgresKyselyMigrator.ts
 const logger = console;

package/dist/PostgresKyselyMigrator.cjs

@@ -1,4 +1,4 @@
-require('./PostgresMigrator-BJ2-5A_b.cjs');
-const require_PostgresKyselyMigrator = require('./PostgresKyselyMigrator-rY3hO_-1.cjs');
+require('./PostgresMigrator-Bz-tnjB6.cjs');
+const require_PostgresKyselyMigrator = require('./PostgresKyselyMigrator-JTY2LfwD.cjs');
 
 exports.PostgresKyselyMigrator = require_PostgresKyselyMigrator.PostgresKyselyMigrator;

package/dist/PostgresKyselyMigrator.mjs

@@ -1,4 +1,4 @@
-import "./PostgresMigrator-BKaNTth5.mjs";
-import { PostgresKyselyMigrator } from "./PostgresKyselyMigrator-ChMJpPrQ.mjs";
+import "./PostgresMigrator-CEoRKTdq.mjs";
+import { PostgresKyselyMigrator } from "./PostgresKyselyMigrator-D8fm35-s.mjs";
 
 export { PostgresKyselyMigrator };