spindb 0.37.2 → 0.38.0

package/core/update-manager.ts

@@ -1,308 +0,0 @@
-import { exec } from 'child_process'
-import { promisify } from 'util'
-import { createRequire } from 'module'
-import { configManager } from './config-manager'
-import { logDebug } from './error-handler'
-
-const execAsync = promisify(exec)
-const require = createRequire(import.meta.url)
-
-const NPM_REGISTRY_URL = 'https://registry.npmjs.org/spindb'
-const CHECK_THROTTLE_MS = 24 * 60 * 60 * 1000 // 24 hours
-
-type PackageManager = 'npm' | 'pnpm' | 'yarn' | 'bun'
-
-const KNOWN_PACKAGE_MANAGERS: PackageManager[] = ['pnpm', 'yarn', 'bun', 'npm']
-
-export function parseUserAgent(
-  userAgent: string | undefined,
-): PackageManager | null {
-  if (!userAgent) return null
-  const firstToken = userAgent.split('/')[0]?.toLowerCase().trim()
-  if (!firstToken) return null
-  return KNOWN_PACKAGE_MANAGERS.find((pm) => pm === firstToken) ?? null
-}
-
-export type UpdateCheckResult = {
-  currentVersion: string
-  latestVersion: string
-  updateAvailable: boolean
-  lastChecked: string
-}
-
-export type UpdateResult = {
-  success: boolean
-  previousVersion: string
-  newVersion: string
-  error?: string
-}
-
-export class UpdateManager {
-  getCurrentVersion(): string {
-    const pkg = require('../package.json') as { version: string }
-    return pkg.version
-  }
-
-  // Throttled to once per 24 hours unless force=true
-  async checkForUpdate(force = false): Promise<UpdateCheckResult | null> {
-    const config = await configManager.load()
-    const lastCheck = config.update?.lastCheck
-
-    if (!force && lastCheck) {
-      const elapsed = Date.now() - new Date(lastCheck).getTime()
-      if (elapsed < CHECK_THROTTLE_MS && config.update?.latestVersion) {
-        const currentVersion = this.getCurrentVersion()
-        return {
-          currentVersion,
-          latestVersion: config.update.latestVersion,
-          updateAvailable:
-            this.compareVersions(config.update.latestVersion, currentVersion) >
-            0,
-          lastChecked: lastCheck,
-        }
-      }
-    }
-
-    try {
-      const latestVersion = await this.fetchLatestVersion()
-      const currentVersion = this.getCurrentVersion()
-
-      config.update = {
-        ...config.update,
-        lastCheck: new Date().toISOString(),
-        latestVersion,
-      }
-      await configManager.save()
-
-      return {
-        currentVersion,
-        latestVersion,
-        updateAvailable:
-          this.compareVersions(latestVersion, currentVersion) > 0,
-        lastChecked: new Date().toISOString(),
-      }
-    } catch {
-      // Offline or registry error - return null
-      return null
-    }
-  }
-
-  // Checks all PMs in parallel, falls back to npm_config_user_agent, then npm
-  async detectPackageManager(): Promise<PackageManager> {
-    const checks = await Promise.all([
-      this.checkGlobalInstall(
-        'pnpm',
-        'pnpm list -g spindb --json',
-        (stdout) => {
-          const data = JSON.parse(stdout) as Array<{
-            dependencies?: { spindb?: unknown }
-          }>
-          return !!data[0]?.dependencies?.spindb
-        },
-      ),
-      this.checkGlobalInstall('yarn', 'yarn global list --json', (stdout) => {
-        return stdout.includes('"spindb@')
-      }),
-      this.checkGlobalInstall('bun', 'bun pm ls -g', (stdout) => {
-        return stdout.includes('spindb@')
-      }),
-      this.checkGlobalInstall('npm', 'npm list -g spindb --json', (stdout) => {
-        const data = JSON.parse(stdout) as {
-          dependencies?: { spindb?: unknown }
-        }
-        return !!data.dependencies?.spindb
-      }),
-    ])
-
-    const globalPm = checks.find((result) => result !== null)
-    if (globalPm) {
-      logDebug(`Detected global install via ${globalPm}`)
-      return globalPm
-    }
-
-    const agentPm = parseUserAgent(process.env.npm_config_user_agent)
-    if (agentPm) {
-      logDebug(`Detected package manager from user agent: ${agentPm}`)
-      return agentPm
-    }
-
-    return 'npm'
-  }
-
-  private async checkGlobalInstall(
-    pm: PackageManager,
-    command: string,
-    checkOutput: (stdout: string) => boolean,
-  ): Promise<PackageManager | null> {
-    try {
-      const { stdout } = await execAsync(command, { timeout: 5000, cwd: '/' })
-      return checkOutput(stdout) ? pm : null
-    } catch {
-      return null
-    }
-  }
-
-  getInstallCommand(pm: PackageManager): string {
-    switch (pm) {
-      case 'pnpm':
-        return 'pnpm add -g spindb@latest'
-      case 'yarn':
-        return 'yarn global add spindb@latest'
-      case 'bun':
-        return 'bun add -g spindb@latest'
-      case 'npm':
-        return 'npm install -g spindb@latest'
-    }
-  }
-
-  private getListCommand(pm: PackageManager): string {
-    switch (pm) {
-      case 'pnpm':
-        return 'pnpm list -g spindb --json'
-      case 'yarn':
-        return 'yarn global list --json'
-      case 'bun':
-        return 'bun pm ls -g'
-      case 'npm':
-        return 'npm list -g spindb --json'
-    }
-  }
-
-  private parseVersionFromListOutput(
-    pm: PackageManager,
-    stdout: string,
-    fallback: string,
-  ): string {
-    try {
-      switch (pm) {
-        case 'pnpm': {
-          const data = JSON.parse(stdout) as Array<{
-            dependencies?: { spindb?: { version?: string } }
-          }>
-          return data[0]?.dependencies?.spindb?.version || fallback
-        }
-        case 'npm': {
-          const data = JSON.parse(stdout) as {
-            dependencies?: { spindb?: { version?: string } }
-          }
-          return data.dependencies?.spindb?.version || fallback
-        }
-        case 'yarn':
-        case 'bun': {
-          // Extract version from "spindb@x.y.z" pattern
-          const match = stdout.match(/spindb@(\d+\.\d+\.\d+)/)
-          return match?.[1] || fallback
-        }
-      }
-    } catch {
-      return fallback
-    }
-  }
-
-  async performUpdate(): Promise<UpdateResult> {
-    const previousVersion = this.getCurrentVersion()
-    const pm = await this.detectPackageManager()
-    const installCmd = this.getInstallCommand(pm)
-
-    // Run install command
-    try {
-      await execAsync(installCmd, { timeout: 60000, cwd: '/' })
-    } catch (error) {
-      const message = error instanceof Error ? error.message : String(error)
-
-      if (message.includes('EACCES') || message.includes('permission')) {
-        const sudoCmd = pm === 'npm' ? `sudo ${installCmd}` : installCmd
-        return {
-          success: false,
-          previousVersion,
-          newVersion: previousVersion,
-          error: `Permission denied. Try: ${sudoCmd}`,
-        }
-      }
-
-      return {
-        success: false,
-        previousVersion,
-        newVersion: previousVersion,
-        error: `${message}\nManual update: ${installCmd}`,
-      }
-    }
-
-    // Verify new version - use explicit cwd to avoid stale directory issues
-    // (fnm and other version managers can invalidate the cwd during global installs)
-    let newVersion = previousVersion
-    try {
-      const { stdout } = await execAsync(this.getListCommand(pm), {
-        timeout: 10000,
-        cwd: '/',
-      })
-      newVersion = this.parseVersionFromListOutput(pm, stdout, previousVersion)
-    } catch {
-      // Verification failed but install likely succeeded - fetch from registry instead
-      try {
-        newVersion = await this.fetchLatestVersion()
-      } catch {
-        // Fall back to previous version (install still succeeded)
-      }
-    }
-
-    return {
-      success: true,
-      previousVersion,
-      newVersion,
-    }
-  }
-
-  async getCachedUpdateInfo(): Promise<{
-    latestVersion?: string
-    autoCheckEnabled: boolean
-  }> {
-    const config = await configManager.load()
-    return {
-      latestVersion: config.update?.latestVersion,
-      autoCheckEnabled: config.update?.autoCheckEnabled !== false,
-    }
-  }
-
-  async setAutoCheckEnabled(enabled: boolean): Promise<void> {
-    const config = await configManager.load()
-    config.update = {
-      ...config.update,
-      autoCheckEnabled: enabled,
-    }
-    await configManager.save()
-  }
-
-  private async fetchLatestVersion(): Promise<string> {
-    const controller = new AbortController()
-    const timeout = setTimeout(() => controller.abort(), 10000)
-
-    try {
-      const response = await fetch(NPM_REGISTRY_URL, {
-        signal: controller.signal,
-      })
-      if (!response.ok) {
-        throw new Error(`Registry returned ${response.status}`)
-      }
-      const data = (await response.json()) as {
-        'dist-tags': { latest: string }
-      }
-      return data['dist-tags'].latest
-    } finally {
-      clearTimeout(timeout)
-    }
-  }
-
-  compareVersions(a: string, b: string): number {
-    const partsA = a.split('.').map((n) => parseInt(n, 10) || 0)
-    const partsB = b.split('.').map((n) => parseInt(n, 10) || 0)
-
-    for (let i = 0; i < 3; i++) {
-      const diff = (partsA[i] || 0) - (partsB[i] || 0)
-      if (diff !== 0) return diff
-    }
-    return 0
-  }
-}
-
-export const updateManager = new UpdateManager()

package/core/version-migration.ts

@@ -1,346 +0,0 @@
-/**
- * Version migration utilities for detecting and updating outdated container versions
- *
- * Detects containers using versions that are no longer in the version maps
- * (e.g., from the zonky.io era) and offers to migrate them to currently
- * supported versions while preserving major version compatibility.
- */
-
-import { existsSync } from 'fs'
-import { rm } from 'fs/promises'
-import { paths } from '../config/paths'
-import { containerManager } from './container-manager'
-import { platformService } from './platform-service'
-import { Engine, isFileBasedEngine, type ContainerConfig } from '../types'
-
-// Import version maps from all engines
-import {
-  POSTGRESQL_VERSION_MAP,
-  SUPPORTED_MAJOR_VERSIONS as PG_MAJORS,
-} from '../engines/postgresql/version-maps'
-import {
-  MYSQL_VERSION_MAP,
-  SUPPORTED_MAJOR_VERSIONS as MYSQL_MAJORS,
-} from '../engines/mysql/version-maps'
-import {
-  MARIADB_VERSION_MAP,
-  SUPPORTED_MAJOR_VERSIONS as MARIADB_MAJORS,
-} from '../engines/mariadb/version-maps'
-import {
-  MONGODB_VERSION_MAP,
-  SUPPORTED_MAJOR_VERSIONS as MONGODB_MAJORS,
-} from '../engines/mongodb/version-maps'
-import {
-  FERRETDB_VERSION_MAP,
-  DOCUMENTDB_VERSION_MAP,
-  SUPPORTED_MAJOR_VERSIONS as FERRET_MAJORS,
-} from '../engines/ferretdb/version-maps'
-import {
-  REDIS_VERSION_MAP,
-  SUPPORTED_MAJOR_VERSIONS as REDIS_MAJORS,
-} from '../engines/redis/version-maps'
-import {
-  VALKEY_VERSION_MAP,
-  SUPPORTED_MAJOR_VERSIONS as VALKEY_MAJORS,
-} from '../engines/valkey/version-maps'
-import {
-  CLICKHOUSE_VERSION_MAP,
-  SUPPORTED_MAJOR_VERSIONS as CH_MAJORS,
-} from '../engines/clickhouse/version-maps'
-import {
-  QDRANT_VERSION_MAP,
-  SUPPORTED_MAJOR_VERSIONS as QDRANT_MAJORS,
-} from '../engines/qdrant/version-maps'
-import {
-  MEILISEARCH_VERSION_MAP,
-  SUPPORTED_MAJOR_VERSIONS as MEILI_MAJORS,
-} from '../engines/meilisearch/version-maps'
-
-type VersionMapInfo = {
-  versionMap: Record<string, string>
-  majorVersions: readonly string[]
-}
-
-// Registry of version maps per engine
-const VERSION_MAPS: Partial<Record<Engine, VersionMapInfo>> = {
-  [Engine.PostgreSQL]: {
-    versionMap: POSTGRESQL_VERSION_MAP,
-    majorVersions: PG_MAJORS,
-  },
-  [Engine.MySQL]: {
-    versionMap: MYSQL_VERSION_MAP,
-    majorVersions: MYSQL_MAJORS,
-  },
-  [Engine.MariaDB]: {
-    versionMap: MARIADB_VERSION_MAP,
-    majorVersions: MARIADB_MAJORS,
-  },
-  [Engine.MongoDB]: {
-    versionMap: MONGODB_VERSION_MAP,
-    majorVersions: MONGODB_MAJORS,
-  },
-  [Engine.FerretDB]: {
-    versionMap: FERRETDB_VERSION_MAP,
-    majorVersions: FERRET_MAJORS,
-  },
-  [Engine.Redis]: {
-    versionMap: REDIS_VERSION_MAP,
-    majorVersions: REDIS_MAJORS,
-  },
-  [Engine.Valkey]: {
-    versionMap: VALKEY_VERSION_MAP,
-    majorVersions: VALKEY_MAJORS,
-  },
-  [Engine.ClickHouse]: {
-    versionMap: CLICKHOUSE_VERSION_MAP,
-    majorVersions: CH_MAJORS,
-  },
-  [Engine.Qdrant]: {
-    versionMap: QDRANT_VERSION_MAP,
-    majorVersions: QDRANT_MAJORS,
-  },
-  [Engine.Meilisearch]: {
-    versionMap: MEILISEARCH_VERSION_MAP,
-    majorVersions: MEILI_MAJORS,
-  },
-}
-
-// Separate map for FerretDB backend (DocumentDB)
-const DOCUMENTDB_INFO: VersionMapInfo = {
-  versionMap: DOCUMENTDB_VERSION_MAP,
-  majorVersions: ['17'],
-}
-
-export type OutdatedContainer = {
-  container: ContainerConfig
-  currentVersion: string
-  targetVersion: string
-  majorVersion: string
-  field: 'version' | 'backendVersion'
-}
-
-/**
- * Find which major version a full version belongs to by checking prefixes
- * against SUPPORTED_MAJOR_VERSIONS.
- *
- * Different engines use different major version formats:
- * - PostgreSQL: Single digit (e.g., '17')
- * - MySQL: Two-part (e.g., '8.4')
- * - MariaDB: Two-part (e.g., '11.8')
- * - MongoDB: Two-part (e.g., '8.0')
- * - ClickHouse: Two-part YY.MM (e.g., '25.12')
- * - Redis/Valkey: Single digit (e.g., '7', '8')
- * - Qdrant/Meilisearch: Single digit (e.g., '1')
- *
- * @param engine - The database engine
- * @param version - Full version string (e.g., '17.2.0')
- * @returns Major version string or null if not found
- */
-export function getMajorVersion(
-  engine: Engine,
-  version: string,
-): string | null {
-  const info = VERSION_MAPS[engine]
-  if (!info) return null
-
-  // Sort by length descending so "8.4" matches before "8"
-  const sorted = [...info.majorVersions].sort((a, b) => b.length - a.length)
-  for (const major of sorted) {
-    if (version.startsWith(major + '.') || version === major) {
-      return major
-    }
-  }
-  return null
-}
-
-/**
- * Get the major version for FerretDB backend (DocumentDB).
- * Backend versions use format like "17-0.107.0" where "17" is the major.
- */
-export function getDocumentDBMajorVersion(version: string): string | null {
-  // Format: "17-0.107.0" -> major is "17"
-  const dashIndex = version.indexOf('-')
-  if (dashIndex > 0) {
-    const major = version.substring(0, dashIndex)
-    if (DOCUMENTDB_INFO.majorVersions.includes(major)) {
-      return major
-    }
-  }
-  return null
-}
-
-/**
- * Check if a version exists as a VALUE in the version map
- * (not just a key).
- *
- * @param engine - The database engine
- * @param version - Version string to check
- * @returns True if the version is a supported full version
- */
-export function isVersionSupported(engine: Engine, version: string): boolean {
-  const info = VERSION_MAPS[engine]
-  if (!info) return false
-
-  const supportedVersions = Object.values(info.versionMap)
-  return supportedVersions.includes(version)
-}
-
-/**
- * Check if a DocumentDB backend version is supported.
- */
-export function isDocumentDBVersionSupported(version: string): boolean {
-  const supportedVersions = Object.values(DOCUMENTDB_INFO.versionMap)
-  return supportedVersions.includes(version)
-}
-
-/**
- * Get the current full version for a major version.
- *
- * @param engine - The database engine
- * @param majorVersion - Major version (e.g., '17', '8.4')
- * @returns Current full version or null if not found
- */
-export function getTargetVersion(
-  engine: Engine,
-  majorVersion: string,
-): string | null {
-  const info = VERSION_MAPS[engine]
-  if (!info) return null
-
-  return info.versionMap[majorVersion] || null
-}
-
-/**
- * Get the current full version for a DocumentDB major version.
- */
-export function getDocumentDBTargetVersion(
-  majorVersion: string,
-): string | null {
-  return DOCUMENTDB_INFO.versionMap[majorVersion] || null
-}
-
-/**
- * Find all containers that have outdated versions.
- * Returns containers whose versions are not in the current version maps.
- *
- * @returns Array of outdated container information
- */
-export async function findOutdatedContainers(): Promise<OutdatedContainer[]> {
-  const containers = await containerManager.list()
-  const outdated: OutdatedContainer[] = []
-
-  for (const container of containers) {
-    const engine = container.engine as Engine
-
-    // Skip file-based engines - they use simplified major versions (e.g., "3", "1")
-    // that always resolve to current
-    if (isFileBasedEngine(engine)) {
-      continue
-    }
-
-    // Check main version
-    if (!isVersionSupported(engine, container.version)) {
-      const majorVersion = getMajorVersion(engine, container.version)
-      if (majorVersion) {
-        const targetVersion = getTargetVersion(engine, majorVersion)
-        if (targetVersion && targetVersion !== container.version) {
-          outdated.push({
-            container,
-            currentVersion: container.version,
-            targetVersion,
-            majorVersion,
-            field: 'version',
-          })
-        }
-      }
-    }
-
-    // Check FerretDB backend version
-    if (engine === Engine.FerretDB && container.backendVersion) {
-      if (!isDocumentDBVersionSupported(container.backendVersion)) {
-        const majorVersion = getDocumentDBMajorVersion(container.backendVersion)
-        if (majorVersion) {
-          const targetVersion = getDocumentDBTargetVersion(majorVersion)
-          if (targetVersion && targetVersion !== container.backendVersion) {
-            outdated.push({
-              container,
-              currentVersion: container.backendVersion,
-              targetVersion,
-              majorVersion,
-              field: 'backendVersion',
-            })
-          }
-        }
-      }
-    }
-  }
-
-  return outdated
-}
-
-/**
- * Update a container's version in its config file.
- *
- * @param name - Container name
- * @param targetVersion - New version to set
- * @param field - Which field to update ('version' or 'backendVersion')
- */
-export async function migrateContainerVersion(
-  name: string,
-  targetVersion: string,
-  field: 'version' | 'backendVersion',
-): Promise<void> {
-  await containerManager.updateConfig(name, { [field]: targetVersion })
-}
-
-/**
- * Check if any containers are using a specific version.
- *
- * @param engine - The database engine
- * @param version - The version to check
- * @returns True if at least one container uses this version
- */
-export async function isVersionInUse(
-  engine: Engine,
-  version: string,
-): Promise<boolean> {
-  const containers = await containerManager.list()
-  return containers.some(
-    (c) =>
-      c.engine === engine &&
-      (c.version === version || c.backendVersion === version),
-  )
-}
-
-/**
- * Delete an old binary directory from ~/.spindb/bin/
- * Only deletes if no other containers are using this version.
- *
- * @param engine - The database engine
- * @param oldVersion - The old version to remove
- * @returns True if the binary was deleted, false if still in use or not found
- */
-export async function deleteOldBinaryIfUnused(
-  engine: Engine | string,
-  oldVersion: string,
-): Promise<boolean> {
-  // Check if any containers still use this version
-  if (await isVersionInUse(engine as Engine, oldVersion)) {
-    return false
-  }
-
-  const platformInfo = platformService.getPlatformInfo()
-  const binaryPath = paths.getBinaryPath({
-    engine: engine as string,
-    version: oldVersion,
-    platform: platformInfo.platform,
-    arch: platformInfo.arch,
-  })
-
-  if (existsSync(binaryPath)) {
-    await rm(binaryPath, { recursive: true, force: true })
-    return true
-  }
-
-  return false
-}