@geekmidas/testkit 0.0.12 → 0.0.13

package/src/__tests__/ObjectionFactory.spec.ts

@@ -1,22 +1,19 @@
 import type { Knex } from 'knex';
 import { Model } from 'objection';
-import { afterAll, beforeAll, describe, expect, it } from 'vitest';
-import { setupKnexTest } from '../../test/helpers';
+import { describe, expect, test } from 'vitest';
+import { createKnexDb, createTestTablesKnex } from '../../test/helpers';
 import { ObjectionFactory } from '../ObjectionFactory';
 import { faker } from '../faker';
+import { wrapVitestObjectionTransaction } from '../objection';
 
-// Define real Objection models for testing
+// Define simple Objection models for testing
 class User extends Model {
   static get tableName() {
     return 'users';
   }
 
-  id!: number;
+  id!: string;
   name!: string;
-  email!: string;
-  role?: string;
-  createdAt!: Date;
-  updatedAt?: Date;
 }
 
 class Post extends Model {
@@ -24,13 +21,9 @@ class Post extends Model {
     return 'posts';
   }
 
-  id!: number;
+  id!: string;
   title!: string;
-  content!: string;
-  userId!: number;
-  published?: boolean;
-  createdAt!: Date;
-  updatedAt?: Date;
+  user_id!: string;
 }
 
 class Comment extends Model {
@@ -38,657 +31,545 @@ class Comment extends Model {
     return 'comments';
   }
 
-  id!: number;
+  id!: string;
   content!: string;
-  postId!: number;
-  userId!: number;
-  createdAt!: Date;
+  post_id!: string;
+  user_id!: string;
 }
 
-describe.skip('ObjectionFactory', () => {
-  let factory: ObjectionFactory<any, any>;
-  let db: Knex;
-  let trx: Knex.Transaction;
-  let cleanup: () => Promise<void>;
-
-  beforeAll(async () => {
-    const setup = await setupKnexTest();
-    db = setup.db;
-    trx = setup.trx;
-    cleanup = setup.cleanup;
-
-    // Bind models to the transaction
-    User.knex(trx);
-    Post.knex(trx);
-    Comment.knex(trx);
-  });
+const it = wrapVitestObjectionTransaction(
+  test,
+  createKnexDb(),
+  createTestTablesKnex,
+);
+describe('ObjectionFactory', () => {
+  it('should create an ObjectionFactory instance', ({ trx }) => {
+    const builders = {};
+    const seeds = {};
 
-  afterAll(async () => {
-    await cleanup();
+    const factory = new ObjectionFactory(builders, seeds, trx);
+
+    expect(factory).toBeInstanceOf(ObjectionFactory);
   });
 
-  describe('constructor', () => {
-    it('should create an ObjectionFactory instance', () => {
-      const builders = {};
-      const seeds = {};
+  it('should call builder and insert the record', async ({ trx }) => {
+    const userBuilder = async (attrs: any, factory: any, db: Knex) => {
+      return User.fromJson({
+        name: attrs.name || 'Default Name',
+      });
+    };
 
-      factory = new ObjectionFactory(builders, seeds, trx);
+    const builders = {
+      user: userBuilder,
+    };
 
-      expect(factory).toBeInstanceOf(ObjectionFactory);
-    });
-  });
+    const factory = new ObjectionFactory(builders, {}, trx);
 
-  describe('insert method', () => {
-    it('should call builder and insert the record', async () => {
-      const userBuilder = async (attrs: any, factory: any, db: Knex) => {
-        return User.fromJson({
-          name: attrs.name || 'Default Name',
-          email: attrs.email || `user${Date.now()}@example.com`,
-          role: attrs.role || 'user',
-          createdAt: new Date(),
-          updatedAt: new Date(),
-        });
-      };
+    const attrs = { name: 'John Doe', email: 'john@example.com' };
+    const result = await factory.insert('user', attrs);
 
-      const builders = {
-        user: userBuilder,
-      };
+    expect(result).toBeInstanceOf(User);
+    expect(result.name).toBe('John Doe');
+    expect(result.id).toBeDefined();
+  });
 
-      factory = new ObjectionFactory(builders, {}, trx);
+  it('should use empty object as default attributes', async ({ trx }) => {
+    const userBuilder = async (attrs: any, factory: any, db: Knex) => {
+      return User.fromJson({
+        name: 'Default Name',
+      });
+    };
 
-      const attrs = { name: 'John Doe', email: 'john@example.com' };
-      const result = await factory.insert('user', attrs);
+    const builders = {
+      user: userBuilder,
+    };
 
-      expect(result).toBeInstanceOf(User);
-      expect(result.name).toBe('John Doe');
-      expect(result.email).toBe('john@example.com');
-      expect(result.id).toBeDefined();
-    });
+    const factory = new ObjectionFactory(builders, {}, trx);
 
-    it('should use empty object as default attributes', async () => {
-      const userBuilder = async (attrs: any, factory: any, db: Knex) => {
-        return User.fromJson({
-          name: 'Default Name',
-          email: `user${Date.now()}@example.com`,
-          role: 'user',
-          createdAt: new Date(),
-          updatedAt: new Date(),
-        });
-      };
+    const result = await factory.insert('user');
+
+    expect(result).toBeInstanceOf(User);
+    expect(result.name).toBe('Default Name');
+    expect(result.id).toBeDefined();
+  });
 
-      const builders = {
-        user: userBuilder,
-      };
+  it('should throw error for non-existent factory', async ({ trx }) => {
+    const factory = new ObjectionFactory({}, {}, trx);
+    // @ts-ignore
+    await expect(factory.insert('nonExistent')).rejects.toThrow(
+      'Factory "nonExistent" does not exist',
+    );
+  });
 
-      factory = new ObjectionFactory(builders, {}, trx);
+  it('should handle builder that returns a promise', async ({ trx }) => {
+    const userBuilder = async (attrs: any, factory: any, db: Knex) => {
+      // Simulate async operation
+      await new Promise((resolve) => setTimeout(resolve, 10));
+      return User.fromJson({
+        name: attrs.name || 'Default Name',
+      });
+    };
 
-      const result = await factory.insert('user');
+    const builders = {
+      user: userBuilder,
+    };
 
-      expect(result).toBeInstanceOf(User);
-      expect(result.name).toBe('Default Name');
-      expect(result.id).toBeDefined();
-    });
+    const factory = new ObjectionFactory(builders, {}, trx);
 
-    it('should throw error for non-existent factory', async () => {
-      factory = new ObjectionFactory({}, {}, trx);
+    const result = await factory.insert('user', { name: 'Jane' });
 
-      await expect(factory.insert('nonExistent')).rejects.toThrow(
-        'Factory "nonExistent" does not exist',
-      );
-    });
+    expect(result).toBeInstanceOf(User);
+    expect(result.name).toBe('Jane');
+  });
 
-    it('should handle builder that returns a promise', async () => {
-      const userBuilder = async (attrs: any, factory: any, db: Knex) => {
-        // Simulate async operation
-        await new Promise((resolve) => setTimeout(resolve, 10));
-        return User.fromJson({
-          name: attrs.name || 'Default Name',
-          email: `async${Date.now()}@example.com`,
-          role: 'user',
-          createdAt: new Date(),
-          updatedAt: new Date(),
-        });
-      };
+  it('should insert multiple records with same attributes', async ({ trx }) => {
+    const userBuilder = async (attrs: any, factory: any, db: Knex) => {
+      return User.fromJson({
+        name: attrs.name || 'Default Name',
+      });
+    };
 
-      const builders = {
-        user: userBuilder,
-      };
+    const builders = {
+      user: userBuilder,
+    };
 
-      factory = new ObjectionFactory(builders, {}, trx);
+    const factory = new ObjectionFactory(builders, {}, trx);
 
-      const result = await factory.insert('user', { name: 'Jane' });
+    const attrs = { name: 'User' };
+    const results = await factory.insertMany(3, 'user', attrs);
 
+    expect(results).toHaveLength(3);
+    results.forEach((result) => {
       expect(result).toBeInstanceOf(User);
-      expect(result.name).toBe('Jane');
+      expect(result.name).toBe('User');
+      expect(result.id).toBeDefined();
     });
   });
 
-  describe('insertMany method', () => {
-    it('should insert multiple records with same attributes', async () => {
-      const userBuilder = async (attrs: any, factory: any, db: Knex) => {
-        return User.fromJson({
-          name: attrs.name || 'Default Name',
-          email: `user${Date.now()}-${Math.random()}@example.com`,
-          role: 'user',
-          createdAt: new Date(),
-          updatedAt: new Date(),
-        });
-      };
+  it('should insert multiple records with dynamic attributes', async ({
+    trx,
+  }) => {
+    const userBuilder = async (attrs: any, factory: any, db: Knex) => {
+      return User.fromJson({
+        name: attrs.name || 'Default Name',
+      });
+    };
 
-      const builders = {
-        user: userBuilder,
-      };
+    const builders = {
+      user: userBuilder,
+    };
 
-      factory = new ObjectionFactory(builders, {}, trx);
+    const factory = new ObjectionFactory(builders, {}, trx);
 
-      const attrs = { name: 'User' };
-      const results = await factory.insertMany(3, 'user', attrs);
+    const attrsFn = (idx: number) => ({ name: `User ${idx}` });
+    const results = await factory.insertMany(2, 'user', attrsFn);
 
-      expect(results).toHaveLength(3);
-      results.forEach((result) => {
-        expect(result).toBeInstanceOf(User);
-        expect(result.name).toBe('User');
-        expect(result.id).toBeDefined();
-      });
+    expect(results).toHaveLength(2);
+    expect(results[0].name).toBe('User 0');
+    expect(results[1].name).toBe('User 1');
+    results.forEach((result) => {
+      expect(result).toBeInstanceOf(User);
+      expect(result.id).toBeDefined();
     });
+  });
 
-    it('should insert multiple records with dynamic attributes', async () => {
-      const userBuilder = async (attrs: any, factory: any, db: Knex) => {
-        return User.fromJson({
-          name: attrs.name || 'Default Name',
-          email: `user${Date.now()}-${Math.random()}@example.com`,
-          role: 'user',
-          createdAt: new Date(),
-          updatedAt: new Date(),
-        });
-      };
+  it('should use empty object as default attributes for insertMany', async ({
+    trx,
+  }) => {
+    const userBuilder = async (attrs: any, factory: any, db: Knex) => {
+      return User.fromJson({
+        name: 'Default Name',
+      });
+    };
 
-      const builders = {
-        user: userBuilder,
-      };
+    const builders = {
+      user: userBuilder,
+    };
 
-      factory = new ObjectionFactory(builders, {}, trx);
+    const factory = new ObjectionFactory(builders, {}, trx);
 
-      const attrsFn = (idx: number) => ({ name: `User ${idx}` });
-      const results = await factory.insertMany(2, 'user', attrsFn);
+    const results = await factory.insertMany(2, 'user');
 
-      expect(results).toHaveLength(2);
-      expect(results[0].name).toBe('User 0');
-      expect(results[1].name).toBe('User 1');
-      results.forEach((result) => {
-        expect(result).toBeInstanceOf(User);
-        expect(result.id).toBeDefined();
-      });
+    expect(results).toHaveLength(2);
+    results.forEach((result) => {
+      expect(result).toBeInstanceOf(User);
+      expect(result.name).toBe('Default Name');
+      expect(result.id).toBeDefined();
     });
+  });
 
-    it('should use empty object as default attributes for insertMany', async () => {
-      const userBuilder = async (attrs: any, factory: any, db: Knex) => {
-        return User.fromJson({
-          name: 'Default Name',
-          email: `user${Date.now()}-${Math.random()}@example.com`,
-          role: 'user',
-          createdAt: new Date(),
-          updatedAt: new Date(),
-        });
-      };
-
-      const builders = {
-        user: userBuilder,
-      };
+  it('should throw error for non-existent builder in insertMany', async ({
+    trx,
+  }) => {
+    const factory = new ObjectionFactory({}, {}, trx);
+    // @ts-ignore
+    await expect(factory.insertMany(2, 'nonExistent')).rejects.toThrow(
+      'Builder "nonExistent" is not registered',
+    );
+  });
 
-      factory = new ObjectionFactory(builders, {}, trx);
+  it('should execute seed function', async ({ trx }) => {
+    const userBuilder = async (attrs: any, factory: any, db: Knex) => {
+      return User.fromJson({
+        name: attrs.name || 'Default Name',
+      });
+    };
 
-      const results = await factory.insertMany(2, 'user');
+    const builders = { user: userBuilder };
 
-      expect(results).toHaveLength(2);
-      results.forEach((result) => {
-        expect(result).toBeInstanceOf(User);
-        expect(result.name).toBe('Default Name');
-        expect(result.id).toBeDefined();
+    const createAdminSeed = async (attrs: any, factory: any, db: Knex) => {
+      return await factory.insert('user', {
+        name: attrs.name || 'Admin User',
       });
-    });
+    };
 
-    it('should throw error for non-existent builder in insertMany', async () => {
-      factory = new ObjectionFactory({}, {}, trx);
+    const seeds = {
+      createAdmin: createAdminSeed,
+    };
 
-      await expect(factory.insertMany(2, 'nonExistent')).rejects.toThrow(
-        'Builder "nonExistent" is not registered',
-      );
-    });
-  });
+    const factory = new ObjectionFactory(builders, seeds, trx);
 
-  describe('seed method', () => {
-    it('should execute seed function', async () => {
-      const userBuilder = async (attrs: any, factory: any, db: Knex) => {
-        return User.fromJson({
-          name: attrs.name || 'Default Name',
-          email: attrs.email || `admin${Date.now()}@example.com`,
-          role: 'admin',
-          createdAt: new Date(),
-          updatedAt: new Date(),
-        });
-      };
+    const attrs = { name: 'Super Admin' };
+    const result = await factory.seed('createAdmin', attrs);
 
-      const builders = { user: userBuilder };
+    expect(result).toBeInstanceOf(User);
+    expect(result.name).toBe('Super Admin');
+    expect(result.id).toBeDefined();
+  });
 
-      const createAdminSeed = async (attrs: any, factory: any, db: Knex) => {
-        return await factory.insert('user', {
-          name: attrs.name || 'Admin User',
-          email: 'admin@example.com',
-          role: 'admin',
-        });
-      };
+  it('should use empty object as default attributes for seed', async ({
+    trx,
+  }) => {
+    const userBuilder = async (attrs: any, factory: any, db: Knex) => {
+      return User.fromJson({
+        name: 'Default Admin',
+      });
+    };
 
-      const seeds = {
-        createAdmin: createAdminSeed,
-      };
+    const builders = { user: userBuilder };
 
-      factory = new ObjectionFactory(builders, seeds, trx);
+    const createAdminSeed = async (attrs: any, factory: any, db: Knex) => {
+      return await factory.insert('user', {
+        name: 'Default Admin',
+        role: 'admin',
+      });
+    };
 
-      const attrs = { name: 'Super Admin' };
-      const result = await factory.seed('createAdmin', attrs);
+    const seeds = {
+      createAdmin: createAdminSeed,
+    };
 
-      expect(result).toBeInstanceOf(User);
-      expect(result.name).toBe('Super Admin');
-      expect(result.role).toBe('admin');
-      expect(result.id).toBeDefined();
-    });
+    const factory = new ObjectionFactory(builders, seeds, trx);
 
-    it('should use empty object as default attributes for seed', async () => {
-      const userBuilder = async (attrs: any, factory: any, db: Knex) => {
-        return User.fromJson({
-          name: 'Default Admin',
-          email: `admin${Date.now()}@example.com`,
-          role: 'admin',
-          createdAt: new Date(),
-          updatedAt: new Date(),
-        });
-      };
+    const result = await factory.seed('createAdmin');
 
-      const builders = { user: userBuilder };
+    expect(result).toBeInstanceOf(User);
+    expect(result.name).toBe('Default Admin');
+  });
 
-      const createAdminSeed = async (attrs: any, factory: any, db: Knex) => {
-        return await factory.insert('user', {
-          name: 'Default Admin',
-          role: 'admin',
-        });
-      };
+  it('should throw error for non-existent seed', ({ trx }) => {
+    const factory = new ObjectionFactory({}, {}, trx);
+    // @ts-ignore
+    expect(() => factory.seed('nonExistent')).toThrow(
+      'Seed "nonExistent" is not registered',
+    );
+  });
 
-      const seeds = {
-        createAdmin: createAdminSeed,
-      };
+  it('should pass factory and db to seed function', async ({ trx }) => {
+    const userBuilder = async (attrs: any, factory: any, db: Knex) => {
+      return User.fromJson({
+        name: attrs.name || 'Test User',
+      });
+    };
 
-      factory = new ObjectionFactory(builders, seeds, trx);
+    const builders = { user: userBuilder };
 
-      const result = await factory.seed('createAdmin');
+    const complexSeed = async (
+      attrs: any,
+      passedFactory: any,
+      passedDb: Knex,
+    ) => {
+      // Verify that factory and db are passed correctly
+      expect(passedFactory).toBe(factory);
+      expect(passedDb).toBe(trx);
 
-      expect(result).toBeInstanceOf(User);
-      expect(result.name).toBe('Default Admin');
-      expect(result.role).toBe('admin');
-    });
+      return await passedFactory.insert('user', {
+        name: `Complex ${attrs.data}`,
+      });
+    };
 
-    it('should throw error for non-existent seed', () => {
-      factory = new ObjectionFactory({}, {}, trx);
+    const seeds = {
+      complexSeed,
+    };
 
-      expect(() => factory.seed('nonExistent')).toThrow(
-        'Seed "nonExistent" is not registered',
-      );
-    });
+    const factory = new ObjectionFactory(builders, seeds, trx);
 
-    it('should pass factory and db to seed function', async () => {
-      const userBuilder = async (attrs: any, factory: any, db: Knex) => {
-        return User.fromJson({
-          name: attrs.name || 'Test User',
-          email: `test${Date.now()}@example.com`,
-          role: 'user',
-          createdAt: new Date(),
-          updatedAt: new Date(),
-        });
-      };
+    const result = await factory.seed('complexSeed', { data: 'test' });
 
-      const builders = { user: userBuilder };
+    expect(result).toBeInstanceOf(User);
+    expect(result.name).toBe('Complex test');
+  });
 
-      const complexSeed = async (
-        attrs: any,
-        passedFactory: any,
-        passedDb: Knex,
-      ) => {
-        // Verify that factory and db are passed correctly
-        expect(passedFactory).toBe(factory);
-        expect(passedDb).toBe(trx);
+  it('should return the seed function unchanged', () => {
+    const seedFn = async (attrs: any, factory: any, db: any) => {
+      return { id: 1, name: 'test' };
+    };
 
-        return await passedFactory.insert('user', {
-          name: `Complex ${attrs.data}`,
-        });
-      };
+    const result = ObjectionFactory.createSeed(seedFn);
 
-      const seeds = {
-        complexSeed,
-      };
+    expect(result).toBe(seedFn);
+  });
 
-      factory = new ObjectionFactory(builders, seeds, trx);
+  it('should create a builder function with auto-insert', async ({ trx }) => {
+    const userBuilder = ObjectionFactory.createBuilder(
+      User,
+      (attrs, factory, db, faker) => ({
+        name: faker.person.fullName(),
+        ...attrs,
+      }),
+    );
 
-      const result = await factory.seed('complexSeed', { data: 'test' });
+    const builders = { user: userBuilder };
+    const factory = new ObjectionFactory(builders, {}, trx);
 
-      expect(result).toBeInstanceOf(User);
-      expect(result.name).toBe('Complex test');
-    });
+    const result = await factory.insert('user', { name: 'Test User' });
+
+    expect(result).toBeInstanceOf(User);
+    expect(result.name).toBe('Test User');
+    expect(result.id).toBeDefined();
   });
 
-  describe('createSeed static method', () => {
-    it('should return the seed function unchanged', () => {
-      const seedFn = async (attrs: any, factory: any, db: any) => {
-        return { id: 1, name: 'test' };
-      };
+  it('should create a builder function without auto-insert', async ({
+    trx,
+  }) => {
+    const userBuilder = ObjectionFactory.createBuilder(
+      User,
+      (attrs) => ({
+        name: 'No Insert User',
+        ...attrs,
+      }),
+      false, // Don't auto-insert
+    );
+
+    const builders = { user: userBuilder };
+    const factory = new ObjectionFactory(builders, {}, trx);
+
+    const result = await factory.insert('user');
+
+    // The factory's insert method should handle the insertion
+    expect(result).toBeInstanceOf(User);
+    expect(result.name).toBe('No Insert User');
+    expect(result.id).toBeDefined();
+  });
 
-      const result = ObjectionFactory.createSeed(seedFn);
+  it('should pass all parameters to the item function', async ({ trx }) => {
+    let capturedFactory: any;
+    let capturedDb: any;
+    let capturedFaker: any;
 
-      expect(result).toBe(seedFn);
-    });
-  });
+    const userBuilder = ObjectionFactory.createBuilder(
+      User,
+      (attrs, factory, db, fakerInstance) => {
+        capturedFactory = factory;
+        capturedDb = db;
+        capturedFaker = fakerInstance;
 
-  describe('createBuilder static method', () => {
-    it('should create a builder function with auto-insert', async () => {
-      const userBuilder = ObjectionFactory.createBuilder(
-        User,
-        (attrs, factory, db, faker) => ({
-          name: faker.person.fullName(),
-          email: faker.internet.email(),
-          role: 'user',
-          createdAt: new Date(),
-          updatedAt: new Date(),
+        return {
+          name: 'Test User',
           ...attrs,
-        }),
-      );
+        };
+      },
+    );
 
-      const builders = { user: userBuilder };
-      factory = new ObjectionFactory(builders, {}, trx);
+    const builders = { user: userBuilder };
+    const factory = new ObjectionFactory(builders, {}, trx);
 
-      const result = await factory.insert('user', { name: 'Test User' });
+    await factory.insert('user');
 
-      expect(result).toBeInstanceOf(User);
-      expect(result.name).toBe('Test User');
-      expect(result.email).toMatch(/@/);
-      expect(result.id).toBeDefined();
-    });
+    expect(capturedFactory).toBe(factory);
+    expect(capturedDb).toBe(trx);
+    expect(capturedFaker).toBe(faker);
+  });
+
+  it('should handle async item functions', async ({ trx }) => {
+    const userBuilder = ObjectionFactory.createBuilder(
+      User,
+      async (attrs, factory, db, faker) => {
+        // Simulate async operation
+        await new Promise((resolve) => setTimeout(resolve, 10));
 
-    it('should create a builder function without auto-insert', async () => {
-      const userBuilder = ObjectionFactory.createBuilder(
-        User,
-        (attrs) => ({
-          name: 'No Insert User',
-          email: 'noinsert@example.com',
-          role: 'user',
-          createdAt: new Date(),
-          updatedAt: new Date(),
+        return {
+          name: 'Async User',
           ...attrs,
-        }),
-        false, // Don't auto-insert
-      );
+        };
+      },
+    );
 
-      const builders = { user: userBuilder };
-      factory = new ObjectionFactory(builders, {}, trx);
+    const builders = { user: userBuilder };
+    const factory = new ObjectionFactory(builders, {}, trx);
 
-      const result = await factory.insert('user');
+    const result = await factory.insert('user');
 
-      // The factory's insert method should handle the insertion
-      expect(result).toBeInstanceOf(User);
-      expect(result.name).toBe('No Insert User');
-      expect(result.id).toBeDefined();
-    });
+    expect(result).toBeInstanceOf(User);
+    expect(result.name).toBe('Async User');
+    expect(result.id).toBeDefined();
+  });
 
-    it('should pass all parameters to the item function', async () => {
-      let capturedFactory: any;
-      let capturedDb: any;
-      let capturedFaker: any;
-
-      const userBuilder = ObjectionFactory.createBuilder(
-        User,
-        (attrs, factory, db, fakerInstance) => {
-          capturedFactory = factory;
-          capturedDb = db;
-          capturedFaker = fakerInstance;
-
-          return {
-            name: 'Test User',
-            email: 'test@example.com',
-            role: 'user',
-            createdAt: new Date(),
-            updatedAt: new Date(),
-            ...attrs,
-          };
-        },
-      );
-
-      const builders = { user: userBuilder };
-      factory = new ObjectionFactory(builders, {}, trx);
-
-      await factory.insert('user');
-
-      expect(capturedFactory).toBe(factory);
-      expect(capturedDb).toBe(trx);
-      expect(capturedFaker).toBe(faker);
-    });
+  it('should work without item function', async ({ trx }) => {
+    const userBuilder = ObjectionFactory.createBuilder(User);
 
-    it('should handle async item functions', async () => {
-      const userBuilder = ObjectionFactory.createBuilder(
-        User,
-        async (attrs, factory, db, faker) => {
-          // Simulate async operation
-          await new Promise((resolve) => setTimeout(resolve, 10));
-
-          return {
-            name: 'Async User',
-            email: faker.internet.email(),
-            role: 'user',
-            createdAt: new Date(),
-            updatedAt: new Date(),
-            ...attrs,
-          };
-        },
-      );
-
-      const builders = { user: userBuilder };
-      factory = new ObjectionFactory(builders, {}, trx);
-
-      const result = await factory.insert('user');
+    const builders = { user: userBuilder };
+    const factory = new ObjectionFactory(builders, {}, trx);
 
-      expect(result).toBeInstanceOf(User);
-      expect(result.name).toBe('Async User');
-      expect(result.id).toBeDefined();
-    });
+    const attrs = {
+      name: 'Manual User',
+    };
 
-    it('should work without item function', async () => {
-      const userBuilder = ObjectionFactory.createBuilder(User);
+    const result = await factory.insert('user', attrs);
 
-      const builders = { user: userBuilder };
-      factory = new ObjectionFactory(builders, {}, trx);
+    expect(result).toBeInstanceOf(User);
+    expect(result.name).toBe('Manual User');
+    expect(result.id).toBeDefined();
+  });
 
-      const attrs = {
-        name: 'Manual User',
-        email: 'manual@example.com',
-        role: 'user',
-        createdAt: new Date(),
-        updatedAt: new Date(),
-      };
+  it('should allow overriding default values', async ({ trx }) => {
+    const userBuilder = ObjectionFactory.createBuilder(
+      User,
+      (attrs, factory, db, faker) => ({
+        name: 'Default Name',
+        ...attrs,
+      }),
+    );
 
-      const result = await factory.insert('user', attrs);
+    const builders = { user: userBuilder };
+    const factory = new ObjectionFactory(builders, {}, trx);
 
-      expect(result).toBeInstanceOf(User);
-      expect(result.name).toBe('Manual User');
-      expect(result.email).toBe('manual@example.com');
-      expect(result.id).toBeDefined();
+    const result = await factory.insert('user', {
+      name: 'Override Name',
     });
 
-    it('should allow overriding default values', async () => {
-      const userBuilder = ObjectionFactory.createBuilder(
-        User,
-        (attrs, factory, db, faker) => ({
-          name: 'Default Name',
-          email: 'default@example.com',
-          role: 'user',
-          createdAt: new Date(),
-          updatedAt: new Date(),
-          ...attrs,
-        }),
-      );
-
-      const builders = { user: userBuilder };
-      factory = new ObjectionFactory(builders, {}, trx);
-
-      const result = await factory.insert('user', {
-        name: 'Override Name',
-        email: 'override@example.com',
-      });
-
-      expect(result).toBeInstanceOf(User);
-      expect(result.name).toBe('Override Name');
-      expect(result.email).toBe('override@example.com');
-      expect(result.role).toBe('user'); // Default not overridden
-    });
+    expect(result).toBeInstanceOf(User);
+    expect(result.name).toBe('Override Name');
   });
 
-  describe('error handling', () => {
-    it('should handle builder errors gracefully', async () => {
-      const userBuilder = async (attrs: any, factory: any, db: Knex) => {
-        throw new Error('Builder failed');
-      };
+  it('should handle builder errors gracefully', async ({ trx }) => {
+    const userBuilder = async (attrs: any, factory: any, db: Knex) => {
+      throw new Error('Builder failed');
+    };
 
-      const builders = {
-        user: userBuilder,
-      };
+    const builders = {
+      user: userBuilder,
+    };
 
-      factory = new ObjectionFactory(builders, {}, trx);
+    const factory = new ObjectionFactory(builders, {}, trx);
 
-      await expect(factory.insert('user')).rejects.toThrow('Builder failed');
-    });
+    await expect(factory.insert('user')).rejects.toThrow('Builder failed');
+  });
 
-    it('should handle invalid model data gracefully', async () => {
-      const userBuilder = async (attrs: any, factory: any, db: Knex) => {
-        // Return invalid model data that will fail validation
-        return User.fromJson({
-          // Missing required fields
-          invalidField: 'invalid',
-        } as any);
-      };
+  it('should handle invalid model data gracefully', async ({ trx }) => {
+    const userBuilder = async (attrs: any, factory: any, db: Knex) => {
+      // Return invalid model data that will fail validation
+      return User.fromJson({
+        // Missing required fields
+        invalidField: 'invalid',
+      } as any);
+    };
 
-      const builders = {
-        user: userBuilder,
-      };
+    const builders = {
+      user: userBuilder,
+    };
 
-      factory = new ObjectionFactory(builders, {}, trx);
+    const factory = new ObjectionFactory(builders, {}, trx);
 
-      await expect(factory.insert('user')).rejects.toThrow();
-    });
+    await expect(factory.insert('user')).rejects.toThrow();
+  });
 
-    it('should handle seed function errors gracefully', async () => {
-      const failingSeed = async (attrs: any, factory: any, db: Knex) => {
-        throw new Error('Seed failed');
-      };
+  it('should handle seed function errors gracefully', async ({ trx }) => {
+    const failingSeed = async (attrs: any, factory: any, db: Knex) => {
+      throw new Error('Seed failed');
+    };
 
-      const seeds = {
-        failingSeed,
-      };
+    const seeds = {
+      failingSeed,
+    };
 
-      factory = new ObjectionFactory({}, seeds, trx);
+    const factory = new ObjectionFactory({}, seeds, trx);
 
-      await expect(factory.seed('failingSeed')).rejects.toThrow('Seed failed');
-    });
+    await expect(factory.seed('failingSeed')).rejects.toThrow('Seed failed');
   });
 
-  describe('type safety and integration', () => {
-    it('should work with typed builders and seeds', async () => {
-      interface UserInterface {
-        id: number;
-        name: string;
-        email: string;
-      }
+  it('should work with typed builders and seeds', async ({ trx }) => {
+    interface UserInterface {
+      id: string;
+      name: string;
+    }
 
-      type UserAttrs = Partial<Pick<UserInterface, 'name' | 'email'>>;
+    type UserAttrs = Partial<Pick<UserInterface, 'name'>>;
 
-      const userBuilder = async (attrs: UserAttrs, factory: any, db: Knex) => {
-        return User.fromJson({
-          name: attrs.name || 'Default User',
-          email: attrs.email || `user${Date.now()}@example.com`,
-          role: 'user',
-          createdAt: new Date(),
-          updatedAt: new Date(),
-        });
-      };
-
-      const adminSeed = async (
-        attrs: { isSuper?: boolean },
-        factory: any,
-        db: Knex,
-      ) => {
-        return factory.insert('user', {
-          name: 'Admin',
-          email: 'admin@example.com',
-          role: 'admin',
-        });
-      };
+    const userBuilder = async (attrs: UserAttrs, factory: any, db: Knex) => {
+      return User.fromJson({
+        name: attrs.name || 'Default User',
+      });
+    };
+
+    const adminSeed = async (
+      attrs: { isSuper?: boolean },
+      factory: any,
+      db: Knex,
+    ) => {
+      return factory.insert('user', {
+        name: 'Admin',
+      });
+    };
 
-      const builders = { user: userBuilder };
-      const seeds = { admin: adminSeed };
+    const builders = { user: userBuilder };
+    const seeds = { admin: adminSeed };
 
-      // This should compile without type errors
-      factory = new ObjectionFactory(builders, seeds, trx);
+    // This should compile without type errors
+    const factory = new ObjectionFactory(builders, seeds, trx);
 
-      expect(factory).toBeInstanceOf(ObjectionFactory);
+    expect(factory).toBeInstanceOf(ObjectionFactory);
 
-      // Test actual functionality
-      const admin = await factory.seed('admin', { isSuper: true });
-      expect(admin).toBeInstanceOf(User);
-      expect(admin.name).toBe('Admin');
-    });
+    // Test actual functionality
+    const admin = await factory.seed('admin', { isSuper: true });
+    expect(admin).toBeInstanceOf(User);
+    expect(admin.name).toBe('Admin');
+  });
 
-    it('should handle complex builder scenarios', async () => {
-      const userBuilder = async (attrs: any, factory: any, db: Knex) => {
-        return User.fromJson({
-          name: attrs.name || 'Default User',
-          email: attrs.email || `user${Date.now()}@example.com`,
-          role: 'user',
-          createdAt: new Date(),
-          updatedAt: new Date(),
-        });
-      };
-
-      const postBuilder = async (attrs: any, factory: any, db: Knex) => {
-        // If no userId provided, create a user
-        if (!attrs.userId) {
-          const user = await factory.insert('user');
-          return Post.fromJson({
-            title: attrs.title || 'Default Post',
-            content: attrs.content || 'Default content',
-            userId: user.id,
-            published: attrs.published || false,
-            createdAt: new Date(),
-            updatedAt: new Date(),
-          });
-        }
+  it('should handle complex builder scenarios', async ({ trx }) => {
+    const userBuilder = async (attrs: any, factory: any, db: Knex) => {
+      return User.fromJson({
+        name: attrs.name || 'Default User',
+      });
+    };
+
+    const postBuilder = async (attrs: any, factory: any, db: Knex) => {
+      // If no user_id provided, create a user
+      if (!attrs.user_id) {
+        const user = await factory.insert('user');
         return Post.fromJson({
           title: attrs.title || 'Default Post',
-          content: attrs.content || 'Default content',
-          userId: attrs.userId,
-          published: attrs.published || false,
-          createdAt: new Date(),
-          updatedAt: new Date(),
+          user_id: user.id,
         });
-      };
+      }
+      return Post.fromJson({
+        title: attrs.title || 'Default Post',
+        user_id: attrs.user_id,
+      });
+    };
 
-      const builders = {
-        user: userBuilder,
-        post: postBuilder,
-      };
+    const builders = {
+      user: userBuilder,
+      post: postBuilder,
+    };
 
-      factory = new ObjectionFactory(builders, {}, trx);
+    const factory = new ObjectionFactory(builders, {}, trx);
 
-      const post = await factory.insert('post', { title: 'Test Post' });
+    const post = await factory.insert('post', { title: 'Test Post' });
 
-      expect(post).toBeInstanceOf(Post);
-      expect(post.title).toBe('Test Post');
-      expect(post.userId).toBeDefined();
-      expect(typeof post.userId).toBe('number');
-    });
+    expect(post).toBeInstanceOf(Post);
+    expect(post.title).toBe('Test Post');
+    expect(post.user_id).toBeDefined();
+    expect(typeof post.user_id).toBe('string'); // PostgreSQL returns bigint as string
   });
 });