spindb 0.5.2 → 0.5.4

package/core/start-with-retry.ts

@@ -0,0 +1,167 @@
+/**
+ * Start with Retry
+ *
+ * Handles port race conditions by automatically retrying with a new port
+ * when the original port becomes unavailable between check and bind.
+ */
+
+import { portManager } from './port-manager'
+import { containerManager } from './container-manager'
+import { logWarning, logDebug } from './error-handler'
+import type { BaseEngine } from '../engines/base-engine'
+import type { ContainerConfig } from '../types'
+
+// =============================================================================
+// Types
+// =============================================================================
+
+export type StartWithRetryOptions = {
+  engine: BaseEngine
+  config: ContainerConfig
+  maxRetries?: number // Default: 3
+  onPortChange?: (oldPort: number, newPort: number) => void
+}
+
+export type StartWithRetryResult = {
+  success: boolean
+  finalPort: number
+  retriesUsed: number
+  error?: Error
+}
+
+// =============================================================================
+// Port Error Detection
+// =============================================================================
+
+/**
+ * Check if an error is a port-in-use error
+ */
+function isPortInUseError(err: unknown): boolean {
+  const message = (err as Error)?.message?.toLowerCase() || ''
+  return (
+    message.includes('address already in use') ||
+    message.includes('eaddrinuse') ||
+    (message.includes('port') && message.includes('in use')) ||
+    message.includes('could not bind') ||
+    message.includes('socket already in use')
+  )
+}
+
+// =============================================================================
+// Start with Retry Implementation
+// =============================================================================
+
+/**
+ * Start a database container with automatic port retry on conflict
+ *
+ * This handles the race condition where a port is available when checked
+ * but taken by the time the database server tries to bind to it.
+ */
+export async function startWithRetry(
+  options: StartWithRetryOptions,
+): Promise<StartWithRetryResult> {
+  const { engine, config, maxRetries = 3, onPortChange } = options
+
+  for (let attempt = 1; attempt <= maxRetries; attempt++) {
+    try {
+      logDebug(`Starting ${engine.name} (attempt ${attempt}/${maxRetries})`, {
+        containerName: config.name,
+        port: config.port,
+      })
+
+      await engine.start(config)
+
+      return {
+        success: true,
+        finalPort: config.port,
+        retriesUsed: attempt - 1,
+      }
+    } catch (err) {
+      const isPortError = isPortInUseError(err)
+
+      logDebug(`Start attempt ${attempt} failed`, {
+        containerName: config.name,
+        port: config.port,
+        isPortError,
+        error: err instanceof Error ? err.message : String(err),
+      })
+
+      if (isPortError && attempt < maxRetries) {
+        const oldPort = config.port
+
+        // Find a new available port, excluding the one that just failed
+        const { port: newPort } = await portManager.findAvailablePort({
+          portRange: getEnginePortRange(config.engine),
+        })
+
+        // Update config with new port
+        config.port = newPort
+        await containerManager.updateConfig(config.name, { port: newPort })
+
+        // Notify caller of port change
+        if (onPortChange) {
+          onPortChange(oldPort, newPort)
+        }
+
+        // Log and retry
+        logWarning(
+          `Port ${oldPort} is in use, retrying with port ${newPort}...`,
+        )
+        continue
+      }
+
+      // Not a port error or max retries exceeded
+      return {
+        success: false,
+        finalPort: config.port,
+        retriesUsed: attempt - 1,
+        error: err instanceof Error ? err : new Error(String(err)),
+      }
+    }
+  }
+
+  // Should never reach here, but TypeScript needs a return
+  return {
+    success: false,
+    finalPort: config.port,
+    retriesUsed: maxRetries,
+    error: new Error('Max retries exceeded'),
+  }
+}
+
+/**
+ * Get the port range for an engine
+ */
+function getEnginePortRange(engine: string): { start: number; end: number } {
+  // Import defaults dynamically to avoid circular dependency
+  // These are the standard ranges from config/defaults.ts
+  if (engine === 'postgresql') {
+    return { start: 5432, end: 5500 }
+  }
+  if (engine === 'mysql') {
+    return { start: 3306, end: 3400 }
+  }
+  // Default fallback range
+  return { start: 5432, end: 6000 }
+}
+
+/**
+ * Wrapper that simplifies the common use case
+ */
+export async function startContainerWithRetry(
+  engine: BaseEngine,
+  config: ContainerConfig,
+  options?: {
+    onPortChange?: (oldPort: number, newPort: number) => void
+  },
+): Promise<void> {
+  const result = await startWithRetry({
+    engine,
+    config,
+    onPortChange: options?.onPortChange,
+  })
+
+  if (!result.success && result.error) {
+    throw result.error
+  }
+}

package/core/transaction-manager.ts

@@ -0,0 +1,170 @@
+/**
+ * Transaction Manager
+ *
+ * Provides rollback support for multi-step operations like container creation.
+ * If any step fails, all previously completed steps are rolled back in reverse order.
+ */
+
+import { logError, logDebug, ErrorCodes } from './error-handler'
+
+// =============================================================================
+// Types
+// =============================================================================
+
+export type RollbackAction = {
+  description: string
+  execute: () => Promise<void>
+}
+
+// =============================================================================
+// Transaction Manager Implementation
+// =============================================================================
+
+/**
+ * Manages a stack of rollback actions for transactional operations.
+ *
+ * Usage:
+ * ```typescript
+ * const tx = new TransactionManager()
+ *
+ * try {
+ *   await createDirectory()
+ *   tx.addRollback({
+ *     description: 'Delete directory',
+ *     execute: () => deleteDirectory()
+ *   })
+ *
+ *   await initDatabase()
+ *   // Directory rollback covers this too
+ *
+ *   await startServer()
+ *   tx.addRollback({
+ *     description: 'Stop server',
+ *     execute: () => stopServer()
+ *   })
+ *
+ *   tx.commit() // Success - clear rollback stack
+ * } catch (err) {
+ *   await tx.rollback() // Error - undo everything
+ *   throw err
+ * }
+ * ```
+ */
+export class TransactionManager {
+  private rollbackStack: RollbackAction[] = []
+  private committed = false
+
+  /**
+   * Add a rollback action to the stack.
+   * Actions are executed in reverse order during rollback.
+   */
+  addRollback(action: RollbackAction): void {
+    if (this.committed) {
+      throw new Error('Cannot add rollback action after commit')
+    }
+    this.rollbackStack.push(action)
+    logDebug(`Added rollback action: ${action.description}`, {
+      totalActions: this.rollbackStack.length,
+    })
+  }
+
+  /**
+   * Execute all rollbacks in reverse order.
+   * Continues even if individual rollback actions fail.
+   */
+  async rollback(): Promise<void> {
+    if (this.committed) {
+      logDebug('Skipping rollback - transaction was committed')
+      return
+    }
+
+    if (this.rollbackStack.length === 0) {
+      logDebug('No rollback actions to execute')
+      return
+    }
+
+    logDebug(`Starting rollback of ${this.rollbackStack.length} actions`)
+
+    // Execute in reverse order (LIFO)
+    while (this.rollbackStack.length > 0) {
+      const action = this.rollbackStack.pop()!
+
+      try {
+        logDebug(`Executing rollback: ${action.description}`)
+        await action.execute()
+        logDebug(`Rollback successful: ${action.description}`)
+      } catch (err) {
+        // Log error but continue with other rollbacks
+        logError({
+          code: ErrorCodes.ROLLBACK_FAILED,
+          message: `Failed to rollback: ${action.description}`,
+          severity: 'warning',
+          context: {
+            error: err instanceof Error ? err.message : String(err),
+          },
+        })
+      }
+    }
+
+    logDebug('Rollback complete')
+  }
+
+  /**
+   * Mark the transaction as committed.
+   * Clears the rollback stack since we don't need to undo anything.
+   */
+  commit(): void {
+    if (this.committed) {
+      return // Already committed
+    }
+
+    logDebug(`Committing transaction with ${this.rollbackStack.length} actions`)
+    this.rollbackStack = []
+    this.committed = true
+  }
+
+  /**
+   * Check if the transaction has been committed.
+   */
+  isCommitted(): boolean {
+    return this.committed
+  }
+
+  /**
+   * Get the number of pending rollback actions.
+   */
+  getPendingCount(): number {
+    return this.rollbackStack.length
+  }
+}
+
+/**
+ * Helper function to execute an operation with automatic rollback on failure.
+ *
+ * Usage:
+ * ```typescript
+ * await withTransaction(async (tx) => {
+ *   await step1()
+ *   tx.addRollback({ description: 'Undo step1', execute: undoStep1 })
+ *
+ *   await step2()
+ *   tx.addRollback({ description: 'Undo step2', execute: undoStep2 })
+ *
+ *   // If we get here without throwing, transaction commits automatically
+ * })
+ * ```
+ */
+export async function withTransaction<T>(
+  operation: (tx: TransactionManager) => Promise<T>,
+): Promise<T> {
+  const tx = new TransactionManager()
+
+  try {
+    const result = await operation(tx)
+    tx.commit()
+    return result
+  } catch (err) {
+    await tx.rollback()
+    throw err
+  }
+}

package/engines/mysql/binary-detection.ts

@@ -5,89 +5,15 @@
 
 import { exec } from 'child_process'
 import { promisify } from 'util'
-import { existsSync } from 'fs'
-import { platform } from 'os'
+import { platformService } from '../../core/platform-service'
 
 const execAsync = promisify(exec)
 
 /**
- * Common paths where MySQL binaries might be installed
+ * Find a MySQL binary by name using the platform service
  */
-const MYSQL_SEARCH_PATHS = {
-  darwin: [
-    // Homebrew (Apple Silicon)
-    '/opt/homebrew/bin',
-    '/opt/homebrew/opt/mysql/bin',
-    '/opt/homebrew/opt/mysql@8.0/bin',
-    '/opt/homebrew/opt/mysql@8.4/bin',
-    '/opt/homebrew/opt/mysql@5.7/bin',
-    // Homebrew (Intel)
-    '/usr/local/bin',
-    '/usr/local/opt/mysql/bin',
-    '/usr/local/opt/mysql@8.0/bin',
-    '/usr/local/opt/mysql@8.4/bin',
-    '/usr/local/opt/mysql@5.7/bin',
-    // Official MySQL installer
-    '/usr/local/mysql/bin',
-  ],
-  linux: [
-    '/usr/bin',
-    '/usr/sbin',
-    '/usr/local/bin',
-    '/usr/local/mysql/bin',
-  ],
-  win32: [
-    'C:\\Program Files\\MySQL\\MySQL Server 8.0\\bin',
-    'C:\\Program Files\\MySQL\\MySQL Server 8.4\\bin',
-    'C:\\Program Files\\MySQL\\MySQL Server 5.7\\bin',
-  ],
-}
-
-/**
- * Get search paths for the current platform
- */
-function getSearchPaths(): string[] {
-  const plat = platform()
-  return MYSQL_SEARCH_PATHS[plat as keyof typeof MYSQL_SEARCH_PATHS] || []
-}
-
-/**
- * Check if a binary exists at the given path
- */
-function binaryExists(path: string): boolean {
-  return existsSync(path)
-}
-
-/**
- * Find a MySQL binary by name
- */
-export async function findMysqlBinary(
-  name: string,
-): Promise<string | null> {
-  // First, try using 'which' or 'where' command
-  try {
-    const cmd = platform() === 'win32' ? 'where' : 'which'
-    const { stdout } = await execAsync(`${cmd} ${name}`)
-    const path = stdout.trim().split('\n')[0]
-    if (path && binaryExists(path)) {
-      return path
-    }
-  } catch {
-    // Not found in PATH, continue to search common locations
-  }
-
-  // Search common installation paths
-  const searchPaths = getSearchPaths()
-  for (const dir of searchPaths) {
-    const fullPath = platform() === 'win32'
-      ? `${dir}\\${name}.exe`
-      : `${dir}/${name}`
-    if (binaryExists(fullPath)) {
-      return fullPath
-    }
-  }
-
-  return null
+export async function findMysqlBinary(name: string): Promise<string | null> {
+  return platformService.findToolPath(name)
 }
 
 /**
@@ -180,6 +106,7 @@ export async function detectInstalledVersions(): Promise<
   Record<string, string>
 > {
   const versions: Record<string, string> = {}
+  const { platform } = platformService.getPlatformInfo()
 
   // Check default mysqld
   const defaultMysqld = await getMysqldPath()
@@ -191,25 +118,26 @@ export async function detectInstalledVersions(): Promise<
     }
   }
 
-  // Check versioned Homebrew installations
-  const homebrewPaths = platform() === 'darwin'
-    ? [
-        '/opt/homebrew/opt/mysql@5.7/bin/mysqld',
-        '/opt/homebrew/opt/mysql@8.0/bin/mysqld',
-        '/opt/homebrew/opt/mysql@8.4/bin/mysqld',
-        '/usr/local/opt/mysql@5.7/bin/mysqld',
-        '/usr/local/opt/mysql@8.0/bin/mysqld',
-        '/usr/local/opt/mysql@8.4/bin/mysqld',
-      ]
-    : []
-
-  for (const path of homebrewPaths) {
-    if (binaryExists(path)) {
-      const version = await getMysqlVersion(path)
-      if (version) {
-        const major = getMajorVersion(version)
-        if (!versions[major]) {
-          versions[major] = version
+  // Check versioned Homebrew installations (macOS only)
+  if (platform === 'darwin') {
+    const homebrewPaths = [
+      '/opt/homebrew/opt/mysql@5.7/bin/mysqld',
+      '/opt/homebrew/opt/mysql@8.0/bin/mysqld',
+      '/opt/homebrew/opt/mysql@8.4/bin/mysqld',
+      '/usr/local/opt/mysql@5.7/bin/mysqld',
+      '/usr/local/opt/mysql@8.0/bin/mysqld',
+      '/usr/local/opt/mysql@8.4/bin/mysqld',
+    ]
+
+    const { existsSync } = await import('fs')
+    for (const path of homebrewPaths) {
+      if (existsSync(path)) {
+        const version = await getMysqlVersion(path)
+        if (version) {
+          const major = getMajorVersion(version)
+          if (!versions[major]) {
+            versions[major] = version
+          }
         }
       }
     }
@@ -222,9 +150,9 @@ export async function detectInstalledVersions(): Promise<
  * Get install instructions for MySQL
  */
 export function getInstallInstructions(): string {
-  const plat = platform()
+  const { platform } = platformService.getPlatformInfo()
 
-  if (plat === 'darwin') {
+  if (platform === 'darwin') {
     return (
       'MySQL server not found. Install MySQL:\n' +
       '  brew install mysql\n' +
@@ -233,7 +161,7 @@ export function getInstallInstructions(): string {
     )
   }
 
-  if (plat === 'linux') {
+  if (platform === 'linux') {
     return (
       'MySQL server not found. Install MySQL:\n' +
       '  Ubuntu/Debian: sudo apt install mysql-server\n' +
@@ -246,3 +174,152 @@ export function getInstallInstructions(): string {
     '  https://dev.mysql.com/downloads/mysql/'
   )
 }
+
+export type MysqlPackageManager =
+  | 'homebrew'
+  | 'apt'
+  | 'yum'
+  | 'dnf'
+  | 'pacman'
+  | 'unknown'
+
+export type MysqlInstallInfo = {
+  packageManager: MysqlPackageManager
+  packageName: string
+  path: string
+  uninstallCommand: string
+  isMariaDB: boolean
+}
+
+/**
+ * Detect which package manager installed MySQL and get uninstall info
+ */
+export async function getMysqlInstallInfo(
+  mysqldPath: string,
+): Promise<MysqlInstallInfo> {
+  const { platform } = platformService.getPlatformInfo()
+  const mariadb = await isMariaDB()
+
+  // macOS: Check if path is in Homebrew directories
+  if (platform === 'darwin') {
+    if (
+      mysqldPath.includes('/opt/homebrew/') ||
+      mysqldPath.includes('/usr/local/Cellar/')
+    ) {
+      // Extract package name from path
+      // e.g., /opt/homebrew/opt/mysql@8.0/bin/mysqld -> mysql@8.0
+      // e.g., /opt/homebrew/bin/mysqld -> mysql (linked)
+      let packageName = mariadb ? 'mariadb' : 'mysql'
+
+      const versionMatch = mysqldPath.match(/mysql@(\d+\.\d+)/)
+      if (versionMatch) {
+        packageName = `mysql@${versionMatch[1]}`
+      } else {
+        // Try to get from Homebrew directly
+        try {
+          const { stdout } = await execAsync('brew list --formula')
+          const packages = stdout.split('\n')
+          const mysqlPackage = packages.find(
+            (p) =>
+              p.startsWith('mysql') ||
+              p.startsWith('mariadb') ||
+              p === 'percona-server',
+          )
+          if (mysqlPackage) {
+            packageName = mysqlPackage
+          }
+        } catch {
+          // Ignore errors
+        }
+      }
+
+      return {
+        packageManager: 'homebrew',
+        packageName,
+        path: mysqldPath,
+        uninstallCommand: `brew uninstall ${packageName}`,
+        isMariaDB: mariadb,
+      }
+    }
+  }
+
+  // Linux: Detect package manager from path or check installed packages
+  if (platform === 'linux') {
+    // Check for apt (Debian/Ubuntu)
+    try {
+      const { stdout } = await execAsync('which apt 2>/dev/null')
+      if (stdout.trim()) {
+        const packageName = mariadb ? 'mariadb-server' : 'mysql-server'
+        return {
+          packageManager: 'apt',
+          packageName,
+          path: mysqldPath,
+          uninstallCommand: `sudo apt remove ${packageName}`,
+          isMariaDB: mariadb,
+        }
+      }
+    } catch {
+      // Not apt
+    }
+
+    // Check for dnf (Fedora/RHEL 8+)
+    try {
+      const { stdout } = await execAsync('which dnf 2>/dev/null')
+      if (stdout.trim()) {
+        const packageName = mariadb ? 'mariadb-server' : 'mysql-server'
+        return {
+          packageManager: 'dnf',
+          packageName,
+          path: mysqldPath,
+          uninstallCommand: `sudo dnf remove ${packageName}`,
+          isMariaDB: mariadb,
+        }
+      }
+    } catch {
+      // Not dnf
+    }
+
+    // Check for yum (CentOS/RHEL 7)
+    try {
+      const { stdout } = await execAsync('which yum 2>/dev/null')
+      if (stdout.trim()) {
+        const packageName = mariadb ? 'mariadb-server' : 'mysql-server'
+        return {
+          packageManager: 'yum',
+          packageName,
+          path: mysqldPath,
+          uninstallCommand: `sudo yum remove ${packageName}`,
+          isMariaDB: mariadb,
+        }
+      }
+    } catch {
+      // Not yum
+    }
+
+    // Check for pacman (Arch Linux)
+    try {
+      const { stdout } = await execAsync('which pacman 2>/dev/null')
+      if (stdout.trim()) {
+        const packageName = mariadb ? 'mariadb' : 'mysql'
+        return {
+          packageManager: 'pacman',
+          packageName,
+          path: mysqldPath,
+          uninstallCommand: `sudo pacman -Rs ${packageName}`,
+          isMariaDB: mariadb,
+        }
+      }
+    } catch {
+      // Not pacman
+    }
+  }
+
+  // Unknown package manager
+  return {
+    packageManager: 'unknown',
+    packageName: mariadb ? 'mariadb' : 'mysql',
+    path: mysqldPath,
+    uninstallCommand: 'Use your system package manager to uninstall',
+    isMariaDB: mariadb,
+  }
+}