spindb 0.37.2 → 0.38.0

package/config/paths.ts

@@ -1,200 +0,0 @@
-import { join } from 'path'
-import { readdirSync, existsSync } from 'fs'
-import { getEngineDefaults } from './engine-defaults'
-import { platformService } from '../core/platform-service'
-
-/**
- * Get the SpinDB home directory.
- * Checks SPINDB_HOME env var first (useful for testing), then falls back
- * to platform-specific home directory detection.
- */
-function getSpinDBHome(): string {
-  if (process.env.SPINDB_HOME) {
-    return process.env.SPINDB_HOME
-  }
-  const platformInfo = platformService.getPlatformInfo()
-  return join(platformInfo.homeDir, '.spindb')
-}
-
-const SPINDB_HOME = getSpinDBHome()
-
-// 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,
-
-  // Directory for downloaded database binaries
-  bin: join(SPINDB_HOME, 'bin'),
-
-  // Directory for container data
-  containers: join(SPINDB_HOME, 'containers'),
-
-  // Global config file
-  config: join(SPINDB_HOME, 'config.json'),
-
-  // 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
-   * 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 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, 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, 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 engine-specific containers directory
-  getEngineContainersPath(engine: string): string {
-    return join(this.containers, engine)
-  },
-
-  /**
-   * Find all installed binary versions for an engine.
-   * Scans the bin directory for directories matching the pattern:
-   * {engine}-{version}-{platform}-{arch}
-   *
-   * @returns Array of { version, path } objects sorted by version descending
-   */
-  findInstalledBinaries(
-    engine: string,
-    platform: string,
-    arch: string,
-  ): Array<{ version: string; path: string }> {
-    if (!existsSync(this.bin)) {
-      return []
-    }
-
-    const suffix = `-${platform}-${arch}`
-    const prefix = `${engine}-`
-
-    try {
-      const entries = readdirSync(this.bin, { withFileTypes: true })
-      const results: Array<{ version: string; path: string }> = []
-
-      for (const entry of entries) {
-        if (!entry.isDirectory()) continue
-        if (!entry.name.startsWith(prefix)) continue
-        if (!entry.name.endsWith(suffix)) continue
-
-        // Extract version from directory name
-        // e.g., "postgresql-17.7.0-darwin-arm64" -> "17.7.0"
-        const versionPart = entry.name.slice(prefix.length, -suffix.length)
-        if (versionPart) {
-          results.push({
-            version: versionPart,
-            path: join(this.bin, entry.name),
-          })
-        }
-      }
-
-      // Sort by version descending (newest first)
-      // Handles non-numeric segments (e.g., "1.0.0-beta") by falling back to string comparison
-      return results.sort((a, b) => {
-        const aParts = a.version.split('.')
-        const bParts = b.version.split('.')
-        for (let i = 0; i < Math.max(aParts.length, bParts.length); i++) {
-          const aRaw = aParts[i] || '0'
-          const bRaw = bParts[i] || '0'
-          const aNum = Number(aRaw)
-          const bNum = Number(bRaw)
-          // If both are valid numbers, compare numerically
-          if (!isNaN(aNum) && !isNaN(bNum)) {
-            if (bNum !== aNum) return bNum - aNum
-          } else {
-            // Fall back to string comparison for non-numeric segments
-            const cmp = bRaw.localeCompare(aRaw)
-            if (cmp !== 0) return cmp
-          }
-        }
-        return 0
-      })
-    } catch {
-      return []
-    }
-  },
-
-  /**
-   * Find installed binaries for an engine with a specific major version.
-   *
-   * @returns The newest installed version matching the major version, or null
-   */
-  findInstalledBinaryForMajor(
-    engine: string,
-    majorVersion: string,
-    platform: string,
-    arch: string,
-  ): { version: string; path: string } | null {
-    const installed = this.findInstalledBinaries(engine, platform, arch)
-    const majorPrefix = `${majorVersion}.`
-
-    // Find the first (newest) version that matches the major version
-    for (const entry of installed) {
-      if (
-        entry.version.startsWith(majorPrefix) ||
-        entry.version === majorVersion
-      ) {
-        return entry
-      }
-    }
-
-    return null
-  },
-}

package/core/backup-restore.ts

@@ -1,330 +0,0 @@
-/**
- * Core backup and restore functionality
- *
- * This module provides shared backup/restore logic used by:
- * - CLI commands (backup.ts, restore.ts)
- * - Interactive menu handlers (backup-handlers.ts)
- *
- * By centralizing this logic, we avoid duplication and ensure consistency.
- */
-
-import chalk from 'chalk'
-import { existsSync, statSync } from 'fs'
-import { mkdir } from 'fs/promises'
-import { join } from 'path'
-import { containerManager } from './container-manager'
-import { getMissingDependencies } from './dependency-manager'
-import { platformService } from './platform-service'
-import { getEngine } from '../engines'
-import { createSpinner } from '../cli/ui/spinner'
-import { uiSuccess, uiError, formatBytes } from '../cli/ui/theme'
-import {
-  getBackupExtension,
-  getBackupSpinnerLabel,
-  LARGE_BACKUP_THRESHOLD,
-  VERY_LARGE_BACKUP_THRESHOLD,
-} from '../config/backup-formats'
-import type { ContainerConfig, BackupFormatType } from '../types'
-
-// Generate a timestamp string for backup filenames
-export function generateBackupTimestamp(): string {
-  const now = new Date()
-  return now.toISOString().replace(/:/g, '').split('.')[0]
-}
-
-// Generate a default backup filename
-export function generateBackupFilename(
-  containerName: string,
-  databaseName: string,
-): string {
-  const timestamp = generateBackupTimestamp()
-  return `${containerName}-${databaseName}-backup-${timestamp}`
-}
-
-/**
- * Check if required tools are installed for an engine
- * @returns Array of missing dependencies, or empty if all available
- */
-export async function checkBackupDependencies(
-  engine: string,
-): Promise<{ name: string; binary: string }[]> {
-  return getMissingDependencies(engine)
-}
-
-// Get the estimated size of a database for backup
-export async function estimateBackupSize(
-  config: ContainerConfig,
-): Promise<number | null> {
-  try {
-    const engine = getEngine(config.engine)
-    return await engine.getDatabaseSize(config)
-  } catch {
-    return null
-  }
-}
-
-// Options for performing a backup
-export type BackupOptions = {
-  containerName: string
-  databaseName: string
-  format: BackupFormatType
-  outputDir: string
-  filename: string
-  // Show spinner and console output
-  interactive?: boolean
-  // Callback for progress updates
-  onProgress?: (message: string) => void
-}
-
-// Result of a backup operation
-export type BackupResult = {
-  success: boolean
-  path?: string
-  size?: number
-  format?: string
-  error?: string
-}
-
-// Perform a backup operation
-export async function performBackup(
-  options: BackupOptions,
-): Promise<BackupResult> {
-  const {
-    containerName,
-    databaseName,
-    format,
-    outputDir,
-    filename,
-    interactive = true,
-    onProgress,
-  } = options
-
-  const config = await containerManager.getConfig(containerName)
-  if (!config) {
-    return { success: false, error: `Container "${containerName}" not found` }
-  }
-
-  const engine = getEngine(config.engine)
-  const extension = getBackupExtension(config.engine, format)
-  const outputPath = join(outputDir, `${filename}${extension}`)
-
-  // Ensure output directory exists
-  if (!existsSync(outputDir)) {
-    await mkdir(outputDir, { recursive: true })
-  }
-
-  const spinnerLabel = getBackupSpinnerLabel(config.engine, format)
-  const spinner = interactive
-    ? createSpinner(`Creating ${spinnerLabel} backup of "${databaseName}"...`)
-    : null
-
-  spinner?.start()
-  onProgress?.(`Creating ${spinnerLabel} backup...`)
-
-  try {
-    const result = await engine.backup(config, outputPath, {
-      database: databaseName,
-      format,
-    })
-
-    spinner?.succeed('Backup created successfully')
-
-    if (interactive) {
-      console.log()
-      console.log(uiSuccess('Backup complete'))
-      console.log()
-      console.log(chalk.gray('  Saved to:'), chalk.cyan(result.path))
-      console.log(chalk.gray('  Size:'), chalk.white(formatBytes(result.size)))
-      console.log(chalk.gray('  Format:'), chalk.white(result.format))
-      console.log()
-    }
-
-    return {
-      success: true,
-      path: result.path,
-      size: result.size,
-      format: result.format,
-    }
-  } catch (error) {
-    const e = error as Error
-    spinner?.fail('Backup failed')
-
-    if (interactive) {
-      console.log()
-      console.log(uiError(e.message))
-      console.log()
-    }
-
-    return { success: false, error: e.message }
-  }
-}
-
-// Options for performing a restore
-export type RestoreOptions = {
-  containerName: string
-  databaseName: string
-  backupPath: string
-  // Create new database if it doesn't exist
-  createDatabase?: boolean
-  // Force overwrite existing database
-  force?: boolean
-  // Show spinner and console output
-  interactive?: boolean
-  // Callback for progress updates
-  onProgress?: (message: string) => void
-}
-
-// Result of a restore operation
-export type RestoreResult = {
-  success: boolean
-  databaseName?: string
-  connectionString?: string
-  warnings?: string[]
-  error?: string
-}
-
-// Check backup file size and return warning level
-export function checkBackupSize(backupPath: string): {
-  size: number
-  level: 'normal' | 'large' | 'very_large'
-} {
-  try {
-    const stats = statSync(backupPath)
-    const size = stats.size
-
-    if (size >= VERY_LARGE_BACKUP_THRESHOLD) {
-      return { size, level: 'very_large' }
-    }
-    if (size >= LARGE_BACKUP_THRESHOLD) {
-      return { size, level: 'large' }
-    }
-    return { size, level: 'normal' }
-  } catch {
-    return { size: 0, level: 'normal' }
-  }
-}
-
-// Perform a restore operation
-export async function performRestore(
-  options: RestoreOptions,
-): Promise<RestoreResult> {
-  const {
-    containerName,
-    databaseName,
-    backupPath,
-    createDatabase = true,
-    interactive = true,
-    onProgress,
-  } = options
-
-  const config = await containerManager.getConfig(containerName)
-  if (!config) {
-    return { success: false, error: `Container "${containerName}" not found` }
-  }
-
-  const engine = getEngine(config.engine)
-
-  // Create database if needed
-  if (createDatabase) {
-    const existingDbs = config.databases || [config.database]
-    if (!existingDbs.includes(databaseName)) {
-      const spinner = interactive
-        ? createSpinner(`Creating database "${databaseName}"...`)
-        : null
-      spinner?.start()
-      onProgress?.(`Creating database "${databaseName}"...`)
-
-      try {
-        await engine.createDatabase(config, databaseName)
-        spinner?.succeed(`Database "${databaseName}" created`)
-
-        // Update container config
-        await containerManager.updateConfig(containerName, {
-          databases: [...existingDbs, databaseName],
-        })
-      } catch (error) {
-        const e = error as Error
-        spinner?.fail('Failed to create database')
-        return { success: false, error: e.message }
-      }
-    }
-  }
-
-  // Perform restore
-  const spinner = interactive
-    ? createSpinner(`Restoring to "${databaseName}"...`)
-    : null
-  spinner?.start()
-  onProgress?.(`Restoring to "${databaseName}"...`)
-
-  try {
-    const result = await engine.restore(config, backupPath, {
-      database: databaseName,
-    })
-
-    const warnings: string[] = []
-
-    if (result.code === 0) {
-      spinner?.succeed('Restore completed successfully')
-    } else {
-      spinner?.warn('Restore completed with warnings')
-      if (result.stderr) {
-        const lines = result.stderr.split('\n').filter((l) => l.trim())
-        warnings.push(...lines.slice(0, 10))
-      }
-    }
-
-    const connectionString = engine.getConnectionString(config, databaseName)
-
-    if (interactive) {
-      console.log()
-      console.log(uiSuccess(`Database "${databaseName}" restored`))
-      console.log(chalk.gray('  Connection string:'))
-      console.log(chalk.cyan(`  ${connectionString}`))
-
-      const copied = await platformService.copyToClipboard(connectionString)
-      if (copied) {
-        console.log(chalk.gray('  ✓ Connection string copied to clipboard'))
-      }
-      console.log()
-
-      if (warnings.length > 0) {
-        console.log(chalk.yellow('  Warnings:'))
-        for (const warning of warnings) {
-          console.log(chalk.gray(`  ${warning}`))
-        }
-        console.log()
-      }
-    }
-
-    return {
-      success: true,
-      databaseName,
-      connectionString,
-      warnings: warnings.length > 0 ? warnings : undefined,
-    }
-  } catch (error) {
-    const e = error as Error
-    spinner?.fail('Restore failed')
-
-    if (interactive) {
-      console.log()
-      console.log(uiError(e.message))
-      console.log()
-    }
-
-    return { success: false, error: e.message }
-  }
-}
-
-/**
- * Get the default/primary database for a container
- * If there's only one database, returns it; otherwise returns null
- */
-export function getDefaultDatabase(config: ContainerConfig): string | null {
-  const databases = config.databases || [config.database]
-  if (databases.length === 1) {
-    return databases[0]
-  }
-  return null
-}