spindb 0.37.2 → 0.38.0

package/engines/mongodb/backup.ts

@@ -1,127 +0,0 @@
-/**
- * MongoDB backup module
- * Wraps mongodump for creating database backups
- */
-
-import { spawn, type SpawnOptions } from 'child_process'
-import { stat } from 'fs/promises'
-import { existsSync } from 'fs'
-import { join, dirname } from 'path'
-import { mkdir } from 'fs/promises'
-import { logDebug } from '../../core/error-handler'
-import { getMongodumpPath, MONGODUMP_NOT_FOUND_ERROR } from './cli-utils'
-import type { ContainerConfig, BackupOptions, BackupResult } from '../../types'
-
-/**
- * Create a backup of a MongoDB database using mongodump
- *
- * Supports two formats:
- * - 'bson': Directory dump with BSON files per collection
- * - 'archive' (default): Single compressed archive file
- */
-export async function createBackup(
-  container: ContainerConfig,
-  outputPath: string,
-  options: BackupOptions,
-): Promise<BackupResult> {
-  const { port, database, version } = container
-  const db = options.database || database
-
-  const mongodump = await getMongodumpPath(version)
-  if (!mongodump) {
-    throw new Error(MONGODUMP_NOT_FOUND_ERROR)
-  }
-
-  // Ensure output directory exists
-  const outputDir = dirname(outputPath)
-  if (!existsSync(outputDir)) {
-    await mkdir(outputDir, { recursive: true })
-  }
-
-  const args: string[] = [
-    '--host',
-    '127.0.0.1',
-    '--port',
-    String(port),
-    '--db',
-    db,
-  ]
-
-  // Determine output format (default to 'archive' as per backup-formats.ts)
-  const format = options.format ?? 'archive'
-  if (format === 'archive') {
-    // Archive format: single compressed file
-    args.push('--archive=' + outputPath, '--gzip')
-  } else {
-    // Directory format (bson): output to directory
-    args.push('--out', outputPath)
-  }
-
-  logDebug(`Running mongodump with args: ${args.join(' ')}`)
-
-  // Note: Don't use shell mode - spawn handles paths with spaces correctly
-  // when shell: false (the default). Shell mode breaks paths like "C:\Program Files\..."
-  const spawnOptions: SpawnOptions = {
-    stdio: ['pipe', 'pipe', 'pipe'],
-  }
-
-  return new Promise((resolve, reject) => {
-    const proc = spawn(mongodump, args, spawnOptions)
-
-    let stderr = ''
-
-    proc.stdout?.on('data', () => {
-      // mongodump outputs progress to stderr, stdout is typically empty
-    })
-    proc.stderr?.on('data', (data: Buffer) => {
-      stderr += data.toString()
-    })
-
-    proc.on('error', reject)
-
-    proc.on('close', async (code) => {
-      if (code === 0) {
-        // Get backup size
-        let size = 0
-        try {
-          if (options.format === 'archive') {
-            // Archive file
-            const stats = await stat(outputPath)
-            size = stats.size
-          } else {
-            // Directory - sum up all files (simplified)
-            const dbDir = join(outputPath, db)
-            if (existsSync(dbDir)) {
-              const stats = await stat(dbDir)
-              size = stats.size
-            }
-          }
-        } catch {
-          // Size calculation failed, use 0
-        }
-
-        resolve({
-          path: outputPath,
-          format: options.format === 'archive' ? 'archive' : 'directory',
-          size,
-        })
-      } else {
-        reject(new Error(stderr || `mongodump exited with code ${code}`))
-      }
-    })
-  })
-}
-
-/**
- * Create a backup for cloning purposes
- * Uses archive format by default for reliability
- */
-export async function createCloneBackup(
-  container: ContainerConfig,
-  outputPath: string,
-): Promise<BackupResult> {
-  return createBackup(container, outputPath, {
-    database: container.database,
-    format: 'archive',
-  })
-}

package/engines/mongodb/binary-manager.ts

@@ -1,48 +0,0 @@
-/**
- * MongoDB Binary Manager
- *
- * Handles downloading, extracting, and managing MongoDB binaries from hostdb.
- * Extends BaseDocumentBinaryManager with MongoDB-specific configuration.
- */
-
-import {
-  BaseDocumentBinaryManager,
-  type DocumentBinaryManagerConfig,
-} from '../../core/base-document-binary-manager'
-import { getBinaryUrl } from './binary-urls'
-import { normalizeVersion } from './version-maps'
-import { Engine, type Platform, type Arch } from '../../types'
-
-class MongoDBBinaryManager extends BaseDocumentBinaryManager {
-  protected readonly config: DocumentBinaryManagerConfig = {
-    engine: Engine.MongoDB,
-    engineName: 'mongodb',
-    displayName: 'MongoDB',
-    serverBinary: 'mongod',
-  }
-
-  protected getBinaryUrlFromModule(
-    version: string,
-    platform: Platform,
-    arch: Arch,
-  ): string {
-    return getBinaryUrl(version, platform, arch)
-  }
-
-  protected normalizeVersionFromModule(version: string): string {
-    return normalizeVersion(version)
-  }
-
-  protected parseVersionFromOutput(stdout: string): string | null {
-    // Extract version from output like "db version v7.0.28"
-    const match = stdout.match(/db version v(\d+\.\d+\.\d+)/)
-    if (match) {
-      return match[1]
-    }
-    // Fallback: try to match any semver-like version
-    const altMatch = stdout.match(/(\d+\.\d+\.\d+)/)
-    return altMatch?.[1] ?? null
-  }
-}
-
-export const mongodbBinaryManager = new MongoDBBinaryManager()

package/engines/mongodb/binary-urls.ts

@@ -1,63 +0,0 @@
-/**
- * MongoDB binary URL generation for hostdb
- *
- * Generates download URLs for MongoDB binaries from the hostdb GitHub releases.
- * All platforms (macOS, Linux, Windows) use hostdb binaries.
- */
-
-import { normalizeVersion } from './version-maps'
-import { buildHostdbUrl } from '../../core/hostdb-client'
-import { Engine, Platform, type Arch } from '../../types'
-
-// Supported platforms for MongoDB hostdb binaries
-export const SUPPORTED_PLATFORMS = ['darwin', 'linux', 'win32'] as const
-export type SupportedPlatform = (typeof SUPPORTED_PLATFORMS)[number]
-
-// Supported platform/arch combinations for MongoDB hostdb binaries
-const SUPPORTED_PLATFORM_KEYS = new Set([
-  'darwin-arm64',
-  'darwin-x64',
-  'linux-arm64',
-  'linux-x64',
-  'win32-x64',
-])
-
-// Map Node.js platform/arch to hostdb platform key
-export function getHostdbPlatform(
-  platform: Platform,
-  arch: Arch,
-): string | null {
-  const key = `${platform}-${arch}`
-  return SUPPORTED_PLATFORM_KEYS.has(key) ? key : null
-}
-
-/**
- * Get the download URL for MongoDB binaries
- *
- * @param version - MongoDB version (major.minor or full)
- * @param platform - Operating system (darwin, linux, win32)
- * @param arch - Architecture (arm64, x64)
- * @returns Download URL
- */
-export function getBinaryUrl(
-  version: string,
-  platform: Platform,
-  arch: Arch,
-): string {
-  const fullVersion = normalizeVersion(version)
-  const hostdbPlatform = getHostdbPlatform(platform, arch)
-
-  if (!hostdbPlatform) {
-    throw new Error(
-      `Unsupported platform: ${platform}-${arch}. MongoDB hostdb binaries are available for: darwin-arm64, darwin-x64, linux-arm64, linux-x64, win32-x64`,
-    )
-  }
-
-  const ext = platform === Platform.Win32 ? 'zip' : 'tar.gz'
-
-  return buildHostdbUrl(Engine.MongoDB, {
-    version: fullVersion,
-    hostdbPlatform,
-    extension: ext,
-  })
-}

package/engines/mongodb/cli-utils.ts

@@ -1,171 +0,0 @@
-/**
- * Shared MongoDB CLI utilities
- *
- * Provides common functions for locating MongoDB binaries,
- * used by backup.ts, restore.ts, and index.ts to avoid duplication.
- */
-
-import { existsSync } from 'fs'
-import { join } from 'path'
-import { configManager } from '../../core/config-manager'
-import { platformService } from '../../core/platform-service'
-import { paths } from '../../config/paths'
-import { normalizeVersion } from './version-maps'
-
-/**
- * Get the path to mongodump binary for a specific MongoDB version.
- *
- * Prioritizes SpinDB-managed binaries that match the container's version,
- * falling back to system mongodump only if no matching version is found.
- *
- * Lookup order:
- * 1. SpinDB-managed mongodump matching exact container version
- * 2. SpinDB-managed mongodump matching major version
- * 3. configManager cache (bundled/downloaded binaries from hostdb)
- * 4. System PATH (fallback for system-installed mongodb-database-tools)
- *
- * @param containerVersion - Optional container's MongoDB version for version-matched lookup
- * @returns Path to mongodump or null if not found
- */
-export async function getMongodumpPath(
-  containerVersion?: string,
-): Promise<string | null> {
-  // Try version-matched SpinDB binary if containerVersion is provided
-  if (containerVersion) {
-    const fullVersion = normalizeVersion(containerVersion)
-    const platformInfo = platformService.getPlatformInfo()
-    const ext = platformInfo.platform === 'win32' ? '.exe' : ''
-
-    // Try exact version match
-    const versionedBinPath = paths.getBinaryPath({
-      engine: 'mongodb',
-      version: fullVersion,
-      platform: platformInfo.platform,
-      arch: platformInfo.arch,
-    })
-
-    const versionedMongodump = join(versionedBinPath, 'bin', `mongodump${ext}`)
-    if (existsSync(versionedMongodump)) {
-      return versionedMongodump
-    }
-
-    // Try major version match
-    const majorVersion = containerVersion.split('.')[0]
-    const installed = paths.findInstalledBinaryForMajor(
-      'mongodb',
-      majorVersion,
-      platformInfo.platform,
-      platformInfo.arch,
-    )
-
-    if (installed) {
-      const installedMongodump = join(installed.path, 'bin', `mongodump${ext}`)
-      if (existsSync(installedMongodump)) {
-        return installedMongodump
-      }
-    }
-  }
-
-  // Check if we have a cached/bundled mongodump from hostdb
-  const cachedPath = await configManager.getBinaryPath('mongodump')
-  if (cachedPath && existsSync(cachedPath)) {
-    return cachedPath
-  }
-
-  // Fallback to system PATH
-  return platformService.findToolPath('mongodump')
-}
-
-/**
- * Get the path to mongorestore binary for a specific MongoDB version.
- *
- * Prioritizes SpinDB-managed binaries that match the container's version,
- * falling back to system mongorestore only if no matching version is found.
- *
- * Lookup order:
- * 1. SpinDB-managed mongorestore matching exact container version
- * 2. SpinDB-managed mongorestore matching major version
- * 3. configManager cache (bundled/downloaded binaries from hostdb)
- * 4. System PATH (fallback for system-installed mongodb-database-tools)
- *
- * @param containerVersion - Optional container's MongoDB version for version-matched lookup
- * @returns Path to mongorestore or null if not found
- */
-export async function getMongorestorePath(
-  containerVersion?: string,
-): Promise<string | null> {
-  // Try version-matched SpinDB binary if containerVersion is provided
-  if (containerVersion) {
-    const fullVersion = normalizeVersion(containerVersion)
-    const platformInfo = platformService.getPlatformInfo()
-    const ext = platformInfo.platform === 'win32' ? '.exe' : ''
-
-    // Try exact version match
-    const versionedBinPath = paths.getBinaryPath({
-      engine: 'mongodb',
-      version: fullVersion,
-      platform: platformInfo.platform,
-      arch: platformInfo.arch,
-    })
-
-    const versionedMongorestore = join(
-      versionedBinPath,
-      'bin',
-      `mongorestore${ext}`,
-    )
-    if (existsSync(versionedMongorestore)) {
-      return versionedMongorestore
-    }
-
-    // Try major version match
-    const majorVersion = containerVersion.split('.')[0]
-    const installed = paths.findInstalledBinaryForMajor(
-      'mongodb',
-      majorVersion,
-      platformInfo.platform,
-      platformInfo.arch,
-    )
-
-    if (installed) {
-      const installedMongorestore = join(
-        installed.path,
-        'bin',
-        `mongorestore${ext}`,
-      )
-      if (existsSync(installedMongorestore)) {
-        return installedMongorestore
-      }
-    }
-  }
-
-  // Check if we have a cached/bundled mongorestore from hostdb
-  const cachedPath = await configManager.getBinaryPath('mongorestore')
-  if (cachedPath && existsSync(cachedPath)) {
-    return cachedPath
-  }
-
-  // Fallback to system PATH
-  return platformService.findToolPath('mongorestore')
-}
-
-/**
- * Error message for missing mongodump
- * Directs users to download via hostdb (preferred) or MongoDB website (fallback)
- */
-export const MONGODUMP_NOT_FOUND_ERROR =
-  'mongodump not found. Download MongoDB binaries:\n' +
-  '  spindb engines download mongodb\n' +
-  '\n' +
-  'Or download from:\n' +
-  '  https://www.mongodb.com/try/download/database-tools'
-
-/**
- * Error message for missing mongorestore
- * Directs users to download via hostdb (preferred) or MongoDB website (fallback)
- */
-export const MONGORESTORE_NOT_FOUND_ERROR =
-  'mongorestore not found. Download MongoDB binaries:\n' +
-  '  spindb engines download mongodb\n' +
-  '\n' +
-  'Or download from:\n' +
-  '  https://www.mongodb.com/try/download/database-tools'

package/engines/mongodb/hostdb-releases.ts

@@ -1,91 +0,0 @@
-/**
- * MongoDB hostdb releases integration
- *
- * Fetches available MongoDB versions from the hostdb repository at
- * https://github.com/robertjbass/hostdb
- *
- * hostdb provides pre-built MongoDB binaries for multiple platforms.
- */
-
-import { logDebug } from '../../core/error-handler'
-import { FALLBACK_VERSION_MAP } from './version-maps'
-import { isNewerVersion } from '../../core/version-utils'
-import { mongodbBinaryManager } from './binary-manager'
-import { getAvailableVersions as getHostdbVersions } from '../../core/hostdb-metadata'
-import { Engine } from '../../types'
-
-/**
- * Fetch available MongoDB versions from hostdb databases.json
- * Falls back to locally installed versions, then hardcoded version map
- */
-export async function fetchAvailableVersions(): Promise<
-  Record<string, string>
-> {
-  // Try to fetch from hostdb databases.json (authoritative source)
-  try {
-    const versions = await getHostdbVersions(Engine.MongoDB)
-
-    if (versions && versions.length > 0) {
-      const versionMap: Record<string, string> = {}
-
-      // Iterate over version strings (e.g., "7.0.28", "8.0.17", "8.2.3")
-      for (const fullVersion of versions) {
-        // Extract major.minor (e.g., "7.0.28" -> "7.0")
-        const parts = fullVersion.split('.')
-        if (parts.length >= 2) {
-          const majorMinor = `${parts[0]}.${parts[1]}`
-          // Keep the latest full version for each major.minor
-          if (
-            !versionMap[majorMinor] ||
-            isNewerVersion(fullVersion, versionMap[majorMinor])
-          ) {
-            versionMap[majorMinor] = fullVersion
-          }
-        }
-      }
-
-      logDebug('Fetched MongoDB versions from hostdb', { versions: versionMap })
-      return versionMap
-    }
-  } catch (error) {
-    logDebug('Failed to fetch MongoDB versions from hostdb, checking local', {
-      error: error instanceof Error ? error.message : String(error),
-    })
-  }
-
-  // Offline fallback: return only locally installed versions
-  const installed = await mongodbBinaryManager.listInstalled()
-  if (installed.length > 0) {
-    const versionMap: Record<string, string> = {}
-    for (const binary of installed) {
-      // MongoDB uses X.Y format for major versions
-      const parts = binary.version.split('.')
-      if (parts.length >= 2) {
-        const majorMinor = `${parts[0]}.${parts[1]}`
-        // Keep the latest full version for each major.minor
-        if (
-          !versionMap[majorMinor] ||
-          isNewerVersion(binary.version, versionMap[majorMinor])
-        ) {
-          versionMap[majorMinor] = binary.version
-        }
-      }
-    }
-    logDebug('Using locally installed MongoDB versions', {
-      versions: versionMap,
-    })
-    return versionMap
-  }
-
-  // Last resort: return hardcoded version map
-  logDebug('Using fallback MongoDB version map')
-  return FALLBACK_VERSION_MAP
-}
-
-// Get the latest full version for a major.minor version
-export async function getLatestVersion(
-  majorMinor: string,
-): Promise<string | null> {
-  const versions = await fetchAvailableVersions()
-  return versions[majorMinor] || null
-}