spindb 0.4.1 → 0.5.2

package/core/binary-manager.ts

@@ -62,7 +62,12 @@ export class BinaryManager {
     platform: string,
     arch: string,
   ): Promise<boolean> {
-    const binPath = paths.getBinaryPath('postgresql', version, platform, arch)
+    const binPath = paths.getBinaryPath({
+      engine: 'postgresql',
+      version,
+      platform,
+      arch,
+    })
     const postgresPath = join(binPath, 'bin', 'postgres')
     return existsSync(postgresPath)
   }
@@ -109,7 +114,12 @@ export class BinaryManager {
     onProgress?: ProgressCallback,
   ): Promise<string> {
     const url = this.getDownloadUrl(version, platform, arch)
-    const binPath = paths.getBinaryPath('postgresql', version, platform, arch)
+    const binPath = paths.getBinaryPath({
+      engine: 'postgresql',
+      version,
+      platform,
+      arch,
+    })
     const tempDir = join(paths.bin, `temp-${version}-${platform}-${arch}`)
     const jarFile = join(tempDir, 'postgres.jar')
 
@@ -190,7 +200,12 @@ export class BinaryManager {
     platform: string,
     arch: string,
   ): Promise<boolean> {
-    const binPath = paths.getBinaryPath('postgresql', version, platform, arch)
+    const binPath = paths.getBinaryPath({
+      engine: 'postgresql',
+      version,
+      platform,
+      arch,
+    })
     const postgresPath = join(binPath, 'bin', 'postgres')
 
     if (!existsSync(postgresPath)) {
@@ -241,7 +256,12 @@ export class BinaryManager {
     arch: string,
     binary: string,
   ): string {
-    const binPath = paths.getBinaryPath('postgresql', version, platform, arch)
+    const binPath = paths.getBinaryPath({
+      engine: 'postgresql',
+      version,
+      platform,
+      arch,
+    })
     return join(binPath, 'bin', binary)
   }
 
@@ -259,7 +279,12 @@ export class BinaryManager {
         stage: 'cached',
         message: 'Using cached PostgreSQL binaries',
       })
-      return paths.getBinaryPath('postgresql', version, platform, arch)
+      return paths.getBinaryPath({
+        engine: 'postgresql',
+        version,
+        platform,
+        arch,
+      })
     }
 
     return this.download(version, platform, arch, onProgress)

package/core/container-manager.ts

@@ -3,10 +3,12 @@ import { mkdir, readdir, readFile, writeFile, rm, cp } from 'fs/promises'
 import { paths } from '../config/paths'
 import { processManager } from './process-manager'
 import { portManager } from './port-manager'
-import type { ContainerConfig } from '../types'
+import { getEngineDefaults, getSupportedEngines } from '../config/defaults'
+import { getEngine } from '../engines'
+import type { ContainerConfig, EngineName } from '../types'
 
 export type CreateOptions = {
-  engine: string
+  engine: EngineName
   version: string
   port: number
   database: string
@@ -30,14 +32,14 @@ export class ContainerManager {
       )
     }
 
-    // Check if container already exists
-    if (await this.exists(name)) {
-      throw new Error(`Container "${name}" already exists`)
+    // Check if container already exists (for this engine)
+    if (await this.exists(name, { engine })) {
+      throw new Error(`Container "${name}" already exists for engine ${engine}`)
     }
 
-    // Create container directory
-    const containerPath = paths.getContainerPath(name)
-    const dataPath = paths.getContainerDataPath(name)
+    // Create container directory (engine-scoped)
+    const containerPath = paths.getContainerPath(name, { engine })
+    const dataPath = paths.getContainerDataPath(name, { engine })
 
     await mkdir(containerPath, { recursive: true })
     await mkdir(dataPath, { recursive: true })
@@ -53,30 +55,54 @@ export class ContainerManager {
       status: 'created',
     }
 
-    await this.saveConfig(name, config)
+    await this.saveConfig(name, { engine }, config)
 
     return config
   }
 
   /**
    * Get container configuration
+   * If engine is not provided, searches all engine directories
    */
-  async getConfig(name: string): Promise<ContainerConfig | null> {
-    const configPath = paths.getContainerConfigPath(name)
+  async getConfig(
+    name: string,
+    options?: { engine?: string },
+  ): Promise<ContainerConfig | null> {
+    const { engine } = options || {}
+
+    if (engine) {
+      // Look in specific engine directory
+      const configPath = paths.getContainerConfigPath(name, { engine })
+      if (!existsSync(configPath)) {
+        return null
+      }
+      const content = await readFile(configPath, 'utf8')
+      return JSON.parse(content) as ContainerConfig
+    }
 
-    if (!existsSync(configPath)) {
-      return null
+    // Search all engine directories
+    const engines = getSupportedEngines()
+    for (const eng of engines) {
+      const configPath = paths.getContainerConfigPath(name, { engine: eng })
+      if (existsSync(configPath)) {
+        const content = await readFile(configPath, 'utf8')
+        return JSON.parse(content) as ContainerConfig
+      }
     }
 
-    const content = await readFile(configPath, 'utf8')
-    return JSON.parse(content) as ContainerConfig
+    return null
   }
 
   /**
    * Save container configuration
    */
-  async saveConfig(name: string, config: ContainerConfig): Promise<void> {
-    const configPath = paths.getContainerConfigPath(name)
+  async saveConfig(
+    name: string,
+    options: { engine: string },
+    config: ContainerConfig,
+  ): Promise<void> {
+    const { engine } = options
+    const configPath = paths.getContainerConfigPath(name, { engine })
     await writeFile(configPath, JSON.stringify(config, null, 2))
   }
 
@@ -93,20 +119,36 @@ export class ContainerManager {
     }
 
     const updatedConfig = { ...config, ...updates }
-    await this.saveConfig(name, updatedConfig)
+    await this.saveConfig(name, { engine: config.engine }, updatedConfig)
     return updatedConfig
   }
 
   /**
    * Check if a container exists
+   * If engine is not provided, checks all engine directories
    */
-  async exists(name: string): Promise<boolean> {
-    const configPath = paths.getContainerConfigPath(name)
-    return existsSync(configPath)
+  async exists(name: string, options?: { engine?: string }): Promise<boolean> {
+    const { engine } = options || {}
+
+    if (engine) {
+      const configPath = paths.getContainerConfigPath(name, { engine })
+      return existsSync(configPath)
+    }
+
+    // Check all engine directories
+    const engines = getSupportedEngines()
+    for (const eng of engines) {
+      const configPath = paths.getContainerConfigPath(name, { engine: eng })
+      if (existsSync(configPath)) {
+        return true
+      }
+    }
+
+    return false
   }
 
   /**
-   * List all containers
+   * List all containers across all engines
    */
   async list(): Promise<ContainerConfig[]> {
     const containersDir = paths.containers
@@ -115,19 +157,30 @@ export class ContainerManager {
       return []
     }
 
-    const entries = await readdir(containersDir, { withFileTypes: true })
     const containers: ContainerConfig[] = []
+    const engines = getSupportedEngines()
+
+    for (const engine of engines) {
+      const engineDir = paths.getEngineContainersPath(engine)
+      if (!existsSync(engineDir)) {
+        continue
+      }
 
-    for (const entry of entries) {
-      if (entry.isDirectory()) {
-        const config = await this.getConfig(entry.name)
-        if (config) {
-          // Check if actually running
-          const running = await processManager.isRunning(entry.name)
-          containers.push({
-            ...config,
-            status: running ? 'running' : 'stopped',
-          })
+      const entries = await readdir(engineDir, { withFileTypes: true })
+
+      for (const entry of entries) {
+        if (entry.isDirectory()) {
+          const config = await this.getConfig(entry.name, { engine })
+          if (config) {
+            // Check if actually running
+            const running = await processManager.isRunning(entry.name, {
+              engine,
+            })
+            containers.push({
+              ...config,
+              status: running ? 'running' : 'stopped',
+            })
+          }
         }
       }
     }
@@ -141,19 +194,23 @@ export class ContainerManager {
   async delete(name: string, options: DeleteOptions = {}): Promise<void> {
     const { force = false } = options
 
-    if (!(await this.exists(name))) {
+    // Get container config to find engine
+    const config = await this.getConfig(name)
+    if (!config) {
       throw new Error(`Container "${name}" not found`)
     }
 
+    const { engine } = config
+
     // Check if running
-    const running = await processManager.isRunning(name)
+    const running = await processManager.isRunning(name, { engine })
     if (running && !force) {
       throw new Error(
         `Container "${name}" is running. Stop it first or use --force`,
       )
     }
 
-    const containerPath = paths.getContainerPath(name)
+    const containerPath = paths.getContainerPath(name, { engine })
     await rm(containerPath, { recursive: true, force: true })
   }
 
@@ -171,18 +228,21 @@ export class ContainerManager {
       )
     }
 
-    // Check source exists
-    if (!(await this.exists(sourceName))) {
+    // Get source config
+    const sourceConfig = await this.getConfig(sourceName)
+    if (!sourceConfig) {
       throw new Error(`Source container "${sourceName}" not found`)
     }
 
-    // Check target doesn't exist
-    if (await this.exists(targetName)) {
+    const { engine } = sourceConfig
+
+    // Check target doesn't exist (for this engine)
+    if (await this.exists(targetName, { engine })) {
       throw new Error(`Target container "${targetName}" already exists`)
     }
 
     // Check source is not running
-    const running = await processManager.isRunning(sourceName)
+    const running = await processManager.isRunning(sourceName, { engine })
     if (running) {
       throw new Error(
         `Source container "${sourceName}" is running. Stop it first`,
@@ -190,13 +250,13 @@ export class ContainerManager {
     }
 
     // Copy container directory
-    const sourcePath = paths.getContainerPath(sourceName)
-    const targetPath = paths.getContainerPath(targetName)
+    const sourcePath = paths.getContainerPath(sourceName, { engine })
+    const targetPath = paths.getContainerPath(targetName, { engine })
 
     await cp(sourcePath, targetPath, { recursive: true })
 
     // Update target config
-    const config = await this.getConfig(targetName)
+    const config = await this.getConfig(targetName, { engine })
     if (!config) {
       throw new Error('Failed to read cloned container config')
     }
@@ -206,10 +266,13 @@ export class ContainerManager {
     config.clonedFrom = sourceName
 
     // Assign new port (excluding ports already used by other containers)
-    const { port } = await portManager.findAvailablePortExcludingContainers()
+    const engineDefaults = getEngineDefaults(engine)
+    const { port } = await portManager.findAvailablePortExcludingContainers({
+      portRange: engineDefaults.portRange,
+    })
     config.port = port
 
-    await this.saveConfig(targetName, config)
+    await this.saveConfig(targetName, { engine }, config)
 
     return config
   }
@@ -225,37 +288,40 @@ export class ContainerManager {
       )
     }
 
-    // Check source exists
-    if (!(await this.exists(oldName))) {
+    // Get source config
+    const sourceConfig = await this.getConfig(oldName)
+    if (!sourceConfig) {
       throw new Error(`Container "${oldName}" not found`)
     }
 
+    const { engine } = sourceConfig
+
     // Check target doesn't exist
-    if (await this.exists(newName)) {
+    if (await this.exists(newName, { engine })) {
       throw new Error(`Container "${newName}" already exists`)
     }
 
     // Check container is not running
-    const running = await processManager.isRunning(oldName)
+    const running = await processManager.isRunning(oldName, { engine })
     if (running) {
       throw new Error(`Container "${oldName}" is running. Stop it first`)
     }
 
     // Rename directory
-    const oldPath = paths.getContainerPath(oldName)
-    const newPath = paths.getContainerPath(newName)
+    const oldPath = paths.getContainerPath(oldName, { engine })
+    const newPath = paths.getContainerPath(newName, { engine })
 
     await cp(oldPath, newPath, { recursive: true })
     await rm(oldPath, { recursive: true, force: true })
 
     // Update config with new name
-    const config = await this.getConfig(newName)
+    const config = await this.getConfig(newName, { engine })
     if (!config) {
       throw new Error('Failed to read renamed container config')
     }
 
     config.name = newName
-    await this.saveConfig(newName, config)
+    await this.saveConfig(newName, { engine }, config)
 
     return config
   }
@@ -269,13 +335,11 @@ export class ContainerManager {
 
   /**
    * Get connection string for a container
+   * Delegates to the appropriate engine
    */
-  getConnectionString(
-    config: ContainerConfig,
-    database: string = 'postgres',
-  ): string {
-    const { port } = config
-    return `postgresql://postgres@localhost:${port}/${database}`
+  getConnectionString(config: ContainerConfig, database?: string): string {
+    const engine = getEngine(config.engine)
+    return engine.getConnectionString(config, database)
   }
 }
 

package/core/port-manager.ts

@@ -3,12 +3,20 @@ import { exec } from 'child_process'
 import { promisify } from 'util'
 import { existsSync } from 'fs'
 import { readdir, readFile } from 'fs/promises'
-import { defaults } from '../config/defaults'
+import { defaults, getSupportedEngines } from '../config/defaults'
 import { paths } from '../config/paths'
 import type { ContainerConfig, PortResult } from '../types'
 
 const execAsync = promisify(exec)
 
+/**
+ * Options for finding an available port
+ */
+type FindPortOptions = {
+  preferredPort?: number
+  portRange?: { start: number; end: number }
+}
+
 export class PortManager {
   /**
    * Check if a specific port is available
@@ -36,12 +44,13 @@ export class PortManager {
   }
 
   /**
-   * Find the next available port starting from the default
+   * Find the next available port starting from the preferred port
    * Returns the port number and whether it's the default port
    */
-  async findAvailablePort(
-    preferredPort: number = defaults.port,
-  ): Promise<PortResult> {
+  async findAvailablePort(options: FindPortOptions = {}): Promise<PortResult> {
+    const preferredPort = options.preferredPort ?? defaults.port
+    const portRange = options.portRange ?? defaults.portRange
+
     // First try the preferred port
     if (await this.isPortAvailable(preferredPort)) {
       return {
@@ -51,11 +60,7 @@ export class PortManager {
     }
 
     // Scan for available ports in the range
-    for (
-      let port = defaults.portRange.start;
-      port <= defaults.portRange.end;
-      port++
-    ) {
+    for (let port = portRange.start; port <= portRange.end; port++) {
       if (port === preferredPort) continue // Already tried this one
 
       if (await this.isPortAvailable(port)) {
@@ -67,7 +72,7 @@ export class PortManager {
     }
 
     throw new Error(
-      `No available ports found in range ${defaults.portRange.start}-${defaults.portRange.end}`,
+      `No available ports found in range ${portRange.start}-${portRange.end}`,
     )
   }
 
@@ -84,7 +89,7 @@ export class PortManager {
   }
 
   /**
-   * Get all ports currently assigned to containers
+   * Get all ports currently assigned to containers across all engines
    */
   async getContainerPorts(): Promise<number[]> {
     const containersDir = paths.containers
@@ -94,18 +99,26 @@ export class PortManager {
     }
 
     const ports: number[] = []
-    const entries = await readdir(containersDir, { withFileTypes: true })
-
-    for (const entry of entries) {
-      if (entry.isDirectory()) {
-        const configPath = `${containersDir}/${entry.name}/container.json`
-        if (existsSync(configPath)) {
-          try {
-            const content = await readFile(configPath, 'utf8')
-            const config = JSON.parse(content) as ContainerConfig
-            ports.push(config.port)
-          } catch {
-            // Skip invalid configs
+    const engines = getSupportedEngines()
+
+    for (const engine of engines) {
+      const engineDir = paths.getEngineContainersPath(engine)
+      if (!existsSync(engineDir)) continue
+
+      const entries = await readdir(engineDir, { withFileTypes: true })
+      for (const entry of entries) {
+        if (entry.isDirectory()) {
+          const configPath = paths.getContainerConfigPath(entry.name, {
+            engine,
+          })
+          if (existsSync(configPath)) {
+            try {
+              const content = await readFile(configPath, 'utf8')
+              const config = JSON.parse(content) as ContainerConfig
+              ports.push(config.port)
+            } catch {
+              // Skip invalid configs
+            }
           }
         }
       }
@@ -118,8 +131,10 @@ export class PortManager {
    * Find an available port that's not in use by any process AND not assigned to any container
    */
   async findAvailablePortExcludingContainers(
-    preferredPort: number = defaults.port,
+    options: FindPortOptions = {},
   ): Promise<PortResult> {
+    const preferredPort = options.preferredPort ?? defaults.port
+    const portRange = options.portRange ?? defaults.portRange
     const containerPorts = await this.getContainerPorts()
 
     // First try the preferred port
@@ -134,11 +149,7 @@ export class PortManager {
     }
 
     // Scan for available ports in the range
-    for (
-      let port = defaults.portRange.start;
-      port <= defaults.portRange.end;
-      port++
-    ) {
+    for (let port = portRange.start; port <= portRange.end; port++) {
       if (containerPorts.includes(port)) continue // Skip ports used by containers
       if (port === preferredPort) continue // Already tried this one
 
@@ -151,7 +162,7 @@ export class PortManager {
     }
 
     throw new Error(
-      `No available ports found in range ${defaults.portRange.start}-${defaults.portRange.end}`,
+      `No available ports found in range ${portRange.start}-${portRange.end}`,
     )
   }
 }

package/core/process-manager.ts

@@ -202,10 +202,14 @@ export class ProcessManager {
   }
 
   /**
-   * Check if PostgreSQL is running by looking for PID file
+   * Check if a database server is running by looking for PID file
    */
-  async isRunning(containerName: string): Promise<boolean> {
-    const pidFile = paths.getContainerPidPath(containerName)
+  async isRunning(
+    containerName: string,
+    options: { engine: string },
+  ): Promise<boolean> {
+    const { engine } = options
+    const pidFile = paths.getContainerPidPath(containerName, { engine })
     if (!existsSync(pidFile)) {
       return false
     }
@@ -223,10 +227,14 @@ export class ProcessManager {
   }
 
   /**
-   * Get the PID of a running PostgreSQL server
+   * Get the PID of a running database server
    */
-  async getPid(containerName: string): Promise<number | null> {
-    const pidFile = paths.getContainerPidPath(containerName)
+  async getPid(
+    containerName: string,
+    options: { engine: string },
+  ): Promise<number | null> {
+    const { engine } = options
+    const pidFile = paths.getContainerPidPath(containerName, { engine })
     if (!existsSync(pidFile)) {
       return null
     }

package/engines/index.ts

@@ -1,4 +1,5 @@
 import { postgresqlEngine } from './postgresql'
+import { mysqlEngine } from './mysql'
 import type { BaseEngine } from './base-engine'
 import type { EngineInfo } from '../types'
 
@@ -6,9 +7,13 @@ import type { EngineInfo } from '../types'
  * Registry of available database engines
  */
 export const engines: Record<string, BaseEngine> = {
+  // PostgreSQL and aliases
   postgresql: postgresqlEngine,
-  postgres: postgresqlEngine, // Alias
-  pg: postgresqlEngine, // Alias
+  postgres: postgresqlEngine,
+  pg: postgresqlEngine,
+  // MySQL and aliases
+  mysql: mysqlEngine,
+  mariadb: mysqlEngine, // MariaDB is MySQL-compatible
 }
 
 /**