spindb 0.34.5 → 0.35.3

package/engines/ferretdb/binary-manager.ts

@@ -1,9 +1,15 @@
 /**
  * FerretDB Composite Binary Manager
  *
- * Handles downloading and managing both FerretDB binaries:
- * 1. ferretdb - The MongoDB-compatible Go proxy
- * 2. postgresql-documentdb - PostgreSQL 17 with DocumentDB extension
+ * Handles downloading and managing FerretDB binaries:
+ *
+ * v2 (default): Two binaries required:
+ *   1. ferretdb - The MongoDB-compatible Go proxy
+ *   2. postgresql-documentdb - PostgreSQL 17 with DocumentDB extension
+ *
+ * v1: Two binaries, but backend is shared:
+ *   1. ferretdb - The MongoDB-compatible Go proxy
+ *   2. Plain PostgreSQL - Managed by postgresqlBinaryManager (shared with standalone PG containers)
  *
  * This is a composite manager that coordinates the installation of both
  * binaries, which are required for FerretDB to function.
@@ -15,9 +21,10 @@ import { join } from 'path'
 import { Readable } from 'stream'
 import { pipeline } from 'stream/promises'
 import { paths } from '../../config/paths'
-import { spawnAsync } from '../../core/spawn-utils'
+import { spawnAsync, extractWindowsArchive } from '../../core/spawn-utils'
 import { isRenameFallbackError } from '../../core/fs-error-utils'
 import { logDebug } from '../../core/error-handler'
+import { fetchWithRegistryFallback } from '../../core/hostdb-client'
 import {
   Engine,
   Platform,
@@ -31,12 +38,15 @@ import {
   normalizeVersion,
   normalizeDocumentDBVersion,
   DEFAULT_DOCUMENTDB_VERSION,
+  DEFAULT_V1_POSTGRESQL_VERSION,
+  isV1,
 } from './version-maps'
 import {
   isPlatformSupported,
   getFerretDBBinaryUrl,
   getDocumentDBBinaryUrl,
 } from './binary-urls'
+import { postgresqlBinaryManager } from '../postgresql/binary-manager'
 
 const DOWNLOAD_TIMEOUT_MS = 5 * 60 * 1000 // 5 minutes
 
@@ -45,7 +55,7 @@ const DOWNLOAD_TIMEOUT_MS = 5 * 60 * 1000 // 5 minutes
  */
 export type FerretDBBinaryPaths = {
   ferretdbPath: string // Path to ferretdb binary directory
-  documentdbPath: string // Path to postgresql-documentdb binary directory
+  backendPath: string // Path to backend binary directory (postgresql-documentdb for v2, postgresql for v1)
 }
 
 /**
@@ -56,9 +66,14 @@ export type FerretDBBinaryPaths = {
 class FerretDBCompositeBinaryManager {
   /**
    * Check if the current platform supports FerretDB
+   * @param version - Optional version to check platform support for (v1 supports Windows, v2 does not)
    */
-  isPlatformSupported(platform: Platform, arch: Arch): boolean {
-    return isPlatformSupported(platform, arch)
+  isPlatformSupported(
+    platform: Platform,
+    arch: Arch,
+    version?: string,
+  ): boolean {
+    return isPlatformSupported(platform, arch, version)
   }
 
   /**
@@ -85,7 +100,6 @@ class FerretDBCompositeBinaryManager {
     backendVersion: string = DEFAULT_DOCUMENTDB_VERSION,
   ): Promise<boolean> {
     const fullVersion = this.getFullVersion(version)
-    const fullBackendVersion = this.getFullDocumentDBVersion(backendVersion)
 
     // Check FerretDB proxy
     const ferretdbPath = this.getFerretDBBinaryPath(fullVersion, platform, arch)
@@ -95,7 +109,18 @@ class FerretDBCompositeBinaryManager {
       return false
     }
 
-    // Check postgresql-documentdb
+    // Check backend
+    if (isV1(version)) {
+      // v1: check plain PostgreSQL via postgresqlBinaryManager
+      return postgresqlBinaryManager.isInstalled(
+        DEFAULT_V1_POSTGRESQL_VERSION,
+        platform,
+        arch,
+      )
+    }
+
+    // v2: check postgresql-documentdb
+    const fullBackendVersion = this.getFullDocumentDBVersion(backendVersion)
     const documentdbPath = this.getDocumentDBBinaryPath(
       fullBackendVersion,
       platform,
@@ -176,6 +201,82 @@ class FerretDBCompositeBinaryManager {
     }
   }
 
+  /**
+   * Get the backend binary directory path for a FerretDB version.
+   * For v1: returns the plain PostgreSQL binary path
+   * For v2: returns the postgresql-documentdb binary path
+   *
+   * @param ferretdbVersion - FerretDB version (e.g., "1.24.2" or "2.7.0")
+   * @param backendVersion - Backend version (PostgreSQL version for v1, DocumentDB version for v2)
+   * @param platform - Operating system
+   * @param arch - Architecture
+   */
+  getBackendBinaryPath(
+    ferretdbVersion: string,
+    backendVersion: string,
+    platform: Platform,
+    arch: Arch,
+  ): string {
+    if (isV1(ferretdbVersion)) {
+      const pgFullVersion = postgresqlBinaryManager.getFullVersion(
+        backendVersion || DEFAULT_V1_POSTGRESQL_VERSION,
+      )
+      return paths.getBinaryPath({
+        engine: 'postgresql',
+        version: pgFullVersion,
+        platform,
+        arch,
+      })
+    }
+
+    const fullBackendVersion = this.getFullDocumentDBVersion(
+      backendVersion || DEFAULT_DOCUMENTDB_VERSION,
+    )
+    return this.getDocumentDBBinaryPath(fullBackendVersion, platform, arch)
+  }
+
+  /**
+   * Get environment variables needed to run backend binaries.
+   * For v1: delegates to PostgreSQL's standard env (usually none needed)
+   * For v2: delegates to getDocumentDBSpawnEnv
+   *
+   * @param ferretdbVersion - FerretDB version
+   * @param backendVersion - Backend version
+   * @param platform - Operating system
+   * @param arch - Architecture
+   */
+  getBackendSpawnEnv(
+    ferretdbVersion: string,
+    backendVersion: string,
+    platform: Platform,
+    arch: Arch,
+  ): Record<string, string> | undefined {
+    if (isV1(ferretdbVersion)) {
+      // Plain PostgreSQL doesn't need special env vars on most platforms
+      // Linux may need LD_LIBRARY_PATH
+      if (platform !== Platform.Linux) {
+        return undefined
+      }
+      const pgPath = this.getBackendBinaryPath(
+        ferretdbVersion,
+        backendVersion,
+        platform,
+        arch,
+      )
+      const libPath = join(pgPath, 'lib')
+      const existingLdPath = process.env['LD_LIBRARY_PATH'] || ''
+      const newLdPath = existingLdPath
+        ? `${libPath}:${existingLdPath}`
+        : libPath
+      return { LD_LIBRARY_PATH: newLdPath }
+    }
+
+    const fullBackendVersion = this.getFullDocumentDBVersion(
+      backendVersion || DEFAULT_DOCUMENTDB_VERSION,
+    )
+    return this.getDocumentDBSpawnEnv(fullBackendVersion, platform, arch)
+  }
+
   /**
    * List all installed FerretDB versions
    */
@@ -223,7 +324,7 @@ class FerretDBCompositeBinaryManager {
    * @param platform - Operating system
    * @param arch - Architecture
    * @param onProgress - Progress callback
-   * @param backendVersion - postgresql-documentdb version (optional)
+   * @param backendVersion - Backend version (postgresql-documentdb for v2, PostgreSQL major for v1)
    * @returns Paths to both binary directories
    */
   async ensureInstalled(
@@ -231,27 +332,97 @@ class FerretDBCompositeBinaryManager {
     platform: Platform,
     arch: Arch,
     onProgress?: ProgressCallback,
-    backendVersion: string = DEFAULT_DOCUMENTDB_VERSION,
+    backendVersion?: string,
   ): Promise<FerretDBBinaryPaths> {
     const fullVersion = this.getFullVersion(version)
-    const fullBackendVersion = this.getFullDocumentDBVersion(backendVersion)
+    const v1 = isV1(version)
+    const effectiveBackendVersion =
+      backendVersion ||
+      (v1 ? DEFAULT_V1_POSTGRESQL_VERSION : DEFAULT_DOCUMENTDB_VERSION)
 
     // Check if already installed
-    if (await this.isInstalled(version, platform, arch, backendVersion)) {
+    if (
+      await this.isInstalled(version, platform, arch, effectiveBackendVersion)
+    ) {
       onProgress?.({
         stage: 'cached',
         message: 'Using cached FerretDB binaries',
       })
       return {
         ferretdbPath: this.getFerretDBBinaryPath(fullVersion, platform, arch),
-        documentdbPath: this.getDocumentDBBinaryPath(
-          fullBackendVersion,
+        backendPath: this.getBackendBinaryPath(
+          fullVersion,
+          effectiveBackendVersion,
           platform,
           arch,
         ),
       }
     }
 
+    if (v1) {
+      return this.ensureInstalledV1(
+        version,
+        platform,
+        arch,
+        onProgress,
+        effectiveBackendVersion,
+      )
+    }
+
+    return this.ensureInstalledV2(
+      version,
+      platform,
+      arch,
+      onProgress,
+      effectiveBackendVersion,
+    )
+  }
+
+  /**
+   * Ensure v1 FerretDB binaries are installed (proxy + plain PostgreSQL)
+   */
+  private async ensureInstalledV1(
+    version: string,
+    platform: Platform,
+    arch: Arch,
+    onProgress?: ProgressCallback,
+    backendVersion: string = DEFAULT_V1_POSTGRESQL_VERSION,
+  ): Promise<FerretDBBinaryPaths> {
+    // Download FerretDB v1 proxy
+    const ferretdbPath = await this.downloadFerretDB(
+      version,
+      platform,
+      arch,
+      onProgress,
+    )
+
+    // Ensure plain PostgreSQL is installed via postgresqlBinaryManager
+    onProgress?.({
+      stage: 'downloading',
+      message: 'Ensuring PostgreSQL backend is available...',
+    })
+    const backendPath = await postgresqlBinaryManager.ensureInstalled(
+      backendVersion,
+      platform,
+      arch,
+      onProgress,
+    )
+
+    return { ferretdbPath, backendPath }
+  }
+
+  /**
+   * Ensure v2 FerretDB binaries are installed (proxy + postgresql-documentdb)
+   */
+  private async ensureInstalledV2(
+    version: string,
+    platform: Platform,
+    arch: Arch,
+    onProgress?: ProgressCallback,
+    backendVersion: string = DEFAULT_DOCUMENTDB_VERSION,
+  ): Promise<FerretDBBinaryPaths> {
+    const fullVersion = this.getFullVersion(version)
+
     // Check if FerretDB is already installed (DocumentDB might be missing)
     const ext = platform === Platform.Win32 ? '.exe' : ''
     const ferretdbBinaryPath = this.getFerretDBBinaryPath(
@@ -271,9 +442,9 @@ class FerretDBCompositeBinaryManager {
       onProgress,
     )
 
-    let documentdbPath: string
+    let backendPath: string
     try {
-      documentdbPath = await this.downloadDocumentDB(
+      backendPath = await this.downloadDocumentDB(
         backendVersion,
         platform,
         arch,
@@ -292,7 +463,7 @@ class FerretDBCompositeBinaryManager {
       throw error
     }
 
-    return { ferretdbPath, documentdbPath }
+    return { ferretdbPath, backendPath }
   }
 
   /**
@@ -498,14 +669,16 @@ class FerretDBCompositeBinaryManager {
     const timeoutId = setTimeout(() => controller.abort(), DOWNLOAD_TIMEOUT_MS)
 
     try {
-      const response = await fetch(url, { signal: controller.signal })
+      const response = await fetchWithRegistryFallback(url, {
+        signal: controller.signal,
+      })
 
       if (!response.ok) {
         if (response.status === 404) {
           throw new Error(
             `${displayName} binaries not found (404). ` +
               'This version may have been removed from hostdb. ' +
-              'Try a different version or check https://github.com/robertjbass/hostdb/releases',
+              'Try a different version or check https://registry.layerbase.host',
           )
         }
         throw new Error(
@@ -585,19 +758,24 @@ class FerretDBCompositeBinaryManager {
   /**
    * Extract Windows binaries from ZIP file
    *
-   * FerretDB does not support Windows due to postgresql-documentdb startup issues.
-   * Override to throw a clear error.
+   * FerretDB v1 supports Windows. v2 does not (postgresql-documentdb startup issues).
    */
   private async extractWindowsBinaries(
-    _zipFile: string,
-    _binPath: string,
-    _tempDir: string,
-    _onProgress?: ProgressCallback,
+    zipFile: string,
+    binPath: string,
+    tempDir: string,
+    onProgress?: ProgressCallback,
   ): Promise<void> {
-    throw new Error(
-      'FerretDB binaries are not available for Windows. ' +
-        'FerretDB is only supported on macOS and Linux.',
-    )
+    onProgress?.({
+      stage: 'extracting',
+      message: 'Extracting binaries...',
+    })
+
+    const extractDir = join(tempDir, 'extract')
+    await mkdir(extractDir, { recursive: true })
+
+    await extractWindowsArchive(zipFile, extractDir)
+    await this.moveExtractedEntries(extractDir, binPath)
   }
 
   /**
@@ -656,6 +834,12 @@ class FerretDBCompositeBinaryManager {
       throw new Error(`FerretDB binary not found at ${binPath}/bin/`)
     }
 
+    // FerretDB v1 hostdb builds panic on --version due to missing version.txt
+    // at build time. For v1, just verify the binary exists (checked above).
+    if (isV1(version)) {
+      return
+    }
+
     try {
       const { stdout } = await spawnAsync(ferretdbBinary, ['--version'])
       const match = stdout.match(
@@ -794,6 +978,11 @@ class FerretDBCompositeBinaryManager {
 
   /**
    * Delete installed binaries for a specific version
+   *
+   * For v1: Only deletes the FerretDB proxy. Plain PostgreSQL binaries are shared
+   * with standalone PostgreSQL containers and should NOT be deleted.
+   *
+   * For v2: Deletes both FerretDB proxy and postgresql-documentdb backend.
    */
   async delete(
     version: string,
@@ -802,18 +991,27 @@ class FerretDBCompositeBinaryManager {
     backendVersion: string = DEFAULT_DOCUMENTDB_VERSION,
   ): Promise<void> {
     const fullVersion = this.getFullVersion(version)
-    const fullBackendVersion = this.getFullDocumentDBVersion(backendVersion)
 
     const ferretdbPath = this.getFerretDBBinaryPath(fullVersion, platform, arch)
+    if (existsSync(ferretdbPath)) {
+      await rm(ferretdbPath, { recursive: true, force: true })
+    }
+
+    // v1: Don't delete shared PostgreSQL binaries (cascadeDelete: false)
+    if (isV1(version)) {
+      logDebug(
+        'Skipping PostgreSQL backend deletion for FerretDB v1 (shared with standalone PG containers)',
+      )
+      return
+    }
+
+    // v2: Delete postgresql-documentdb backend
+    const fullBackendVersion = this.getFullDocumentDBVersion(backendVersion)
     const documentdbPath = this.getDocumentDBBinaryPath(
       fullBackendVersion,
       platform,
       arch,
     )
-
-    if (existsSync(ferretdbPath)) {
-      await rm(ferretdbPath, { recursive: true, force: true })
-    }
     if (existsSync(documentdbPath)) {
       await rm(documentdbPath, { recursive: true, force: true })
     }

package/engines/ferretdb/binary-urls.ts

@@ -2,47 +2,77 @@
  * FerretDB binary URL generation for hostdb
  *
  * Generates download URLs for FerretDB binaries from the hostdb GitHub releases.
- * FerretDB requires two binaries:
+ *
+ * FerretDB v2 requires two binaries:
  * - ferretdb: MongoDB-compatible proxy
  * - postgresql-documentdb: PostgreSQL 17 + DocumentDB extension
  *
- * Note: Windows is not currently supported due to postgresql-documentdb startup issues.
- * The binaries exist on hostdb but fail to start properly on Windows.
+ * FerretDB v1 requires:
+ * - ferretdb: MongoDB-compatible proxy
+ * - Plain PostgreSQL (managed by postgresqlBinaryManager, not downloaded here)
+ *
+ * Both v1 and v2 use the same "ferretdb" hostdb engine name.
+ * v1 supports all platforms including Windows.
+ * v2 is macOS/Linux only (postgresql-documentdb has Windows startup issues).
  */
 
-import { normalizeVersion, normalizeDocumentDBVersion } from './version-maps'
+import {
+  normalizeVersion,
+  normalizeDocumentDBVersion,
+  isV1,
+} from './version-maps'
 import { buildHostdbUrl } from '../../core/hostdb-client'
 import { Engine, Platform, type Arch } from '../../types'
 
-// Supported platforms for FerretDB (both proxy and backend)
-// Note: Windows (win32-x64) is excluded due to postgresql-documentdb startup issues
-export const FERRETDB_SUPPORTED_PLATFORMS = new Set([
+// Supported platforms for FerretDB v2 (requires postgresql-documentdb)
+// Windows is excluded due to postgresql-documentdb startup issues
+export const FERRETDB_V2_SUPPORTED_PLATFORMS = new Set([
   'darwin-arm64',
   'darwin-x64',
   'linux-arm64',
   'linux-x64',
 ])
 
-// Supported platforms for postgresql-documentdb backend
-export const DOCUMENTDB_SUPPORTED_PLATFORMS = FERRETDB_SUPPORTED_PLATFORMS
+// Supported platforms for FerretDB v1 (uses plain PostgreSQL)
+// All platforms including Windows
+export const FERRETDB_V1_SUPPORTED_PLATFORMS = new Set([
+  'darwin-arm64',
+  'darwin-x64',
+  'linux-arm64',
+  'linux-x64',
+  'win32-x64',
+])
+
+// Supported platforms for postgresql-documentdb backend (v2 only)
+export const DOCUMENTDB_SUPPORTED_PLATFORMS = FERRETDB_V2_SUPPORTED_PLATFORMS
 
 /**
  * Map Node.js platform/arch to hostdb platform key
+ * @param version - Optional FerretDB version to determine platform support (v1 vs v2)
  */
 export function getHostdbPlatform(
   platform: Platform,
   arch: Arch,
+  version?: string,
 ): string | null {
   const key = `${platform}-${arch}`
-  return FERRETDB_SUPPORTED_PLATFORMS.has(key) ? key : null
+  const platforms =
+    version && isV1(version)
+      ? FERRETDB_V1_SUPPORTED_PLATFORMS
+      : FERRETDB_V2_SUPPORTED_PLATFORMS
+  return platforms.has(key) ? key : null
 }
 
 /**
  * Check if the current platform supports FerretDB
+ * @param version - Optional FerretDB version to determine platform support (v1 vs v2)
  */
-export function isPlatformSupported(platform: Platform, arch: Arch): boolean {
-  const key = `${platform}-${arch}`
-  return FERRETDB_SUPPORTED_PLATFORMS.has(key)
+export function isPlatformSupported(
+  platform: Platform,
+  arch: Arch,
+  version?: string,
+): boolean {
+  return getHostdbPlatform(platform, arch, version) !== null
 }
 
 /**
@@ -59,11 +89,12 @@ export function getFerretDBBinaryUrl(
   arch: Arch,
 ): string {
   const fullVersion = normalizeVersion(version)
-  const hostdbPlatform = getHostdbPlatform(platform, arch)
+  const hostdbPlatform = getHostdbPlatform(platform, arch, version)
 
   if (!hostdbPlatform) {
+    const v1 = isV1(version)
     throw new Error(
-      `Unsupported platform: ${platform}-${arch}. FerretDB is only supported on macOS and Linux.`,
+      `Unsupported platform: ${platform}-${arch}. FerretDB ${v1 ? 'v1' : 'v2'} is ${v1 ? 'not available on this platform' : 'only supported on macOS and Linux'}.`,
     )
   }
 
@@ -94,7 +125,7 @@ export function getDocumentDBBinaryUrl(
 
   if (!DOCUMENTDB_SUPPORTED_PLATFORMS.has(key)) {
     throw new Error(
-      `Unsupported platform: ${platform}-${arch}. FerretDB is only supported on macOS and Linux.`,
+      `Unsupported platform: ${platform}-${arch}. postgresql-documentdb (FerretDB v2 backend) is only supported on macOS and Linux.`,
     )
   }
 
@@ -109,28 +140,42 @@ export function getDocumentDBBinaryUrl(
 }
 
 /**
- * Get the combined binary URLs for FerretDB (both proxy and backend)
+ * Get the combined binary URLs for FerretDB (proxy and backend)
+ *
+ * For v1: Returns only ferretdb URL (backend is plain PostgreSQL, managed separately)
+ * For v2: Returns both ferretdb and documentdb URLs
  *
  * @param version - FerretDB version (major or full)
- * @param backendVersion - postgresql-documentdb version (e.g., "17-0.107.0")
+ * @param backendVersion - postgresql-documentdb version (e.g., "17-0.107.0"), used for v2 only
  * @param platform - Operating system
  * @param arch - Architecture
- * @returns Object with ferretdb and documentdb URLs
+ * @returns Object with ferretdb URL and optional documentdb URL
  */
 export function getBinaryUrls(
   version: string,
   backendVersion: string,
   platform: Platform,
   arch: Arch,
-): { ferretdb: string; documentdb: string } {
-  // Validate platform supports FerretDB
-  if (!isPlatformSupported(platform, arch)) {
+): { ferretdb: string; documentdb?: string } {
+  // Validate platform supports this FerretDB version
+  if (!isPlatformSupported(platform, arch, version)) {
+    const v1 = isV1(version)
     throw new Error(
-      `FerretDB is not available on ${platform}-${arch}.\n` +
-        'FerretDB is only supported on macOS and Linux.',
+      `FerretDB ${v1 ? 'v1' : 'v2'} is not available on ${platform}-${arch}.\n` +
+        (v1
+          ? 'This platform is not supported.'
+          : 'FerretDB v2 is only supported on macOS and Linux. Try v1 for Windows support.'),
     )
   }
 
+  if (isV1(version)) {
+    // v1: backend is plain PostgreSQL (managed by postgresqlBinaryManager)
+    return {
+      ferretdb: getFerretDBBinaryUrl(version, platform, arch),
+    }
+  }
+
+  // v2: backend is postgresql-documentdb
   return {
     ferretdb: getFerretDBBinaryUrl(version, platform, arch),
     documentdb: getDocumentDBBinaryUrl(backendVersion, platform, arch),