spindb 0.37.2 → 0.38.0

package/engines/duckdb/registry.ts

@@ -1,303 +0,0 @@
-/**
- * DuckDB Registry Manager
- *
- * Unlike PostgreSQL/MySQL which store containers in ~/.spindb/containers/,
- * DuckDB databases are stored in user project directories. This registry
- * tracks the file paths of all DuckDB databases managed by SpinDB.
- *
- * The registry is stored in ~/.spindb/config.json under registry.duckdb
- *
- * Note: Mutation operations use file-based locking to prevent race conditions
- * when multiple processes access the registry concurrently.
- */
-
-import { existsSync } from 'fs'
-import { mkdir, writeFile, unlink, stat } from 'fs/promises'
-import { join, dirname } from 'path'
-import { configManager } from '../../core/config-manager'
-import { paths } from '../../config/paths'
-import type { DuckDBEngineRegistry, DuckDBRegistryEntry } from '../../types'
-
-// Lock file settings
-const LOCK_STALE_MS = 10000 // Consider lock stale after 10 seconds
-const LOCK_RETRY_MS = 50 // Retry interval when waiting for lock
-const LOCK_TIMEOUT_MS = 5000 // Max time to wait for lock
-
-/**
- * Simple file-based lock for registry mutations.
- * Uses atomic file creation to ensure exclusive access.
- */
-class RegistryLock {
-  private lockPath: string
-
-  constructor() {
-    this.lockPath = join(paths.root, '.duckdb-registry.lock')
-  }
-
-  /**
-   * Acquire the lock, waiting if necessary.
-   * Returns a release function that must be called when done.
-   */
-  async acquire(): Promise<() => Promise<void>> {
-    const startTime = Date.now()
-
-    while (Date.now() - startTime < LOCK_TIMEOUT_MS) {
-      try {
-        // Check if existing lock is stale
-        if (existsSync(this.lockPath)) {
-          try {
-            const lockStat = await stat(this.lockPath)
-            const lockAge = Date.now() - lockStat.mtimeMs
-            if (lockAge > LOCK_STALE_MS) {
-              // Stale lock, remove it
-              await unlink(this.lockPath).catch(() => {})
-            }
-          } catch {
-            // Lock file disappeared, continue to acquire
-          }
-        }
-
-        // Ensure parent directory exists
-        await mkdir(dirname(this.lockPath), { recursive: true })
-
-        // Try to create lock file exclusively
-        // Using 'wx' flag: create exclusively, fail if exists
-        await writeFile(this.lockPath, String(process.pid), { flag: 'wx' })
-
-        // Successfully acquired lock
-        return async () => {
-          await unlink(this.lockPath).catch(() => {})
-        }
-      } catch (err) {
-        const error = err as NodeJS.ErrnoException
-        if (error.code === 'EEXIST') {
-          // Lock exists, wait and retry
-          await new Promise((resolve) => setTimeout(resolve, LOCK_RETRY_MS))
-        } else {
-          throw err
-        }
-      }
-    }
-
-    throw new Error(
-      `Timeout acquiring DuckDB registry lock after ${LOCK_TIMEOUT_MS}ms`,
-    )
-  }
-}
-
-const registryLock = new RegistryLock()
-
-/**
- * DuckDB Registry Manager
- * Manages the registry that tracks external DuckDB database files
- * Data is stored in config.json under registry.duckdb
- */
-class DuckDBRegistryManager {
-  /**
-   * Load the registry from config.json
-   * Returns an empty registry if none exists
-   */
-  async load(): Promise<DuckDBEngineRegistry> {
-    return configManager.getDuckDBRegistry()
-  }
-
-  // Save the registry to config.json
-  async save(registry: DuckDBEngineRegistry): Promise<void> {
-    await configManager.saveDuckDBRegistry(registry)
-  }
-
-  /**
-   * Add a new entry to the registry
-   * @throws Error if a container with the same name or file path already exists
-   */
-  async add(entry: DuckDBRegistryEntry): Promise<void> {
-    const release = await registryLock.acquire()
-    try {
-      const registry = await this.load()
-
-      // Check for duplicate name
-      if (registry.entries.some((e) => e.name === entry.name)) {
-        throw new Error(`DuckDB container "${entry.name}" already exists`)
-      }
-
-      // Check for duplicate file path
-      if (registry.entries.some((e) => e.filePath === entry.filePath)) {
-        throw new Error(
-          `DuckDB container for path "${entry.filePath}" already exists`,
-        )
-      }
-
-      registry.entries.push(entry)
-      await this.save(registry)
-    } finally {
-      await release()
-    }
-  }
-
-  /**
-   * Get an entry by name
-   * Returns null if not found
-   */
-  async get(name: string): Promise<DuckDBRegistryEntry | null> {
-    const registry = await this.load()
-    return registry.entries.find((e) => e.name === name) || null
-  }
-
-  /**
-   * Remove an entry by name
-   * Returns true if the entry was found and removed, false otherwise
-   */
-  async remove(name: string): Promise<boolean> {
-    const release = await registryLock.acquire()
-    try {
-      const registry = await this.load()
-      const index = registry.entries.findIndex((e) => e.name === name)
-
-      if (index === -1) {
-        return false
-      }
-
-      registry.entries.splice(index, 1)
-      await this.save(registry)
-      return true
-    } finally {
-      await release()
-    }
-  }
-
-  /**
-   * Update an existing entry
-   * Returns true if the entry was found and updated, false otherwise
-   */
-  async update(
-    name: string,
-    updates: Partial<Omit<DuckDBRegistryEntry, 'name'>>,
-  ): Promise<boolean> {
-    const release = await registryLock.acquire()
-    try {
-      const registry = await this.load()
-      const entry = registry.entries.find((e) => e.name === name)
-
-      if (!entry) {
-        return false
-      }
-
-      Object.assign(entry, updates)
-      await this.save(registry)
-      return true
-    } finally {
-      await release()
-    }
-  }
-
-  // List all entries in the registry
-  async list(): Promise<DuckDBRegistryEntry[]> {
-    const registry = await this.load()
-    return registry.entries
-  }
-
-  // Check if a container with the given name exists
-  async exists(name: string): Promise<boolean> {
-    const entry = await this.get(name)
-    return entry !== null
-  }
-
-  // Find orphaned entries (where the file no longer exists)
-  async findOrphans(): Promise<DuckDBRegistryEntry[]> {
-    const registry = await this.load()
-    return registry.entries.filter((e) => !existsSync(e.filePath))
-  }
-
-  /**
-   * Remove all orphaned entries from the registry
-   * Returns the number of entries removed
-   */
-  async removeOrphans(): Promise<number> {
-    const release = await registryLock.acquire()
-    try {
-      const registry = await this.load()
-      const originalCount = registry.entries.length
-
-      registry.entries = registry.entries.filter((e) => existsSync(e.filePath))
-
-      const removedCount = originalCount - registry.entries.length
-      if (removedCount > 0) {
-        await this.save(registry)
-      }
-
-      return removedCount
-    } finally {
-      await release()
-    }
-  }
-
-  // Update the lastVerified timestamp for an entry
-  async updateVerified(name: string): Promise<void> {
-    await this.update(name, { lastVerified: new Date().toISOString() })
-  }
-
-  // Check if a file path is already registered (by any container)
-  async isPathRegistered(filePath: string): Promise<boolean> {
-    const registry = await this.load()
-    return registry.entries.some((e) => e.filePath === filePath)
-  }
-
-  /**
-   * Get the container name for a given file path
-   * Returns null if not found
-   */
-  async getByPath(filePath: string): Promise<DuckDBRegistryEntry | null> {
-    const registry = await this.load()
-    return registry.entries.find((e) => e.filePath === filePath) || null
-  }
-
-  // ============================================================
-  // Folder Ignore Methods
-  // ============================================================
-
-  // Check if a folder is in the ignore list
-  async isFolderIgnored(folderPath: string): Promise<boolean> {
-    const registry = await this.load()
-    return folderPath in registry.ignoreFolders
-  }
-
-  // Add a folder to the ignore list
-  async addIgnoreFolder(folderPath: string): Promise<void> {
-    const release = await registryLock.acquire()
-    try {
-      const registry = await this.load()
-      registry.ignoreFolders[folderPath] = true
-      await this.save(registry)
-    } finally {
-      await release()
-    }
-  }
-
-  /**
-   * Remove a folder from the ignore list
-   * Returns true if the folder was in the list and removed, false otherwise
-   */
-  async removeIgnoreFolder(folderPath: string): Promise<boolean> {
-    const release = await registryLock.acquire()
-    try {
-      const registry = await this.load()
-      if (folderPath in registry.ignoreFolders) {
-        delete registry.ignoreFolders[folderPath]
-        await this.save(registry)
-        return true
-      }
-      return false
-    } finally {
-      await release()
-    }
-  }
-
-  // List all ignored folders
-  async listIgnoredFolders(): Promise<string[]> {
-    const registry = await this.load()
-    return Object.keys(registry.ignoreFolders)
-  }
-}
-
-// Export singleton instance
-export const duckdbRegistry = new DuckDBRegistryManager()

package/engines/duckdb/scanner.ts

@@ -1,22 +0,0 @@
-/**
- * DuckDB Scanner — thin wrapper around shared file-based-utils
- */
-
-import { Engine } from '../../types'
-import {
-  scanForUnregisteredFiles,
-  deriveContainerName as sharedDeriveContainerName,
-  type UnregisteredFile,
-} from '../file-based-utils'
-
-export type { UnregisteredFile }
-
-export async function scanForUnregisteredDuckDBFiles(
-  directory?: string,
-): Promise<UnregisteredFile[]> {
-  return scanForUnregisteredFiles(Engine.DuckDB, directory)
-}
-
-export function deriveContainerName(fileName: string): string {
-  return sharedDeriveContainerName(fileName, Engine.DuckDB)
-}

package/engines/duckdb/version-maps.ts

@@ -1,78 +0,0 @@
-/**
- * DuckDB Version Maps
- *
- * TEMPORARY: This version map will be replaced by the hostdb npm package once published.
- * Until then, manually keep this in sync with robertjbass/hostdb releases.json:
- * https://github.com/robertjbass/hostdb/blob/main/releases.json
- *
- * When updating versions:
- * 1. Check hostdb releases.json for available versions
- * 2. Update DUCKDB_VERSION_MAP to match
- */
-
-import { logDebug } from '../../core/error-handler'
-
-/**
- * Map of major DuckDB versions to their latest stable patch versions.
- * Must match versions available in hostdb releases.json.
- */
-export const DUCKDB_VERSION_MAP: Record<string, string> = {
-  // 1-part: major version → latest
-  '1': '1.4.3',
-  // 2-part: major.minor → latest patch
-  '1.4': '1.4.3',
-  // 3-part: exact version (identity mapping)
-  '1.4.3': '1.4.3',
-}
-
-/**
- * Supported major DuckDB versions (1-part format).
- * Used for grouping and display purposes.
- */
-export const SUPPORTED_MAJOR_VERSIONS = ['1']
-
-/**
- * Get the full version string for a major version.
- *
- * @param majorVersion - Major version (e.g., '1')
- * @returns Full version string (e.g., '1.4.3') or null if not supported
- */
-export function getFullVersion(majorVersion: string): string | null {
-  return DUCKDB_VERSION_MAP[majorVersion] || null
-}
-
-/**
- * Normalize a version string to X.Y.Z format.
- *
- * @param version - Version string (e.g., '1', '1.4', '1.4.3')
- * @returns Normalized version (e.g., '1.4.3')
- */
-export function normalizeVersion(version: string): string {
-  // If it's a version key in the map (major, major.minor, or full), return the mapped version
-  // Identity mappings for 3-part versions (e.g., '1.4.3' -> '1.4.3') are already in the map
-  const fullVersion = DUCKDB_VERSION_MAP[version]
-  if (fullVersion) {
-    return fullVersion
-  }
-
-  // Unknown version - validate format and log at debug level
-  // This may cause download failures if the version doesn't exist in hostdb
-  const parts = version.split('.')
-
-  // Validate format: must be 1-3 numeric segments (e.g., "1", "1.4", "1.4.3")
-  const isValidFormat =
-    parts.length >= 1 &&
-    parts.length <= 3 &&
-    parts.every((p) => /^\d+$/.test(p))
-
-  if (!isValidFormat) {
-    logDebug(
-      `DuckDB version '${version}' has invalid format, may not be available in hostdb`,
-    )
-  } else {
-    logDebug(
-      `DuckDB version '${version}' not in version map, may not be available in hostdb`,
-    )
-  }
-  return version
-}

package/engines/duckdb/version-validator.ts

@@ -1,78 +0,0 @@
-/**
- * DuckDB Version Validator
- *
- * Handles version parsing, validation, and compatibility checking for DuckDB.
- */
-
-import { DUCKDB_VERSION_MAP, SUPPORTED_MAJOR_VERSIONS } from './version-maps'
-
-export type ParsedVersion = {
-  major: number
-  minor: number
-  patch: number
-  full: string
-}
-
-/**
- * Parse a version string into its components.
- *
- * @param version - Version string (e.g., '1.4.3', '1.4', '1')
- * @returns Parsed version object or null if invalid
- */
-export function parseVersion(version: string): ParsedVersion | null {
-  const parts = version.split('.')
-
-  if (parts.length < 1 || parts.length > 3) {
-    return null
-  }
-
-  const major = parseInt(parts[0], 10)
-  const minor = parts.length >= 2 ? parseInt(parts[1], 10) : 0
-  const patch = parts.length >= 3 ? parseInt(parts[2], 10) : 0
-
-  if (isNaN(major) || isNaN(minor) || isNaN(patch)) {
-    return null
-  }
-
-  return {
-    major,
-    minor,
-    patch,
-    full: `${major}.${minor}.${patch}`,
-  }
-}
-
-/**
- * Check if a version is supported by SpinDB.
- *
- * @param version - Version string to check
- * @returns True if the version is supported
- */
-export function isVersionSupported(version: string): boolean {
-  // Check if version is in the map directly
-  if (DUCKDB_VERSION_MAP[version]) {
-    return true
-  }
-
-  // Check if major version is supported
-  const parsed = parseVersion(version)
-  if (!parsed) {
-    return false
-  }
-
-  return SUPPORTED_MAJOR_VERSIONS.includes(String(parsed.major))
-}
-
-/**
- * Get the major version from a version string.
- *
- * @param version - Version string (e.g., '1.4.3')
- * @returns Major version string (e.g., '1') or null if invalid
- */
-export function getMajorVersion(version: string): string | null {
-  const parsed = parseVersion(version)
-  if (!parsed) {
-    return null
-  }
-  return String(parsed.major)
-}