spindb 0.4.1 → 0.5.2

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()
 
@@ -410,11 +412,72 @@ export async function promptInstallDependencies(
     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',

package/config/engine-defaults.ts

@@ -0,0 +1,84 @@
+/**
+ * Engine-specific default configurations
+ * Extracted for dependency injection pattern - allows each engine to define its own defaults
+ */
+
+export type EngineDefaults = {
+  /** Default version to use when not specified */
+  defaultVersion: string
+  /** Default port for this engine */
+  defaultPort: number
+  /** Port range to scan if default is busy */
+  portRange: { start: number; end: number }
+  /** Supported major versions */
+  supportedVersions: string[]
+  /** Default superuser name */
+  superuser: string
+  /** Connection string scheme (e.g., 'postgresql', 'mysql') */
+  connectionScheme: string
+  /** Log file name within container directory */
+  logFileName: string
+  /** PID file name (relative to data directory or container) */
+  pidFileName: string
+  /** Subdirectory for data files within container */
+  dataSubdir: string
+  /** Client tools required for this engine */
+  clientTools: string[]
+}
+
+export const engineDefaults: Record<string, EngineDefaults> = {
+  postgresql: {
+    defaultVersion: '16',
+    defaultPort: 5432,
+    portRange: { start: 5432, end: 5500 },
+    supportedVersions: ['14', '15', '16', '17'],
+    superuser: 'postgres',
+    connectionScheme: 'postgresql',
+    logFileName: 'postgres.log',
+    pidFileName: 'postmaster.pid',
+    dataSubdir: 'data',
+    clientTools: ['psql', 'pg_dump', 'pg_restore', 'pg_basebackup'],
+  },
+  mysql: {
+    defaultVersion: '9.0',
+    defaultPort: 3306,
+    portRange: { start: 3306, end: 3400 },
+    supportedVersions: ['5.7', '8.0', '8.4', '9.0'],
+    superuser: 'root',
+    connectionScheme: 'mysql',
+    logFileName: 'mysql.log',
+    pidFileName: 'mysql.pid',
+    dataSubdir: 'data',
+    clientTools: ['mysql', 'mysqldump', 'mysqlpump'],
+  },
+}
+
+/**
+ * Get engine defaults by name
+ * @throws Error if engine is not found
+ */
+export function getEngineDefaults(engine: string): EngineDefaults {
+  const normalized = engine.toLowerCase()
+  const defaults = engineDefaults[normalized]
+  if (!defaults) {
+    const available = Object.keys(engineDefaults).join(', ')
+    throw new Error(
+      `Unknown engine "${engine}". Available engines: ${available}`,
+    )
+  }
+  return defaults
+}
+
+/**
+ * Check if an engine is supported
+ */
+export function isEngineSupported(engine: string): boolean {
+  return engine.toLowerCase() in engineDefaults
+}
+
+/**
+ * Get list of all supported engine names
+ */
+export function getSupportedEngines(): string[] {
+  return Object.keys(engineDefaults)
+}

package/config/os-dependencies.ts

@@ -241,28 +241,53 @@ const postgresqlDependencies: EngineDependencies = {
 
 const mysqlDependencies: EngineDependencies = {
   engine: 'mysql',
-  displayName: 'MySQL',
+  displayName: 'MySQL/MariaDB',
   dependencies: [
+    {
+      name: 'mysqld',
+      binary: 'mysqld',
+      description: 'MySQL/MariaDB server daemon',
+      packages: {
+        brew: { package: 'mysql' },
+        // Modern Debian/Ubuntu use mariadb-server (MySQL-compatible)
+        apt: { package: 'mariadb-server' },
+        yum: { package: 'mariadb-server' },
+        dnf: { package: 'mariadb-server' },
+        pacman: { package: 'mariadb' },
+      },
+      manualInstall: {
+        darwin: [
+          'Install Homebrew: /bin/bash -c "$(curl -fsSL https://raw.githubusercontent.com/Homebrew/install/HEAD/install.sh)"',
+          'Then run: brew install mysql',
+        ],
+        linux: [
+          'Debian/Ubuntu: sudo apt install mariadb-server',
+          'CentOS/RHEL: sudo yum install mariadb-server',
+          'Fedora: sudo dnf install mariadb-server',
+          'Arch: sudo pacman -S mariadb',
+        ],
+      },
+    },
     {
       name: 'mysql',
       binary: 'mysql',
-      description: 'MySQL command-line client',
+      description: 'MySQL/MariaDB command-line client',
       packages: {
-        brew: { package: 'mysql-client' },
-        apt: { package: 'mysql-client' },
-        yum: { package: 'mysql' },
-        dnf: { package: 'mysql' },
+        brew: { package: 'mysql' },
+        apt: { package: 'mariadb-client' },
+        yum: { package: 'mariadb' },
+        dnf: { package: 'mariadb' },
         pacman: { package: 'mariadb-clients' },
       },
       manualInstall: {
         darwin: [
           'Install Homebrew: /bin/bash -c "$(curl -fsSL https://raw.githubusercontent.com/Homebrew/install/HEAD/install.sh)"',
-          'Then run: brew install mysql-client',
+          'Then run: brew install mysql',
         ],
         linux: [
-          'Ubuntu/Debian: sudo apt install mysql-client',
-          'CentOS/RHEL: sudo yum install mysql',
-          'Fedora: sudo dnf install mysql',
+          'Debian/Ubuntu: sudo apt install mariadb-client',
+          'CentOS/RHEL: sudo yum install mariadb',
+          'Fedora: sudo dnf install mariadb',
           'Arch: sudo pacman -S mariadb-clients',
         ],
       },
@@ -270,23 +295,47 @@ const mysqlDependencies: EngineDependencies = {
     {
       name: 'mysqldump',
       binary: 'mysqldump',
-      description: 'MySQL database backup utility',
+      description: 'MySQL/MariaDB database backup utility',
+      packages: {
+        brew: { package: 'mysql' },
+        apt: { package: 'mariadb-client' },
+        yum: { package: 'mariadb' },
+        dnf: { package: 'mariadb' },
+        pacman: { package: 'mariadb-clients' },
+      },
+      manualInstall: {
+        darwin: [
+          'Install Homebrew: /bin/bash -c "$(curl -fsSL https://raw.githubusercontent.com/Homebrew/install/HEAD/install.sh)"',
+          'Then run: brew install mysql',
+        ],
+        linux: [
+          'Debian/Ubuntu: sudo apt install mariadb-client',
+          'CentOS/RHEL: sudo yum install mariadb',
+          'Fedora: sudo dnf install mariadb',
+          'Arch: sudo pacman -S mariadb-clients',
+        ],
+      },
+    },
+    {
+      name: 'mysqladmin',
+      binary: 'mysqladmin',
+      description: 'MySQL/MariaDB server administration utility',
       packages: {
-        brew: { package: 'mysql-client' },
-        apt: { package: 'mysql-client' },
-        yum: { package: 'mysql' },
-        dnf: { package: 'mysql' },
+        brew: { package: 'mysql' },
+        apt: { package: 'mariadb-client' },
+        yum: { package: 'mariadb' },
+        dnf: { package: 'mariadb' },
         pacman: { package: 'mariadb-clients' },
       },
       manualInstall: {
         darwin: [
           'Install Homebrew: /bin/bash -c "$(curl -fsSL https://raw.githubusercontent.com/Homebrew/install/HEAD/install.sh)"',
-          'Then run: brew install mysql-client',
+          'Then run: brew install mysql',
         ],
         linux: [
-          'Ubuntu/Debian: sudo apt install mysql-client',
-          'CentOS/RHEL: sudo yum install mysql',
-          'Fedora: sudo dnf install mysql',
+          'Debian/Ubuntu: sudo apt install mariadb-client',
+          'CentOS/RHEL: sudo yum install mariadb',
+          'Fedora: sudo dnf install mariadb',
           'Arch: sudo pacman -S mariadb-clients',
         ],
       },

package/config/paths.ts

@@ -1,6 +1,7 @@
 import { homedir } from 'os'
 import { join } from 'path'
 import { execSync } from 'child_process'
+import { getEngineDefaults } from './engine-defaults'
 
 /**
  * Get the real user's home directory, even when running under sudo.
@@ -41,6 +42,23 @@ function getRealHomeDir(): string {
 
 const SPINDB_HOME = join(getRealHomeDir(), '.spindb')
 
+/**
+ * Options for container path functions
+ */
+type ContainerPathOptions = {
+  engine: string
+}
+
+/**
+ * Options for binary path functions
+ */
+type BinaryPathOptions = {
+  engine: string
+  version: string
+  platform: string
+  arch: string
+}
+
 export const paths = {
   // Root directory for all spindb data
   root: SPINDB_HOME,
@@ -54,38 +72,75 @@ export const paths = {
   // Global config file
   config: join(SPINDB_HOME, 'config.json'),
 
-  // Get path for a specific binary version
-  getBinaryPath(
-    engine: string,
-    version: string,
-    platform: string,
-    arch: string,
-  ): string {
+  /**
+   * Get path for a specific binary version
+   */
+  getBinaryPath(options: BinaryPathOptions): string {
+    const { engine, version, platform, arch } = options
     return join(this.bin, `${engine}-${version}-${platform}-${arch}`)
   },
 
-  // Get path for a specific container
-  getContainerPath(name: string): string {
-    return join(this.containers, name)
+  /**
+   * Get path for a specific container
+   * New structure: ~/.spindb/containers/{engine}/{name}/
+   */
+  getContainerPath(name: string, options: ContainerPathOptions): string {
+    const { engine } = options
+    return join(this.containers, engine, name)
   },
 
-  // Get path for container config
-  getContainerConfigPath(name: string): string {
-    return join(this.containers, name, 'container.json')
+  /**
+   * Get path for container config file
+   */
+  getContainerConfigPath(name: string, options: ContainerPathOptions): string {
+    const { engine } = options
+    return join(this.containers, engine, name, 'container.json')
   },
 
-  // Get path for container data directory
-  getContainerDataPath(name: string): string {
-    return join(this.containers, name, 'data')
+  /**
+   * Get path for container data directory
+   */
+  getContainerDataPath(name: string, options: ContainerPathOptions): string {
+    const { engine } = options
+    const engineDef = getEngineDefaults(engine)
+    return join(this.containers, engine, name, engineDef.dataSubdir)
   },
 
-  // Get path for container log file
-  getContainerLogPath(name: string): string {
-    return join(this.containers, name, 'postgres.log')
+  /**
+   * Get path for container log file
+   */
+  getContainerLogPath(name: string, options: ContainerPathOptions): string {
+    const { engine } = options
+    const engineDef = getEngineDefaults(engine)
+    return join(this.containers, engine, name, engineDef.logFileName)
+  },
+
+  /**
+   * Get path for container PID file
+   * Note: For PostgreSQL, PID is inside data dir. For MySQL, it may differ.
+   */
+  getContainerPidPath(name: string, options: ContainerPathOptions): string {
+    const { engine } = options
+    const engineDef = getEngineDefaults(engine)
+    // PostgreSQL: data/postmaster.pid
+    // MySQL: data/mysql.pid (or just mysql.pid depending on config)
+    if (engine === 'postgresql') {
+      return join(
+        this.containers,
+        engine,
+        name,
+        engineDef.dataSubdir,
+        engineDef.pidFileName,
+      )
+    }
+    // MySQL and others: PID file at container level
+    return join(this.containers, engine, name, engineDef.pidFileName)
   },
 
-  // Get path for container PID file
-  getContainerPidPath(name: string): string {
-    return join(this.containers, name, 'data', 'postmaster.pid')
+  /**
+   * Get path for engine-specific containers directory
+   */
+  getEngineContainersPath(engine: string): string {
+    return join(this.containers, engine)
   },
 }