spindb 0.1.0 → 0.2.0

package/src/engines/base-engine.ts

@@ -88,6 +88,14 @@ export abstract class BaseEngine {
     database: string,
   ): Promise<void>
 
+  /**
+   * Drop a database within the container
+   */
+  abstract dropDatabase(
+    container: ContainerConfig,
+    database: string,
+  ): Promise<void>
+
   /**
    * Check if binaries are installed
    */
@@ -100,4 +108,18 @@ export abstract class BaseEngine {
     version: string,
     onProgress?: ProgressCallback,
   ): Promise<string>
+
+  /**
+   * Fetch all available versions from remote source (grouped by major version)
+   * Returns a map of major version -> array of full versions (sorted latest first)
+   * Falls back to hardcoded versions if network fails
+   */
+  async fetchAvailableVersions(): Promise<Record<string, string[]>> {
+    // Default implementation returns supported versions as single-item arrays
+    const versions: Record<string, string[]> = {}
+    for (const v of this.supportedVersions) {
+      versions[v] = [v]
+    }
+    return versions
+  }
 }

package/src/engines/postgresql/binary-urls.ts

@@ -1,15 +1,126 @@
+import { platform, arch } from 'os'
 import { defaults } from '@/config/defaults'
 
 /**
- * Map major versions to latest stable patch versions
+ * Fallback map of major versions to stable patch versions
+ * Used when Maven repository is unreachable
  */
-export const VERSION_MAP: Record<string, string> = {
-  '14': '14.15.0',
-  '15': '15.10.0',
-  '16': '16.6.0',
-  '17': '17.2.0',
+export const FALLBACK_VERSION_MAP: Record<string, string> = {
+  '14': '14.20.0',
+  '15': '15.15.0',
+  '16': '16.11.0',
+  '17': '17.7.0',
 }
 
+/**
+ * Supported major versions (in order of display)
+ */
+export const SUPPORTED_MAJOR_VERSIONS = ['14', '15', '16', '17']
+
+// Cache for fetched versions
+let cachedVersions: Record<string, string[]> | null = null
+let cacheTimestamp = 0
+const CACHE_TTL_MS = 5 * 60 * 1000 // 5 minutes
+
+/**
+ * Fetch available versions from Maven repository
+ */
+export async function fetchAvailableVersions(): Promise<
+  Record<string, string[]>
+> {
+  // Return cached versions if still valid
+  if (cachedVersions && Date.now() - cacheTimestamp < CACHE_TTL_MS) {
+    return cachedVersions
+  }
+
+  const zonkyPlatform = getZonkyPlatform(platform(), arch())
+  if (!zonkyPlatform) {
+    throw new Error(`Unsupported platform: ${platform()}-${arch()}`)
+  }
+
+  const url = `https://repo1.maven.org/maven2/io/zonky/test/postgres/embedded-postgres-binaries-${zonkyPlatform}/`
+
+  try {
+    const response = await fetch(url, { signal: AbortSignal.timeout(5000) })
+    if (!response.ok) {
+      throw new Error(`HTTP ${response.status}`)
+    }
+
+    const html = await response.text()
+
+    // Parse version directories from the HTML listing
+    // Format: <a href="14.15.0/">14.15.0/</a>
+    const versionRegex = /href="(\d+\.\d+\.\d+)\/"/g
+    const versions: string[] = []
+    let match
+
+    while ((match = versionRegex.exec(html)) !== null) {
+      versions.push(match[1])
+    }
+
+    // Group versions by major version
+    const grouped: Record<string, string[]> = {}
+    for (const major of SUPPORTED_MAJOR_VERSIONS) {
+      grouped[major] = versions
+        .filter((v) => v.startsWith(`${major}.`))
+        .sort((a, b) => compareVersions(b, a)) // Sort descending (latest first)
+    }
+
+    // Cache the results
+    cachedVersions = grouped
+    cacheTimestamp = Date.now()
+
+    return grouped
+  } catch {
+    // Return fallback on any error
+    return getFallbackVersions()
+  }
+}
+
+/**
+ * Get fallback versions when network is unavailable
+ */
+function getFallbackVersions(): Record<string, string[]> {
+  const grouped: Record<string, string[]> = {}
+  for (const major of SUPPORTED_MAJOR_VERSIONS) {
+    grouped[major] = [FALLBACK_VERSION_MAP[major]]
+  }
+  return grouped
+}
+
+/**
+ * Compare two version strings (e.g., "16.11.0" vs "16.9.0")
+ * Returns positive if a > b, negative if a < b, 0 if equal
+ */
+function compareVersions(a: string, b: string): number {
+  const partsA = a.split('.').map(Number)
+  const partsB = b.split('.').map(Number)
+
+  for (let i = 0; i < Math.max(partsA.length, partsB.length); i++) {
+    const numA = partsA[i] || 0
+    const numB = partsB[i] || 0
+    if (numA !== numB) {
+      return numA - numB
+    }
+  }
+  return 0
+}
+
+/**
+ * Get the latest version for a major version
+ */
+export async function getLatestVersion(major: string): Promise<string> {
+  const versions = await fetchAvailableVersions()
+  const majorVersions = versions[major]
+  if (majorVersions && majorVersions.length > 0) {
+    return majorVersions[0] // First is latest due to descending sort
+  }
+  return FALLBACK_VERSION_MAP[major] || `${major}.0.0`
+}
+
+// Legacy export for backward compatibility
+export const VERSION_MAP = FALLBACK_VERSION_MAP
+
 /**
  * Get the zonky.io platform identifier
  */
@@ -34,16 +145,23 @@ export function getBinaryUrl(
     throw new Error(`Unsupported platform: ${platform}-${arch}`)
   }
 
-  const fullVersion = VERSION_MAP[version]
-  if (!fullVersion) {
-    throw new Error(
-      `Unsupported PostgreSQL version: ${version}. Supported: ${Object.keys(VERSION_MAP).join(', ')}`,
-    )
-  }
+  // Use VERSION_MAP for major versions, otherwise treat as full version
+  const fullVersion = VERSION_MAP[version] || normalizeVersion(version)
 
   return `https://repo1.maven.org/maven2/io/zonky/test/postgres/embedded-postgres-binaries-${zonkyPlatform}/${fullVersion}/embedded-postgres-binaries-${zonkyPlatform}-${fullVersion}.jar`
 }
 
+/**
+ * Normalize version string to X.Y.Z format
+ */
+function normalizeVersion(version: string): string {
+  const parts = version.split('.')
+  if (parts.length === 2) {
+    return `${version}.0`
+  }
+  return version
+}
+
 /**
  * Get the full version string for a major version
  */

package/src/engines/postgresql/index.ts

@@ -8,7 +8,11 @@ import { processManager } from '@/core/process-manager'
 import { configManager } from '@/core/config-manager'
 import { paths } from '@/config/paths'
 import { defaults } from '@/config/defaults'
-import { getBinaryUrl, VERSION_MAP } from './binary-urls'
+import {
+  getBinaryUrl,
+  SUPPORTED_MAJOR_VERSIONS,
+  fetchAvailableVersions,
+} from './binary-urls'
 import { detectBackupFormat, restoreBackup } from './restore'
 import type {
   ContainerConfig,
@@ -24,7 +28,15 @@ export class PostgreSQLEngine extends BaseEngine {
   name = 'postgresql'
   displayName = 'PostgreSQL'
   defaultPort = 5432
-  supportedVersions = Object.keys(VERSION_MAP)
+  supportedVersions = SUPPORTED_MAJOR_VERSIONS
+
+  /**
+   * Fetch all available versions from Maven (grouped by major version)
+   * Falls back to hardcoded versions if network fails
+   */
+  async fetchAvailableVersions(): Promise<Record<string, string[]>> {
+    return fetchAvailableVersions()
+  }
 
   /**
    * Get current platform info
@@ -178,6 +190,7 @@ export class PostgreSQLEngine extends BaseEngine {
       port,
       database,
       user: defaults.superuser,
+      pgRestorePath: options.pgRestorePath as string, // Use custom path if provided
       ...(options as { format?: string }),
     })
   }
@@ -187,8 +200,8 @@ export class PostgreSQLEngine extends BaseEngine {
    */
   getConnectionString(container: ContainerConfig, database?: string): string {
     const { port } = container
-    const db = database || 'postgres'
-    return `postgresql://${defaults.superuser}@localhost:${port}/${db}`
+    const db = database || container.database || 'postgres'
+    return `postgresql://${defaults.superuser}@127.0.0.1:${port}/${db}`
   }
 
   /**
@@ -293,6 +306,29 @@ export class PostgreSQLEngine extends BaseEngine {
       }
     }
   }
+
+  /**
+   * Drop a database
+   */
+  async dropDatabase(
+    container: ContainerConfig,
+    database: string,
+  ): Promise<void> {
+    const { port } = container
+    const psqlPath = await this.getPsqlPath()
+
+    try {
+      await execAsync(
+        `"${psqlPath}" -h 127.0.0.1 -p ${port} -U ${defaults.superuser} -d postgres -c 'DROP DATABASE IF EXISTS "${database}"'`,
+      )
+    } catch (error) {
+      const err = error as Error
+      // Ignore "database does not exist" error
+      if (!err.message.includes('does not exist')) {
+        throw error
+      }
+    }
+  }
 }
 
 export const postgresqlEngine = new PostgreSQLEngine()

package/src/engines/postgresql/restore.ts

@@ -2,6 +2,7 @@ import { readFile } from 'fs/promises'
 import { exec } from 'child_process'
 import { promisify } from 'util'
 import { configManager } from '@/core/config-manager'
+import { findBinaryPathFresh } from '@/core/postgres-binary-manager'
 import type { BackupFormat, RestoreResult } from '@/types'
 
 const execAsync = promisify(exec)
@@ -77,11 +78,12 @@ export async function detectBackupFormat(
   }
 }
 
-export interface RestoreOptions {
+export type RestoreOptions = {
   port: number
   database: string
   user?: string
   format?: string
+  pgRestorePath?: string
 }
 
 /**
@@ -101,19 +103,27 @@ async function getPsqlPath(): Promise<string> {
 }
 
 /**
- * Get pg_restore path from config, with helpful error message
+ * Get pg_restore path from config or system PATH, with helpful error message
  */
 async function getPgRestorePath(): Promise<string> {
-  const pgRestorePath = await configManager.getBinaryPath('pg_restore')
-  if (!pgRestorePath) {
+  // First try to get from config (in case user has set a custom path)
+  const configPath = await configManager.getBinaryPath('pg_restore')
+  if (configPath) {
+    return configPath
+  }
+
+  // Fall back to finding it on the system PATH with cache refresh
+  const systemPath = await findBinaryPathFresh('pg_restore')
+  if (!systemPath) {
     throw new Error(
       'pg_restore not found. Install PostgreSQL client tools:\n' +
         '  macOS: brew install libpq && brew link --force libpq\n' +
-        '  Ubuntu/Debian: apt install postgresql-client\n\n' +
+        '  Ubuntu/Debian: apt install postgresql-client\n' +
+        '  CentOS/RHEL/Fedora: yum install postgresql\n\n' +
         'Or configure manually: spindb config set pg_restore /path/to/pg_restore',
     )
   }
-  return pgRestorePath
+  return systemPath
 }
 
 /**
@@ -124,7 +134,7 @@ export async function restoreBackup(
   backupPath: string,
   options: RestoreOptions,
 ): Promise<RestoreResult> {
-  const { port, database, user = 'postgres', format } = options
+  const { port, database, user = 'postgres', format, pgRestorePath } = options
 
   const detectedFormat = format || (await detectBackupFormat(backupPath)).format
 
@@ -141,7 +151,8 @@ export async function restoreBackup(
       ...result,
     }
   } else {
-    const pgRestorePath = await getPgRestorePath()
+    // Use custom path if provided, otherwise find it dynamically
+    const restorePath = pgRestorePath || (await getPgRestorePath())
 
     try {
       const formatFlag =
@@ -151,7 +162,7 @@ export async function restoreBackup(
             ? '-Ft'
             : ''
       const result = await execAsync(
-        `"${pgRestorePath}" -h 127.0.0.1 -p ${port} -U ${user} -d ${database} --no-owner --no-privileges ${formatFlag} "${backupPath}"`,
+        `"${restorePath}" -h 127.0.0.1 -p ${port} -U ${user} -d ${database} --no-owner --no-privileges ${formatFlag} "${backupPath}"`,
         { maxBuffer: 50 * 1024 * 1024 },
       )
 

package/src/types/index.ts

@@ -1,54 +1,56 @@
-export interface ContainerConfig {
+export type ContainerConfig = {
   name: string
   engine: string
   version: string
   port: number
+  database: string
   created: string
   status: 'created' | 'running' | 'stopped'
   clonedFrom?: string
 }
 
-export interface ProgressCallback {
-  (progress: { stage: string; message: string }): void
-}
+export type ProgressCallback = (progress: {
+  stage: string
+  message: string
+}) => void
 
-export interface InstalledBinary {
+export type InstalledBinary = {
   engine: string
   version: string
   platform: string
   arch: string
 }
 
-export interface PortResult {
+export type PortResult = {
   port: number
   isDefault: boolean
 }
 
-export interface ProcessResult {
+export type ProcessResult = {
   stdout: string
   stderr: string
   code?: number
 }
 
-export interface StatusResult {
+export type StatusResult = {
   running: boolean
   message: string
 }
 
-export interface BackupFormat {
+export type BackupFormat = {
   format: string
   description: string
   restoreCommand: string
 }
 
-export interface RestoreResult {
+export type RestoreResult = {
   format: string
   stdout?: string
   stderr?: string
   code?: number
 }
 
-export interface EngineInfo {
+export type EngineInfo = {
   name: string
   displayName: string
   defaultPort: number
@@ -68,7 +70,7 @@ export type BinarySource = 'bundled' | 'system' | 'custom'
 /**
  * Configuration for a single binary tool
  */
-export interface BinaryConfig {
+export type BinaryConfig = {
   tool: BinaryTool
   path: string
   source: BinarySource
@@ -78,7 +80,7 @@ export interface BinaryConfig {
 /**
  * Global spindb configuration stored in ~/.spindb/config.json
  */
-export interface SpinDBConfig {
+export type SpinDBConfig = {
   // Binary paths for client tools
   binaries: {
     psql?: BinaryConfig

package/tsconfig.json

@@ -1,13 +1,14 @@
 {
   "compilerOptions": {
     "target": "ES2022",
-    "module": "NodeNext",
-    "moduleResolution": "NodeNext",
+    "module": "ESNext",
+    "moduleResolution": "bundler",
     "lib": ["ES2022"],
     "outDir": "./dist",
     "rootDir": "./src",
     "strict": true,
     "esModuleInterop": true,
+    "allowSyntheticDefaultImports": true,
     "skipLibCheck": true,
     "forceConsistentCasingInFileNames": true,
     "resolveJsonModule": true,
@@ -17,7 +18,9 @@
     "baseUrl": ".",
     "paths": {
       "@/*": ["./src/*"]
-    }
+    },
+    "allowImportingTsExtensions": true,
+    "noEmit": true
   },
   "include": ["src/**/*"],
   "exclude": ["node_modules", "dist"]