spindb 0.4.0 → 0.5.2

package/cli/commands/restore.ts

@@ -15,6 +15,7 @@ import { success, error, warning } from '../ui/theme'
 import { platform, tmpdir } from 'os'
 import { spawn } from 'child_process'
 import { join } from 'path'
+import { getMissingDependencies } from '../../core/dependency-manager'
 
 export const restoreCommand = new Command('restore')
   .description('Restore a backup to a container')
@@ -75,8 +76,12 @@ export const restoreCommand = new Command('restore')
           process.exit(1)
         }
 
+        const { engine: engineName } = config
+
         // Check if running
-        const running = await processManager.isRunning(containerName)
+        const running = await processManager.isRunning(containerName, {
+          engine: engineName,
+        })
         if (!running) {
           console.error(
             error(
@@ -87,18 +92,75 @@ export const restoreCommand = new Command('restore')
         }
 
         // Get engine
-        const engine = getEngine(config.engine)
+        const engine = getEngine(engineName)
+
+        // Check for required client tools BEFORE doing anything
+        const depsSpinner = createSpinner('Checking required tools...')
+        depsSpinner.start()
+
+        let missingDeps = await getMissingDependencies(config.engine)
+        if (missingDeps.length > 0) {
+          depsSpinner.warn(
+            `Missing tools: ${missingDeps.map((d) => d.name).join(', ')}`,
+          )
+
+          // Offer to install
+          const installed = await promptInstallDependencies(
+            missingDeps[0].binary,
+            config.engine,
+          )
+
+          if (!installed) {
+            process.exit(1)
+          }
+
+          // Verify installation worked
+          missingDeps = await getMissingDependencies(config.engine)
+          if (missingDeps.length > 0) {
+            console.error(
+              error(
+                `Still missing tools: ${missingDeps.map((d) => d.name).join(', ')}`,
+              ),
+            )
+            process.exit(1)
+          }
+
+          console.log(chalk.green('  ✓ All required tools are now available'))
+          console.log()
+        } else {
+          depsSpinner.succeed('Required tools available')
+        }
 
         // Handle --from-url option
         if (options.fromUrl) {
-          // Validate connection string
-          if (
-            !options.fromUrl.startsWith('postgresql://') &&
-            !options.fromUrl.startsWith('postgres://')
-          ) {
+          // Validate connection string matches container's engine
+          const isPgUrl =
+            options.fromUrl.startsWith('postgresql://') ||
+            options.fromUrl.startsWith('postgres://')
+          const isMysqlUrl = options.fromUrl.startsWith('mysql://')
+
+          if (engineName === 'postgresql' && !isPgUrl) {
+            console.error(
+              error(
+                'Connection string must start with postgresql:// or postgres:// for PostgreSQL containers',
+              ),
+            )
+            process.exit(1)
+          }
+
+          if (engineName === 'mysql' && !isMysqlUrl) {
             console.error(
               error(
-                'Connection string must start with postgresql:// or postgres://',
+                'Connection string must start with mysql:// for MySQL containers',
+              ),
+            )
+            process.exit(1)
+          }
+
+          if (!isPgUrl && !isMysqlUrl) {
+            console.error(
+              error(
+                'Connection string must start with postgresql://, postgres://, or mysql://',
               ),
             )
             process.exit(1)
@@ -108,31 +170,53 @@ export const restoreCommand = new Command('restore')
           const timestamp = Date.now()
           tempDumpPath = join(tmpdir(), `spindb-dump-${timestamp}.dump`)
 
-          const dumpSpinner = createSpinner(
-            'Creating dump from remote database...',
-          )
-          dumpSpinner.start()
+          let dumpSuccess = false
+          let attempts = 0
+          const maxAttempts = 2 // Allow one retry after installing deps
 
-          try {
-            await engine.dumpFromConnectionString(options.fromUrl, tempDumpPath)
-            dumpSpinner.succeed('Dump created from remote database')
-            backupPath = tempDumpPath
-          } catch (err) {
-            const e = err as Error
-            dumpSpinner.fail('Failed to create dump')
-
-            // Check if this is a missing tool error
-            if (
-              e.message.includes('pg_dump not found') ||
-              e.message.includes('ENOENT')
-            ) {
-              await promptInstallDependencies('pg_dump')
+          while (!dumpSuccess && attempts < maxAttempts) {
+            attempts++
+            const dumpSpinner = createSpinner(
+              'Creating dump from remote database...',
+            )
+            dumpSpinner.start()
+
+            try {
+              await engine.dumpFromConnectionString(options.fromUrl, tempDumpPath)
+              dumpSpinner.succeed('Dump created from remote database')
+              backupPath = tempDumpPath
+              dumpSuccess = true
+            } catch (err) {
+              const e = err as Error
+              dumpSpinner.fail('Failed to create dump')
+
+              // Check if this is a missing tool error
+              const dumpTool = engineName === 'mysql' ? 'mysqldump' : 'pg_dump'
+              if (
+                e.message.includes(`${dumpTool} not found`) ||
+                e.message.includes('ENOENT')
+              ) {
+                const installed = await promptInstallDependencies(
+                  dumpTool,
+                  engineName,
+                )
+                if (!installed) {
+                  process.exit(1)
+                }
+                // Loop will retry
+                continue
+              }
+
+              console.log()
+              console.error(error(`${dumpTool} error:`))
+              console.log(chalk.gray(`  ${e.message}`))
               process.exit(1)
             }
+          }
 
-            console.log()
-            console.error(error('pg_dump error:'))
-            console.log(chalk.gray(`  ${e.message}`))
+          // Safety check - should never reach here without backupPath set
+          if (!dumpSuccess) {
+            console.error(error('Failed to create dump after retries'))
             process.exit(1)
           }
         } else {
@@ -162,6 +246,12 @@ export const restoreCommand = new Command('restore')
           databaseName = await promptDatabaseName(containerName)
         }
 
+        // At this point backupPath is guaranteed to be set
+        if (!backupPath) {
+          console.error(error('No backup path specified'))
+          process.exit(1)
+        }
+
         // Detect backup format
         const detectSpinner = createSpinner('Detecting backup format...')
         detectSpinner.start()
@@ -251,15 +341,29 @@ export const restoreCommand = new Command('restore')
       } catch (err) {
         const e = err as Error
 
-        // Check if this is a missing tool error
-        if (
-          e.message.includes('pg_restore not found') ||
-          e.message.includes('psql not found')
-        ) {
-          const missingTool = e.message.includes('pg_restore')
-            ? 'pg_restore'
-            : 'psql'
-          await promptInstallDependencies(missingTool)
+        // Check if this is a missing tool error (PostgreSQL or MySQL)
+        const missingToolPatterns = [
+          // PostgreSQL
+          'pg_restore not found',
+          'psql not found',
+          'pg_dump not found',
+          // MySQL
+          'mysql not found',
+          'mysqldump not found',
+        ]
+
+        const matchingPattern = missingToolPatterns.find((p) =>
+          e.message.includes(p),
+        )
+
+        if (matchingPattern) {
+          const missingTool = matchingPattern.replace(' not found', '')
+          const installed = await promptInstallDependencies(missingTool)
+          if (installed) {
+            console.log(
+              chalk.yellow('  Please re-run your command to continue.'),
+            )
+          }
           process.exit(1)
         }
 

package/cli/commands/start.ts

@@ -4,6 +4,7 @@ import { containerManager } from '../../core/container-manager'
 import { portManager } from '../../core/port-manager'
 import { processManager } from '../../core/process-manager'
 import { getEngine } from '../../engines'
+import { getEngineDefaults } from '../../config/defaults'
 import { promptContainerSelect } from '../ui/prompts'
 import { createSpinner } from '../ui/spinner'
 import { error, warning } from '../ui/theme'
@@ -46,18 +47,27 @@ export const startCommand = new Command('start')
         process.exit(1)
       }
 
+      const { engine: engineName } = config
+
       // Check if already running
-      const running = await processManager.isRunning(containerName)
+      const running = await processManager.isRunning(containerName, {
+        engine: engineName,
+      })
       if (running) {
         console.log(warning(`Container "${containerName}" is already running`))
         return
       }
 
+      // Get engine defaults for port range and database name
+      const engineDefaults = getEngineDefaults(engineName)
+
       // Check port availability
       const portAvailable = await portManager.isPortAvailable(config.port)
       if (!portAvailable) {
-        // Try to find a new port
-        const { port: newPort } = await portManager.findAvailablePort()
+        // Try to find a new port (using engine-specific port range)
+        const { port: newPort } = await portManager.findAvailablePort({
+          portRange: engineDefaults.portRange,
+        })
         console.log(
           warning(
             `Port ${config.port} is in use, switching to port ${newPort}`,
@@ -68,7 +78,7 @@ export const startCommand = new Command('start')
       }
 
       // Get engine and start
-      const engine = getEngine(config.engine)
+      const engine = getEngine(engineName)
 
       const spinner = createSpinner(`Starting ${containerName}...`)
       spinner.start()
@@ -78,6 +88,22 @@ export const startCommand = new Command('start')
 
       spinner.succeed(`Container "${containerName}" started`)
 
+      // Ensure the user's database exists (if different from default)
+      const defaultDb = engineDefaults.superuser // postgres or root
+      if (config.database && config.database !== defaultDb) {
+        const dbSpinner = createSpinner(
+          `Ensuring database "${config.database}" exists...`,
+        )
+        dbSpinner.start()
+        try {
+          await engine.createDatabase(config, config.database)
+          dbSpinner.succeed(`Database "${config.database}" ready`)
+        } catch {
+          // Database might already exist, which is fine
+          dbSpinner.succeed(`Database "${config.database}" ready`)
+        }
+      }
+
       // Show connection info
       const connectionString = engine.getConnectionString(config)
       console.log()

package/cli/commands/stop.ts

@@ -67,7 +67,9 @@ export const stopCommand = new Command('stop')
       }
 
       // Check if running
-      const running = await processManager.isRunning(containerName)
+      const running = await processManager.isRunning(containerName, {
+        engine: config.engine,
+      })
       if (!running) {
         console.log(warning(`Container "${containerName}" is not running`))
         return

package/cli/ui/prompts.ts

@@ -2,12 +2,13 @@ import inquirer from 'inquirer'
 import chalk from 'chalk'
 import ora from 'ora'
 import { listEngines, getEngine } from '../../engines'
-import { defaults } from '../../config/defaults'
+import { defaults, getEngineDefaults } from '../../config/defaults'
 import { installPostgresBinaries } from '../../core/postgres-binary-manager'
 import {
   detectPackageManager,
   getManualInstallInstructions,
   getCurrentPlatform,
+  installEngineDependencies,
 } from '../../core/dependency-manager'
 import { getEngineDependencies } from '../../config/os-dependencies'
 import type { ContainerConfig } from '../../types'
@@ -36,25 +37,26 @@ export async function promptContainerName(
   return name
 }
 
+/**
+ * Engine icons for display
+ */
+const engineIcons: Record<string, string> = {
+  postgresql: '🐘',
+  mysql: '🐬',
+}
+
 /**
  * Prompt for database engine selection
  */
 export async function promptEngine(): Promise<string> {
   const engines = listEngines()
 
-  // Build choices from available engines plus coming soon engines
-  const choices = [
-    ...engines.map((e) => ({
-      name: `🐘 ${e.displayName} ${chalk.gray(`(versions: ${e.supportedVersions.join(', ')})`)}`,
-      value: e.name,
-      short: e.displayName,
-    })),
-    {
-      name: chalk.gray('🐬 MySQL (coming soon)'),
-      value: 'mysql',
-      disabled: 'Coming soon',
-    },
-  ]
+  // Build choices from available engines
+  const choices = engines.map((e) => ({
+    name: `${engineIcons[e.name] || '🗄️'} ${e.displayName} ${chalk.gray(`(versions: ${e.supportedVersions.join(', ')})`)}`,
+    value: e.name,
+    short: e.displayName,
+  }))
 
   const { engine } = await inquirer.prompt<{ engine: string }>([
     {
@@ -69,8 +71,8 @@ export async function promptEngine(): Promise<string> {
 }
 
 /**
- * Prompt for PostgreSQL version
- * Two-step selection: first major version, then specific minor version
+ * Prompt for database version
+ * Two-step selection: first major version, then specific minor version (if available)
  */
 export async function promptVersion(engineName: string): Promise<string> {
   const engine = getEngine(engineName)
@@ -112,13 +114,13 @@ export async function promptVersion(engineName: string): Promise<string> {
     const countLabel =
       versionCount > 0 ? chalk.gray(`(${versionCount} versions)`) : ''
     const label = isLatestMajor
-      ? `PostgreSQL ${major} ${countLabel} ${chalk.green('← latest')}`
-      : `PostgreSQL ${major} ${countLabel}`
+      ? `${engine.displayName} ${major} ${countLabel} ${chalk.green('← latest')}`
+      : `${engine.displayName} ${major} ${countLabel}`
 
     majorChoices.push({
       name: label,
       value: major,
-      short: `PostgreSQL ${major}`,
+      short: `${engine.displayName} ${major}`,
     })
   }
 
@@ -150,7 +152,7 @@ export async function promptVersion(engineName: string): Promise<string> {
     {
       type: 'list',
       name: 'version',
-      message: `Select PostgreSQL ${majorVersion} version:`,
+      message: `Select ${engine.displayName} ${majorVersion} version:`,
       choices: minorChoices,
       default: minorVersions[0], // Default to latest
     },
@@ -225,7 +227,7 @@ export async function promptContainerSelect(
       name: 'container',
       message,
       choices: containers.map((c) => ({
-        name: `${c.name} ${chalk.gray(`(${c.engine} ${c.version}, port ${c.port})`)} ${
+        name: `${c.name} ${chalk.gray(`(${engineIcons[c.engine] || '🗄️'} ${c.engine} ${c.version}, port ${c.port})`)} ${
           c.status === 'running'
             ? chalk.green('● running')
             : chalk.gray('○ stopped')
@@ -279,16 +281,17 @@ export type CreateOptions = {
 /**
  * Full interactive create flow
  */
-export async function promptCreateOptions(
-  defaultPort: number = defaults.port,
-): Promise<CreateOptions> {
+export async function promptCreateOptions(): Promise<CreateOptions> {
   console.log(chalk.cyan('\n  🗄️  Create New Database Container\n'))
 
   const engine = await promptEngine()
   const version = await promptVersion(engine)
   const name = await promptContainerName()
   const database = await promptDatabaseName(name) // Default to container name
-  const port = await promptPort(defaultPort)
+
+  // Get engine-specific default port
+  const engineDefaults = getEngineDefaults(engine)
+  const port = await promptPort(engineDefaults.defaultPort)
 
   return { name, engine, version, port, database }
 }
@@ -393,8 +396,7 @@ export async function promptInstallDependencies(
 
   console.log()
 
-  // For now, only PostgreSQL has full install support
-  // Future engines will need their own install functions
+  // PostgreSQL has its own install function with extra logic
   if (engine === 'postgresql') {
     const success = await installPostgresBinaries()
 
@@ -403,18 +405,79 @@ export async function promptInstallDependencies(
       console.log(
         chalk.green(`  ${engineName} client tools installed successfully!`),
       )
-      console.log(chalk.gray('  Please try your operation again.'))
+      console.log(chalk.gray('  Continuing with your operation...'))
       console.log()
     }
 
     return success
   }
 
-  // For other engines, show manual instructions
+  // For other engines (MySQL, etc.), use the generic installer
   console.log(
-    chalk.yellow(`  Automatic installation for ${engineName} is not yet supported.`),
+    chalk.cyan(`  Installing ${engineName} with ${packageManager.name}...`),
   )
-  console.log(chalk.gray('  Please install manually.'))
+  console.log(chalk.gray('  You may be prompted for your password.'))
   console.log()
-  return false
+
+  try {
+    const results = await installEngineDependencies(engine, packageManager)
+    const allSuccess = results.every((r) => r.success)
+
+    if (allSuccess) {
+      console.log()
+      console.log(
+        chalk.green(`  ${engineName} tools installed successfully!`),
+      )
+      console.log(chalk.gray('  Continuing with your operation...'))
+      console.log()
+      return true
+    } else {
+      const failed = results.filter((r) => !r.success)
+      console.log()
+      console.log(chalk.red('  Some installations failed:'))
+      for (const f of failed) {
+        console.log(chalk.red(`    ${f.dependency.name}: ${f.error}`))
+      }
+      console.log()
+
+      // Show manual install instructions
+      if (engineDeps) {
+        const instructions = getManualInstallInstructions(
+          engineDeps.dependencies[0],
+          platform,
+        )
+        if (instructions.length > 0) {
+          console.log(chalk.gray('  To install manually:'))
+          for (const instruction of instructions) {
+            console.log(chalk.gray(`    ${instruction}`))
+          }
+          console.log()
+        }
+      }
+
+      return false
+    }
+  } catch (err) {
+    const e = err as Error
+    console.log()
+    console.log(chalk.red(`  Installation failed: ${e.message}`))
+    console.log()
+
+    // Show manual install instructions on error
+    if (engineDeps) {
+      const instructions = getManualInstallInstructions(
+        engineDeps.dependencies[0],
+        platform,
+      )
+      if (instructions.length > 0) {
+        console.log(chalk.gray('  To install manually:'))
+        for (const instruction of instructions) {
+          console.log(chalk.gray(`    ${instruction}`))
+        }
+        console.log()
+      }
+    }
+
+    return false
+  }
 }

package/config/defaults.ts

@@ -1,3 +1,20 @@
+import {
+  engineDefaults,
+  getEngineDefaults,
+  isEngineSupported,
+  getSupportedEngines,
+  type EngineDefaults,
+} from './engine-defaults'
+
+// Re-export engine-related functions and types
+export {
+  engineDefaults,
+  getEngineDefaults,
+  isEngineSupported,
+  getSupportedEngines,
+  type EngineDefaults,
+}
+
 export type PlatformMappings = {
   [key: string]: string
 }
@@ -7,42 +24,50 @@ export type PortRange = {
   end: number
 }
 
+/**
+ * Legacy Defaults type - kept for backward compatibility
+ * New code should use getEngineDefaults(engine) instead
+ */
 export type Defaults = {
+  /** @deprecated Use getEngineDefaults(engine).defaultVersion instead */
   postgresVersion: string
   port: number
   portRange: PortRange
   engine: string
+  /** @deprecated Use getEngineDefaults(engine).supportedVersions instead */
   supportedPostgresVersions: string[]
   superuser: string
   platformMappings: PlatformMappings
 }
 
-// TODO - make defaults configurable via env vars or config file
-// TODO - make defaults generic so it supports multiple engines
-// TODO - consider using a configuration file or environment variables for overrides
+// Get PostgreSQL defaults from engine-defaults
+const pgDefaults = engineDefaults.postgresql
+
+/**
+ * Default configuration values
+ * For backward compatibility, this defaults to PostgreSQL settings.
+ * New code should use getEngineDefaults(engine) for engine-specific defaults.
+ */
 export const defaults: Defaults = {
-  // Default PostgreSQL version
-  postgresVersion: '16',
+  // Default PostgreSQL version (from engine defaults)
+  postgresVersion: pgDefaults.defaultVersion,
 
   // Default port (standard PostgreSQL port)
-  port: 5432,
+  port: pgDefaults.defaultPort,
 
   // Port range to scan if default is busy
-  portRange: {
-    start: 5432,
-    end: 5500,
-  },
+  portRange: pgDefaults.portRange,
 
   // Default engine
   engine: 'postgresql',
 
-  // Supported PostgreSQL versions
-  supportedPostgresVersions: ['14', '15', '16', '17'],
+  // Supported PostgreSQL versions (from engine defaults)
+  supportedPostgresVersions: pgDefaults.supportedVersions,
 
-  // Default superuser
-  superuser: 'postgres',
+  // Default superuser (from engine defaults)
+  superuser: pgDefaults.superuser,
 
-  // Platform mappings for zonky.io binaries
+  // Platform mappings for zonky.io binaries (PostgreSQL specific)
   platformMappings: {
     'darwin-arm64': 'darwin-arm64v8',
     'darwin-x64': 'darwin-amd64',