@geekmidas/testkit 0.0.17 → 0.1.0

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,10 @@ export { KyselyFactory } from './KyselyFactory';
 export { PostgresKyselyMigrator } from './PostgresKyselyMigrator';
 export { VitestKyselyTransactionIsolator } from './VitestKyselyTransactionIsolator';
 export { IsolationLevel } from './VitestTransactionIsolator';
+export type { FixtureCreators } 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 +88,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,10 @@ export { ObjectionFactory } from './ObjectionFactory';
 export { VitestObjectionTransactionIsolator } from './VitestObjectionTransactionIsolator';
 export { IsolationLevel } from './VitestTransactionIsolator';
 export { PostgresObjectionMigrator } from './PostgresObjectionMigrator';
+export type { FixtureCreators } 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 +104,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,
+  );
+}

package/dist/KyselyFactory-BcYkC0t2.mjs.map

@@ -1 +0,0 @@
-{"version":3,"file":"KyselyFactory-BcYkC0t2.mjs","names":["seedFn: Seed","builders: Builders","seeds: Seeds","db: Kysely<DB> | ControlledTransaction<DB, []>","table: TableName","item?: (\n      attrs: Attrs,\n      factory: Factory,\n      db: Kysely<DB>,\n      faker: FakerFactory,\n    ) =>\n      | Partial<Insertable<DB[TableName]>>\n      | Promise<Partial<Insertable<DB[TableName]>>>","autoInsert?: boolean","attrs: Attrs","factory: Factory","db: Kysely<DB>","faker: FakerFactory","data: Partial<Insertable<DB[TableName]>>","faker","builderName: K","attrs?: Parameters<Builders[K]>[0]","count: number","attrs?: any","promises: Promise<any>[]","seedName: K","attrs?: Parameters<Seeds[K]>[0]"],"sources":["../src/KyselyFactory.ts"],"sourcesContent":["import type {\n  ControlledTransaction,\n  Insertable,\n  Kysely,\n  Selectable,\n} from 'kysely';\nimport { Factory, type FactorySeed } from './Factory.ts';\nimport { type FakerFactory, faker } from './faker.ts';\n\n/**\n * Factory implementation for Kysely ORM, providing test data creation utilities.\n * Extends the base Factory class with Kysely-specific database operations.\n *\n * @template DB - The database schema type\n * @template Builders - Record of builder functions for creating entities\n * @template Seeds - Record of seed functions for complex test scenarios\n *\n * @example\n * ```typescript\n * // Define your database schema\n * interface Database {\n *   users: UsersTable;\n *   posts: PostsTable;\n * }\n *\n * // Create builders\n * const builders = {\n *   user: KyselyFactory.createBuilder<Database, 'users'>('users', (attrs, factory, db, faker) => ({\n *     id: faker.string.uuid(),\n *     name: faker.person.fullName(),\n *     email: faker.internet.email(),\n *     ...attrs\n *   })),\n *   post: KyselyFactory.createBuilder<Database, 'posts'>('posts', (attrs) => ({\n *     title: 'Test Post',\n *     content: 'Test content',\n *     ...attrs\n *   }))\n * };\n *\n * // Create factory instance\n * const factory = new KyselyFactory(builders, seeds, db);\n *\n * // Use in tests\n * const user = await factory.insert('user', { name: 'John Doe' });\n * ```\n */\nexport class KyselyFactory<\n  DB,\n  Builders extends Record<string, any>,\n  Seeds extends Record<string, any>,\n> extends Factory<Builders, Seeds> {\n  /**\n   * Creates a typed seed function with proper type inference.\n   * Inherits from the base Factory class implementation.\n   *\n   * @template Seed - The seed function type\n   * @param seedFn - The seed function to wrap\n   * @returns The same seed function with proper typing\n   */\n  static createSeed<Seed extends FactorySeed>(seedFn: Seed): Seed {\n    return Factory.createSeed(seedFn);\n  }\n\n  /**\n   * Creates a new KyselyFactory instance.\n   *\n   * @param builders - Record of builder functions for creating individual entities\n   * @param seeds - Record of seed functions for creating complex test scenarios\n   * @param db - Kysely database instance or controlled transaction\n   */\n  constructor(\n    private builders: Builders,\n    private seeds: Seeds,\n    private db: Kysely<DB> | ControlledTransaction<DB, []>,\n  ) {\n    super();\n  }\n\n  /**\n   * Creates a typed builder function for a specific database table.\n   * This is a utility method that helps create builders with proper type inference for Kysely.\n   *\n   * @template DB - The database schema type\n   * @template TableName - The name of the table (must be a key of DB)\n   * @template Attrs - The attributes type for the builder (defaults to Partial<Insertable>)\n   * @template Factory - The factory instance type\n   * @template Result - The result type (defaults to Selectable of the table)\n   *\n   * @param table - The name of the database table\n   * @param item - Optional function to provide default values and transformations\n   * @param autoInsert - Whether to automatically insert the record (default: true)\n   * @returns A builder function that creates and optionally inserts records\n   *\n   * @example\n   * ```typescript\n   * // Create a simple builder with defaults\n   * const userBuilder = KyselyFactory.createBuilder<DB, 'users'>('users',\n   *   (attrs, factory, db, faker) => ({\n   *     id: faker.string.uuid(),\n   *     name: faker.person.fullName(),\n   *     email: faker.internet.email(),\n   *     createdAt: new Date(),\n   *     ...attrs\n   *   })\n   * );\n   *\n   * // Create a builder that doesn't auto-insert (useful for nested inserts)\n   * const addressBuilder = KyselyFactory.createBuilder<DB, 'addresses'>('addresses',\n   *   (attrs) => ({\n   *     street: '123 Main St',\n   *     city: 'Anytown',\n   *     ...attrs\n   *   }),\n   *   false // Don't auto-insert\n   * );\n   * ```\n   */\n  static createBuilder<\n    DB,\n    TableName extends keyof DB & string,\n    Attrs extends Partial<Insertable<DB[TableName]>> = Partial<\n      Insertable<DB[TableName]>\n    >,\n    Factory = any,\n    Result = Selectable<DB[TableName]>,\n  >(\n    table: TableName,\n    item?: (\n      attrs: Attrs,\n      factory: Factory,\n      db: Kysely<DB>,\n      faker: FakerFactory,\n    ) =>\n      | Partial<Insertable<DB[TableName]>>\n      | Promise<Partial<Insertable<DB[TableName]>>>,\n    autoInsert?: boolean,\n  ): (\n    attrs: Attrs,\n    factory: Factory,\n    db: Kysely<DB>,\n    faker: FakerFactory,\n  ) => Promise<Result> {\n    return async (\n      attrs: Attrs,\n      factory: Factory,\n      db: Kysely<DB>,\n      faker: FakerFactory,\n    ) => {\n      // Start with attributes\n      let data: Partial<Insertable<DB[TableName]>> = { ...attrs };\n\n      // Apply defaults\n      if (item) {\n        const defaults = await item(attrs, factory, db, faker);\n        data = { ...defaults, ...data };\n      }\n\n      // Handle insertion based on autoInsert flag\n      if (autoInsert !== false) {\n        // Auto insert is enabled by default\n        const result = await db\n          .insertInto(table)\n          .values(data as Insertable<DB[TableName]>)\n          .returningAll()\n          .executeTakeFirst();\n\n        if (!result) {\n          throw new Error(`Failed to insert into ${table}`);\n        }\n\n        return result as Result;\n      } else {\n        // Return object for factory to handle insertion\n        return { table, data } as any;\n      }\n    };\n  }\n\n  /**\n   * Inserts a single record into the database using the specified builder.\n   * The builder function is responsible for generating the record data with defaults\n   * and the factory handles the actual database insertion.\n   *\n   * @template K - The builder name (must be a key of Builders)\n   * @param builderName - The name of the builder to use\n   * @param attrs - Optional attributes to override builder defaults\n   * @returns A promise resolving to the inserted record\n   * @throws Error if the specified builder doesn't exist\n   *\n   * @example\n   * ```typescript\n   * // Insert with defaults\n   * const user = await factory.insert('user');\n   *\n   * // Insert with overrides\n   * const adminUser = await factory.insert('user', {\n   *   email: 'admin@example.com',\n   *   role: 'admin'\n   * });\n   *\n   * // Use the inserted record\n   * const post = await factory.insert('post', {\n   *   userId: user.id,\n   *   title: 'My First Post'\n   * });\n   * ```\n   */\n  async insert<K extends keyof Builders>(\n    builderName: K,\n    attrs?: Parameters<Builders[K]>[0],\n  ): Promise<Awaited<ReturnType<Builders[K]>>> {\n    if (!(builderName in this.builders)) {\n      throw new Error(\n        `Factory \"${\n          builderName as string\n        }\" does not exist. Make sure it is correct and registered in src/test/setup.ts`,\n      );\n    }\n\n    const result = await this.builders[builderName](\n      attrs || {},\n      this,\n      this.db,\n      faker,\n    );\n\n    // For Kysely, we expect the builder to return an object with table and data properties\n    // or to handle the insertion itself and return the inserted record\n    if (\n      result &&\n      typeof result === 'object' &&\n      'table' in result &&\n      'data' in result\n    ) {\n      // If the builder returns {table: string, data: object}, we insert it\n      const inserted = await this.db\n        .insertInto(result.table)\n        .values(result.data)\n        .returningAll()\n        .executeTakeFirst();\n\n      return inserted as any;\n    }\n\n    // Otherwise, assume the builder handled the insertion itself\n    return result;\n  }\n\n  /**\n   * Inserts multiple records into the database using the specified builder.\n   * Supports both static attributes and dynamic attribute generation via a function.\n   *\n   * @template K - The builder name (must be a key of Builders)\n   * @param count - The number of records to insert\n   * @param builderName - The name of the builder to use\n   * @param attrs - Static attributes or a function that generates attributes for each record\n   * @returns A promise resolving to an array of inserted records\n   * @throws Error if the specified builder doesn't exist\n   *\n   * @example\n   * ```typescript\n   * // Insert multiple with same attributes\n   * const users = await factory.insertMany(5, 'user', { role: 'member' });\n   *\n   * // Insert multiple with dynamic attributes\n   * const posts = await factory.insertMany(10, 'post', (idx, faker) => ({\n   *   title: `Post ${idx + 1}`,\n   *   content: faker.lorem.paragraph(),\n   *   publishedAt: faker.date.past()\n   * }));\n   *\n   * // Create users with sequential emails\n   * const admins = await factory.insertMany(3, 'user', (idx) => ({\n   *   email: `admin${idx + 1}@example.com`,\n   *   role: 'admin'\n   * }));\n   * ```\n   */\n  // Method overloads for better type inference\n  async insertMany<K extends keyof Builders>(\n    count: number,\n    builderName: K,\n    attrs?: Parameters<Builders[K]>[0],\n  ): Promise<Awaited<ReturnType<Builders[K]>>[]>;\n  async insertMany<K extends keyof Builders>(\n    count: number,\n    builderName: K,\n    attrs: (\n      idx: number,\n      faker: FakerFactory,\n    ) => Parameters<Builders[K]>[0] | Promise<Parameters<Builders[K]>[0]>,\n  ): Promise<Awaited<ReturnType<Builders[K]>>[]>;\n  async insertMany<K extends keyof Builders>(\n    count: number,\n    builderName: K,\n    attrs?: any,\n  ): Promise<Awaited<ReturnType<Builders[K]>>[]> {\n    if (!(builderName in this.builders)) {\n      throw new Error(\n        `Builder \"${\n          builderName as string\n        }\" is not registered in this factory. Make sure it is correct and registered in src/test/setup.ts`,\n      );\n    }\n\n    const promises: Promise<any>[] = [];\n\n    for (let i = 0; i < count; i++) {\n      const newAttrs =\n        typeof attrs === 'function' ? await attrs(i, faker) : attrs;\n      promises.push(this.insert(builderName, newAttrs));\n    }\n\n    return Promise.all(promises);\n  }\n\n  /**\n   * Executes a seed function to create complex test scenarios with multiple related records.\n   * Seeds are useful for setting up complete test environments with realistic data relationships.\n   *\n   * @template K - The seed name (must be a key of Seeds)\n   * @param seedName - The name of the seed to execute\n   * @param attrs - Optional configuration attributes for the seed\n   * @returns The result of the seed function (typically the primary record created)\n   * @throws Error if the specified seed doesn't exist\n   *\n   * @example\n   * ```typescript\n   * // Execute a simple seed\n   * const user = await factory.seed('userWithProfile');\n   *\n   * // Execute a seed with configuration\n   * const author = await factory.seed('authorWithBooks', {\n   *   bookCount: 5,\n   *   includeReviews: true\n   * });\n   *\n   * // Use seed result in tests\n   * const company = await factory.seed('companyWithDepartments', {\n   *   departmentCount: 3,\n   *   employeesPerDepartment: 10\n   * });\n   * expect(company.departments).toHaveLength(3);\n   * ```\n   */\n  seed<K extends keyof Seeds>(\n    seedName: K,\n    attrs?: Parameters<Seeds[K]>[0],\n  ): ReturnType<Seeds[K]> {\n    if (!(seedName in this.seeds)) {\n      throw new Error(\n        `Seed \"${\n          seedName as string\n        }\" is not registered in this factory. Make sure it is correct and registered in src/test/setup.ts`,\n      );\n    }\n\n    return this.seeds[seedName](attrs || {}, this, this.db);\n  }\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA+CA,IAAa,gBAAb,cAIU,QAAyB;;;;;;;;;CASjC,OAAO,WAAqCA,QAAoB;AAC9D,SAAO,QAAQ,WAAW,OAAO;CAClC;;;;;;;;CASD,YACUC,UACAC,OACAC,IACR;AACA,SAAO;EAJC;EACA;EACA;CAGT;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAyCD,OAAO,cASLC,OACAC,MAQAC,YAMmB;AACnB,SAAO,OACLC,OACAC,SACAC,IACAC,YACG;GAEH,IAAIC,OAA2C,EAAE,GAAG,MAAO;AAG3D,OAAI,MAAM;IACR,MAAM,WAAW,MAAM,KAAK,OAAO,SAAS,IAAIC,QAAM;AACtD,WAAO;KAAE,GAAG;KAAU,GAAG;IAAM;GAChC;AAGD,OAAI,eAAe,OAAO;IAExB,MAAM,SAAS,MAAM,GAClB,WAAW,MAAM,CACjB,OAAO,KAAkC,CACzC,cAAc,CACd,kBAAkB;AAErB,SAAK,OACH,OAAM,IAAI,OAAO,wBAAwB,MAAM;AAGjD,WAAO;GACR,MAEC,QAAO;IAAE;IAAO;GAAM;EAEzB;CACF;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA+BD,MAAM,OACJC,aACAC,OAC2C;AAC3C,QAAM,eAAe,KAAK,UACxB,OAAM,IAAI,OACP,WACC,YACD;EAIL,MAAM,SAAS,MAAM,KAAK,SAAS,aACjC,SAAS,CAAE,GACX,MACA,KAAK,IACL,MACD;AAID,MACE,iBACO,WAAW,YAClB,WAAW,UACX,UAAU,QACV;GAEA,MAAM,WAAW,MAAM,KAAK,GACzB,WAAW,OAAO,MAAM,CACxB,OAAO,OAAO,KAAK,CACnB,cAAc,CACd,kBAAkB;AAErB,UAAO;EACR;AAGD,SAAO;CACR;CA8CD,MAAM,WACJC,OACAF,aACAG,OAC6C;AAC7C,QAAM,eAAe,KAAK,UACxB,OAAM,IAAI,OACP,WACC,YACD;EAIL,MAAMC,WAA2B,CAAE;AAEnC,OAAK,IAAI,IAAI,GAAG,IAAI,OAAO,KAAK;GAC9B,MAAM,kBACG,UAAU,aAAa,MAAM,MAAM,GAAG,MAAM,GAAG;AACxD,YAAS,KAAK,KAAK,OAAO,aAAa,SAAS,CAAC;EAClD;AAED,SAAO,QAAQ,IAAI,SAAS;CAC7B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA+BD,KACEC,UACAC,OACsB;AACtB,QAAM,YAAY,KAAK,OACrB,OAAM,IAAI,OACP,QACC,SACD;AAIL,SAAO,KAAK,MAAM,UAAU,SAAS,CAAE,GAAE,MAAM,KAAK,GAAG;CACxD;AACF"}

package/dist/KyselyFactory-Cf0o2YxO.cjs.map

@@ -1 +0,0 @@
-{"version":3,"file":"KyselyFactory-Cf0o2YxO.cjs","names":["Factory","seedFn: Seed","builders: Builders","seeds: Seeds","db: Kysely<DB> | ControlledTransaction<DB, []>","table: TableName","item?: (\n      attrs: Attrs,\n      factory: Factory,\n      db: Kysely<DB>,\n      faker: FakerFactory,\n    ) =>\n      | Partial<Insertable<DB[TableName]>>\n      | Promise<Partial<Insertable<DB[TableName]>>>","autoInsert?: boolean","attrs: Attrs","factory: Factory","db: Kysely<DB>","faker: FakerFactory","data: Partial<Insertable<DB[TableName]>>","faker","builderName: K","attrs?: Parameters<Builders[K]>[0]","count: number","attrs?: any","promises: Promise<any>[]","seedName: K","attrs?: Parameters<Seeds[K]>[0]"],"sources":["../src/KyselyFactory.ts"],"sourcesContent":["import type {\n  ControlledTransaction,\n  Insertable,\n  Kysely,\n  Selectable,\n} from 'kysely';\nimport { Factory, type FactorySeed } from './Factory.ts';\nimport { type FakerFactory, faker } from './faker.ts';\n\n/**\n * Factory implementation for Kysely ORM, providing test data creation utilities.\n * Extends the base Factory class with Kysely-specific database operations.\n *\n * @template DB - The database schema type\n * @template Builders - Record of builder functions for creating entities\n * @template Seeds - Record of seed functions for complex test scenarios\n *\n * @example\n * ```typescript\n * // Define your database schema\n * interface Database {\n *   users: UsersTable;\n *   posts: PostsTable;\n * }\n *\n * // Create builders\n * const builders = {\n *   user: KyselyFactory.createBuilder<Database, 'users'>('users', (attrs, factory, db, faker) => ({\n *     id: faker.string.uuid(),\n *     name: faker.person.fullName(),\n *     email: faker.internet.email(),\n *     ...attrs\n *   })),\n *   post: KyselyFactory.createBuilder<Database, 'posts'>('posts', (attrs) => ({\n *     title: 'Test Post',\n *     content: 'Test content',\n *     ...attrs\n *   }))\n * };\n *\n * // Create factory instance\n * const factory = new KyselyFactory(builders, seeds, db);\n *\n * // Use in tests\n * const user = await factory.insert('user', { name: 'John Doe' });\n * ```\n */\nexport class KyselyFactory<\n  DB,\n  Builders extends Record<string, any>,\n  Seeds extends Record<string, any>,\n> extends Factory<Builders, Seeds> {\n  /**\n   * Creates a typed seed function with proper type inference.\n   * Inherits from the base Factory class implementation.\n   *\n   * @template Seed - The seed function type\n   * @param seedFn - The seed function to wrap\n   * @returns The same seed function with proper typing\n   */\n  static createSeed<Seed extends FactorySeed>(seedFn: Seed): Seed {\n    return Factory.createSeed(seedFn);\n  }\n\n  /**\n   * Creates a new KyselyFactory instance.\n   *\n   * @param builders - Record of builder functions for creating individual entities\n   * @param seeds - Record of seed functions for creating complex test scenarios\n   * @param db - Kysely database instance or controlled transaction\n   */\n  constructor(\n    private builders: Builders,\n    private seeds: Seeds,\n    private db: Kysely<DB> | ControlledTransaction<DB, []>,\n  ) {\n    super();\n  }\n\n  /**\n   * Creates a typed builder function for a specific database table.\n   * This is a utility method that helps create builders with proper type inference for Kysely.\n   *\n   * @template DB - The database schema type\n   * @template TableName - The name of the table (must be a key of DB)\n   * @template Attrs - The attributes type for the builder (defaults to Partial<Insertable>)\n   * @template Factory - The factory instance type\n   * @template Result - The result type (defaults to Selectable of the table)\n   *\n   * @param table - The name of the database table\n   * @param item - Optional function to provide default values and transformations\n   * @param autoInsert - Whether to automatically insert the record (default: true)\n   * @returns A builder function that creates and optionally inserts records\n   *\n   * @example\n   * ```typescript\n   * // Create a simple builder with defaults\n   * const userBuilder = KyselyFactory.createBuilder<DB, 'users'>('users',\n   *   (attrs, factory, db, faker) => ({\n   *     id: faker.string.uuid(),\n   *     name: faker.person.fullName(),\n   *     email: faker.internet.email(),\n   *     createdAt: new Date(),\n   *     ...attrs\n   *   })\n   * );\n   *\n   * // Create a builder that doesn't auto-insert (useful for nested inserts)\n   * const addressBuilder = KyselyFactory.createBuilder<DB, 'addresses'>('addresses',\n   *   (attrs) => ({\n   *     street: '123 Main St',\n   *     city: 'Anytown',\n   *     ...attrs\n   *   }),\n   *   false // Don't auto-insert\n   * );\n   * ```\n   */\n  static createBuilder<\n    DB,\n    TableName extends keyof DB & string,\n    Attrs extends Partial<Insertable<DB[TableName]>> = Partial<\n      Insertable<DB[TableName]>\n    >,\n    Factory = any,\n    Result = Selectable<DB[TableName]>,\n  >(\n    table: TableName,\n    item?: (\n      attrs: Attrs,\n      factory: Factory,\n      db: Kysely<DB>,\n      faker: FakerFactory,\n    ) =>\n      | Partial<Insertable<DB[TableName]>>\n      | Promise<Partial<Insertable<DB[TableName]>>>,\n    autoInsert?: boolean,\n  ): (\n    attrs: Attrs,\n    factory: Factory,\n    db: Kysely<DB>,\n    faker: FakerFactory,\n  ) => Promise<Result> {\n    return async (\n      attrs: Attrs,\n      factory: Factory,\n      db: Kysely<DB>,\n      faker: FakerFactory,\n    ) => {\n      // Start with attributes\n      let data: Partial<Insertable<DB[TableName]>> = { ...attrs };\n\n      // Apply defaults\n      if (item) {\n        const defaults = await item(attrs, factory, db, faker);\n        data = { ...defaults, ...data };\n      }\n\n      // Handle insertion based on autoInsert flag\n      if (autoInsert !== false) {\n        // Auto insert is enabled by default\n        const result = await db\n          .insertInto(table)\n          .values(data as Insertable<DB[TableName]>)\n          .returningAll()\n          .executeTakeFirst();\n\n        if (!result) {\n          throw new Error(`Failed to insert into ${table}`);\n        }\n\n        return result as Result;\n      } else {\n        // Return object for factory to handle insertion\n        return { table, data } as any;\n      }\n    };\n  }\n\n  /**\n   * Inserts a single record into the database using the specified builder.\n   * The builder function is responsible for generating the record data with defaults\n   * and the factory handles the actual database insertion.\n   *\n   * @template K - The builder name (must be a key of Builders)\n   * @param builderName - The name of the builder to use\n   * @param attrs - Optional attributes to override builder defaults\n   * @returns A promise resolving to the inserted record\n   * @throws Error if the specified builder doesn't exist\n   *\n   * @example\n   * ```typescript\n   * // Insert with defaults\n   * const user = await factory.insert('user');\n   *\n   * // Insert with overrides\n   * const adminUser = await factory.insert('user', {\n   *   email: 'admin@example.com',\n   *   role: 'admin'\n   * });\n   *\n   * // Use the inserted record\n   * const post = await factory.insert('post', {\n   *   userId: user.id,\n   *   title: 'My First Post'\n   * });\n   * ```\n   */\n  async insert<K extends keyof Builders>(\n    builderName: K,\n    attrs?: Parameters<Builders[K]>[0],\n  ): Promise<Awaited<ReturnType<Builders[K]>>> {\n    if (!(builderName in this.builders)) {\n      throw new Error(\n        `Factory \"${\n          builderName as string\n        }\" does not exist. Make sure it is correct and registered in src/test/setup.ts`,\n      );\n    }\n\n    const result = await this.builders[builderName](\n      attrs || {},\n      this,\n      this.db,\n      faker,\n    );\n\n    // For Kysely, we expect the builder to return an object with table and data properties\n    // or to handle the insertion itself and return the inserted record\n    if (\n      result &&\n      typeof result === 'object' &&\n      'table' in result &&\n      'data' in result\n    ) {\n      // If the builder returns {table: string, data: object}, we insert it\n      const inserted = await this.db\n        .insertInto(result.table)\n        .values(result.data)\n        .returningAll()\n        .executeTakeFirst();\n\n      return inserted as any;\n    }\n\n    // Otherwise, assume the builder handled the insertion itself\n    return result;\n  }\n\n  /**\n   * Inserts multiple records into the database using the specified builder.\n   * Supports both static attributes and dynamic attribute generation via a function.\n   *\n   * @template K - The builder name (must be a key of Builders)\n   * @param count - The number of records to insert\n   * @param builderName - The name of the builder to use\n   * @param attrs - Static attributes or a function that generates attributes for each record\n   * @returns A promise resolving to an array of inserted records\n   * @throws Error if the specified builder doesn't exist\n   *\n   * @example\n   * ```typescript\n   * // Insert multiple with same attributes\n   * const users = await factory.insertMany(5, 'user', { role: 'member' });\n   *\n   * // Insert multiple with dynamic attributes\n   * const posts = await factory.insertMany(10, 'post', (idx, faker) => ({\n   *   title: `Post ${idx + 1}`,\n   *   content: faker.lorem.paragraph(),\n   *   publishedAt: faker.date.past()\n   * }));\n   *\n   * // Create users with sequential emails\n   * const admins = await factory.insertMany(3, 'user', (idx) => ({\n   *   email: `admin${idx + 1}@example.com`,\n   *   role: 'admin'\n   * }));\n   * ```\n   */\n  // Method overloads for better type inference\n  async insertMany<K extends keyof Builders>(\n    count: number,\n    builderName: K,\n    attrs?: Parameters<Builders[K]>[0],\n  ): Promise<Awaited<ReturnType<Builders[K]>>[]>;\n  async insertMany<K extends keyof Builders>(\n    count: number,\n    builderName: K,\n    attrs: (\n      idx: number,\n      faker: FakerFactory,\n    ) => Parameters<Builders[K]>[0] | Promise<Parameters<Builders[K]>[0]>,\n  ): Promise<Awaited<ReturnType<Builders[K]>>[]>;\n  async insertMany<K extends keyof Builders>(\n    count: number,\n    builderName: K,\n    attrs?: any,\n  ): Promise<Awaited<ReturnType<Builders[K]>>[]> {\n    if (!(builderName in this.builders)) {\n      throw new Error(\n        `Builder \"${\n          builderName as string\n        }\" is not registered in this factory. Make sure it is correct and registered in src/test/setup.ts`,\n      );\n    }\n\n    const promises: Promise<any>[] = [];\n\n    for (let i = 0; i < count; i++) {\n      const newAttrs =\n        typeof attrs === 'function' ? await attrs(i, faker) : attrs;\n      promises.push(this.insert(builderName, newAttrs));\n    }\n\n    return Promise.all(promises);\n  }\n\n  /**\n   * Executes a seed function to create complex test scenarios with multiple related records.\n   * Seeds are useful for setting up complete test environments with realistic data relationships.\n   *\n   * @template K - The seed name (must be a key of Seeds)\n   * @param seedName - The name of the seed to execute\n   * @param attrs - Optional configuration attributes for the seed\n   * @returns The result of the seed function (typically the primary record created)\n   * @throws Error if the specified seed doesn't exist\n   *\n   * @example\n   * ```typescript\n   * // Execute a simple seed\n   * const user = await factory.seed('userWithProfile');\n   *\n   * // Execute a seed with configuration\n   * const author = await factory.seed('authorWithBooks', {\n   *   bookCount: 5,\n   *   includeReviews: true\n   * });\n   *\n   * // Use seed result in tests\n   * const company = await factory.seed('companyWithDepartments', {\n   *   departmentCount: 3,\n   *   employeesPerDepartment: 10\n   * });\n   * expect(company.departments).toHaveLength(3);\n   * ```\n   */\n  seed<K extends keyof Seeds>(\n    seedName: K,\n    attrs?: Parameters<Seeds[K]>[0],\n  ): ReturnType<Seeds[K]> {\n    if (!(seedName in this.seeds)) {\n      throw new Error(\n        `Seed \"${\n          seedName as string\n        }\" is not registered in this factory. Make sure it is correct and registered in src/test/setup.ts`,\n      );\n    }\n\n    return this.seeds[seedName](attrs || {}, this, this.db);\n  }\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA+CA,IAAa,gBAAb,cAIUA,wBAAyB;;;;;;;;;CASjC,OAAO,WAAqCC,QAAoB;AAC9D,SAAO,wBAAQ,WAAW,OAAO;CAClC;;;;;;;;CASD,YACUC,UACAC,OACAC,IACR;AACA,SAAO;EAJC;EACA;EACA;CAGT;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAyCD,OAAO,cASLC,OACAC,MAQAC,YAMmB;AACnB,SAAO,OACLC,OACAC,SACAC,IACAC,YACG;GAEH,IAAIC,OAA2C,EAAE,GAAG,MAAO;AAG3D,OAAI,MAAM;IACR,MAAM,WAAW,MAAM,KAAK,OAAO,SAAS,IAAIC,QAAM;AACtD,WAAO;KAAE,GAAG;KAAU,GAAG;IAAM;GAChC;AAGD,OAAI,eAAe,OAAO;IAExB,MAAM,SAAS,MAAM,GAClB,WAAW,MAAM,CACjB,OAAO,KAAkC,CACzC,cAAc,CACd,kBAAkB;AAErB,SAAK,OACH,OAAM,IAAI,OAAO,wBAAwB,MAAM;AAGjD,WAAO;GACR,MAEC,QAAO;IAAE;IAAO;GAAM;EAEzB;CACF;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA+BD,MAAM,OACJC,aACAC,OAC2C;AAC3C,QAAM,eAAe,KAAK,UACxB,OAAM,IAAI,OACP,WACC,YACD;EAIL,MAAM,SAAS,MAAM,KAAK,SAAS,aACjC,SAAS,CAAE,GACX,MACA,KAAK,IACLF,oBACD;AAID,MACE,iBACO,WAAW,YAClB,WAAW,UACX,UAAU,QACV;GAEA,MAAM,WAAW,MAAM,KAAK,GACzB,WAAW,OAAO,MAAM,CACxB,OAAO,OAAO,KAAK,CACnB,cAAc,CACd,kBAAkB;AAErB,UAAO;EACR;AAGD,SAAO;CACR;CA8CD,MAAM,WACJG,OACAF,aACAG,OAC6C;AAC7C,QAAM,eAAe,KAAK,UACxB,OAAM,IAAI,OACP,WACC,YACD;EAIL,MAAMC,WAA2B,CAAE;AAEnC,OAAK,IAAI,IAAI,GAAG,IAAI,OAAO,KAAK;GAC9B,MAAM,kBACG,UAAU,aAAa,MAAM,MAAM,GAAGL,oBAAM,GAAG;AACxD,YAAS,KAAK,KAAK,OAAO,aAAa,SAAS,CAAC;EAClD;AAED,SAAO,QAAQ,IAAI,SAAS;CAC7B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA+BD,KACEM,UACAC,OACsB;AACtB,QAAM,YAAY,KAAK,OACrB,OAAM,IAAI,OACP,QACC,SACD;AAIL,SAAO,KAAK,MAAM,UAAU,SAAS,CAAE,GAAE,MAAM,KAAK,GAAG;CACxD;AACF"}