@geekmidas/testkit 0.0.16 → 0.1.0

package/src/ObjectionFactory.ts

@@ -19,17 +19,17 @@ import { type FakerFactory, faker } from './faker.ts';
  *
  * // Create builders
  * const builders = {
- *   user: (attrs) => User.fromJson({
+ *   user: ObjectionFactory.createBuilder(User, ({ attrs, faker }) => ({
  *     id: faker.string.uuid(),
  *     name: faker.person.fullName(),
  *     email: faker.internet.email(),
  *     ...attrs
- *   }),
- *   post: (attrs) => Post.fromJson({
+ *   })),
+ *   post: ObjectionFactory.createBuilder(Post, ({ attrs }) => ({
  *     title: 'Test Post',
  *     content: 'Test content',
  *     ...attrs
- *   })
+ *   })),
  * };
  *
  * // Create factory instance
@@ -65,15 +65,15 @@ export class ObjectionFactory<
    * @template Result - The result type (defaults to the model instance)
    *
    * @param ModelClass - The Objection.js Model class
-   * @param item - Optional function to provide default values and transformations
+   * @param defaults - Optional function to provide default values (receives destructured context)
    * @param autoInsert - Whether to automatically insert the record (default: true)
    * @returns A builder function that creates and optionally inserts records
    *
    * @example
    * ```typescript
-   * // Create a simple builder with defaults
+   * // Create a simple builder with defaults - destructure only what you need
    * const userBuilder = ObjectionFactory.createBuilder(User,
-   *   (attrs, factory, db, faker) => ({
+   *   ({ attrs, faker }) => ({
    *     id: faker.string.uuid(),
    *     name: faker.person.fullName(),
    *     email: faker.internet.email(),
@@ -82,9 +82,17 @@ export class ObjectionFactory<
    *   })
    * );
    *
+   * // Only need faker? Just destructure that
+   * const leaveTypeBuilder = ObjectionFactory.createBuilder(LeaveType,
+   *   ({ faker }) => ({
+   *     name: faker.helpers.arrayElement(['Annual', 'Sick', 'Maternity']),
+   *     code: faker.string.alpha({ length: 3, casing: 'upper' }),
+   *   })
+   * );
+   *
    * // Create a builder that doesn't auto-insert (useful for nested inserts)
    * const addressBuilder = ObjectionFactory.createBuilder(Address,
-   *   (attrs) => ({
+   *   ({ attrs }) => ({
    *     street: '123 Main St',
    *     city: 'Anytown',
    *     ...attrs
@@ -94,7 +102,7 @@ export class ObjectionFactory<
    *
    * // Use with relations
    * const postBuilder = ObjectionFactory.createBuilder(Post,
-   *   async (attrs, factory) => ({
+   *   async ({ attrs, factory, faker }) => ({
    *     title: faker.lorem.sentence(),
    *     content: faker.lorem.paragraphs(),
    *     authorId: attrs.authorId || (await factory.insert('user')).id,
@@ -110,12 +118,14 @@ export class ObjectionFactory<
     Result = InstanceType<TModel>,
   >(
     ModelClass: TModel,
-    item?: (
-      attrs: Attrs,
-      factory: Factory,
-      db: Knex,
-      faker: FakerFactory,
-    ) => Partial<InstanceType<TModel>> | Promise<Partial<InstanceType<TModel>>>,
+    defaults?: (context: {
+      attrs: Attrs;
+      factory: Factory;
+      db: Knex;
+      faker: FakerFactory;
+    }) =>
+      | Partial<InstanceType<TModel>>
+      | Promise<Partial<InstanceType<TModel>>>,
     autoInsert?: boolean,
   ): (
     attrs: Attrs,
@@ -127,15 +137,20 @@ export class ObjectionFactory<
       attrs: Attrs,
       factory: Factory,
       db: Knex,
-      faker: FakerFactory,
+      fakerInstance: FakerFactory,
     ) => {
       // Start with attributes
       let data: Partial<InstanceType<TModel>> = { ...attrs };
 
       // Apply defaults
-      if (item) {
-        const defaults = await item(attrs, factory, db, faker);
-        data = { ...defaults, ...data };
+      if (defaults) {
+        const defaultValues = await defaults({
+          attrs,
+          factory,
+          db,
+          faker: fakerInstance,
+        });
+        data = { ...defaultValues, ...data };
       }
 
       // Create model instance

package/src/VitestTransactionIsolator.ts

@@ -5,8 +5,9 @@ import type { TestAPI } from 'vitest';
  * Used with Vitest's test.extend() API to inject transactions into tests.
  *
  * @template Transaction - The transaction type specific to the database driver
+ * @template Extended - Additional context properties provided by the extend function
  */
-export interface DatabaseFixtures<Transaction> {
+export interface DatabaseFixtures<Transaction, Extended = object> {
   /**
    * The database transaction available to the test.
    * All database operations should use this transaction to ensure proper rollback.
@@ -14,6 +15,31 @@ export interface DatabaseFixtures<Transaction> {
   trx: Transaction;
 }
 
+/**
+ * Combined fixtures type that merges the base transaction fixture with extended context.
+ */
+export type ExtendedDatabaseFixtures<
+  Transaction,
+  Extended = object,
+> = DatabaseFixtures<Transaction> & Extended;
+
+/**
+ * Function type for extending test context with additional properties.
+ * Receives the transaction and returns additional context to be merged with { trx }.
+ *
+ * @template Transaction - The transaction type
+ * @template Extended - The type of additional context to provide
+ *
+ * @example
+ * ```typescript
+ * const extendContext: ExtendContextFn<Transaction<DB>, { factory: KyselyFactory }> =
+ *   (trx) => ({ factory: new KyselyFactory(builders, seeds, trx) });
+ * ```
+ */
+export type ExtendContextFn<Transaction, Extended> = (
+  trx: Transaction,
+) => Extended | Promise<Extended>;
+
 /**
  * PostgreSQL transaction isolation levels.
  * Controls the visibility of concurrent transactions.
@@ -123,7 +149,7 @@ export abstract class VitestPostgresTransactionIsolator<TConn, Transaction> {
   ) {
     return this.api.extend<DatabaseFixtures<Transaction>>({
       // This fixture automatically provides a transaction to each test
-      trx: async ({}, use) => {
+      trx: async ({}, use: (value: Transaction) => Promise<void>) => {
         // Create a custom error class for rollback
         class TestRollback extends Error {
           constructor() {
@@ -168,3 +194,85 @@ export abstract class VitestPostgresTransactionIsolator<TConn, Transaction> {
 
 export type DatabaseConnectionFn<Conn> = () => Conn | Promise<Conn>;
 export type DatabaseConnection<Conn> = DatabaseConnectionFn<Conn>;
+
+/**
+ * Type for fixture creator functions that depend on the transaction.
+ * Each function receives the transaction and returns the fixture value.
+ */
+export type FixtureCreators<
+  Transaction,
+  Extended extends Record<string, unknown>,
+> = {
+  [K in keyof Extended]: (
+    trx: Transaction,
+  ) => Extended[K] | Promise<Extended[K]>;
+};
+
+/**
+ * Extends a wrapped test API with additional fixtures that depend on the transaction.
+ * This allows composing test context with factories, repositories, or other helpers.
+ *
+ * @template Transaction - The transaction type
+ * @template Extended - The type of additional context to provide
+ * @param wrappedTest - The base wrapped test from wrapVitestWithTransaction
+ * @param fixtures - Object mapping fixture names to creator functions
+ * @returns An extended test API with both trx and the additional fixtures
+ *
+ * @example
+ * ```typescript
+ * import { wrapVitestKyselyTransaction, extendWithFixtures } from '@geekmidas/testkit/kysely';
+ *
+ * // Create base wrapped test
+ * const baseTest = wrapVitestKyselyTransaction(test, db, createTestTables);
+ *
+ * // Extend with fixtures
+ * const it = extendWithFixtures(baseTest, {
+ *   factory: (trx) => new KyselyFactory(builders, seeds, trx),
+ *   userRepo: (trx) => new UserRepository(trx),
+ * });
+ *
+ * // Use in tests - trx and all fixtures are available
+ * it('should create user with factory', async ({ trx, factory, userRepo }) => {
+ *   const user = await factory.insert('user', { name: 'Test' });
+ *   expect(user).toBeDefined();
+ * });
+ * ```
+ */
+export function extendWithFixtures<
+  Transaction,
+  Extended extends Record<string, unknown>,
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  T extends ReturnType<TestAPI['extend']> = any,
+>(
+  wrappedTest: T,
+  fixtures: FixtureCreators<Transaction, Extended>,
+): T & {
+  <C extends object>(
+    name: string,
+    fn: (
+      context: DatabaseFixtures<Transaction> & Extended & C,
+    ) => Promise<void>,
+  ): void;
+  <C extends object>(
+    name: string,
+    options: object,
+    fn: (
+      context: DatabaseFixtures<Transaction> & Extended & C,
+    ) => Promise<void>,
+  ): void;
+} {
+  // Build fixture definitions for Vitest's extend API
+  const fixtureDefinitions: Record<string, any> = {};
+
+  for (const [key, creator] of Object.entries(fixtures)) {
+    fixtureDefinitions[key] = async (
+      { trx }: { trx: Transaction },
+      use: (value: unknown) => Promise<void>,
+    ) => {
+      const value = await (creator as (trx: Transaction) => unknown)(trx);
+      await use(value);
+    };
+  }
+
+  return (wrappedTest as any).extend(fixtureDefinitions);
+}

package/src/__tests__/KyselyFactory.spec.ts

@@ -24,7 +24,7 @@ describe('KyselyFactory', () => {
       async ({ trx }) => {
         const userBuilder = KyselyFactory.createBuilder<TestDatabase, 'users'>(
           'users',
-          async (attrs) => ({
+          async ({ attrs }) => ({
             name: 'John Doe',
             email: `user${Date.now()}@example.com`,
             createdAt: new Date(),
@@ -57,7 +57,7 @@ describe('KyselyFactory', () => {
       async ({ trx }) => {
         const userBuilder = KyselyFactory.createBuilder<TestDatabase, 'users'>(
           'users',
-          async (attrs) => ({
+          async ({ attrs }) => ({
             name: 'John Doe',
             email: `user${Date.now()}@example.com`,
             createdAt: new Date(),
@@ -98,7 +98,7 @@ describe('KyselyFactory', () => {
 
       const postBuilder = KyselyFactory.createBuilder<TestDatabase, 'posts'>(
         'posts',
-        async (attrs, factory) => {
+        async ({ attrs, factory }) => {
           // Create a user if userId not provided
           if (!attrs.userId) {
             const user = await factory.insert('user');
@@ -156,7 +156,7 @@ describe('KyselyFactory', () => {
       async ({ trx }) => {
         const userBuilder = KyselyFactory.createBuilder<TestDatabase, 'users'>(
           'users',
-          async (attrs) => ({
+          async () => ({
             name: 'John Doe',
             email: `user${Date.now()}-${Math.random()}@example.com`,
             createdAt: new Date(),
@@ -189,7 +189,7 @@ describe('KyselyFactory', () => {
       async ({ trx }) => {
         const userBuilder = KyselyFactory.createBuilder<TestDatabase, 'users'>(
           'users',
-          async (attrs) => ({
+          async () => ({
             email: `user${Date.now()}-${Math.random()}@example.com`,
             createdAt: new Date(),
           }),
@@ -233,7 +233,7 @@ describe('KyselyFactory', () => {
       let counter = 0;
       const userBuilder = KyselyFactory.createBuilder<TestDatabase, 'users'>(
         'users',
-        async (attrs) => {
+        async () => {
           // Simulate async operation
           await new Promise((resolve) => setTimeout(resolve, 10));
           counter++;
@@ -307,7 +307,7 @@ describe('KyselyFactory', () => {
       async ({ trx }) => {
         const userBuilder = KyselyFactory.createBuilder<TestDatabase, 'users'>(
           'users',
-          async (attrs) => ({
+          async ({ attrs }) => ({
             name: 'John Doe',
             email: `user${Date.now()}@example.com`,
             createdAt: new Date(),
@@ -364,7 +364,7 @@ describe('KyselyFactory', () => {
       async ({ trx }) => {
         const userBuilder = KyselyFactory.createBuilder<TestDatabase, 'users'>(
           'users',
-          async (attrs) => ({
+          async ({ attrs }) => ({
             name: 'John Doe',
             email: `user${Date.now()}@example.com`,
             createdAt: new Date(),
@@ -400,7 +400,7 @@ describe('KyselyFactory', () => {
       async ({ trx }) => {
         const userBuilder = KyselyFactory.createBuilder<TestDatabase, 'users'>(
           'users',
-          async (attrs) => ({
+          async ({ attrs }) => ({
             name: 'John Doe',
             email: `user${Date.now()}@example.com`,
             createdAt: new Date(),
@@ -409,7 +409,7 @@ describe('KyselyFactory', () => {
 
         const postBuilder = KyselyFactory.createBuilder<TestDatabase, 'posts'>(
           'posts',
-          async (attrs, factory) => {
+          async ({ factory }) => {
             const user = await factory.insert('user');
             return {
               title: 'Default Post',

package/src/__tests__/ObjectionFactory.spec.ts

@@ -323,7 +323,7 @@ describe('ObjectionFactory', () => {
   it('should create a builder function with auto-insert', async ({ trx }) => {
     const userBuilder = ObjectionFactory.createBuilder(
       User,
-      (attrs, factory, db, faker) => ({
+      ({ attrs, faker }) => ({
         name: faker.person.fullName(),
         ...attrs,
       }),
@@ -344,7 +344,7 @@ describe('ObjectionFactory', () => {
   }) => {
     const userBuilder = ObjectionFactory.createBuilder(
       User,
-      (attrs) => ({
+      ({ attrs }) => ({
         name: 'No Insert User',
         ...attrs,
       }),
@@ -369,8 +369,8 @@ describe('ObjectionFactory', () => {
 
     const userBuilder = ObjectionFactory.createBuilder(
       User,
-      (attrs, factory, db, fakerInstance) => {
-        capturedFactory = factory;
+      ({ attrs, factory: passedFactory, db, faker: fakerInstance }) => {
+        capturedFactory = passedFactory;
         capturedDb = db;
         capturedFaker = fakerInstance;
 
@@ -394,7 +394,7 @@ describe('ObjectionFactory', () => {
   it('should handle async item functions', async ({ trx }) => {
     const userBuilder = ObjectionFactory.createBuilder(
       User,
-      async (attrs, factory, db, faker) => {
+      async ({ attrs }) => {
         // Simulate async operation
         await new Promise((resolve) => setTimeout(resolve, 10));
 
@@ -433,13 +433,10 @@ describe('ObjectionFactory', () => {
   });
 
   it('should allow overriding default values', async ({ trx }) => {
-    const userBuilder = ObjectionFactory.createBuilder(
-      User,
-      (attrs, factory, db, faker) => ({
-        name: 'Default Name',
-        ...attrs,
-      }),
-    );
+    const userBuilder = ObjectionFactory.createBuilder(User, ({ attrs }) => ({
+      name: 'Default Name',
+      ...attrs,
+    }));
 
     const builders = { user: userBuilder };
     const factory = new ObjectionFactory(builders, {}, trx);

package/src/__tests__/better-auth.spec.ts

@@ -0,0 +1,21 @@
+import { runAdapterTest } from 'better-auth/adapters/test';
+import { afterAll, describe } from 'vitest';
+import { memoryAdapter } from '../better-auth';
+
+describe.skip('Memory Adapter Tests', async () => {
+  afterAll(async () => {
+    // Run DB cleanup here...
+  });
+  const adapter = memoryAdapter({
+    debugLogs: {
+      // If your adapter config allows passing in debug logs, then pass this here.
+      isRunningAdapterTests: true, // This is our super secret flag to let us know to only log debug logs if a test fails.
+    },
+  });
+
+  await runAdapterTest({
+    getAdapter: async (betterAuthOptions = {}) => {
+      return adapter(betterAuthOptions);
+    },
+  });
+});

package/src/__tests__/integration.spec.ts

@@ -3,7 +3,7 @@ import { TEST_DATABASE_CONFIG } from '../../test/globalSetup';
 import { type TestDatabase, createTestTables } from '../../test/helpers';
 import { KyselyFactory } from '../KyselyFactory';
 import { createKyselyDb } from '../helpers';
-import { wrapVitestKyselyTransaction } from '../kysely';
+import { extendWithFixtures, wrapVitestKyselyTransaction } from '../kysely';
 
 const db = () => createKyselyDb<TestDatabase>(TEST_DATABASE_CONFIG);
 const it = wrapVitestKyselyTransaction<TestDatabase>(
@@ -18,7 +18,7 @@ describe('Testkit Integration Tests', () => {
       // Create builders for all entities
       const userBuilder = KyselyFactory.createBuilder<TestDatabase, 'users'>(
         'users',
-        async (attrs) => ({
+        async () => ({
           name: 'John Doe',
           email: `user${Date.now()}-${Math.random()}@example.com`,
           role: 'user' as const,
@@ -29,7 +29,7 @@ describe('Testkit Integration Tests', () => {
 
       const postBuilder = KyselyFactory.createBuilder<TestDatabase, 'posts'>(
         'posts',
-        async (attrs, factory) => {
+        async ({ attrs, factory }) => {
           // Create a user if no userId provided
           if (!attrs.userId) {
             const user = await factory.insert('user');
@@ -55,7 +55,7 @@ describe('Testkit Integration Tests', () => {
       const commentBuilder = KyselyFactory.createBuilder<
         TestDatabase,
         'comments'
-      >('comments', async (attrs, factory) => {
+      >('comments', async ({ attrs, factory }) => {
         let postId = attrs.postId;
         let userId = attrs.userId;
 
@@ -152,7 +152,7 @@ describe('Testkit Integration Tests', () => {
 
       const userBuilder = KyselyFactory.createBuilder<TestDatabase, 'users'>(
         'users',
-        async (attrs) => ({
+        async () => ({
           name: 'Default User',
           email: `user${Date.now()}-${Math.random()}@example.com`,
           role: 'user' as const,
@@ -163,7 +163,7 @@ describe('Testkit Integration Tests', () => {
 
       const postBuilder = KyselyFactory.createBuilder<TestDatabase, 'posts'>(
         'posts',
-        async (attrs, factory) => {
+        async ({ attrs, factory }) => {
           if (!attrs.userId) {
             const user = await factory.insert('user');
             return {
@@ -193,7 +193,10 @@ describe('Testkit Integration Tests', () => {
       // Create complex seeds
       const seeds = {
         blogWithAdminAndPosts: KyselyFactory.createSeed(
-          async (attrs: { postCount?: number }, factory: any, db: any) => {
+          async (
+            attrs: { postCount?: number },
+            factory: KyselyFactory<TestDatabase, typeof builders, {}>,
+          ) => {
             // Create admin user
             const admin = await factory.insert('user', {
               name: 'Blog Admin',
@@ -229,13 +232,15 @@ describe('Testkit Integration Tests', () => {
         usersWithPosts: KyselyFactory.createSeed(
           async (
             attrs: { userCount?: number; postsPerUser?: number },
-            factory: any,
-            db: any,
+            factory: KyselyFactory<TestDatabase, typeof builders, {}>,
           ) => {
             const userCount = attrs.userCount || 2;
             const postsPerUser = attrs.postsPerUser || 2;
 
-            const results: Array<{ user: any; posts: any[] }> = [];
+            const results: Array<{
+              user: Awaited<ReturnType<typeof builders.user>>;
+              posts: Awaited<ReturnType<typeof builders.post>>[];
+            }> = [];
 
             for (let i = 0; i < userCount; i++) {
               const user = await factory.insert('user', {
@@ -306,7 +311,7 @@ describe('Testkit Integration Tests', () => {
     it('should handle transaction isolation properly', async ({ trx }) => {
       const userBuilder = KyselyFactory.createBuilder<TestDatabase, 'users'>(
         'users',
-        async (attrs, factory, db, faker) => ({
+        async ({ faker }) => ({
           name: 'Test User',
           email: faker.internet.email(),
           role: 'user' as const,
@@ -345,7 +350,7 @@ describe('Testkit Integration Tests', () => {
     it('should handle creating many records efficiently', async ({ trx }) => {
       const userBuilder = KyselyFactory.createBuilder<TestDatabase, 'users'>(
         'users',
-        async (attrs, factory, db, faker) => ({
+        async ({ faker }) => ({
           name: `User ${Math.random()}`,
           email: faker.internet.email().toLowerCase(),
           role: 'user' as const,
@@ -381,7 +386,7 @@ describe('Testkit Integration Tests', () => {
     it('should handle complex attribute generation', async ({ trx }) => {
       const userBuilder = KyselyFactory.createBuilder<TestDatabase, 'users'>(
         'users',
-        async (attrs, factory, db, faker) => {
+        async ({ attrs, faker }) => {
           return {
             name: `Generated User ${attrs.id}`,
             email: faker.internet.email().toLowerCase(),
@@ -392,7 +397,7 @@ describe('Testkit Integration Tests', () => {
 
       const postBuilder = KyselyFactory.createBuilder<TestDatabase, 'posts'>(
         'posts',
-        async (attrs, factory) => {
+        async ({ attrs, factory }) => {
           let userId = attrs.userId;
           if (!userId) {
             const user = await factory.insert('user');
@@ -445,3 +450,155 @@ describe('Testkit Integration Tests', () => {
     });
   });
 });
+
+describe('extendWithFixtures', () => {
+  // Create builders for use in extended fixtures
+  const builders = {
+    user: KyselyFactory.createBuilder<TestDatabase, 'users'>(
+      'users',
+      ({ faker }) => ({
+        name: faker.person.fullName(),
+        email: faker.internet.email().toLowerCase(),
+        role: 'user' as const,
+        createdAt: new Date(),
+        updatedAt: new Date(),
+      }),
+    ),
+    post: KyselyFactory.createBuilder<TestDatabase, 'posts'>(
+      'posts',
+      async ({ attrs, factory, faker }) => {
+        const userId = attrs.userId ?? (await factory.insert('user')).id;
+        return {
+          title: faker.lorem.sentence(),
+          content: faker.lorem.paragraphs(),
+          userId,
+          published: false,
+          createdAt: new Date(),
+          updatedAt: new Date(),
+        };
+      },
+    ),
+  };
+
+  // Create base test with transaction
+  const baseTest = wrapVitestKyselyTransaction<TestDatabase>(
+    base,
+    db,
+    createTestTables,
+  );
+
+  // Extend with factory fixture
+  const itWithFactory = extendWithFixtures<
+    TestDatabase,
+    { factory: KyselyFactory<TestDatabase, typeof builders, {}> }
+  >(baseTest, {
+    factory: (trx) => new KyselyFactory(builders, {}, trx),
+  });
+
+  itWithFactory(
+    'should provide factory fixture alongside trx',
+    async ({ trx, factory }) => {
+      // Both trx and factory should be available
+      expect(trx).toBeDefined();
+      expect(factory).toBeDefined();
+      expect(factory).toBeInstanceOf(KyselyFactory);
+
+      // Factory should work with the transaction
+      const user = await factory.insert('user', { name: 'Test User' });
+      expect(user.id).toBeDefined();
+      expect(user.name).toBe('Test User');
+
+      // Verify user exists in transaction
+      const found = await trx
+        .selectFrom('users')
+        .where('id', '=', user.id)
+        .selectAll()
+        .executeTakeFirst();
+
+      expect(found).toBeDefined();
+      expect(found?.name).toBe('Test User');
+    },
+  );
+
+  itWithFactory(
+    'should allow factory to create related records',
+    async ({ factory }) => {
+      // Create user first
+      const user = await factory.insert('user', {
+        name: 'Author',
+        email: 'author@example.com',
+      });
+
+      // Create posts for the user
+      const posts = await factory.insertMany(3, 'post', (idx: number) => ({
+        title: `Post ${idx + 1}`,
+        userId: user.id,
+        published: idx === 0,
+      }));
+
+      expect(posts).toHaveLength(3);
+      expect(posts[0].userId).toBe(user.id);
+      expect(posts[0].published).toBe(true);
+      expect(posts[1].published).toBe(false);
+    },
+  );
+
+  // Test with multiple fixtures
+  const itWithMultipleFixtures = extendWithFixtures<
+    TestDatabase,
+    {
+      factory: KyselyFactory<TestDatabase, typeof builders, {}>;
+      userCount: number;
+    }
+  >(baseTest, {
+    factory: (trx) => new KyselyFactory(builders, {}, trx),
+    userCount: () => 42, // Simple fixture that doesn't use trx
+  });
+
+  itWithMultipleFixtures(
+    'should support multiple fixtures',
+    async ({ trx, factory, userCount }) => {
+      expect(trx).toBeDefined();
+      expect(factory).toBeInstanceOf(KyselyFactory);
+      expect(userCount).toBe(42);
+
+      // Use the factory
+      const user = await factory.insert('user');
+      expect(user.id).toBeDefined();
+    },
+  );
+
+  // Test async fixture creators
+  const itWithAsyncFixture = extendWithFixtures<
+    TestDatabase,
+    { initialUser: Awaited<ReturnType<typeof builders.user>> }
+  >(baseTest, {
+    initialUser: async (trx) => {
+      // Create a user directly in the fixture
+      const factory = new KyselyFactory(builders, {}, trx);
+      return factory.insert('user', {
+        name: 'Initial User',
+        email: 'initial@example.com',
+      });
+    },
+  });
+
+  itWithAsyncFixture(
+    'should support async fixture creators',
+    async ({ trx, initialUser }) => {
+      expect(initialUser).toBeDefined();
+      expect(initialUser.name).toBe('Initial User');
+      expect(initialUser.email).toBe('initial@example.com');
+
+      // Verify user exists in database
+      const found = await trx
+        .selectFrom('users')
+        .where('id', '=', initialUser.id)
+        .selectAll()
+        .executeTakeFirst();
+
+      expect(found).toBeDefined();
+      expect(found?.id).toBe(initialUser.id);
+    },
+  );
+});