@geekmidas/testkit 0.0.17 → 0.1.1

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__/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);
+    },
+  );
+});

package/src/better-auth.ts

@@ -65,22 +65,24 @@ function matchesWhere(record: any, where?: Where[]): boolean {
         matches = recordValue !== value;
         break;
       case 'lt':
-        matches = recordValue < value;
+        matches = value != null && recordValue < value;
         break;
       case 'lte':
-        matches = recordValue <= value;
+        matches = value != null && recordValue <= value;
         break;
       case 'gt':
-        matches = recordValue > value;
+        matches = value != null && recordValue > value;
         break;
       case 'gte':
-        matches = recordValue >= value;
+        matches = value != null && recordValue >= value;
         break;
       case 'in':
-        matches = Array.isArray(value) && value.includes(recordValue);
+        matches =
+          Array.isArray(value) && (value as unknown[]).includes(recordValue);
         break;
       case 'not_in':
-        matches = Array.isArray(value) && !value.includes(recordValue);
+        matches =
+          Array.isArray(value) && !(value as unknown[]).includes(recordValue);
         break;
       case 'contains':
         matches =
@@ -207,7 +209,7 @@ export const memoryAdapter = (
         return null;
       },
 
-      findMany: async ({ where, model, limit, offset, sortBy, select }) => {
+      findMany: async ({ where, model, limit, offset, sortBy }) => {
         debugLog('FIND_MANY', { model, where });
 
         const modelName = getModelName(model);
@@ -230,15 +232,11 @@ export const memoryAdapter = (
         }
 
         return Promise.all(
-          results.map(async (record) => {
-            const transformed = await transformOutput(record, model, select);
-
-            return transformed;
-          }),
-        );
+          results.map((record) => transformOutput(record, model)),
+        ) as any;
       },
 
-      update: async ({ where, update, model, select }) => {
+      update: async ({ where, update, model }) => {
         debugLog('UPDATE', { model, where });
 
         const modelName = getModelName(model);
@@ -254,7 +252,7 @@ export const memoryAdapter = (
             );
             const updated = { ...record, ...transformedData };
             modelData.set(id, updated);
-            return transformOutput(updated, model, select) as any;
+            return transformOutput(updated, model) as any;
           }
         }
         return null;

package/src/kysely.ts

@@ -3,7 +3,9 @@ import type { TestAPI } from 'vitest';
 import { VitestKyselyTransactionIsolator } from './VitestKyselyTransactionIsolator';
 import {
   type DatabaseConnection,
+  type FixtureCreators,
   IsolationLevel,
+  extendWithFixtures as baseExtendWithFixtures,
 } from './VitestTransactionIsolator';
 
 /**
@@ -15,6 +17,15 @@ export { KyselyFactory } from './KyselyFactory';
 export { PostgresKyselyMigrator } from './PostgresKyselyMigrator';
 export { VitestKyselyTransactionIsolator } from './VitestKyselyTransactionIsolator';
 export { IsolationLevel } from './VitestTransactionIsolator';
+export type {
+  DatabaseFixtures,
+  ExtendedDatabaseFixtures,
+  FixtureCreators,
+  TestWithExtendedFixtures,
+} from './VitestTransactionIsolator';
+
+// Re-export faker and FakerFactory for type portability in declaration files
+export { faker, type FakerFactory } from './faker';
 
 /**
  * Creates a wrapped Vitest test API with automatic transaction rollback for Kysely.
@@ -82,3 +93,63 @@ export function wrapVitestKyselyTransaction<Database>(
 
   return wrapper.wrapVitestWithTransaction(connection, setup, level);
 }
+
+/**
+ * Extends a Kysely transaction-wrapped test with additional fixtures.
+ * Each fixture receives the transaction and can create dependencies like factories or repositories.
+ *
+ * @template Database - The database schema type
+ * @template Extended - The type of additional fixtures to provide
+ * @param wrappedTest - The base wrapped test from wrapVitestKyselyTransaction
+ * @param fixtures - Object mapping fixture names to creator functions
+ * @returns An extended test API with both trx and the additional fixtures
+ *
+ * @example
+ * ```typescript
+ * import { test } from 'vitest';
+ * import { wrapVitestKyselyTransaction, extendWithFixtures, KyselyFactory } from '@geekmidas/testkit/kysely';
+ *
+ * // Define your builders
+ * const builders = {
+ *   user: KyselyFactory.createBuilder<DB, 'users'>('users', ({ faker }) => ({
+ *     name: faker.person.fullName(),
+ *     email: faker.internet.email(),
+ *   })),
+ * };
+ *
+ * // Create base wrapped test
+ * const baseTest = wrapVitestKyselyTransaction<DB>(test, db, createTestTables);
+ *
+ * // Extend with fixtures - each fixture receives the transaction
+ * const it = extendWithFixtures<DB, { factory: KyselyFactory<DB, typeof builders, {}> }>(
+ *   baseTest,
+ *   {
+ *     factory: (trx) => new KyselyFactory(builders, {}, trx),
+ *   }
+ * );
+ *
+ * // Use in tests - both trx and factory are available
+ * it('should create user with factory', async ({ trx, factory }) => {
+ *   const user = await factory.insert('user', { name: 'Test User' });
+ *   expect(user.id).toBeDefined();
+ *
+ *   // Verify in database
+ *   const found = await trx
+ *     .selectFrom('users')
+ *     .where('id', '=', user.id)
+ *     .selectAll()
+ *     .executeTakeFirst();
+ *   expect(found?.name).toBe('Test User');
+ * });
+ * ```
+ */
+export function extendWithFixtures<
+  Database,
+  Extended extends Record<string, unknown>,
+  T extends ReturnType<TestAPI['extend']> = ReturnType<TestAPI['extend']>,
+>(wrappedTest: T, fixtures: FixtureCreators<Transaction<Database>, Extended>) {
+  return baseExtendWithFixtures<Transaction<Database>, Extended, T>(
+    wrappedTest,
+    fixtures,
+  );
+}

package/src/objection.ts

@@ -3,7 +3,9 @@ import type { TestAPI } from 'vitest';
 import { VitestObjectionTransactionIsolator } from './VitestObjectionTransactionIsolator';
 import {
   type DatabaseConnection,
+  type FixtureCreators,
   IsolationLevel,
+  extendWithFixtures as baseExtendWithFixtures,
 } from './VitestTransactionIsolator';
 
 /**
@@ -16,6 +18,15 @@ export { ObjectionFactory } from './ObjectionFactory';
 export { VitestObjectionTransactionIsolator } from './VitestObjectionTransactionIsolator';
 export { IsolationLevel } from './VitestTransactionIsolator';
 export { PostgresObjectionMigrator } from './PostgresObjectionMigrator';
+export type {
+  DatabaseFixtures,
+  ExtendedDatabaseFixtures,
+  FixtureCreators,
+  TestWithExtendedFixtures,
+} from './VitestTransactionIsolator';
+
+// Re-export faker and FakerFactory for type portability in declaration files
+export { faker, type FakerFactory } from './faker';
 
 /**
  * Creates a wrapped Vitest test API with automatic transaction rollback for Objection.js.
@@ -98,3 +109,58 @@ export function wrapVitestObjectionTransaction(
 
   return wrapper.wrapVitestWithTransaction(conn, setup, level);
 }
+
+/**
+ * Extends an Objection.js transaction-wrapped test with additional fixtures.
+ * Each fixture receives the transaction and can create dependencies like factories or repositories.
+ *
+ * @template Extended - The type of additional fixtures to provide
+ * @param wrappedTest - The base wrapped test from wrapVitestObjectionTransaction
+ * @param fixtures - Object mapping fixture names to creator functions
+ * @returns An extended test API with both trx and the additional fixtures
+ *
+ * @example
+ * ```typescript
+ * import { test } from 'vitest';
+ * import { wrapVitestObjectionTransaction, extendWithFixtures, ObjectionFactory } from '@geekmidas/testkit/objection';
+ * import { User } from './models';
+ *
+ * // Define your builders
+ * const builders = {
+ *   user: ObjectionFactory.createBuilder(User, ({ faker }) => ({
+ *     name: faker.person.fullName(),
+ *     email: faker.internet.email(),
+ *   })),
+ * };
+ *
+ * // Create base wrapped test
+ * const baseTest = wrapVitestObjectionTransaction(test, knex, createTestTables);
+ *
+ * // Extend with fixtures - each fixture receives the transaction
+ * const it = extendWithFixtures<{ factory: ObjectionFactory<typeof builders, {}> }>(
+ *   baseTest,
+ *   {
+ *     factory: (trx) => new ObjectionFactory(builders, {}, trx),
+ *   }
+ * );
+ *
+ * // Use in tests - both trx and factory are available
+ * it('should create user with factory', async ({ trx, factory }) => {
+ *   const user = await factory.insert('user', { name: 'Test User' });
+ *   expect(user.id).toBeDefined();
+ *
+ *   // Verify in database
+ *   const found = await User.query(trx).findById(user.id);
+ *   expect(found?.name).toBe('Test User');
+ * });
+ * ```
+ */
+export function extendWithFixtures<
+  Extended extends Record<string, unknown>,
+  T extends ReturnType<TestAPI['extend']> = ReturnType<TestAPI['extend']>,
+>(wrappedTest: T, fixtures: FixtureCreators<Knex.Transaction, Extended>) {
+  return baseExtendWithFixtures<Knex.Transaction, Extended, T>(
+    wrappedTest,
+    fixtures,
+  );
+}