@onebun/drizzle 0.1.9 → 0.1.10

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@onebun/drizzle",
-  "version": "0.1.9",
+  "version": "0.1.10",
   "description": "Drizzle ORM module for OneBun framework - SQLite and PostgreSQL support",
   "license": "LGPL-3.0",
   "author": "RemRyahirev",
@@ -47,7 +47,7 @@
     "dev": "bun run --watch src/index.ts"
   },
   "dependencies": {
-    "@onebun/core": "^0.1.14",
+    "@onebun/core": "^0.1.15",
     "@onebun/envs": "^0.1.4",
     "@onebun/logger": "^0.1.5",
     "drizzle-orm": "^0.44.7",

package/src/builders/index.ts

@@ -0,0 +1,9 @@
+/**
+ * Universal Query Builders
+ * 
+ * These builders provide type-safe database operations that infer
+ * the correct database type (SQLite or PostgreSQL) from table schemas.
+ */
+
+export { UniversalSelectBuilder, UniversalSelectDistinctBuilder } from './select-builder';
+export { UniversalTransactionClient } from './transaction-client';

package/src/builders/select-builder.ts

@@ -0,0 +1,109 @@
+/* eslint-disable @typescript-eslint/no-explicit-any */
+// Drizzle ORM uses complex conditional types that require `any` for proper type inference
+
+import type { DatabaseInstance } from '../types';
+import type { PgTable } from 'drizzle-orm/pg-core';
+import type { SQLiteSelectBase } from 'drizzle-orm/sqlite-core';
+import type { SQLiteTable, SQLiteColumn } from 'drizzle-orm/sqlite-core';
+
+/**
+ * SQLite select query result type with proper typing for table columns
+ */
+type SQLiteSelectQueryResult<TTable extends SQLiteTable<any>> = SQLiteSelectBase<
+  TTable['_']['name'],
+  'sync',
+  void,
+  TTable['_']['columns'],
+  'single',
+  Record<TTable['_']['name'], 'not-null'>,
+  false,
+  never,
+  TTable['$inferSelect'][],
+  Record<keyof TTable['_']['columns'], SQLiteColumn>
+>;
+
+/**
+ * Universal Select Builder that works with any table type
+ * 
+ * This builder allows using DrizzleService without generic type parameter.
+ * The result type is determined by the actual database operation at runtime,
+ * but the select result array element type is inferred from the table schema.
+ * 
+ * @example
+ * ```typescript
+ * // DrizzleService without generic
+ * const db = new DrizzleService();
+ * 
+ * // Type of result elements is inferred from table schema
+ * const users = await db.select().from(usersTable);
+ * // users has type: UserRow[]
+ * ```
+ */
+export class UniversalSelectBuilder<TFields extends Record<string, unknown> | undefined = undefined> {
+  constructor(
+    private db: DatabaseInstance,
+    private fields?: TFields,
+  ) {}
+
+  /**
+   * Select from a SQLite table
+   * Returns a chainable query builder that resolves to table row type
+   */
+  from<TTable extends SQLiteTable<any>>(
+    table: TTable,
+  ): SQLiteSelectQueryResult<TTable>;
+
+  /**
+   * Select from a PostgreSQL table
+   * Returns a chainable query builder that resolves to table row type
+   */
+  from<TTable extends PgTable<any>>(
+    table: TTable,
+  ): Promise<TTable['$inferSelect'][]> & {
+    where: (condition: any) => Promise<TTable['$inferSelect'][]> & { get: () => Promise<TTable['$inferSelect'] | undefined> };
+  };
+
+  /**
+   * Implementation - runtime call to appropriate database
+   */
+  from(table: SQLiteTable<any> | PgTable<any>): any {
+    const selectBuilder = this.fields
+      ? (this.db as any).select(this.fields)
+      : (this.db as any).select();
+    
+    return selectBuilder.from(table);
+  }
+}
+
+/**
+ * Universal SelectDistinct Builder
+ * Same as UniversalSelectBuilder but for DISTINCT queries
+ */
+export class UniversalSelectDistinctBuilder<TFields extends Record<string, unknown> | undefined = undefined> {
+  constructor(
+    private db: DatabaseInstance,
+    private fields?: TFields,
+  ) {}
+
+  /**
+   * Select distinct from a SQLite table
+   */
+  from<TTable extends SQLiteTable<any>>(
+    table: TTable,
+  ): SQLiteSelectQueryResult<TTable>;
+
+  /**
+   * Select distinct from a PostgreSQL table
+   */
+  from<TTable extends PgTable<any>>(
+    table: TTable,
+  ): Promise<TTable['$inferSelect'][]>;
+
+  from(table: SQLiteTable<any> | PgTable<any>): any {
+    const selectBuilder = this.fields
+      ? (this.db as any).selectDistinct(this.fields)
+      : (this.db as any).selectDistinct();
+    
+    return selectBuilder.from(table);
+  }
+}

package/src/builders/transaction-client.ts

@@ -0,0 +1,116 @@
+/* eslint-disable 
+    @typescript-eslint/no-explicit-any,
+    @typescript-eslint/explicit-module-boundary-types */
+// Drizzle ORM uses complex conditional types that require `any` for proper type inference
+// Method overloads define return types, so explicit return type on implementation is not needed
+
+import type { DatabaseInstance } from '../types';
+import type { BunSQLDatabase } from 'drizzle-orm/bun-sql';
+import type { BunSQLiteDatabase } from 'drizzle-orm/bun-sqlite';
+import type { PgTable } from 'drizzle-orm/pg-core';
+import type { SQLiteTable } from 'drizzle-orm/sqlite-core';
+
+import { UniversalSelectBuilder, UniversalSelectDistinctBuilder } from './select-builder';
+
+// Type helpers for insert/update/delete return types
+type SQLiteDb = BunSQLiteDatabase<Record<string, SQLiteTable>>;
+type PgDb = BunSQLDatabase<Record<string, PgTable>>;
+
+/**
+ * Universal Transaction Client
+ * 
+ * Wraps the transaction object to provide methods with overloads
+ * that infer the correct type from table schemas.
+ * 
+ * @example
+ * ```typescript
+ * await db.transaction(async (tx) => {
+ *   // tx has the same API as DrizzleService
+ *   const users = await tx.select().from(usersTable);
+ *   await tx.insert(usersTable).values({ name: 'John' });
+ * });
+ * ```
+ */
+export class UniversalTransactionClient {
+  constructor(private tx: DatabaseInstance) {}
+
+  /**
+   * Create a SELECT query
+   */
+  select(): UniversalSelectBuilder;
+  select<TFields extends Record<string, unknown>>(fields: TFields): UniversalSelectBuilder<TFields>;
+  select<TFields extends Record<string, unknown>>(fields?: TFields) {
+    return new UniversalSelectBuilder(this.tx, fields);
+  }
+
+  /**
+   * Create a SELECT DISTINCT query
+   */
+  selectDistinct(): UniversalSelectDistinctBuilder;
+  selectDistinct<TFields extends Record<string, unknown>>(fields: TFields): UniversalSelectDistinctBuilder<TFields>;
+  selectDistinct<TFields extends Record<string, unknown>>(fields?: TFields) {
+    return new UniversalSelectDistinctBuilder(this.tx, fields);
+  }
+
+  /**
+   * Create an INSERT query for SQLite table
+   */
+  insert<TTable extends SQLiteTable<any>>(
+    table: TTable,
+  ): ReturnType<SQLiteDb['insert']>;
+
+  /**
+   * Create an INSERT query for PostgreSQL table
+   */
+  insert<TTable extends PgTable<any>>(
+    table: TTable,
+  ): ReturnType<PgDb['insert']>;
+
+  insert(table: SQLiteTable<any> | PgTable<any>) {
+    return (this.tx as any).insert(table);
+  }
+
+  /**
+   * Create an UPDATE query for SQLite table
+   */
+  update<TTable extends SQLiteTable<any>>(
+    table: TTable,
+  ): ReturnType<SQLiteDb['update']>;
+
+  /**
+   * Create an UPDATE query for PostgreSQL table
+   */
+  update<TTable extends PgTable<any>>(
+    table: TTable,
+  ): ReturnType<PgDb['update']>;
+
+  update(table: SQLiteTable<any> | PgTable<any>) {
+    return (this.tx as any).update(table);
+  }
+
+  /**
+   * Create a DELETE query for SQLite table
+   */
+  delete<TTable extends SQLiteTable<any>>(
+    table: TTable,
+  ): ReturnType<SQLiteDb['delete']>;
+
+  /**
+   * Create a DELETE query for PostgreSQL table
+   */
+  delete<TTable extends PgTable<any>>(
+    table: TTable,
+  ): ReturnType<PgDb['delete']>;
+
+  delete(table: SQLiteTable<any> | PgTable<any>) {
+    return (this.tx as any).delete(table);
+  }
+
+  /**
+   * Get the raw transaction object for advanced usage
+   * Note: Returns union type - use type guards for specific database type
+   */
+  getRawTransaction(): DatabaseInstance {
+    return this.tx;
+  }
+}

package/src/drizzle.service.ts

@@ -18,10 +18,14 @@ import {
   EnvParser,
 } from '@onebun/envs';
 
+import {
+  UniversalSelectBuilder,
+  UniversalSelectDistinctBuilder,
+  UniversalTransactionClient,
+} from './builders';
 import {
   type DatabaseConnectionOptions,
   type DatabaseInstance,
-  type DatabaseInstanceForType,
   DatabaseType,
   type DatabaseTypeLiteral,
   type DrizzleModuleOptions,
@@ -29,6 +33,10 @@ import {
   type PostgreSQLConnectionOptions,
 } from './types';
 
+// Type helpers for insert/update/delete return types
+type SQLiteDb = BunSQLiteDatabase<Record<string, SQLiteTable>>;
+type PgDb = BunSQLDatabase<Record<string, PgTable>>;
+
 /**
  * Default environment variable prefix
  */
@@ -170,23 +178,35 @@ interface BufferedLogEntry {
 
 /**
  * Drizzle service for database operations
- * Generic type parameter TDbType specifies the database type (SQLITE or POSTGRESQL)
+ * 
+ * The service automatically infers database types from table schemas.
+ * No generic parameter is required - just use select(), insert(), update(), delete()
+ * with your table schemas and TypeScript will infer the correct types.
  *
  * @example
  * ```typescript
- * // For SQLite
- * const drizzleService = new DrizzleService<DatabaseType.SQLITE>(...);
- * const db = drizzleService.getDatabase(); // Type: BunSQLiteDatabase
- *
- * // For PostgreSQL
- * const drizzleService = new DrizzleService<DatabaseType.POSTGRESQL>(...);
- * const db = drizzleService.getDatabase(); // Type: BunSQLDatabase
+ * // Define tables with proper types
+ * const users = sqliteTable('users', { ... });  // SQLite table
+ * const orders = pgTable('orders', { ... });    // PostgreSQL table
+ * 
+ * // Use DrizzleService without generic parameter
+ * @Service()
+ * class UserService extends BaseService {
+ *   constructor(private db: DrizzleService) {
+ *     super();
+ *   }
+ *   
+ *   async findAll() {
+ *     // TypeScript infers SQLite types from `users` table
+ *     return this.db.select().from(users);
+ *   }
+ * }
  * ```
  */
 @Service()
-export class DrizzleService<TDbType extends DatabaseTypeLiteral = DatabaseTypeLiteral> extends BaseService {
+export class DrizzleService extends BaseService {
   private db: DatabaseInstance | null = null;
-  private dbType: TDbType | null = null;
+  private dbType: DatabaseTypeLiteral | null = null;
   private connectionOptions: DatabaseConnectionOptions | null = null;
   private initialized = false;
   private initPromise: Promise<void> | null = null;
@@ -412,7 +432,7 @@ export class DrizzleService<TDbType extends DatabaseTypeLiteral = DatabaseTypeLi
     }
 
     this.connectionOptions = options;
-    this.dbType = options.type as TDbType;
+    this.dbType = options.type;
 
     if (options.type === DatabaseType.SQLITE) {
       const sqliteOptions = options.options;
@@ -449,16 +469,20 @@ export class DrizzleService<TDbType extends DatabaseTypeLiteral = DatabaseTypeLi
   }
 
   /**
-   * Get database instance with proper typing based on generic type parameter
-   * Returns correctly typed database instance based on TDbType
+   * Get raw database instance
+   * 
+   * Returns a union type - use isSQLite()/isPostgreSQL() type guards
+   * or getSQLiteDatabase()/getPostgreSQLDatabase() for specific types.
+   * 
+   * For most use cases, prefer using select(), insert(), update(), delete()
+   * methods which automatically infer types from table schemas.
    */
-  getDatabase(): DatabaseInstanceForType<TDbType> {
+  getDatabase(): DatabaseInstance {
     if (!this.db || !this.dbType) {
       throw new Error('Database not initialized. Call initialize() first.');
     }
 
-    // Type assertion is safe because dbType matches TDbType
-    return this.db as DatabaseInstanceForType<TDbType>;
+    return this.db;
   }
 
   /**
@@ -595,10 +619,22 @@ export class DrizzleService<TDbType extends DatabaseTypeLiteral = DatabaseTypeLi
   }
 
   /**
-   * Execute a transaction with proper typing based on TDbType
+   * Execute a transaction with universal transaction client
+   * 
+   * The transaction client provides the same API as DrizzleService
+   * with automatic type inference from table schemas.
+   * 
+   * @example
+   * ```typescript
+   * await db.transaction(async (tx) => {
+   *   const users = await tx.select().from(usersTable);
+   *   await tx.insert(usersTable).values({ name: 'John' });
+   *   await tx.update(usersTable).set({ name: 'Jane' }).where(eq(usersTable.id, 1));
+   * });
+   * ```
    */
   async transaction<R>(
-    callback: (tx: DatabaseInstanceForType<TDbType>) => Promise<R>,
+    callback: (tx: UniversalTransactionClient) => Promise<R>,
   ): Promise<R> {
     await this.waitForInit();
 
@@ -606,43 +642,42 @@ export class DrizzleService<TDbType extends DatabaseTypeLiteral = DatabaseTypeLi
       throw new Error('Database not initialized. Call initialize() first.');
     }
 
-    // Type assertion needed because TypeScript cannot infer methods from conditional types
-    // Runtime type is correct - this is a TypeScript limitation
     // eslint-disable-next-line @typescript-eslint/no-explicit-any
-    return await (this.db as any).transaction(callback);
+    return await (this.db as any).transaction(async (rawTx: DatabaseInstance) => {
+      const wrappedTx = new UniversalTransactionClient(rawTx);
+
+      return await callback(wrappedTx);
+    });
   }
 
   // ============================================
-  // Direct database operation methods (proxies)
+  // Direct database operation methods
+  // These methods use universal builders that infer
+  // database type from table schemas
   // ============================================
 
   /**
    * Create a SELECT query
    * 
+   * Returns a builder with from() method that infers the correct
+   * database type from the table schema.
+   * 
    * @example
    * ```typescript
-   * // Select all columns
+   * // Select all columns - type inferred from table
    * const users = await this.db.select().from(usersTable);
    * 
    * // Select specific columns
    * const names = await this.db.select({ name: usersTable.name }).from(usersTable);
    * ```
    */
-  select(): ReturnType<DatabaseInstanceForType<TDbType>['select']>;
-  select<TSelection extends Record<string, unknown>>(
-    fields: TSelection,
-  ): ReturnType<DatabaseInstanceForType<TDbType>['select']>;
-  select<TSelection extends Record<string, unknown>>(
-    fields?: TSelection,
-  ): ReturnType<DatabaseInstanceForType<TDbType>['select']> {
+  select(): UniversalSelectBuilder;
+  select<TFields extends Record<string, unknown>>(fields: TFields): UniversalSelectBuilder<TFields>;
+  // eslint-disable-next-line @typescript-eslint/explicit-module-boundary-types
+  select<TFields extends Record<string, unknown>>(fields?: TFields) {
     const db = this.getDatabase();
-    if (fields) {
-      // eslint-disable-next-line @typescript-eslint/no-explicit-any
-      return (db as any).select(fields);
-    }
 
-    // eslint-disable-next-line @typescript-eslint/no-explicit-any
-    return (db as any).select();
+    return new UniversalSelectBuilder(db, fields);
   }
 
   /**
@@ -654,25 +689,17 @@ export class DrizzleService<TDbType extends DatabaseTypeLiteral = DatabaseTypeLi
    * const uniqueNames = await this.db.selectDistinct({ name: usersTable.name }).from(usersTable);
    * ```
    */
-  selectDistinct(): ReturnType<DatabaseInstanceForType<TDbType>['selectDistinct']>;
-  selectDistinct<TSelection extends Record<string, unknown>>(
-    fields: TSelection,
-  ): ReturnType<DatabaseInstanceForType<TDbType>['selectDistinct']>;
-  selectDistinct<TSelection extends Record<string, unknown>>(
-    fields?: TSelection,
-  ): ReturnType<DatabaseInstanceForType<TDbType>['selectDistinct']> {
+  selectDistinct(): UniversalSelectDistinctBuilder;
+  selectDistinct<TFields extends Record<string, unknown>>(fields: TFields): UniversalSelectDistinctBuilder<TFields>;
+  // eslint-disable-next-line @typescript-eslint/explicit-module-boundary-types
+  selectDistinct<TFields extends Record<string, unknown>>(fields?: TFields) {
     const db = this.getDatabase();
-    if (fields) {
-      // eslint-disable-next-line @typescript-eslint/no-explicit-any
-      return (db as any).selectDistinct(fields);
-    }
 
-    // eslint-disable-next-line @typescript-eslint/no-explicit-any
-    return (db as any).selectDistinct();
+    return new UniversalSelectDistinctBuilder(db, fields);
   }
 
   /**
-   * Create an INSERT query
+   * Create an INSERT query for SQLite table
    * 
    * @example
    * ```typescript
@@ -685,9 +712,15 @@ export class DrizzleService<TDbType extends DatabaseTypeLiteral = DatabaseTypeLi
    *   .returning();
    * ```
    */
-  insert<TTable extends Parameters<DatabaseInstanceForType<TDbType>['insert']>[0]>(
-    table: TTable,
-  ): ReturnType<DatabaseInstanceForType<TDbType>['insert']> {
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  insert<TTable extends SQLiteTable<any>>(table: TTable): ReturnType<SQLiteDb['insert']>;
+  /**
+   * Create an INSERT query for PostgreSQL table
+   */
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  insert<TTable extends PgTable<any>>(table: TTable): ReturnType<PgDb['insert']>;
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any, @typescript-eslint/explicit-module-boundary-types
+  insert(table: SQLiteTable<any> | PgTable<any>) {
     const db = this.getDatabase();
 
     // eslint-disable-next-line @typescript-eslint/no-explicit-any
@@ -695,7 +728,7 @@ export class DrizzleService<TDbType extends DatabaseTypeLiteral = DatabaseTypeLi
   }
 
   /**
-   * Create an UPDATE query
+   * Create an UPDATE query for SQLite table
    * 
    * @example
    * ```typescript
@@ -711,9 +744,15 @@ export class DrizzleService<TDbType extends DatabaseTypeLiteral = DatabaseTypeLi
    *   .returning();
    * ```
    */
-  update<TTable extends Parameters<DatabaseInstanceForType<TDbType>['update']>[0]>(
-    table: TTable,
-  ): ReturnType<DatabaseInstanceForType<TDbType>['update']> {
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  update<TTable extends SQLiteTable<any>>(table: TTable): ReturnType<SQLiteDb['update']>;
+  /**
+   * Create an UPDATE query for PostgreSQL table
+   */
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  update<TTable extends PgTable<any>>(table: TTable): ReturnType<PgDb['update']>;
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any, @typescript-eslint/explicit-module-boundary-types
+  update(table: SQLiteTable<any> | PgTable<any>) {
     const db = this.getDatabase();
 
     // eslint-disable-next-line @typescript-eslint/no-explicit-any
@@ -721,7 +760,7 @@ export class DrizzleService<TDbType extends DatabaseTypeLiteral = DatabaseTypeLi
   }
 
   /**
-   * Create a DELETE query
+   * Create a DELETE query for SQLite table
    * 
    * @example
    * ```typescript
@@ -734,9 +773,15 @@ export class DrizzleService<TDbType extends DatabaseTypeLiteral = DatabaseTypeLi
    *   .returning();
    * ```
    */
-  delete<TTable extends Parameters<DatabaseInstanceForType<TDbType>['delete']>[0]>(
-    table: TTable,
-  ): ReturnType<DatabaseInstanceForType<TDbType>['delete']> {
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  delete<TTable extends SQLiteTable<any>>(table: TTable): ReturnType<SQLiteDb['delete']>;
+  /**
+   * Create a DELETE query for PostgreSQL table
+   */
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  delete<TTable extends PgTable<any>>(table: TTable): ReturnType<PgDb['delete']>;
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any, @typescript-eslint/explicit-module-boundary-types
+  delete(table: SQLiteTable<any> | PgTable<any>) {
     const db = this.getDatabase();
 
     // eslint-disable-next-line @typescript-eslint/no-explicit-any

package/src/entity.decorator.ts

@@ -24,7 +24,6 @@
  */
 import type { DrizzleService } from './drizzle.service';
 import type { BaseRepository } from './repository';
-import type { InferDbTypeFromTable } from './types';
 import type { PgTable } from 'drizzle-orm/pg-core';
 import type { SQLiteTable } from 'drizzle-orm/sqlite-core';
 
@@ -32,8 +31,6 @@ import type { SQLiteTable } from 'drizzle-orm/sqlite-core';
 const ENTITY_METADATA = new Map<Function, PgTable<any> | SQLiteTable<any>>();
 
 export function Entity<TTable extends PgTable<any> | SQLiteTable<any>>(table: TTable) {
-  type TDbType = InferDbTypeFromTable<TTable>;
-  
   return <T extends new (...args: any[]) => BaseRepository<TTable>>(target: T) => {
     // Store table schema in metadata
     ENTITY_METADATA.set(target, table);
@@ -42,8 +39,8 @@ export function Entity<TTable extends PgTable<any> | SQLiteTable<any>>(table: TT
     // The wrapped class only requires DrizzleService as constructor argument
     class WrappedRepository extends target {
       constructor(...args: any[]) {
-        // First argument should be DrizzleService with correct type (inferred from table)
-        const drizzleService = args[0] as DrizzleService<TDbType>;
+        // First argument should be DrizzleService (no generic parameter needed)
+        const drizzleService = args[0] as DrizzleService;
         // Pass drizzleService and table to parent constructor
         super(drizzleService, table);
       }
@@ -57,7 +54,7 @@ export function Entity<TTable extends PgTable<any> | SQLiteTable<any>>(table: TT
     });
     
     // Return wrapped class - TypeScript will infer the correct constructor signature
-    return WrappedRepository as any as new (drizzleService: DrizzleService<TDbType>) => InstanceType<T>;
+    return WrappedRepository as any as new (drizzleService: DrizzleService) => InstanceType<T>;
   };
 }
 

package/src/index.ts

@@ -25,6 +25,13 @@ export { DatabaseType } from './types';
 export { DrizzleModule } from './drizzle.module';
 export { DrizzleService } from './drizzle.service';
 
+// Universal builders for type inference
+export {
+  UniversalSelectBuilder,
+  UniversalSelectDistinctBuilder,
+  UniversalTransactionClient,
+} from './builders';
+
 // Repository
 export { BaseRepository, type QueryBuilder } from './repository';
 

package/src/repository.ts

@@ -4,19 +4,18 @@
 
 import { eq, type SQL } from 'drizzle-orm';
 
-import type { IRepository } from './types';
-import type { DatabaseTypeLiteral, DatabaseInstanceForType } from './types';
+import type { IRepository, DatabaseInstance } from './types';
 import type { PgTable } from 'drizzle-orm/pg-core';
 import type { SQLiteTable } from 'drizzle-orm/sqlite-core';
 
 
+import { UniversalTransactionClient } from './builders';
 import { DrizzleService } from './drizzle.service';
 import {
   getPrimaryKeyColumn,
   type SelectType,
   type InsertType,
 } from './schema-utils';
-import { DatabaseType } from './types';
 
 /**
  * Query builder interface for type-safe database operations
@@ -90,55 +89,13 @@ export interface QueryBuilder {
  * }
  * ```
  */
-/**
- * Infer database type from table schema
- */
-type InferDbTypeFromTable<TTable> =
-  TTable extends SQLiteTable<any>
-    ? DatabaseType.SQLITE
-    : TTable extends PgTable<any>
-      ? DatabaseType.POSTGRESQL
-      : never;
-
-/**
- * Base repository class for Drizzle ORM
- *
- * Simplified version with single generic parameter - database type is automatically inferred from table schema
- *
- * @example
- * ```typescript
- * import { sqliteTable, integer, text } from 'drizzle-orm/sqlite-core';
- * import { BaseRepository } from '@onebun/drizzle';
- *
- * const users = sqliteTable('users', {
- *   id: integer('id').primaryKey({ autoIncrement: true }),
- *   name: text('name').notNull(),
- * });
- *
- * export class UserRepository extends BaseRepository<typeof users> {
- *   constructor(drizzleService: DrizzleService) {
- *     super(drizzleService, users);
- *   }
- * }
- * ```
- *
- * Advanced version with explicit database type (for edge cases):
- * ```typescript
- * export class UserRepository extends BaseRepository<DatabaseType.SQLITE, typeof users> {
- *   constructor(drizzleService: DrizzleService<DatabaseType.SQLITE>) {
- *     super(drizzleService, users);
- *   }
- * }
- * ```
- */
 export class BaseRepository<
   TTable extends PgTable<any> | SQLiteTable<any>,
-  TDbType extends DatabaseTypeLiteral = InferDbTypeFromTable<TTable>
 > implements IRepository<SelectType<TTable>> {
   /**
-   * Database instance with proper typing based on TDbType
+   * Database instance
    */
-  protected readonly db: DatabaseInstanceForType<TDbType>;
+  protected readonly db: DatabaseInstance;
 
   /**
    * Table schema instance
@@ -146,20 +103,16 @@ export class BaseRepository<
   protected readonly table: TTable;
 
   /**
-   * DrizzleService instance (type inferred from table)
+   * DrizzleService instance
    */
-  protected readonly drizzleService: DrizzleService<TDbType>;
+  protected readonly drizzleService: DrizzleService;
 
   constructor(
-    drizzleService: DrizzleService<DatabaseTypeLiteral>,
+    drizzleService: DrizzleService,
     table: TTable,
   ) {
     this.table = table;
-    // Store drizzleService - type is inferred from table schema
-    // Type assertion is safe because TDbType is inferred from TTable
-    this.drizzleService = drizzleService as DrizzleService<TDbType>;
-    // getDatabase() returns correctly typed instance based on TDbType
-    // TDbType is automatically inferred from TTable
+    this.drizzleService = drizzleService;
     this.db = this.drizzleService.getDatabase();
   }
 
@@ -308,9 +261,17 @@ export class BaseRepository<
 
   /**
    * Execute a transaction
+   * 
+   * @example
+   * ```typescript
+   * await userRepository.transaction(async (tx) => {
+   *   const users = await tx.select().from(usersTable);
+   *   await tx.insert(usersTable).values({ name: 'John' });
+   * });
+   * ```
    */
   async transaction<R>(
-    callback: (tx: DatabaseInstanceForType<TDbType>) => Promise<R>,
+    callback: (tx: UniversalTransactionClient) => Promise<R>,
   ): Promise<R> {
     return await this.drizzleService.transaction(callback);
   }