@onebun/drizzle 0.1.10 → 0.1.12

package/package.json

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

package/src/builders/transaction-client.ts

@@ -5,17 +5,22 @@
 // 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 type { BunSQLQueryResultHKT } from 'drizzle-orm/bun-sql/session';
+import type {
+  PgDeleteBase,
+  PgInsertBuilder,
+  PgTable,
+  PgUpdateBuilder,
+} from 'drizzle-orm/pg-core';
+import type {
+  SQLiteDeleteBase,
+  SQLiteInsertBuilder,
+  SQLiteTable,
+  SQLiteUpdateBuilder,
+} 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
  * 
@@ -55,54 +60,42 @@ export class UniversalTransactionClient {
   /**
    * Create an INSERT query for SQLite table
    */
-  insert<TTable extends SQLiteTable<any>>(
-    table: TTable,
-  ): ReturnType<SQLiteDb['insert']>;
+  insert<TTable extends SQLiteTable>(table: TTable): SQLiteInsertBuilder<TTable, 'sync', void>;
 
   /**
    * Create an INSERT query for PostgreSQL table
    */
-  insert<TTable extends PgTable<any>>(
-    table: TTable,
-  ): ReturnType<PgDb['insert']>;
+  insert<TTable extends PgTable>(table: TTable): PgInsertBuilder<TTable, BunSQLQueryResultHKT>;
 
-  insert(table: SQLiteTable<any> | PgTable<any>) {
+  insert(table: SQLiteTable | PgTable) {
     return (this.tx as any).insert(table);
   }
 
   /**
    * Create an UPDATE query for SQLite table
    */
-  update<TTable extends SQLiteTable<any>>(
-    table: TTable,
-  ): ReturnType<SQLiteDb['update']>;
+  update<TTable extends SQLiteTable>(table: TTable): SQLiteUpdateBuilder<TTable, 'sync', void>;
 
   /**
    * Create an UPDATE query for PostgreSQL table
    */
-  update<TTable extends PgTable<any>>(
-    table: TTable,
-  ): ReturnType<PgDb['update']>;
+  update<TTable extends PgTable>(table: TTable): PgUpdateBuilder<TTable, BunSQLQueryResultHKT>;
 
-  update(table: SQLiteTable<any> | PgTable<any>) {
+  update(table: SQLiteTable | PgTable) {
     return (this.tx as any).update(table);
   }
 
   /**
    * Create a DELETE query for SQLite table
    */
-  delete<TTable extends SQLiteTable<any>>(
-    table: TTable,
-  ): ReturnType<SQLiteDb['delete']>;
+  delete<TTable extends SQLiteTable>(table: TTable): SQLiteDeleteBase<TTable, 'sync', void>;
 
   /**
    * Create a DELETE query for PostgreSQL table
    */
-  delete<TTable extends PgTable<any>>(
-    table: TTable,
-  ): ReturnType<PgDb['delete']>;
+  delete<TTable extends PgTable>(table: TTable): PgDeleteBase<TTable, BunSQLQueryResultHKT>;
 
-  delete(table: SQLiteTable<any> | PgTable<any>) {
+  delete(table: SQLiteTable | PgTable) {
     return (this.tx as any).delete(table);
   }
 

package/src/drizzle.service.ts

@@ -1,3 +1,7 @@
+import crypto from 'node:crypto';
+import fs from 'node:fs';
+import path from 'node:path';
+
 import { SQL } from 'bun';
 import { Database } from 'bun:sqlite';
 import { drizzle as drizzlePostgres } from 'drizzle-orm/bun-sql';
@@ -7,11 +11,26 @@ import { migrate } from 'drizzle-orm/bun-sqlite/migrator';
 import { Effect } from 'effect';
 
 import type { BunSQLDatabase } from 'drizzle-orm/bun-sql';
+import type { BunSQLQueryResultHKT } from 'drizzle-orm/bun-sql/session';
 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 type {
+  PgDeleteBase,
+  PgInsertBuilder,
+  PgTable,
+  PgUpdateBuilder,
+} from 'drizzle-orm/pg-core';
+import type {
+  SQLiteDeleteBase,
+  SQLiteInsertBuilder,
+  SQLiteTable,
+  SQLiteUpdateBuilder,
+} from 'drizzle-orm/sqlite-core';
 
-import { BaseService, Service } from '@onebun/core';
+import {
+  BaseService,
+  Service,
+  type OnModuleInit,
+} from '@onebun/core';
 import {
   Env,
   EnvLoader,
@@ -33,10 +52,6 @@ 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
  */
@@ -204,7 +219,7 @@ interface BufferedLogEntry {
  * ```
  */
 @Service()
-export class DrizzleService extends BaseService {
+export class DrizzleService extends BaseService implements OnModuleInit {
   private db: DatabaseInstance | null = null;
   private dbType: DatabaseTypeLiteral | null = null;
   private connectionOptions: DatabaseConnectionOptions | null = null;
@@ -291,10 +306,10 @@ export class DrizzleService extends BaseService {
   }
 
   /**
-   * Async initialization hook - called by the framework after initializeService()
+   * Module initialization hook - called by the framework after initializeService()
    * This ensures the database is fully ready before client code runs
    */
-  override async onAsyncInit(): Promise<void> {
+  async onModuleInit(): Promise<void> {
     // Flush any buffered logs now that logger is available
     this.flushLogBuffer();
 
@@ -546,6 +561,92 @@ export class DrizzleService extends BaseService {
     return this.connectionOptions;
   }
 
+  /**
+   * Read migration journal and compute hashes for each migration file
+   * Returns a map of hash -> migration filename
+   */
+  private readMigrationJournal(migrationsFolder: string): Map<string, string> {
+    const hashToFilename = new Map<string, string>();
+    const journalPath = path.join(migrationsFolder, 'meta', '_journal.json');
+
+    if (!fs.existsSync(journalPath)) {
+      // No journal file - return empty map
+      return hashToFilename;
+    }
+
+    try {
+      const journalContent = fs.readFileSync(journalPath, 'utf-8');
+      const journal = JSON.parse(journalContent) as {
+        entries: Array<{ idx: number; when: number; tag: string; breakpoints: boolean }>;
+      };
+
+      for (const entry of journal.entries) {
+        const migrationPath = path.join(migrationsFolder, `${entry.tag}.sql`);
+
+        if (fs.existsSync(migrationPath)) {
+          const sqlContent = fs.readFileSync(migrationPath, 'utf-8');
+          const hash = crypto.createHash('sha256').update(sqlContent).digest('hex');
+          hashToFilename.set(hash, entry.tag);
+        }
+      }
+    } catch {
+      // If journal parsing fails, return empty map
+      this.safeLog('warn', 'Failed to read migration journal', { journalPath });
+    }
+
+    return hashToFilename;
+  }
+
+  /**
+   * Get set of applied migration hashes from __drizzle_migrations table
+   */
+  private getAppliedMigrationHashes(): Set<string> {
+    const hashes = new Set<string>();
+
+    try {
+      if (this.connectionOptions?.type === DatabaseType.SQLITE && this.sqliteClient) {
+        // Check if table exists
+        const tableExists = this.sqliteClient.query(`
+          SELECT name FROM sqlite_master 
+          WHERE type='table' AND name='__drizzle_migrations'
+        `).all();
+
+        if (tableExists.length > 0) {
+          const migrations = this.sqliteClient.query(`
+            SELECT hash FROM __drizzle_migrations
+          `).all() as Array<{ hash: string }>;
+
+          for (const m of migrations) {
+            hashes.add(m.hash);
+          }
+        }
+      } else if (this.connectionOptions?.type === DatabaseType.POSTGRESQL && this.postgresClient) {
+        // Check if table exists using Bun.SQL template literal syntax
+        // Cast through unknown as Bun.SQL types don't fully reflect runtime behavior
+        const tableExistsResult = this.postgresClient`
+          SELECT EXISTS (
+            SELECT FROM information_schema.tables 
+            WHERE table_name = '__drizzle_migrations'
+          ) as exists
+        ` as unknown as Array<{ exists: boolean }>;
+
+        if (tableExistsResult.length > 0 && tableExistsResult[0]?.exists) {
+          const migrationsResult = this.postgresClient`
+            SELECT hash FROM __drizzle_migrations
+          ` as unknown as Array<{ hash: string }>;
+
+          for (const m of migrationsResult) {
+            hashes.add(m.hash);
+          }
+        }
+      }
+    } catch {
+      // If query fails, return empty set (table might not exist yet)
+    }
+
+    return hashes;
+  }
+
   /**
    * Run migrations
    *
@@ -553,6 +654,8 @@ export class DrizzleService extends BaseService {
    * and prevents double application of migrations. This method uses drizzle's built-in
    * migration system which ensures idempotency.
    *
+   * Logs the names of each migration file that was applied during this run.
+   *
    * @param options - Migration options
    * @param skipWait - Internal flag to skip waitForInit (used by autoInitialize to avoid deadlock)
    * @throws Error if database is not initialized
@@ -569,6 +672,12 @@ export class DrizzleService extends BaseService {
 
     const migrationsFolder = options?.migrationsFolder ?? './drizzle';
 
+    // Read migration journal to get hash -> filename mapping
+    const hashToFilename = this.readMigrationJournal(migrationsFolder);
+
+    // Get already applied migrations before running
+    const appliedBefore = this.getAppliedMigrationHashes();
+
     if (this.connectionOptions.type === DatabaseType.SQLITE) {
       if (!this.db) {
         throw new Error('Database not initialized');
@@ -576,7 +685,6 @@ export class DrizzleService extends BaseService {
       await migrate(this.db as BunSQLiteDatabase<Record<string, SQLiteTable>>, {
         migrationsFolder,
       });
-      this.safeLog('info', 'SQLite migrations applied', { migrationsFolder });
     } else if (this.connectionOptions.type === DatabaseType.POSTGRESQL) {
       if (!this.db) {
         throw new Error('Database not initialized');
@@ -584,8 +692,35 @@ export class DrizzleService extends BaseService {
       await migratePostgres(this.db as BunSQLDatabase<Record<string, PgTable>>, {
         migrationsFolder,
       });
-      this.safeLog('info', 'PostgreSQL migrations applied', { migrationsFolder });
     }
+
+    // Get applied migrations after running
+    const appliedAfter = this.getAppliedMigrationHashes();
+
+    // Find newly applied migrations
+    const newlyApplied: string[] = [];
+    for (const hash of appliedAfter) {
+      if (!appliedBefore.has(hash)) {
+        const filename = hashToFilename.get(hash);
+        if (filename) {
+          newlyApplied.push(filename);
+        }
+      }
+    }
+
+    // Log each applied migration
+    for (const filename of newlyApplied) {
+      this.safeLog('info', `Applied migration: ${filename}`);
+    }
+
+    // Log summary
+    const dbTypeName = this.connectionOptions.type === DatabaseType.SQLITE ? 'SQLite' : 'PostgreSQL';
+
+    this.safeLog('info', `${dbTypeName} migrations applied`, { 
+      migrationsFolder, 
+      newMigrations: newlyApplied.length,
+      appliedFiles: newlyApplied,
+    });
   }
 
   /**
@@ -712,15 +847,13 @@ export class DrizzleService extends BaseService {
    *   .returning();
    * ```
    */
-  // eslint-disable-next-line @typescript-eslint/no-explicit-any
-  insert<TTable extends SQLiteTable<any>>(table: TTable): ReturnType<SQLiteDb['insert']>;
+  insert<TTable extends SQLiteTable>(table: TTable): SQLiteInsertBuilder<TTable, 'sync', void>;
   /**
    * 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>) {
+  insert<TTable extends PgTable>(table: TTable): PgInsertBuilder<TTable, BunSQLQueryResultHKT>;
+  // eslint-disable-next-line @typescript-eslint/explicit-module-boundary-types
+  insert(table: SQLiteTable | PgTable) {
     const db = this.getDatabase();
 
     // eslint-disable-next-line @typescript-eslint/no-explicit-any
@@ -744,15 +877,13 @@ export class DrizzleService extends BaseService {
    *   .returning();
    * ```
    */
-  // eslint-disable-next-line @typescript-eslint/no-explicit-any
-  update<TTable extends SQLiteTable<any>>(table: TTable): ReturnType<SQLiteDb['update']>;
+  update<TTable extends SQLiteTable>(table: TTable): SQLiteUpdateBuilder<TTable, 'sync', void>;
   /**
    * 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>) {
+  update<TTable extends PgTable>(table: TTable): PgUpdateBuilder<TTable, BunSQLQueryResultHKT>;
+  // eslint-disable-next-line @typescript-eslint/explicit-module-boundary-types
+  update(table: SQLiteTable | PgTable) {
     const db = this.getDatabase();
 
     // eslint-disable-next-line @typescript-eslint/no-explicit-any
@@ -773,15 +904,13 @@ export class DrizzleService extends BaseService {
    *   .returning();
    * ```
    */
-  // eslint-disable-next-line @typescript-eslint/no-explicit-any
-  delete<TTable extends SQLiteTable<any>>(table: TTable): ReturnType<SQLiteDb['delete']>;
+  delete<TTable extends SQLiteTable>(table: TTable): SQLiteDeleteBase<TTable, 'sync', void>;
   /**
    * 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>) {
+  delete<TTable extends PgTable>(table: TTable): PgDeleteBase<TTable, BunSQLQueryResultHKT>;
+  // eslint-disable-next-line @typescript-eslint/explicit-module-boundary-types
+  delete(table: SQLiteTable | PgTable) {
     const db = this.getDatabase();
 
     // eslint-disable-next-line @typescript-eslint/no-explicit-any