@onebun/drizzle 0.1.8 → 0.1.10

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@onebun/drizzle",
-  "version": "0.1.8",
+  "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.13",
+    "@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.module.ts

@@ -30,7 +30,7 @@ const DRIZZLE_MODULE_OPTIONS = Symbol('DRIZZLE_MODULE_OPTIONS');
  * - DB_URL: Database connection URL (default: ':memory:' for SQLite)
  * - DB_SCHEMA_PATH: Path to schema files (optional)
  * - DB_MIGRATIONS_FOLDER: Path to migrations folder (default: './drizzle')
- * - DB_AUTO_MIGRATE: Whether to run migrations on startup (default: false)
+ * - DB_AUTO_MIGRATE: Whether to run migrations on startup (default: true)
  * - DB_LOG_QUERIES: Whether to log SQL queries (default: false)
  * 
  * @example Basic usage with environment variables (global by default)

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
  */
@@ -158,68 +166,140 @@ async function loadFromEnv(prefix: string = DEFAULT_ENV_PREFIX): Promise<Databas
   };
 }
 
+/**
+ * Buffered log entry for pre-logger initialization logging
+ */
+interface BufferedLogEntry {
+  level: 'debug' | 'info' | 'warn' | 'error';
+  message: string;
+  meta?: object;
+  timestamp: number;
+}
+
 /**
  * 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;
   private sqliteClient: Database | null = null;
   private postgresClient: SQL | null = null;
+  private logBuffer: BufferedLogEntry[] = [];
+  private exitHandlerRegistered = false;
 
   constructor() {
     super();
-    // Only start auto-initialization if there's configuration to use
-    // Check synchronously to avoid unnecessary async work
-    if (this.shouldAutoInitialize()) {
-      this.initPromise = this.autoInitialize();
+    // Register exit handler to flush buffered logs on crash
+    this.registerExitHandler();
+  }
+
+  /**
+   * Register process exit handler to flush buffered logs to console.error on crash
+   */
+  private registerExitHandler(): void {
+    if (this.exitHandlerRegistered) {
+      return;
     }
+    this.exitHandlerRegistered = true;
+
+    const flushToConsole = () => {
+      if (this.logBuffer.length > 0) {
+        // eslint-disable-next-line no-console
+        console.error('[DrizzleService] Buffered logs (app crashed before logger init):');
+        for (const entry of this.logBuffer) {
+          const timestamp = new Date(entry.timestamp).toISOString();
+          // eslint-disable-next-line no-console
+          console.error(`  [${timestamp}] [${entry.level.toUpperCase()}] ${entry.message}`, entry.meta ?? '');
+        }
+      }
+    };
+
+    // Register handlers for various exit scenarios
+    process.on('exit', flushToConsole);
+    process.on('uncaughtException', (err) => {
+      flushToConsole();
+      // eslint-disable-next-line no-console
+      console.error('[DrizzleService] Uncaught exception:', err);
+    });
+    process.on('unhandledRejection', (reason) => {
+      flushToConsole();
+      // eslint-disable-next-line no-console
+      console.error('[DrizzleService] Unhandled rejection:', reason);
+    });
   }
 
   /**
-   * Check synchronously if auto-initialization should be attempted
-   * This avoids starting async work when there's no configuration
-   * Note: Only checks env vars here to avoid slow require() in constructor.
-   * Module options are checked in autoInitialize() which is async.
+   * Safe logging that buffers logs before logger is available
+   * When logger becomes available, buffered logs are flushed
+   * If app crashes before logger init, logs are output via console.error
    */
-  private shouldAutoInitialize(): boolean {
-    // Check if DB_URL env var is set
-    // Module options will be checked in autoInitialize() if this returns false
-    const dbUrl = process.env.DB_URL;
-    if (dbUrl && dbUrl.trim() !== '') {
-      return true;
+  private safeLog(level: 'debug' | 'info' | 'warn' | 'error', message: string, meta?: object): void {
+    if (this.logger) {
+      this.logger[level](message, meta);
+    } else {
+      // Buffer the log for later
+      this.logBuffer.push({
+        level,
+        message,
+        meta,
+        timestamp: Date.now(),
+      });
     }
+  }
 
-    // Also check if DrizzleModule has options set (static check without require)
-    // This is done by checking if the module was already loaded
-    try {
-      // Only check if module is already in cache (don't trigger new require)
-      const modulePath = require.resolve('./drizzle.module');
-      const cachedModule = require.cache[modulePath];
-      if (cachedModule?.exports?.DrizzleModule?.getOptions?.()?.connection) {
-        return true;
-      }
-    } catch {
-      // Module not resolved or not in cache
+  /**
+   * Flush buffered logs to the logger (called when logger becomes available)
+   */
+  private flushLogBuffer(): void {
+    if (!this.logger || this.logBuffer.length === 0) {
+      return;
+    }
+
+    this.logger.debug(`Flushing ${this.logBuffer.length} buffered log entries`);
+    for (const entry of this.logBuffer) {
+      this.logger[entry.level](entry.message, entry.meta);
     }
+    this.logBuffer = [];
+  }
+
+  /**
+   * Async initialization hook - called by the framework after initializeService()
+   * This ensures the database is fully ready before client code runs
+   */
+  override async onAsyncInit(): Promise<void> {
+    // Flush any buffered logs now that logger is available
+    this.flushLogBuffer();
 
-    return false;
+    // Run auto-initialization
+    await this.autoInitialize();
   }
 
   /**
@@ -232,16 +312,30 @@ export class DrizzleService<TDbType extends DatabaseTypeLiteral = DatabaseTypeLi
 
       // If module options are provided, use them
       if (moduleOptions?.connection) {
-        this.logger.debug('Auto-initializing database service from module options', {
+        this.safeLog('debug', 'Auto-initializing database service from module options', {
           type: moduleOptions.connection.type,
         });
 
-        await this.initialize(moduleOptions.connection);
+        // Pass skipWait=true to avoid deadlock (we're already inside initPromise)
+        await this.initialize(moduleOptions.connection, true);
 
-        // Auto-migrate if enabled
-        if (moduleOptions.autoMigrate) {
+        // Auto-migrate is enabled by default (unless explicitly set to false)
+        const shouldAutoMigrate = moduleOptions.autoMigrate !== false;
+        if (shouldAutoMigrate) {
           const migrationsFolder = moduleOptions.migrationsFolder ?? './drizzle';
-          await this.runMigrations({ migrationsFolder });
+          this.safeLog('debug', 'Running auto-migrations', { migrationsFolder });
+          try {
+            // Pass skipWait=true to avoid deadlock (we're already inside initPromise)
+            await this.runMigrations({ migrationsFolder }, true);
+            this.safeLog('debug', 'Auto-migrations completed successfully');
+          } catch (migrationError) {
+            this.safeLog('warn', 'Auto-migration failed, database initialized without migrations', {
+              error: migrationError instanceof Error ? migrationError.message : String(migrationError),
+            });
+            // Don't rethrow - allow DB to be used even if migrations fail
+          }
+        } else {
+          this.safeLog('debug', 'Auto-migrations disabled via module options');
         }
 
         this.initialized = true;
@@ -255,7 +349,7 @@ export class DrizzleService<TDbType extends DatabaseTypeLiteral = DatabaseTypeLi
       // Check process.env directly to ensure we only auto-initialize when explicitly configured
       const dbUrlFromProcess = process.env[`${envPrefix}_URL`];
       if (!dbUrlFromProcess || dbUrlFromProcess.trim() === '') {
-        this.logger.debug('Skipping auto-initialization: no database configuration found in process.env');
+        this.safeLog('debug', 'Skipping auto-initialization: no database configuration found in process.env');
         this.initialized = false;
 
         return;
@@ -275,22 +369,24 @@ export class DrizzleService<TDbType extends DatabaseTypeLiteral = DatabaseTypeLi
             options: parsePostgreSQLUrl(envConfig.url),
           };
 
-      this.logger.debug(`Auto-initializing database service with type: ${connectionOptions.type}`, {
+      this.safeLog('debug', `Auto-initializing database service with type: ${connectionOptions.type}`, {
         envPrefix,
       });
 
-      await this.initialize(connectionOptions);
+      // Pass skipWait=true to avoid deadlock (we're already inside initPromise)
+      await this.initialize(connectionOptions, true);
 
-      // Auto-migrate if enabled
+      // Auto-migrate is enabled by default (env schema default is true)
       if (envConfig.autoMigrate) {
         const migrationsFolder = envConfig.migrationsFolder ?? './drizzle';
-        await this.runMigrations({ migrationsFolder });
+        // Pass skipWait=true to avoid deadlock (we're already inside initPromise)
+        await this.runMigrations({ migrationsFolder }, true);
       }
 
       this.initialized = true;
     } catch (error) {
       // Don't throw error - just log it and allow manual initialization
-      this.logger.debug('Failed to auto-initialize database from environment', { error });
+      this.safeLog('debug', 'Failed to auto-initialize database from environment', { error });
       this.initialized = false;
     }
   }
@@ -320,23 +416,29 @@ export class DrizzleService<TDbType extends DatabaseTypeLiteral = DatabaseTypeLi
 
   /**
    * Initialize database connection
+   * @param options - Database connection options
+   * @param skipWait - Internal flag to skip waitForInit (used by autoInitialize to avoid deadlock)
    */
-  async initialize(options: DatabaseConnectionOptions): Promise<void> {
-    await this.waitForInit();
+  async initialize(options: DatabaseConnectionOptions, skipWait = false): Promise<void> {
+    // Skip waitForInit when called from autoInitialize to avoid deadlock
+    // (autoInitialize is the function that creates initPromise)
+    if (!skipWait) {
+      await this.waitForInit();
+    }
 
     if (this.initialized && this.connectionOptions) {
-      this.logger.warn('Database already initialized, closing existing connection');
+      this.safeLog('warn', 'Database already initialized, closing existing connection');
       await this.close();
     }
 
     this.connectionOptions = options;
-    this.dbType = options.type as TDbType;
+    this.dbType = options.type;
 
     if (options.type === DatabaseType.SQLITE) {
       const sqliteOptions = options.options;
       this.sqliteClient = new Database(sqliteOptions.url, sqliteOptions.options);
       this.db = drizzleSQLite(this.sqliteClient);
-      this.logger.info('SQLite database initialized', { url: sqliteOptions.url });
+      this.safeLog('info', 'SQLite database initialized', { url: sqliteOptions.url });
     } else if (options.type === DatabaseType.POSTGRESQL) {
       const pgOptions = options.options;
 
@@ -352,7 +454,7 @@ export class DrizzleService<TDbType extends DatabaseTypeLiteral = DatabaseTypeLi
       // eslint-disable-next-line @typescript-eslint/no-explicit-any
       this.postgresClient = (this.db as any).$client as SQL | null;
 
-      this.logger.info('PostgreSQL database initialized with Bun.SQL', {
+      this.safeLog('info', 'PostgreSQL database initialized with Bun.SQL', {
         host: pgOptions.host,
         port: pgOptions.port,
         database: pgOptions.database,
@@ -367,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;
   }
 
   /**
@@ -448,10 +554,14 @@ export class DrizzleService<TDbType extends DatabaseTypeLiteral = DatabaseTypeLi
    * migration system which ensures idempotency.
    *
    * @param options - Migration options
+   * @param skipWait - Internal flag to skip waitForInit (used by autoInitialize to avoid deadlock)
    * @throws Error if database is not initialized
    */
-  async runMigrations(options?: MigrationOptions): Promise<void> {
-    await this.waitForInit();
+  async runMigrations(options?: MigrationOptions, skipWait = false): Promise<void> {
+    // Skip waitForInit when called from autoInitialize to avoid deadlock
+    if (!skipWait) {
+      await this.waitForInit();
+    }
 
     if (!this.db || !this.connectionOptions) {
       throw new Error('Database not initialized. Call initialize() first.');
@@ -466,7 +576,7 @@ export class DrizzleService<TDbType extends DatabaseTypeLiteral = DatabaseTypeLi
       await migrate(this.db as BunSQLiteDatabase<Record<string, SQLiteTable>>, {
         migrationsFolder,
       });
-      this.logger.info('SQLite migrations applied', { migrationsFolder });
+      this.safeLog('info', 'SQLite migrations applied', { migrationsFolder });
     } else if (this.connectionOptions.type === DatabaseType.POSTGRESQL) {
       if (!this.db) {
         throw new Error('Database not initialized');
@@ -474,7 +584,7 @@ export class DrizzleService<TDbType extends DatabaseTypeLiteral = DatabaseTypeLi
       await migratePostgres(this.db as BunSQLDatabase<Record<string, PgTable>>, {
         migrationsFolder,
       });
-      this.logger.info('PostgreSQL migrations applied', { migrationsFolder });
+      this.safeLog('info', 'PostgreSQL migrations applied', { migrationsFolder });
     }
   }
 
@@ -505,14 +615,26 @@ export class DrizzleService<TDbType extends DatabaseTypeLiteral = DatabaseTypeLi
     this.dbType = null;
     this.connectionOptions = null;
     this.initialized = false;
-    this.logger.info('Database connection closed');
+    this.safeLog('info', 'Database connection closed');
   }
 
   /**
-   * 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();
 
@@ -520,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);
   }
 
   /**
@@ -568,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
@@ -599,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
@@ -609,7 +728,7 @@ export class DrizzleService<TDbType extends DatabaseTypeLiteral = DatabaseTypeLi
   }
 
   /**
-   * Create an UPDATE query
+   * Create an UPDATE query for SQLite table
    * 
    * @example
    * ```typescript
@@ -625,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
@@ -635,7 +760,7 @@ export class DrizzleService<TDbType extends DatabaseTypeLiteral = DatabaseTypeLi
   }
 
   /**
-   * Create a DELETE query
+   * Create a DELETE query for SQLite table
    * 
    * @example
    * ```typescript
@@ -648,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);
   }

package/src/types.ts

@@ -125,7 +125,7 @@ export interface DrizzleModuleOptions {
   
   /**
    * Whether to run migrations automatically on startup
-   * Default: false
+   * Default: true
    */
   autoMigrate?: boolean;