spindb 0.37.2 → 0.38.0

package/core/start-with-retry.ts

@@ -1,130 +0,0 @@
-/**
- * Start with Retry
- *
- * Handles port race conditions by automatically retrying with a new port
- * when the original port becomes unavailable between check and bind.
- */
-
-import { portManager } from './port-manager'
-import { containerManager } from './container-manager'
-import { logWarning, logDebug } from './error-handler'
-import { isPortInUseError } from './fs-error-utils'
-import type { BaseEngine } from '../engines/base-engine'
-import { getEngineDefaults } from '../config/defaults'
-import type { ContainerConfig } from '../types'
-
-export type StartWithRetryOptions = {
-  engine: BaseEngine
-  config: ContainerConfig
-  maxRetries?: number // Default: 3
-  onPortChange?: (oldPort: number, newPort: number) => void
-}
-
-export type StartWithRetryResult = {
-  success: boolean
-  finalPort: number
-  retriesUsed: number
-  error?: Error
-}
-
-/**
- * Start a database container with automatic port retry on conflict
- *
- * This handles the race condition where a port is available when checked
- * but taken by the time the database server tries to bind to it.
- */
-export async function startWithRetry(
-  options: StartWithRetryOptions,
-): Promise<StartWithRetryResult> {
-  const { engine, config, maxRetries = 3, onPortChange } = options
-
-  for (let attempt = 1; attempt <= maxRetries; attempt++) {
-    try {
-      logDebug(`Starting ${engine.name} (attempt ${attempt}/${maxRetries})`, {
-        containerName: config.name,
-        port: config.port,
-      })
-
-      await engine.start(config)
-
-      return {
-        success: true,
-        finalPort: config.port,
-        retriesUsed: attempt - 1,
-      }
-    } catch (error) {
-      const isPortError = isPortInUseError(error)
-
-      logDebug(`Start attempt ${attempt} failed`, {
-        containerName: config.name,
-        port: config.port,
-        isPortError,
-        error: error instanceof Error ? error.message : String(error),
-      })
-
-      if (isPortError && attempt < maxRetries) {
-        const oldPort = config.port
-
-        // Find a new available port, excluding the one that just failed
-        const { port: newPort } = await portManager.findAvailablePort({
-          portRange: getEnginePortRange(config.engine),
-        })
-
-        // Update config with new port
-        config.port = newPort
-        await containerManager.updateConfig(config.name, { port: newPort })
-
-        // Notify caller of port change
-        if (onPortChange) {
-          onPortChange(oldPort, newPort)
-        }
-
-        // Log and retry
-        logWarning(
-          `Port ${oldPort} is in use, retrying with port ${newPort}...`,
-        )
-        continue
-      }
-
-      // Not a port error or max retries exceeded
-      return {
-        success: false,
-        finalPort: config.port,
-        retriesUsed: attempt - 1,
-        error: error instanceof Error ? error : new Error(String(error)),
-      }
-    }
-  }
-
-  // Should never reach here, but TypeScript needs a return
-  return {
-    success: false,
-    finalPort: config.port,
-    retriesUsed: maxRetries,
-    error: new Error('Max retries exceeded'),
-  }
-}
-
-function getEnginePortRange(engine: string): { start: number; end: number } {
-  const engineDefaults = getEngineDefaults(engine)
-  return engineDefaults.portRange
-}
-
-// Wrapper that simplifies the common use case
-export async function startContainerWithRetry(
-  engine: BaseEngine,
-  config: ContainerConfig,
-  options?: {
-    onPortChange?: (oldPort: number, newPort: number) => void
-  },
-): Promise<void> {
-  const result = await startWithRetry({
-    engine,
-    config,
-    onPortChange: options?.onPortChange,
-  })
-
-  if (!result.success && result.error) {
-    throw result.error
-  }
-}

package/core/test-cleanup.ts

@@ -1,108 +0,0 @@
-/**
- * Test container cleanup utilities
- *
- * Provides functions to detect and remove orphaned test containers.
- * Can be used by the doctor command or called directly after tests.
- */
-
-import { existsSync } from 'fs'
-import { readdir, rm } from 'fs/promises'
-import { join } from 'path'
-import { paths } from '../config/paths'
-import { getSupportedEngines } from '../config/engine-defaults'
-
-// Test container detection patterns
-// These match the naming conventions used by integration tests
-export const TEST_CONTAINER_PATTERNS = [
-  // Pattern: name-test_<8-char-hex> (e.g., duckdb-test_04b0613f)
-  /^.+-test_[0-9a-f]{6,}$/i,
-  // Pattern: name-test-suffix_<8-char-hex> (e.g., ferretdb-test-conflict_21e4d447)
-  /^.+-test-.+_[0-9a-f]{6,}$/i,
-  // Pattern: name-test-renamed_<8-char-hex> (e.g., mysql-test-renamed-1862f018)
-  /^.+-test-renamed[-_][0-9a-f]{6,}$/i,
-]
-
-export type OrphanedTestContainer = {
-  engine: string
-  name: string
-  path: string
-}
-
-/**
- * Check if a container name matches test container patterns.
- */
-export function isTestContainer(name: string): boolean {
-  return TEST_CONTAINER_PATTERNS.some((pattern) => pattern.test(name))
-}
-
-/**
- * Find all orphaned test container directories.
- * Scans the filesystem directly since these may not have valid container.json files.
- *
- * @returns Array of orphaned test container info
- */
-export async function findOrphanedTestContainers(): Promise<
-  OrphanedTestContainer[]
-> {
-  const containersDir = paths.containers
-  if (!existsSync(containersDir)) {
-    return []
-  }
-
-  const engines = getSupportedEngines()
-  const testDirs: OrphanedTestContainer[] = []
-
-  for (const engine of engines) {
-    const engineDir = paths.getEngineContainersPath(engine)
-    if (!existsSync(engineDir)) {
-      continue
-    }
-
-    try {
-      const entries = await readdir(engineDir, { withFileTypes: true })
-      for (const entry of entries) {
-        if (entry.isDirectory() && isTestContainer(entry.name)) {
-          testDirs.push({
-            engine,
-            name: entry.name,
-            path: join(engineDir, entry.name),
-          })
-        }
-      }
-    } catch {
-      // Ignore errors reading directories
-    }
-  }
-
-  return testDirs
-}
-
-/**
- * Delete a single orphaned test container directory.
- *
- * @param container - The container to delete
- */
-export async function deleteTestContainer(
-  container: OrphanedTestContainer,
-): Promise<void> {
-  await rm(container.path, { recursive: true, force: true })
-}
-
-/**
- * Delete all orphaned test containers in parallel.
- * Useful for cleanup after integration tests.
- *
- * @returns Number of containers successfully deleted
- */
-export async function cleanupTestContainers(): Promise<number> {
-  const orphaned = await findOrphanedTestContainers()
-
-  const results = await Promise.allSettled(
-    orphaned.map((container) => deleteTestContainer(container)),
-  )
-
-  // Count successful deletions
-  const successCount = results.filter((r) => r.status === 'fulfilled').length
-
-  return successCount
-}

package/core/tls-generator.ts

@@ -1,116 +0,0 @@
-/**
- * TLS Certificate Generator
- *
- * Generates self-signed TLS certificates for secure database connections.
- * Uses openssl command-line tool which is available on macOS, Linux, and Windows (Git Bash).
- */
-
-import { execFile } from 'child_process'
-import { promisify } from 'util'
-import { mkdir } from 'fs/promises'
-import { join } from 'path'
-import { existsSync } from 'fs'
-
-const execFileAsync = promisify(execFile)
-
-export type TLSCertificateOptions = {
-  // Output directory for certificates
-  outputDir: string
-  // Common Name (CN) for the certificate (default: localhost)
-  commonName?: string
-  // Validity period in days (default: 365)
-  validDays?: number
-  // Organization name (default: SpinDB)
-  organization?: string
-}
-
-export type TLSCertificateResult = {
-  certPath: string
-  keyPath: string
-}
-
-/**
- * Generate self-signed TLS certificates using openssl
- * @param options Certificate generation options
- * @returns Paths to the generated certificate and key files
- */
-export async function generateTLSCertificates(
-  options: TLSCertificateOptions,
-): Promise<TLSCertificateResult> {
-  const {
-    outputDir,
-    commonName = 'localhost',
-    validDays = 365,
-    organization = 'SpinDB',
-  } = options
-
-  // Ensure output directory exists
-  await mkdir(outputDir, { recursive: true })
-
-  const certPath = join(outputDir, 'server.crt')
-  const keyPath = join(outputDir, 'server.key')
-
-  // Build the subject string for the certificate
-  const subject = `/O=${organization}/CN=${commonName}`
-
-  // Generate self-signed certificate with openssl
-  // -x509: output a self-signed certificate instead of a CSR
-  // -newkey rsa:2048: generate a 2048-bit RSA key
-  // -nodes: don't encrypt the private key
-  // -keyout: output path for the private key
-  // -out: output path for the certificate
-  // -days: validity period
-  // -subj: subject for the certificate
-  // -addext: add Subject Alternative Name for localhost
-  try {
-    await execFileAsync('openssl', [
-      'req',
-      '-x509',
-      '-newkey',
-      'rsa:2048',
-      '-nodes',
-      '-keyout',
-      keyPath,
-      '-out',
-      certPath,
-      '-days',
-      String(validDays),
-      '-subj',
-      subject,
-      '-addext',
-      `subjectAltName=DNS:${commonName},DNS:localhost,IP:127.0.0.1`,
-    ])
-  } catch (error) {
-    const e = error as Error
-    throw new Error(
-      `Failed to generate TLS certificates: ${e.message}. ` +
-        'Make sure openssl is installed and available in PATH.',
-    )
-  }
-
-  return { certPath, keyPath }
-}
-
-/**
- * Check if openssl is available on the system
- * @returns true if openssl is available
- */
-export async function isOpenSSLAvailable(): Promise<boolean> {
-  try {
-    await execFileAsync('openssl', ['version'])
-    return true
-  } catch {
-    return false
-  }
-}
-
-/**
- * Check if TLS certificates already exist in a directory
- * @param certsDir Directory to check
- * @returns true if both server.crt and server.key exist
- */
-export function tlsCertificatesExist(certsDir: string): boolean {
-  const certPath = join(certsDir, 'server.crt')
-  const keyPath = join(certsDir, 'server.key')
-  return existsSync(certPath) && existsSync(keyPath)
-}

package/core/transaction-manager.ts

@@ -1,158 +0,0 @@
-/**
- * Transaction Manager
- *
- * Provides rollback support for multi-step operations like container creation.
- * If any step fails, all previously completed steps are rolled back in reverse order.
- */
-
-import { logError, logDebug, ErrorCodes } from './error-handler'
-
-export type RollbackAction = {
-  description: string
-  execute: () => Promise<void>
-}
-
-/**
- * Manages a stack of rollback actions for transactional operations.
- *
- * Usage:
- * ```ts
- * const tx = new TransactionManager()
- *
- * try {
- *   await createDirectory()
- *   tx.addRollback({
- *     description: 'Delete directory',
- *     execute: () => deleteDirectory()
- *   })
- *
- *   await initDatabase()
- *   // Directory rollback covers this too
- *
- *   await startServer()
- *   tx.addRollback({
- *     description: 'Stop server',
- *     execute: () => stopServer()
- *   })
- *
- *   tx.commit() // Success - clear rollback stack
- * } catch (error) {
- *   await tx.rollback() // Error - undo everything
- *   throw error
- * }
- * ```
- */
-export class TransactionManager {
-  private rollbackStack: RollbackAction[] = []
-  private committed = false
-
-  /**
-   * Add a rollback action to the stack.
-   * Actions are executed in reverse order during rollback.
-   */
-  addRollback(action: RollbackAction): void {
-    if (this.committed) {
-      throw new Error('Cannot add rollback action after commit')
-    }
-    this.rollbackStack.push(action)
-    logDebug(`Added rollback action: ${action.description}`, {
-      totalActions: this.rollbackStack.length,
-    })
-  }
-
-  /**
-   * Execute all rollbacks in reverse order.
-   * Continues even if individual rollback actions fail.
-   */
-  async rollback(): Promise<void> {
-    if (this.committed) {
-      logDebug('Skipping rollback - transaction was committed')
-      return
-    }
-
-    if (this.rollbackStack.length === 0) {
-      logDebug('No rollback actions to execute')
-      return
-    }
-
-    logDebug(`Starting rollback of ${this.rollbackStack.length} actions`)
-
-    // Execute in reverse order (LIFO)
-    while (this.rollbackStack.length > 0) {
-      const action = this.rollbackStack.pop()!
-
-      try {
-        logDebug(`Executing rollback: ${action.description}`)
-        await action.execute()
-        logDebug(`Rollback successful: ${action.description}`)
-      } catch (error) {
-        // Log error but continue with other rollbacks
-        logError({
-          code: ErrorCodes.ROLLBACK_FAILED,
-          message: `Failed to rollback: ${action.description}`,
-          severity: 'warning',
-          context: {
-            error: error instanceof Error ? error.message : String(error),
-          },
-        })
-      }
-    }
-
-    logDebug('Rollback complete')
-  }
-
-  /**
-   * Mark the transaction as committed.
-   * Clears the rollback stack since we don't need to undo anything.
-   */
-  commit(): void {
-    if (this.committed) {
-      return // Already committed
-    }
-
-    logDebug(`Committing transaction with ${this.rollbackStack.length} actions`)
-    this.rollbackStack = []
-    this.committed = true
-  }
-
-  // Check if the transaction has been committed.
-  isCommitted(): boolean {
-    return this.committed
-  }
-
-  // Get the number of pending rollback actions.
-  getPendingCount(): number {
-    return this.rollbackStack.length
-  }
-}
-
-/**
- * Helper function to execute an operation with automatic rollback on failure.
- *
- * Usage:
- * ```ts
- * await withTransaction(async (tx) => {
- *   await step1()
- *   tx.addRollback({ description: 'Undo step1', execute: undoStep1 })
- *
- *   await step2()
- *   tx.addRollback({ description: 'Undo step2', execute: undoStep2 })
- *
- *   // If we get here without throwing, transaction commits automatically
- * })
- * ```
- */
-export async function withTransaction<T>(
-  operation: (tx: TransactionManager) => Promise<T>,
-): Promise<T> {
-  const tx = new TransactionManager()
-
-  try {
-    const result = await operation(tx)
-    tx.commit()
-    return result
-  } catch (error) {
-    await tx.rollback()
-    throw error
-  }
-}