@kysera/dialects 0.7.3 → 0.7.4

package/src/adapters/mssql.ts

@@ -0,0 +1,207 @@
+/**
+ * Microsoft SQL Server Dialect Adapter
+ *
+ * Supports SQL Server 2017+, Azure SQL Database, and Azure SQL Edge
+ */
+
+import type { Kysely } from 'kysely'
+import { sql } from 'kysely'
+import type { DialectAdapter, DatabaseErrorLike } from '../types.js'
+import { assertValidIdentifier } from '../helpers.js'
+
+export class MSSQLAdapter implements DialectAdapter {
+  readonly dialect = 'mssql' as const
+
+  getDefaultPort(): number {
+    return 1433
+  }
+
+  getCurrentTimestamp(): string {
+    return 'GETDATE()'
+  }
+
+  escapeIdentifier(identifier: string): string {
+    // MSSQL uses square brackets for escaping
+    return '[' + identifier.replace(/\]/g, ']]') + ']'
+  }
+
+  formatDate(date: Date): string {
+    // MSSQL datetime format: YYYY-MM-DD HH:MM:SS.mmm
+    return date.toISOString().replace('T', ' ').replace('Z', '')
+  }
+
+  isUniqueConstraintError(error: unknown): boolean {
+    const e = error as DatabaseErrorLike
+    const message = e.message?.toLowerCase() || ''
+    const code = e.code || ''
+    // MSSQL error 2627: Violation of PRIMARY KEY/UNIQUE constraint
+    // MSSQL error 2601: Cannot insert duplicate key row
+    return (
+      code === '2627' ||
+      code === '2601' ||
+      message.includes('violation of unique key constraint') ||
+      message.includes('cannot insert duplicate key') ||
+      message.includes('unique constraint')
+    )
+  }
+
+  isForeignKeyError(error: unknown): boolean {
+    const e = error as DatabaseErrorLike
+    const message = e.message?.toLowerCase() || ''
+    const code = e.code || ''
+    // MSSQL error 547: FOREIGN KEY constraint violation
+    return (
+      code === '547' ||
+      message.includes('foreign key constraint') ||
+      message.includes('conflicted with the foreign key')
+    )
+  }
+
+  isNotNullError(error: unknown): boolean {
+    const e = error as DatabaseErrorLike
+    const message = e.message?.toLowerCase() || ''
+    const code = e.code || ''
+    // MSSQL error 515: Cannot insert NULL value
+    return (
+      code === '515' ||
+      message.includes('cannot insert the value null') ||
+      message.includes('does not allow nulls')
+    )
+  }
+
+  async tableExists(db: Kysely<any>, tableName: string): Promise<boolean> {
+    assertValidIdentifier(tableName, 'table name')
+    try {
+      const result = await db
+        .selectFrom('INFORMATION_SCHEMA.TABLES')
+        .select('TABLE_NAME')
+        .where('TABLE_NAME', '=', tableName)
+        .where('TABLE_TYPE', '=', 'BASE TABLE')
+        .executeTakeFirst()
+      return !!result
+    } catch {
+      return false
+    }
+  }
+
+  async getTableColumns(db: Kysely<any>, tableName: string): Promise<string[]> {
+    assertValidIdentifier(tableName, 'table name')
+    try {
+      const results = await db
+        .selectFrom('INFORMATION_SCHEMA.COLUMNS')
+        .select('COLUMN_NAME')
+        .where('TABLE_NAME', '=', tableName)
+        .execute()
+      return results.map(r => (r as { COLUMN_NAME: string }).COLUMN_NAME)
+    } catch {
+      return []
+    }
+  }
+
+  async getTables(db: Kysely<any>): Promise<string[]> {
+    try {
+      const results = await db
+        .selectFrom('INFORMATION_SCHEMA.TABLES')
+        .select('TABLE_NAME')
+        .where('TABLE_TYPE', '=', 'BASE TABLE')
+        .where('TABLE_SCHEMA', '=', 'dbo')
+        .execute()
+      return results.map(r => (r as { TABLE_NAME: string }).TABLE_NAME)
+    } catch {
+      return []
+    }
+  }
+
+  async getDatabaseSize(db: Kysely<any>, _databaseName?: string): Promise<number> {
+    try {
+      // MSSQL: Get database size using sys.database_files
+      // Note: _databaseName is ignored as MSSQL uses the current database context
+      const result = await sql<{ size: number }>`
+        SELECT SUM(size * 8 * 1024) as size
+        FROM sys.database_files
+        WHERE type = 0
+      `.execute(db)
+      return (result.rows?.[0] as { size?: number })?.size || 0
+    } catch {
+      return 0
+    }
+  }
+
+  async truncateTable(db: Kysely<any>, tableName: string): Promise<boolean> {
+    assertValidIdentifier(tableName, 'table name')
+    try {
+      // MSSQL: First try TRUNCATE, fall back to DELETE if FK constraints exist
+      try {
+        await sql.raw(`TRUNCATE TABLE ${this.escapeIdentifier(tableName)}`).execute(db)
+      } catch (truncateError) {
+        // If truncate fails due to FK, use DELETE
+        const errorMsg = String(truncateError)
+        if (errorMsg.includes('FOREIGN KEY') || errorMsg.includes('Cannot truncate')) {
+          await sql.raw(`DELETE FROM ${this.escapeIdentifier(tableName)}`).execute(db)
+          // Reset identity if table has one
+          try {
+            // Use escaped identifier for SQL injection prevention
+            const escapedTableName = this.escapeIdentifier(tableName)
+            await sql
+              .raw(`DBCC CHECKIDENT (${escapedTableName}, RESEED, 0)`)
+              .execute(db)
+          } catch {
+            // Ignore if table doesn't have identity column
+          }
+        } else {
+          throw truncateError
+        }
+      }
+      return true
+    } catch (error) {
+      const errorMessage = String(error)
+      if (
+        errorMessage.includes('Invalid object name') ||
+        errorMessage.includes('does not exist')
+      ) {
+        return false
+      }
+      // Re-throw with context (logging should be handled by caller)
+      throw new Error(`Failed to truncate MSSQL table "${tableName}": ${String(error)}`)
+    }
+  }
+
+  async truncateAllTables(db: Kysely<any>, exclude: string[] = []): Promise<void> {
+    const tables = await this.getTables(db)
+
+    // MSSQL: Disable all FK constraints first
+    for (const table of tables) {
+      if (!exclude.includes(table)) {
+        try {
+          await sql
+            .raw(`ALTER TABLE ${this.escapeIdentifier(table)} NOCHECK CONSTRAINT ALL`)
+            .execute(db)
+        } catch {
+          // Ignore errors for tables without constraints
+        }
+      }
+    }
+
+    // Truncate all tables
+    for (const table of tables) {
+      if (!exclude.includes(table)) {
+        await this.truncateTable(db, table)
+      }
+    }
+
+    // Re-enable all FK constraints
+    for (const table of tables) {
+      if (!exclude.includes(table)) {
+        try {
+          await sql
+            .raw(`ALTER TABLE ${this.escapeIdentifier(table)} CHECK CONSTRAINT ALL`)
+            .execute(db)
+        } catch {
+          // Ignore errors
+        }
+      }
+    }
+  }
+}
+
+export const mssqlAdapter = new MSSQLAdapter()

package/src/adapters/mysql.ts

@@ -2,79 +2,88 @@
  * MySQL Dialect Adapter
  */
 
-import type { Kysely } from 'kysely';
-import { sql } from 'kysely';
-import type { DialectAdapter, DatabaseErrorLike } from '../types.js';
+import type { Kysely } from 'kysely'
+import { sql } from 'kysely'
+import { silentLogger, type KyseraLogger } from '@kysera/core'
+import type { DialectAdapter, DatabaseErrorLike } from '../types.js'
+import { assertValidIdentifier } from '../helpers.js'
 
 export class MySQLAdapter implements DialectAdapter {
-  readonly dialect = 'mysql' as const;
+  readonly dialect = 'mysql' as const
+  private logger: KyseraLogger
+
+  constructor(logger: KyseraLogger = silentLogger) {
+    this.logger = logger
+  }
 
   getDefaultPort(): number {
-    return 3306;
+    return 3306
   }
 
   getCurrentTimestamp(): string {
-    return 'CURRENT_TIMESTAMP';
+    return 'CURRENT_TIMESTAMP'
   }
 
   escapeIdentifier(identifier: string): string {
-    return `\`${identifier.replace(/`/g, '``')}\``;
+    return '`' + identifier.replace(/`/g, '``') + '`'
   }
 
   formatDate(date: Date): string {
     // MySQL datetime format: YYYY-MM-DD HH:MM:SS
-    return date.toISOString().slice(0, 19).replace('T', ' ');
+    return date.toISOString().slice(0, 19).replace('T', ' ')
   }
 
   isUniqueConstraintError(error: unknown): boolean {
-    const e = error as DatabaseErrorLike;
-    const message = e.message?.toLowerCase() || '';
-    const code = e.code || '';
-    return code === 'ER_DUP_ENTRY' || code === '1062' || message.includes('duplicate entry');
+    const e = error as DatabaseErrorLike
+    const message = e.message?.toLowerCase() || ''
+    const code = e.code || ''
+    return code === 'ER_DUP_ENTRY' || code === '1062' || message.includes('duplicate entry')
   }
 
   isForeignKeyError(error: unknown): boolean {
-    const e = error as DatabaseErrorLike;
-    const code = e.code || '';
+    const e = error as DatabaseErrorLike
+    const code = e.code || ''
     return (
       code === 'ER_ROW_IS_REFERENCED' ||
       code === '1451' ||
       code === 'ER_NO_REFERENCED_ROW' ||
       code === '1452'
-    );
+    )
   }
 
   isNotNullError(error: unknown): boolean {
-    const e = error as DatabaseErrorLike;
-    const code = e.code || '';
-    return code === 'ER_BAD_NULL_ERROR' || code === '1048';
+    const e = error as DatabaseErrorLike
+    const code = e.code || ''
+    return code === 'ER_BAD_NULL_ERROR' || code === '1048'
   }
 
   async tableExists(db: Kysely<any>, tableName: string): Promise<boolean> {
+    assertValidIdentifier(tableName, 'table name')
     try {
       const result = await db
         .selectFrom('information_schema.tables')
         .select('table_name')
         .where('table_name', '=', tableName)
         .where('table_schema', '=', sql`DATABASE()`)
-        .executeTakeFirst();
-      return !!result;
+        .executeTakeFirst()
+      return !!result
     } catch {
-      return false;
+      return false
     }
   }
 
   async getTableColumns(db: Kysely<any>, tableName: string): Promise<string[]> {
+    assertValidIdentifier(tableName, 'table name')
     try {
       const results = await db
         .selectFrom('information_schema.columns')
         .select('column_name')
         .where('table_name', '=', tableName)
         .where('table_schema', '=', sql`DATABASE()`)
-        .execute();
-      return results.map((r) => r.column_name as string);
+        .execute()
+      return results.map(r => r.column_name as string)
     } catch {
-      return [];
+      return []
     }
   }
 
@@ -85,10 +94,10 @@ export class MySQLAdapter implements DialectAdapter {
         .select('table_name')
         .where('table_schema', '=', sql`DATABASE()`)
         .where('table_type', '=', 'BASE TABLE')
-        .execute();
-      return results.map((r) => r.table_name as string);
+        .execute()
+      return results.map(r => r.table_name as string)
     } catch {
-      return [];
+      return []
     }
   }
 
@@ -96,48 +105,61 @@ export class MySQLAdapter implements DialectAdapter {
     try {
       const dbName =
         databaseName ||
-        (await sql
-          .raw('SELECT DATABASE() as name')
+        (await sql<{ name: string }>`SELECT DATABASE() as name`
           .execute(db)
-          .then((r) => (r.rows?.[0] as { name?: string })?.name));
+          .then(r => r.rows?.[0]?.name))
+
+      if (!dbName) {
+        return 0
+      }
 
-      const result = await sql
-        .raw(
-          `SELECT SUM(data_length + index_length) as size FROM information_schema.tables WHERE table_schema = '${dbName}'`
-        )
-        .execute(db)
-        .then((r) => r.rows?.[0]);
+      // Use parameterized query to prevent SQL injection
+      const result = await sql<{ size: number }>`
+        SELECT SUM(data_length + index_length) as size
+        FROM information_schema.tables
+        WHERE table_schema = ${dbName}
+      `.execute(db)
 
-      return (result as { size?: number })?.size || 0;
+      return (result.rows?.[0] as { size?: number })?.size || 0
     } catch {
-      return 0;
+      return 0
     }
   }
 
-  async truncateTable(db: Kysely<any>, tableName: string): Promise<void> {
+  async truncateTable(db: Kysely<any>, tableName: string): Promise<boolean> {
+    assertValidIdentifier(tableName, 'table name')
     try {
-      // Temporarily disable foreign key checks
-      await sql.raw('SET FOREIGN_KEY_CHECKS = 0').execute(db);
-      await sql.raw(`TRUNCATE TABLE ${this.escapeIdentifier(tableName)}`).execute(db);
-      await sql.raw('SET FOREIGN_KEY_CHECKS = 1').execute(db);
-    } catch {
-      // Re-enable foreign key checks even on error
+      await sql.raw('SET FOREIGN_KEY_CHECKS = 0').execute(db)
       try {
-        await sql.raw('SET FOREIGN_KEY_CHECKS = 1').execute(db);
-      } catch {
-        // Ignore
+        await sql.raw(`TRUNCATE TABLE ${this.escapeIdentifier(tableName)}`).execute(db)
+        return true
+      } finally {
+        // Always try to re-enable FK checks
+        try {
+          await sql.raw('SET FOREIGN_KEY_CHECKS = 1').execute(db)
+        } catch (fkError) {
+          this.logger.error('Failed to re-enable foreign key checks:', fkError)
+        }
+      }
+    } catch (error) {
+      const errorMessage = String(error)
+      if (errorMessage.includes("doesn't exist") || errorMessage.includes('Unknown table')) {
+        return false
       }
+      // Log and rethrow unexpected errors
+      this.logger.error(`Failed to truncate table "${tableName}":`, error)
+      throw error
     }
   }
 
   async truncateAllTables(db: Kysely<any>, exclude: string[] = []): Promise<void> {
-    const tables = await this.getTables(db);
+    const tables = await this.getTables(db)
     for (const table of tables) {
       if (!exclude.includes(table)) {
-        await this.truncateTable(db, table);
+        await this.truncateTable(db, table)
       }
     }
   }
 }
 
-export const mysqlAdapter = new MySQLAdapter();
+export const mysqlAdapter = new MySQLAdapter()

package/src/adapters/postgres.ts

@@ -2,75 +2,84 @@
  * PostgreSQL Dialect Adapter
  */
 
-import type { Kysely } from 'kysely';
-import { sql } from 'kysely';
-import type { DialectAdapter, DatabaseErrorLike } from '../types.js';
+import type { Kysely } from 'kysely'
+import { sql } from 'kysely'
+import { silentLogger, type KyseraLogger } from '@kysera/core'
+import type { DialectAdapter, DatabaseErrorLike } from '../types.js'
+import { assertValidIdentifier } from '../helpers.js'
 
 export class PostgresAdapter implements DialectAdapter {
-  readonly dialect = 'postgres' as const;
+  readonly dialect = 'postgres' as const
+  private logger: KyseraLogger
+
+  constructor(logger: KyseraLogger = silentLogger) {
+    this.logger = logger
+  }
 
   getDefaultPort(): number {
-    return 5432;
+    return 5432
   }
 
   getCurrentTimestamp(): string {
-    return 'CURRENT_TIMESTAMP';
+    return 'CURRENT_TIMESTAMP'
   }
 
   escapeIdentifier(identifier: string): string {
-    return `"${identifier.replace(/"/g, '""')}"`;
+    return '"' + identifier.replace(/"/g, '""') + '"'
   }
 
   formatDate(date: Date): string {
-    return date.toISOString();
+    return date.toISOString()
   }
 
   isUniqueConstraintError(error: unknown): boolean {
-    const e = error as DatabaseErrorLike;
-    const message = e.message?.toLowerCase() || '';
-    const code = e.code || '';
-    return code === '23505' || message.includes('unique constraint');
+    const e = error as DatabaseErrorLike
+    const message = e.message?.toLowerCase() || ''
+    const code = e.code || ''
+    return code === '23505' || message.includes('unique constraint')
   }
 
   isForeignKeyError(error: unknown): boolean {
-    const e = error as DatabaseErrorLike;
-    const message = e.message?.toLowerCase() || '';
-    const code = e.code || '';
-    return code === '23503' || message.includes('foreign key constraint');
+    const e = error as DatabaseErrorLike
+    const message = e.message?.toLowerCase() || ''
+    const code = e.code || ''
+    return code === '23503' || message.includes('foreign key constraint')
   }
 
   isNotNullError(error: unknown): boolean {
-    const e = error as DatabaseErrorLike;
-    const message = e.message?.toLowerCase() || '';
-    const code = e.code || '';
-    return code === '23502' || message.includes('not-null constraint');
+    const e = error as DatabaseErrorLike
+    const message = e.message?.toLowerCase() || ''
+    const code = e.code || ''
+    return code === '23502' || message.includes('not-null constraint')
   }
 
   async tableExists(db: Kysely<any>, tableName: string): Promise<boolean> {
+    assertValidIdentifier(tableName, 'table name')
     try {
       const result = await db
         .selectFrom('information_schema.tables')
         .select('table_name')
         .where('table_name', '=', tableName)
         .where('table_schema', '=', 'public')
-        .executeTakeFirst();
-      return !!result;
+        .executeTakeFirst()
+      return !!result
     } catch {
-      return false;
+      return false
     }
   }
 
   async getTableColumns(db: Kysely<any>, tableName: string): Promise<string[]> {
+    assertValidIdentifier(tableName, 'table name')
     try {
       const results = await db
         .selectFrom('information_schema.columns')
         .select('column_name')
         .where('table_name', '=', tableName)
         .where('table_schema', '=', 'public')
-        .execute();
-      return results.map((r) => r.column_name as string);
+        .execute()
+      return results.map(r => r.column_name as string)
     } catch {
-      return [];
+      return []
     }
   }
 
@@ -81,41 +90,57 @@ export class PostgresAdapter implements DialectAdapter {
         .select('table_name')
         .where('table_schema', '=', 'public')
         .where('table_type', '=', 'BASE TABLE')
-        .execute();
-      return results.map((r) => r.table_name as string);
+        .execute()
+      return results.map(r => r.table_name as string)
     } catch {
-      return [];
+      return []
     }
   }
 
   async getDatabaseSize(db: Kysely<any>, databaseName?: string): Promise<number> {
     try {
-      const result = await sql
-        .raw(`SELECT pg_database_size(${databaseName ? `'${databaseName}'` : 'current_database()'}) as size`)
-        .execute(db)
-        .then((r) => r.rows?.[0]);
-      return (result as { size?: number })?.size || 0;
+      // Use parameterized query to prevent SQL injection
+      const result = databaseName
+        ? await sql<{ size: number }>`SELECT pg_database_size(${databaseName}) as size`.execute(db)
+        : await sql<{ size: number }>`SELECT pg_database_size(current_database()) as size`.execute(
+            db
+          )
+      return (result.rows?.[0] as { size?: number })?.size || 0
     } catch {
-      return 0;
+      return 0
     }
   }
 
-  async truncateTable(db: Kysely<any>, tableName: string): Promise<void> {
+  async truncateTable(db: Kysely<any>, tableName: string): Promise<boolean> {
+    assertValidIdentifier(tableName, 'table name')
     try {
-      await sql.raw(`TRUNCATE TABLE ${this.escapeIdentifier(tableName)} RESTART IDENTITY CASCADE`).execute(db);
-    } catch {
-      // Ignore errors for tables that might not exist or have constraints
+      await sql
+        .raw(`TRUNCATE TABLE ${this.escapeIdentifier(tableName)} RESTART IDENTITY CASCADE`)
+        .execute(db)
+      return true
+    } catch (error) {
+      // Only ignore "table does not exist" errors
+      const errorMessage = String(error)
+      if (
+        errorMessage.includes('does not exist') ||
+        (errorMessage.includes('relation') && errorMessage.includes('not exist'))
+      ) {
+        return false
+      }
+      // Log and rethrow unexpected errors
+      this.logger.error(`Failed to truncate table "${tableName}":`, error)
+      throw error
     }
   }
 
   async truncateAllTables(db: Kysely<any>, exclude: string[] = []): Promise<void> {
-    const tables = await this.getTables(db);
+    const tables = await this.getTables(db)
     for (const table of tables) {
       if (!exclude.includes(table)) {
-        await this.truncateTable(db, table);
+        await this.truncateTable(db, table)
       }
     }
   }
 }
 
-export const postgresAdapter = new PostgresAdapter();
+export const postgresAdapter = new PostgresAdapter()