spindb 0.5.4 → 0.6.0

package/README.md

@@ -10,7 +10,7 @@ Spin up local PostgreSQL and MySQL databases without Docker. A lightweight alter
 - **Interactive menu** - Arrow-key navigation for all operations
 - **Auto port management** - Automatically finds available ports
 - **Clone containers** - Duplicate databases with all data
-- **Backup restore** - Restore pg_dump/mysqldump backups
+- **Backup & restore** - Create and restore pg_dump/mysqldump backups
 - **Custom database names** - Specify database name separate from container name
 - **Engine management** - View installed PostgreSQL versions and free up disk space
 - **Dynamic version selection** - Fetches available PostgreSQL versions from Maven Central
@@ -18,11 +18,23 @@ Spin up local PostgreSQL and MySQL databases without Docker. A lightweight alter
 ## Installation
 
 ```bash
-# Run directly with pnpx (no install needed)
+# Install globally (recommended)
+npm install -g spindb
+
+# Or run directly with pnpx (no install needed)
 pnpx spindb
+```
+
+### Updating
+
+SpinDB checks for updates automatically and will notify you when a new version is available:
 
-# Or install globally
-pnpm add -g spindb
+```bash
+# Update to latest version
+spindb self-update
+
+# Or check manually
+spindb version --check
 ```
 
 ## Quick Start
@@ -51,6 +63,7 @@ spindb connect mydb
 | `spindb connect [name]` | Connect with psql/mysql shell (`--pgcli`/`--mycli` for enhanced) |
 | `spindb url [name]` | Output connection string |
 | `spindb edit [name]` | Edit container properties (rename, port) |
+| `spindb backup [name]` | Create a database backup |
 | `spindb restore [name] [backup]` | Restore a backup file |
 | `spindb clone [source] [target]` | Clone a container |
 | `spindb delete [name]` | Delete a container |
@@ -60,6 +73,10 @@ spindb connect mydb
 | `spindb config detect` | Auto-detect database tools |
 | `spindb deps check` | Check status of client tools |
 | `spindb deps install` | Install missing client tools |
+| `spindb version` | Show current version |
+| `spindb version --check` | Check for available updates |
+| `spindb self-update` | Update to latest version |
+| `spindb config update-check [on\|off]` | Enable/disable update notifications |
 
 ## Supported Engines
 
@@ -304,6 +321,31 @@ psql $(spindb url mydb)
 spindb url mydb --copy
 ```
 
+### Backup databases
+
+```bash
+# Backup with default settings (SQL format, auto-generated filename)
+spindb backup mydb
+
+# Backup specific database in container
+spindb backup mydb --database my_app_db
+
+# Custom filename and output directory
+spindb backup mydb --name my-backup --output ./backups/
+
+# Choose format: sql (plain text) or dump (compressed/binary)
+spindb backup mydb --format sql     # Plain SQL (.sql)
+spindb backup mydb --format dump    # PostgreSQL custom format (.dump) / MySQL gzipped (.sql.gz)
+
+# Shorthand flags
+spindb backup mydb --sql            # Same as --format sql
+spindb backup mydb --dump           # Same as --format dump
+```
+
+**Backup formats:**
+- **SQL format** (`.sql`) - Plain text, universal, can be read/edited
+- **Dump format** - PostgreSQL uses custom format (`.dump`), MySQL uses gzipped SQL (`.sql.gz`)
+
 ### Edit containers
 
 ```bash

package/cli/commands/backup.ts

@@ -0,0 +1,269 @@
+import { Command } from 'commander'
+import { join } from 'path'
+import chalk from 'chalk'
+import { containerManager } from '../../core/container-manager'
+import { processManager } from '../../core/process-manager'
+import { getEngine } from '../../engines'
+import {
+  promptContainerSelect,
+  promptDatabaseSelect,
+  promptBackupFormat,
+  promptBackupFilename,
+  promptInstallDependencies,
+} from '../ui/prompts'
+import { createSpinner } from '../ui/spinner'
+import { success, error, warning, formatBytes } from '../ui/theme'
+import { getMissingDependencies } from '../../core/dependency-manager'
+
+/**
+ * Generate a timestamp string for backup filenames
+ * Format: YYYY-MM-DDTHHMMSS (ISO 8601 without colons for filesystem compatibility)
+ */
+function generateTimestamp(): string {
+  const now = new Date()
+  return now.toISOString().replace(/:/g, '').split('.')[0]
+}
+
+/**
+ * Generate default backup filename
+ */
+function generateDefaultFilename(
+  containerName: string,
+  database: string,
+): string {
+  const timestamp = generateTimestamp()
+  return `${containerName}-${database}-backup-${timestamp}`
+}
+
+/**
+ * Get file extension for backup format
+ */
+function getExtension(format: 'sql' | 'dump', engine: string): string {
+  if (format === 'sql') {
+    return '.sql'
+  }
+  // MySQL dump is gzipped SQL, PostgreSQL dump is custom format
+  return engine === 'mysql' ? '.sql.gz' : '.dump'
+}
+
+export const backupCommand = new Command('backup')
+  .description('Create a backup of a database')
+  .argument('[container]', 'Container name')
+  .option('-d, --database <name>', 'Database to backup')
+  .option('-n, --name <name>', 'Custom backup filename (without extension)')
+  .option(
+    '-o, --output <path>',
+    'Output directory (defaults to current directory)',
+  )
+  .option('--format <format>', 'Output format: sql or dump')
+  .option('--sql', 'Output as plain SQL (shorthand for --format sql)')
+  .option('--dump', 'Output as dump format (shorthand for --format dump)')
+  .action(
+    async (
+      containerArg: string | undefined,
+      options: {
+        database?: string
+        name?: string
+        output?: string
+        format?: string
+        sql?: boolean
+        dump?: boolean
+      },
+    ) => {
+      try {
+        let containerName = containerArg
+
+        // Interactive selection if no container provided
+        if (!containerName) {
+          const containers = await containerManager.list()
+          const running = containers.filter((c) => c.status === 'running')
+
+          if (running.length === 0) {
+            if (containers.length === 0) {
+              console.log(
+                warning('No containers found. Create one with: spindb create'),
+              )
+            } else {
+              console.log(
+                warning(
+                  'No running containers. Start one first with: spindb start',
+                ),
+              )
+            }
+            return
+          }
+
+          const selected = await promptContainerSelect(
+            running,
+            'Select container to backup:',
+          )
+          if (!selected) return
+          containerName = selected
+        }
+
+        // Get container config
+        const config = await containerManager.getConfig(containerName)
+        if (!config) {
+          console.error(error(`Container "${containerName}" not found`))
+          process.exit(1)
+        }
+
+        const { engine: engineName } = config
+
+        // Check if running
+        const running = await processManager.isRunning(containerName, {
+          engine: engineName,
+        })
+        if (!running) {
+          console.error(
+            error(
+              `Container "${containerName}" is not running. Start it first.`,
+            ),
+          )
+          process.exit(1)
+        }
+
+        // Get engine
+        const engine = getEngine(engineName)
+
+        // Check for required client tools
+        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')
+        }
+
+        // Determine which database to backup
+        let databaseName = options.database
+
+        if (!databaseName) {
+          // Get list of databases in container
+          const databases = config.databases || [config.database]
+
+          if (databases.length > 1) {
+            // Interactive mode: prompt for database selection
+            databaseName = await promptDatabaseSelect(
+              databases,
+              'Select database to backup:',
+            )
+          } else {
+            // Single database: use it
+            databaseName = databases[0]
+          }
+        }
+
+        // Determine format
+        let format: 'sql' | 'dump' = 'sql' // Default to SQL
+
+        if (options.sql) {
+          format = 'sql'
+        } else if (options.dump) {
+          format = 'dump'
+        } else if (options.format) {
+          if (options.format !== 'sql' && options.format !== 'dump') {
+            console.error(error('Format must be "sql" or "dump"'))
+            process.exit(1)
+          }
+          format = options.format as 'sql' | 'dump'
+        } else if (!containerArg) {
+          // Interactive mode: prompt for format
+          format = await promptBackupFormat(engineName)
+        }
+
+        // Determine filename
+        const defaultFilename = generateDefaultFilename(
+          containerName,
+          databaseName,
+        )
+        let filename = options.name || defaultFilename
+
+        // In interactive mode with no name provided, optionally prompt for custom name
+        if (!containerArg && !options.name) {
+          filename = await promptBackupFilename(defaultFilename)
+        }
+
+        // Build full output path
+        const extension = getExtension(format, engineName)
+        const outputDir = options.output || process.cwd()
+        const outputPath = join(outputDir, `${filename}${extension}`)
+
+        // Create backup
+        const backupSpinner = createSpinner(
+          `Creating ${format === 'sql' ? 'SQL' : 'dump'} backup of "${databaseName}"...`,
+        )
+        backupSpinner.start()
+
+        const result = await engine.backup(config, outputPath, {
+          database: databaseName,
+          format,
+        })
+
+        backupSpinner.succeed('Backup created successfully')
+
+        // Show result
+        console.log()
+        console.log(success('Backup complete'))
+        console.log()
+        console.log(chalk.gray('  File:'), 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()
+      } catch (err) {
+        const e = err as Error
+
+        // Check if this is a missing tool error
+        const missingToolPatterns = ['pg_dump 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)
+        }
+
+        console.error(error(e.message))
+        process.exit(1)
+      }
+    },
+  )