@geekmidas/testkit 0.0.3 → 0.0.4

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@geekmidas/testkit",
-  "version": "0.0.3",
+  "version": "0.0.4",
   "private": false,
   "type": "module",
   "exports": {
@@ -13,6 +13,11 @@
       "types": "./src/kysely.ts",
       "import": "./dist/kysely.mjs",
       "require": "./dist/kysely.cjs"
+    },
+    "./faker": {
+      "types": "./src/faker.ts",
+      "import": "./dist/faker.mjs",
+      "require": "./dist/faker.cjs"
     }
   },
   "dependencies": {
@@ -31,6 +36,6 @@
     "knex": "~3.1.0",
     "objection": "~3.1.5",
     "db-errors": "~0.2.3",
-    "@geekmidas/envkit": "0.0.2"
+    "@geekmidas/envkit": "0.0.3"
   }
 }

package/src/Factory.ts

@@ -1,3 +1,5 @@
+import type { FakerFactory } from './faker';
+
 export abstract class Factory<
   Builders extends Record<string, any>,
   Seeds extends Record<string, any>,
@@ -28,7 +30,7 @@ export abstract class Factory<
     builderName: K,
     attrs?:
       | Parameters<Builders[K]>[0]
-      | ((idx: number) => Parameters<Builders[K]>[0]),
+      | ((idx: number, faker: FakerFactory) => Parameters<Builders[K]>[0]),
   ): Promise<Awaited<ReturnType<Builders[K]>>[]>;
 
   /**

package/src/KyselyFactory.ts

@@ -5,6 +5,7 @@ import type {
   Selectable,
 } from 'kysely';
 import { Factory, type FactorySeed } from './Factory.ts';
+import { type FakerFactory, faker } from './faker.ts';
 
 export class KyselyFactory<
   DB,
@@ -31,67 +32,55 @@ export class KyselyFactory<
     >,
     Factory = any,
     Result = Selectable<DB[TableName]>,
-  >(config: {
-    table: TableName;
-    defaults?: (
+  >(
+    table: TableName,
+    item?: (
       attrs: Attrs,
       factory: Factory,
       db: Kysely<DB>,
+      faker: FakerFactory,
     ) =>
       | Partial<Insertable<DB[TableName]>>
-      | Promise<Partial<Insertable<DB[TableName]>>>;
-    transform?: (
-      data: Partial<Insertable<DB[TableName]>>,
-      factory: Factory,
-      db: Kysely<DB>,
-    ) =>
-      | Partial<Insertable<DB[TableName]>>
-      | Promise<Partial<Insertable<DB[TableName]>>>;
-    relations?: (
-      record: Result,
+      | Promise<Partial<Insertable<DB[TableName]>>>,
+    autoInsert?: boolean,
+  ): (
+    attrs: Attrs,
+    factory: Factory,
+    db: Kysely<DB>,
+    faker: FakerFactory,
+  ) => Promise<Result> {
+    return async (
       attrs: Attrs,
       factory: Factory,
       db: Kysely<DB>,
-    ) => Promise<void>;
-    autoInsert?: boolean;
-  }): (attrs: Attrs, factory: Factory, db: Kysely<DB>) => Promise<Result> {
-    return async (attrs: Attrs, factory: Factory, db: Kysely<DB>) => {
+      faker: FakerFactory,
+    ) => {
       // Start with attributes
       let data: Partial<Insertable<DB[TableName]>> = { ...attrs };
 
       // Apply defaults
-      if (config.defaults) {
-        const defaults = await config.defaults(attrs, factory, db);
+      if (item) {
+        const defaults = await item(attrs, factory, db, faker);
         data = { ...defaults, ...data };
       }
 
-      // Apply transformations
-      if (config.transform) {
-        data = await config.transform(data, factory, db);
-      }
-
       // Handle insertion based on autoInsert flag
-      if (config.autoInsert !== false) {
+      if (autoInsert !== false) {
         // Auto insert is enabled by default
         const result = await db
-          .insertInto(config.table)
+          .insertInto(table)
           .values(data as Insertable<DB[TableName]>)
           .returningAll()
           .executeTakeFirst();
 
         if (!result) {
-          throw new Error(`Failed to insert into ${config.table}`);
-        }
-
-        // Handle relations if defined
-        if (config.relations) {
-          await config.relations(result as Result, attrs, factory, db);
+          throw new Error(`Failed to insert into ${table}`);
         }
 
         return result as Result;
       } else {
         // Return object for factory to handle insertion
-        return { table: config.table, data } as any;
+        return { table, data } as any;
       }
     };
   }
@@ -108,7 +97,12 @@ export class KyselyFactory<
       );
     }
 
-    const result = await this.builders[builderName](attrs || {}, this, this.db);
+    const result = await this.builders[builderName](
+      attrs || {},
+      this,
+      this.db,
+      faker,
+    );
 
     // For Kysely, we expect the builder to return an object with table and data properties
     // or to handle the insertion itself and return the inserted record
@@ -141,7 +135,7 @@ export class KyselyFactory<
   async insertMany<K extends keyof Builders>(
     count: number,
     builderName: K,
-    attrs: (idx: number) => Parameters<Builders[K]>[0],
+    attrs: (idx: number, faker: FakerFactory) => Parameters<Builders[K]>[0],
   ): Promise<Awaited<ReturnType<Builders[K]>>[]>;
   async insertMany<K extends keyof Builders>(
     count: number,
@@ -159,7 +153,7 @@ export class KyselyFactory<
     const promises: Promise<any>[] = [];
 
     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));
     }
 

package/src/VitestKyselyTransactionIsolator.ts

@@ -0,0 +1,23 @@
+import type { Kysely, Transaction } from 'kysely';
+import {
+  type IsolationLevel,
+  VitestPostgresTransactionIsolator,
+} from './VitestTransactionIsolator';
+
+export class VitestKyselyTransactionIsolator<
+  Database,
+> extends VitestPostgresTransactionIsolator<
+  Kysely<Database>,
+  Transaction<Database>
+> {
+  async transact(
+    conn: Kysely<Database>,
+    level: IsolationLevel,
+    fn: (trx: Transaction<Database>) => Promise<void>,
+  ): Promise<void> {
+    const isolationLevel =
+      level.toLocaleLowerCase() as Lowercase<IsolationLevel>;
+    await conn.transaction().setIsolationLevel(isolationLevel).execute(fn);
+  }
+  // Implement any Kysely-specific transaction logic here
+}

package/src/VitestTransactionIsolator.ts

@@ -0,0 +1,70 @@
+import { test as base } from 'vitest';
+
+export interface DatabaseFixtures<Transaction> {
+  trx: Transaction;
+}
+
+export enum IsolationLevel {
+  READ_UNCOMMITTED = 'READ UNCOMMITTED',
+  READ_COMMITTED = 'READ COMMITTED',
+  REPEATABLE_READ = 'REPEATABLE READ',
+  SERIALIZABLE = 'SERIALIZABLE',
+}
+
+export abstract class VitestPostgresTransactionIsolator<
+  Connection,
+  Transaction,
+> {
+  abstract transact(
+    conn: Connection,
+    isolationLevel: IsolationLevel,
+    fn: (trx: Transaction) => Promise<void>,
+  ): Promise<void>;
+
+  wrapVitestWithTransaction(
+    conn: Connection,
+    setup?: (trx: Transaction) => Promise<void>,
+    level: IsolationLevel = IsolationLevel.REPEATABLE_READ,
+  ) {
+    return base.extend<DatabaseFixtures<Transaction>>({
+      // This fixture automatically provides a transaction to each test
+      trx: async ({}, use) => {
+        // Create a custom error class for rollback
+        class TestRollback extends Error {
+          constructor() {
+            super('Test rollback');
+            this.name = 'TestRollback';
+          }
+        }
+
+        let testError: Error | undefined;
+
+        try {
+          await this.transact(conn, level, async (transaction) => {
+            try {
+              // Provide the transaction to the test
+              await setup?.(transaction);
+              await use(transaction);
+            } catch (error) {
+              // Capture any test errors
+              testError = error as Error;
+            }
+
+            // Always throw to trigger rollback
+            throw new TestRollback();
+          });
+        } catch (error) {
+          // Only rethrow if it's not our rollback error
+          if (!(error instanceof TestRollback)) {
+            throw error;
+          }
+
+          // If the test had an error, throw it now
+          if (testError) {
+            throw testError;
+          }
+        }
+      },
+    });
+  }
+}

package/src/__tests__/Factory.spec.ts

@@ -0,0 +1,164 @@
+import { beforeEach, describe, expect, it } from 'vitest';
+import {
+  Factory,
+  type FactorySeed,
+  type MixedFactoryBuilder,
+} from '../Factory';
+
+// Create a concrete implementation for testing
+class TestFactory extends Factory<
+  { testBuilder: (attrs: any) => any },
+  { testSeed: (attrs: any, factory: any, db: any) => any }
+> {
+  async insert(builderName: any, attrs?: any) {
+    return Promise.resolve({ id: 1, ...attrs });
+  }
+
+  async insertMany(count: number, builderName: any, attrs?: any) {
+    const results: any[] = [];
+    for (let i = 0; i < count; i++) {
+      const newAttrs = typeof attrs === 'function' ? attrs(i) : attrs;
+      results.push(await this.insert(builderName, newAttrs));
+    }
+    return results;
+  }
+
+  seed(seedName: any, attrs?: any): any {
+    return Promise.resolve({ seedResult: true, ...attrs });
+  }
+}
+
+describe('Factory', () => {
+  describe('abstract class functionality', () => {
+    it('should be instantiable through concrete implementation', () => {
+      const factory = new TestFactory();
+      expect(factory).toBeInstanceOf(Factory);
+      expect(factory).toBeInstanceOf(TestFactory);
+    });
+
+    it('should have abstract methods defined', () => {
+      const factory = new TestFactory();
+      expect(typeof factory.insert).toBe('function');
+      expect(typeof factory.insertMany).toBe('function');
+      expect(typeof factory.seed).toBe('function');
+    });
+  });
+
+  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' };
+      };
+
+      const result = Factory.createSeed(seedFn);
+
+      expect(result).toBe(seedFn);
+      expect(typeof result).toBe('function');
+    });
+
+    it('should work with different seed function signatures', () => {
+      const simpleSeed = () => Promise.resolve({ simple: true });
+      const complexSeed = async (
+        attrs: { name: string },
+        factory: any,
+        db: any,
+      ) => {
+        return { name: attrs.name, created: true };
+      };
+
+      const result1 = Factory.createSeed(simpleSeed);
+      const result2 = Factory.createSeed(complexSeed);
+
+      expect(result1).toBe(simpleSeed);
+      expect(result2).toBe(complexSeed);
+    });
+  });
+
+  describe('concrete implementation behavior', () => {
+    let factory: TestFactory;
+
+    beforeEach(() => {
+      factory = new TestFactory();
+    });
+
+    it('should implement insert method', async () => {
+      const result = await factory.insert('testBuilder', { name: 'test' });
+      expect(result).toEqual({ id: 1, name: 'test' });
+    });
+
+    it('should implement insertMany method', async () => {
+      const results = await factory.insertMany(3, 'testBuilder', {
+        name: 'test',
+      });
+      expect(results).toHaveLength(3);
+      expect(results[0]).toEqual({ id: 1, name: 'test' });
+    });
+
+    it('should implement insertMany with function attributes', async () => {
+      const results = await factory.insertMany(2, 'testBuilder', (idx) => ({
+        name: `test${idx}`,
+      }));
+      expect(results).toHaveLength(2);
+      expect(results[0]).toEqual({ id: 1, name: 'test0' });
+      expect(results[1]).toEqual({ id: 1, name: 'test1' });
+    });
+
+    it('should implement seed method', async () => {
+      const result = await factory.seed('testSeed', { custom: 'value' });
+      expect(result).toEqual({ seedResult: true, custom: 'value' });
+    });
+  });
+
+  describe('type definitions', () => {
+    it('should properly type MixedFactoryBuilder', () => {
+      // Test that the type allows both sync and async returns
+      const syncBuilder: MixedFactoryBuilder = (attrs, factory, db) => ({
+        sync: true,
+      });
+      const asyncBuilder: MixedFactoryBuilder = async (attrs, factory, db) => ({
+        async: true,
+      });
+
+      expect(typeof syncBuilder).toBe('function');
+      expect(typeof asyncBuilder).toBe('function');
+    });
+
+    it('should properly type FactorySeed', () => {
+      // Test that FactorySeed requires async return
+      const seed: FactorySeed = async (attrs, factory, db) => ({
+        seeded: true,
+      });
+
+      expect(typeof seed).toBe('function');
+    });
+  });
+});
+
+// Test the type exports
+describe('Factory types', () => {
+  it('should export MixedFactoryBuilder type', () => {
+    const builder: MixedFactoryBuilder<
+      { name: string },
+      TestFactory,
+      { id: number; name: string },
+      any
+    > = (attrs, factory, db) => {
+      return { id: 1, name: attrs.name };
+    };
+
+    expect(typeof builder).toBe('function');
+  });
+
+  it('should export FactorySeed type', () => {
+    const seed: FactorySeed<
+      { count: number },
+      TestFactory,
+      { created: number },
+      any
+    > = async (attrs, factory, db) => {
+      return { created: attrs.count };
+    };
+
+    expect(typeof seed).toBe('function');
+  });
+});