@kysera/dialects 0.7.3

package/src/adapters/postgres.ts

@@ -0,0 +1,121 @@
+/**
+ * PostgreSQL Dialect Adapter
+ */
+
+import type { Kysely } from 'kysely';
+import { sql } from 'kysely';
+import type { DialectAdapter, DatabaseErrorLike } from '../types.js';
+
+export class PostgresAdapter implements DialectAdapter {
+  readonly dialect = 'postgres' as const;
+
+  getDefaultPort(): number {
+    return 5432;
+  }
+
+  getCurrentTimestamp(): string {
+    return 'CURRENT_TIMESTAMP';
+  }
+
+  escapeIdentifier(identifier: string): string {
+    return `"${identifier.replace(/"/g, '""')}"`;
+  }
+
+  formatDate(date: Date): string {
+    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');
+  }
+
+  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');
+  }
+
+  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');
+  }
+
+  async tableExists(db: Kysely<any>, tableName: string): Promise<boolean> {
+    try {
+      const result = await db
+        .selectFrom('information_schema.tables')
+        .select('table_name')
+        .where('table_name', '=', tableName)
+        .where('table_schema', '=', 'public')
+        .executeTakeFirst();
+      return !!result;
+    } catch {
+      return false;
+    }
+  }
+
+  async getTableColumns(db: Kysely<any>, tableName: string): Promise<string[]> {
+    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);
+    } catch {
+      return [];
+    }
+  }
+
+  async getTables(db: Kysely<any>): Promise<string[]> {
+    try {
+      const results = await db
+        .selectFrom('information_schema.tables')
+        .select('table_name')
+        .where('table_schema', '=', 'public')
+        .where('table_type', '=', 'BASE TABLE')
+        .execute();
+      return results.map((r) => r.table_name as string);
+    } catch {
+      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;
+    } catch {
+      return 0;
+    }
+  }
+
+  async truncateTable(db: Kysely<any>, tableName: string): Promise<void> {
+    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
+    }
+  }
+
+  async truncateAllTables(db: Kysely<any>, exclude: string[] = []): Promise<void> {
+    const tables = await this.getTables(db);
+    for (const table of tables) {
+      if (!exclude.includes(table)) {
+        await this.truncateTable(db, table);
+      }
+    }
+  }
+}
+
+export const postgresAdapter = new PostgresAdapter();

package/src/adapters/sqlite.ts

@@ -0,0 +1,109 @@
+/**
+ * SQLite Dialect Adapter
+ */
+
+import type { Kysely } from 'kysely';
+import { sql } from 'kysely';
+import type { DialectAdapter, DatabaseErrorLike } from '../types.js';
+
+export class SQLiteAdapter implements DialectAdapter {
+  readonly dialect = 'sqlite' as const;
+
+  getDefaultPort(): null {
+    // SQLite is file-based, no port
+    return null;
+  }
+
+  getCurrentTimestamp(): string {
+    return "datetime('now')";
+  }
+
+  escapeIdentifier(identifier: string): string {
+    return `"${identifier.replace(/"/g, '""')}"`;
+  }
+
+  formatDate(date: Date): string {
+    return date.toISOString();
+  }
+
+  isUniqueConstraintError(error: unknown): boolean {
+    const e = error as DatabaseErrorLike;
+    const message = e.message?.toLowerCase() || '';
+    return message.includes('unique constraint failed');
+  }
+
+  isForeignKeyError(error: unknown): boolean {
+    const e = error as DatabaseErrorLike;
+    const message = e.message?.toLowerCase() || '';
+    return message.includes('foreign key constraint failed');
+  }
+
+  isNotNullError(error: unknown): boolean {
+    const e = error as DatabaseErrorLike;
+    const message = e.message?.toLowerCase() || '';
+    return message.includes('not null constraint failed');
+  }
+
+  async tableExists(db: Kysely<any>, tableName: string): Promise<boolean> {
+    try {
+      const result = await db
+        .selectFrom('sqlite_master')
+        .select('name')
+        .where('type', '=', 'table')
+        .where('name', '=', tableName)
+        .executeTakeFirst();
+      return !!result;
+    } catch {
+      return false;
+    }
+  }
+
+  async getTableColumns(db: Kysely<any>, tableName: string): Promise<string[]> {
+    try {
+      const results = await sql.raw(`PRAGMA table_info(${tableName})`).execute(db);
+      return (results.rows as Array<{ name: string }>).map((r) => r.name);
+    } catch {
+      return [];
+    }
+  }
+
+  async getTables(db: Kysely<any>): Promise<string[]> {
+    try {
+      const results = await db
+        .selectFrom('sqlite_master')
+        .select('name')
+        .where('type', '=', 'table')
+        .where('name', 'not like', 'sqlite_%')
+        .execute();
+      return results.map((r) => r.name as string);
+    } catch {
+      return [];
+    }
+  }
+
+  async getDatabaseSize(_db: Kysely<any>, _databaseName?: string): Promise<number> {
+    // SQLite database size requires file system access
+    // which is not available in a cross-runtime way
+    return 0;
+  }
+
+  async truncateTable(db: Kysely<any>, tableName: string): Promise<void> {
+    try {
+      // SQLite doesn't support TRUNCATE, use DELETE instead
+      await db.deleteFrom(tableName as any).execute();
+    } catch {
+      // Ignore errors for tables that might not exist
+    }
+  }
+
+  async truncateAllTables(db: Kysely<any>, exclude: string[] = []): Promise<void> {
+    const tables = await this.getTables(db);
+    for (const table of tables) {
+      if (!exclude.includes(table)) {
+        await this.truncateTable(db, table);
+      }
+    }
+  }
+}
+
+export const sqliteAdapter = new SQLiteAdapter();

package/src/connection.ts

@@ -0,0 +1,66 @@
+/**
+ * Connection URL utilities
+ */
+
+import type { DatabaseDialect, ConnectionConfig } from './types.js';
+import { getAdapter } from './factory.js';
+
+/**
+ * Parse database connection URL into ConnectionConfig
+ *
+ * @example
+ * const config = parseConnectionUrl('postgresql://user:pass@localhost:5432/mydb?ssl=true');
+ * // { host: 'localhost', port: 5432, database: 'mydb', user: 'user', password: 'pass', ssl: true }
+ */
+export function parseConnectionUrl(url: string): ConnectionConfig {
+  const parsed = new URL(url);
+
+  return {
+    host: parsed.hostname,
+    port: parsed.port ? parseInt(parsed.port) : undefined,
+    database: parsed.pathname.slice(1),
+    user: parsed.username || undefined,
+    password: parsed.password || undefined,
+    ssl: parsed.searchParams.get('ssl') === 'true' || parsed.searchParams.get('sslmode') === 'require',
+  };
+}
+
+/**
+ * Build connection URL from config
+ *
+ * @example
+ * const url = buildConnectionUrl('postgres', { host: 'localhost', database: 'mydb' });
+ * // 'postgresql://localhost:5432/mydb'
+ */
+export function buildConnectionUrl(dialect: DatabaseDialect, config: ConnectionConfig): string {
+  const protocol = dialect === 'postgres' ? 'postgresql' : dialect;
+  const auth = config.user
+    ? config.password
+      ? `${config.user}:${config.password}@`
+      : `${config.user}@`
+    : '';
+
+  const host = config.host || 'localhost';
+  const port = config.port || getAdapter(dialect).getDefaultPort();
+  const database = config.database;
+
+  let url = port ? `${protocol}://${auth}${host}:${port}/${database}` : `${protocol}://${auth}${host}/${database}`;
+
+  if (config.ssl) {
+    url += '?ssl=true';
+  }
+
+  return url;
+}
+
+/**
+ * Get default port for a dialect
+ *
+ * @example
+ * getDefaultPort('postgres') // 5432
+ * getDefaultPort('mysql')    // 3306
+ * getDefaultPort('sqlite')   // null
+ */
+export function getDefaultPort(dialect: DatabaseDialect): number | null {
+  return getAdapter(dialect).getDefaultPort();
+}

package/src/factory.ts

@@ -0,0 +1,58 @@
+/**
+ * Dialect Adapter Factory
+ */
+
+import type { DatabaseDialect, DialectAdapter } from './types.js';
+import { PostgresAdapter, postgresAdapter } from './adapters/postgres.js';
+import { MySQLAdapter, mysqlAdapter } from './adapters/mysql.js';
+import { SQLiteAdapter, sqliteAdapter } from './adapters/sqlite.js';
+
+const adapters: Record<DatabaseDialect, DialectAdapter> = {
+  postgres: postgresAdapter,
+  mysql: mysqlAdapter,
+  sqlite: sqliteAdapter,
+};
+
+/**
+ * Get a dialect adapter for the specified dialect
+ *
+ * @example
+ * const adapter = getAdapter('postgres');
+ * console.log(adapter.getDefaultPort()); // 5432
+ */
+export function getAdapter(dialect: DatabaseDialect): DialectAdapter {
+  const adapter = adapters[dialect];
+  if (!adapter) {
+    throw new Error(`Unknown dialect: ${dialect}. Supported: postgres, mysql, sqlite`);
+  }
+  return adapter;
+}
+
+/**
+ * Create a new dialect adapter instance
+ *
+ * @example
+ * const adapter = createDialectAdapter('mysql');
+ */
+export function createDialectAdapter(dialect: DatabaseDialect): DialectAdapter {
+  switch (dialect) {
+    case 'postgres':
+      return new PostgresAdapter();
+    case 'mysql':
+      return new MySQLAdapter();
+    case 'sqlite':
+      return new SQLiteAdapter();
+    default:
+      throw new Error(`Unknown dialect: ${dialect}. Supported: postgres, mysql, sqlite`);
+  }
+}
+
+/**
+ * Register a custom dialect adapter
+ *
+ * @example
+ * registerAdapter(customAdapter);
+ */
+export function registerAdapter(adapter: DialectAdapter): void {
+  adapters[adapter.dialect] = adapter;
+}

package/src/helpers.ts

@@ -0,0 +1,149 @@
+/**
+ * Dialect Helper Functions
+ *
+ * Standalone helper functions that accept dialect as parameter
+ * for backward compatibility with existing code.
+ */
+
+import type { Kysely } from 'kysely';
+import type { DatabaseDialect } from './types.js';
+import { getAdapter } from './factory.js';
+
+/**
+ * Check if table exists in the database
+ *
+ * @example
+ * const exists = await tableExists(db, 'users', 'postgres');
+ */
+export async function tableExists(db: Kysely<any>, tableName: string, dialect: DatabaseDialect): Promise<boolean> {
+  return getAdapter(dialect).tableExists(db, tableName);
+}
+
+/**
+ * Get column names for a table
+ *
+ * @example
+ * const columns = await getTableColumns(db, 'users', 'postgres');
+ * // ['id', 'name', 'email', 'created_at']
+ */
+export async function getTableColumns(
+  db: Kysely<any>,
+  tableName: string,
+  dialect: DatabaseDialect
+): Promise<string[]> {
+  return getAdapter(dialect).getTableColumns(db, tableName);
+}
+
+/**
+ * Get all tables in the database
+ *
+ * @example
+ * const tables = await getTables(db, 'postgres');
+ * // ['users', 'posts', 'comments']
+ */
+export async function getTables(db: Kysely<any>, dialect: DatabaseDialect): Promise<string[]> {
+  return getAdapter(dialect).getTables(db);
+}
+
+/**
+ * Escape identifier for SQL (table names, column names, etc.)
+ *
+ * @example
+ * escapeIdentifier('my-table', 'postgres') // '"my-table"'
+ * escapeIdentifier('my-table', 'mysql')    // '`my-table`'
+ */
+export function escapeIdentifier(identifier: string, dialect: DatabaseDialect): string {
+  return getAdapter(dialect).escapeIdentifier(identifier);
+}
+
+/**
+ * Get SQL expression for current timestamp
+ *
+ * @example
+ * getCurrentTimestamp('postgres') // 'CURRENT_TIMESTAMP'
+ * getCurrentTimestamp('sqlite')   // "datetime('now')"
+ */
+export function getCurrentTimestamp(dialect: DatabaseDialect): string {
+  return getAdapter(dialect).getCurrentTimestamp();
+}
+
+/**
+ * Format date for database insertion
+ *
+ * @example
+ * formatDate(new Date(), 'postgres') // '2024-01-15T10:30:00.000Z'
+ * formatDate(new Date(), 'mysql')    // '2024-01-15 10:30:00'
+ */
+export function formatDate(date: Date, dialect: DatabaseDialect): string {
+  return getAdapter(dialect).formatDate(date);
+}
+
+/**
+ * Check if error is a unique constraint violation
+ *
+ * @example
+ * try {
+ *   await db.insertInto('users').values({ email: 'duplicate@example.com' }).execute();
+ * } catch (error) {
+ *   if (isUniqueConstraintError(error, 'postgres')) {
+ *     console.log('Email already exists');
+ *   }
+ * }
+ */
+export function isUniqueConstraintError(error: unknown, dialect: DatabaseDialect): boolean {
+  return getAdapter(dialect).isUniqueConstraintError(error);
+}
+
+/**
+ * Check if error is a foreign key constraint violation
+ *
+ * @example
+ * if (isForeignKeyError(error, 'mysql')) {
+ *   console.log('Referenced row does not exist');
+ * }
+ */
+export function isForeignKeyError(error: unknown, dialect: DatabaseDialect): boolean {
+  return getAdapter(dialect).isForeignKeyError(error);
+}
+
+/**
+ * Check if error is a not-null constraint violation
+ *
+ * @example
+ * if (isNotNullError(error, 'sqlite')) {
+ *   console.log('Required field is missing');
+ * }
+ */
+export function isNotNullError(error: unknown, dialect: DatabaseDialect): boolean {
+  return getAdapter(dialect).isNotNullError(error);
+}
+
+/**
+ * Get database size in bytes
+ *
+ * @example
+ * const size = await getDatabaseSize(db, 'postgres');
+ * console.log(`Database size: ${size} bytes`);
+ */
+export async function getDatabaseSize(
+  db: Kysely<any>,
+  dialect: DatabaseDialect,
+  databaseName?: string
+): Promise<number> {
+  return getAdapter(dialect).getDatabaseSize(db, databaseName);
+}
+
+/**
+ * Truncate all tables in the database (useful for testing)
+ *
+ * @example
+ * // Truncate all tables except migrations
+ * await truncateAllTables(db, 'postgres', ['kysely_migrations']);
+ */
+export async function truncateAllTables(
+  db: Kysely<any>,
+  dialect: DatabaseDialect,
+  exclude: string[] = []
+): Promise<void> {
+  return getAdapter(dialect).truncateAllTables(db, exclude);
+}

package/src/index.ts

@@ -0,0 +1,55 @@
+/**
+ * @kysera/dialects
+ *
+ * Dialect-specific utilities for Kysely database operations.
+ * Supports PostgreSQL, MySQL, and SQLite with a unified adapter interface.
+ *
+ * @example
+ * // Using the adapter interface
+ * import { getAdapter } from '@kysera/dialects';
+ *
+ * const adapter = getAdapter('postgres');
+ * const exists = await adapter.tableExists(db, 'users');
+ * const columns = await adapter.getTableColumns(db, 'users');
+ *
+ * @example
+ * // Using helper functions (backward compatible)
+ * import { tableExists, escapeIdentifier, isUniqueConstraintError } from '@kysera/dialects';
+ *
+ * const exists = await tableExists(db, 'users', 'postgres');
+ * const escaped = escapeIdentifier('user-data', 'mysql');
+ *
+ * @example
+ * // Connection URL utilities
+ * import { parseConnectionUrl, buildConnectionUrl } from '@kysera/dialects';
+ *
+ * const config = parseConnectionUrl('postgresql://user:pass@localhost:5432/mydb');
+ * const url = buildConnectionUrl('postgres', { host: 'localhost', database: 'mydb' });
+ */
+
+// Types
+export type { DatabaseDialect, ConnectionConfig, DialectAdapter, DatabaseErrorLike } from './types.js';
+
+// Factory and adapters
+export { getAdapter, createDialectAdapter, registerAdapter } from './factory.js';
+export { PostgresAdapter, postgresAdapter } from './adapters/postgres.js';
+export { MySQLAdapter, mysqlAdapter } from './adapters/mysql.js';
+export { SQLiteAdapter, sqliteAdapter } from './adapters/sqlite.js';
+
+// Connection utilities
+export { parseConnectionUrl, buildConnectionUrl, getDefaultPort } from './connection.js';
+
+// Helper functions (standalone, backward compatible)
+export {
+  tableExists,
+  getTableColumns,
+  getTables,
+  escapeIdentifier,
+  getCurrentTimestamp,
+  formatDate,
+  isUniqueConstraintError,
+  isForeignKeyError,
+  isNotNullError,
+  getDatabaseSize,
+  truncateAllTables,
+} from './helpers.js';

package/src/types.ts

@@ -0,0 +1,79 @@
+/**
+ * @kysera/dialects - Type Definitions
+ *
+ * Dialect-specific types and interfaces for database operations
+ */
+
+import type { Kysely } from 'kysely';
+
+/**
+ * Supported database dialects
+ */
+export type DatabaseDialect = 'postgres' | 'mysql' | 'sqlite';
+
+/**
+ * Database connection configuration
+ */
+export interface ConnectionConfig {
+  host?: string | undefined;
+  port?: number | undefined;
+  database: string;
+  user?: string | undefined;
+  password?: string | undefined;
+  ssl?: boolean | undefined;
+}
+
+/**
+ * Interface for dialect-specific operations
+ */
+export interface DialectAdapter {
+  /** The dialect this adapter handles */
+  readonly dialect: DatabaseDialect;
+
+  /** Get default port for this dialect */
+  getDefaultPort(): number | null;
+
+  /** Get SQL expression for current timestamp */
+  getCurrentTimestamp(): string;
+
+  /** Escape identifier for this dialect */
+  escapeIdentifier(identifier: string): string;
+
+  /** Format date for this dialect */
+  formatDate(date: Date): string;
+
+  /** Check if error is a unique constraint violation */
+  isUniqueConstraintError(error: unknown): boolean;
+
+  /** Check if error is a foreign key constraint violation */
+  isForeignKeyError(error: unknown): boolean;
+
+  /** Check if error is a not-null constraint violation */
+  isNotNullError(error: unknown): boolean;
+
+  /** Check if a table exists in the database */
+  tableExists(db: Kysely<any>, tableName: string): Promise<boolean>;
+
+  /** Get column names for a table */
+  getTableColumns(db: Kysely<any>, tableName: string): Promise<string[]>;
+
+  /** Get all tables in the database */
+  getTables(db: Kysely<any>): Promise<string[]>;
+
+  /** Get database size in bytes */
+  getDatabaseSize(db: Kysely<any>, databaseName?: string): Promise<number>;
+
+  /** Truncate a single table */
+  truncateTable(db: Kysely<any>, tableName: string): Promise<void>;
+
+  /** Truncate all tables (for testing) */
+  truncateAllTables(db: Kysely<any>, exclude?: string[]): Promise<void>;
+}
+
+/**
+ * Error object shape for database error detection
+ */
+export interface DatabaseErrorLike {
+  message?: string;
+  code?: string;
+}