spindb 0.34.5 → 0.35.2

package/engines/ferretdb/restore.ts

@@ -12,47 +12,51 @@ import { logDebug, logWarning } from '../../core/error-handler'
 import { platformService } from '../../core/platform-service'
 import { ferretdbBinaryManager } from './binary-manager'
 import {
-  normalizeDocumentDBVersion,
   DEFAULT_DOCUMENTDB_VERSION,
+  DEFAULT_V1_POSTGRESQL_VERSION,
+  isV1,
 } from './version-maps'
 import type { ContainerConfig, BackupFormat, RestoreResult } from '../../types'
 
 /**
- * Resolve the path to a postgresql-documentdb binary
- * Shared helper to avoid duplication between getPgRestorePath and getPsqlPath
+ * Resolve the path to a backend binary (pg_restore, psql, etc.)
+ * Uses version-aware backend resolution (v1 = plain PostgreSQL, v2 = postgresql-documentdb)
  */
-function getDocumentDBBinaryPath(
+function getBackendBinaryFullPath(
   container: ContainerConfig,
   binaryName: string,
 ): string {
-  const { backendVersion } = container
+  const { version, backendVersion } = container
   const { platform, arch } = platformService.getPlatformInfo()
+  const v1 = isV1(version)
 
-  const fullBackendVersion = normalizeDocumentDBVersion(
-    backendVersion || DEFAULT_DOCUMENTDB_VERSION,
-  )
-  const documentdbPath = ferretdbBinaryManager.getDocumentDBBinaryPath(
-    fullBackendVersion,
+  const effectiveBackendVersion = v1
+    ? backendVersion || DEFAULT_V1_POSTGRESQL_VERSION
+    : backendVersion || DEFAULT_DOCUMENTDB_VERSION
+
+  const backendPath = ferretdbBinaryManager.getBackendBinaryPath(
+    version,
+    effectiveBackendVersion,
     platform,
     arch,
   )
 
   const ext = platformService.getExecutableExtension()
-  return join(documentdbPath, 'bin', `${binaryName}${ext}`)
+  return join(backendPath, 'bin', `${binaryName}${ext}`)
 }
 
 /**
- * Get the path to pg_restore from the postgresql-documentdb installation
+ * Get the path to pg_restore from the backend installation
  */
 function getPgRestorePath(container: ContainerConfig): string {
-  return getDocumentDBBinaryPath(container, 'pg_restore')
+  return getBackendBinaryFullPath(container, 'pg_restore')
 }
 
 /**
- * Get the path to psql from the postgresql-documentdb installation
+ * Get the path to psql from the backend installation
  */
 function getPsqlPath(container: ContainerConfig): string {
-  return getDocumentDBBinaryPath(container, 'psql')
+  return getBackendBinaryFullPath(container, 'psql')
 }
 
 /**
@@ -196,8 +200,11 @@ export async function restoreBackup(
 
   if (!existsSync(toolPath)) {
     const toolName = isSqlFormat ? 'psql' : 'pg_restore'
+    const backendName = isV1(container.version)
+      ? 'PostgreSQL'
+      : 'postgresql-documentdb'
     throw new Error(
-      `${toolName} not found at ${toolPath}. Make sure postgresql-documentdb is installed.`,
+      `${toolName} not found at ${toolPath}. Make sure ${backendName} is installed.`,
     )
   }
 

package/engines/ferretdb/version-maps.ts

@@ -5,11 +5,16 @@
  * Until then, manually keep this in sync with robertjbass/hostdb releases.json:
  * https://github.com/robertjbass/hostdb/blob/main/releases.json
  *
- * FerretDB requires two binaries:
+ * FerretDB v2 requires two binaries:
  * - ferretdb: The MongoDB-compatible proxy
  * - postgresql-documentdb: PostgreSQL 17 with DocumentDB extension
  *
- * To update: Check releases.json, find databases.ferretdb, copy all version strings.
+ * FerretDB v1 requires:
+ * - ferretdb: The MongoDB-compatible proxy
+ * - Plain PostgreSQL (reuses postgresqlBinaryManager)
+ *
+ * To update: Check releases.json, find databases.ferretdb,
+ * copy all version strings (both v1.x and v2.x are under the same engine).
  */
 
 import { logDebug } from '../../core/error-handler'
@@ -17,15 +22,20 @@ import { compareVersions } from '../../core/version-utils'
 
 /**
  * Map major versions to full versions for FerretDB proxy
- * Keys are major versions (e.g., "2")
+ * Keys are major versions (e.g., "1", "2")
  * Values are full versions from hostdb releases.json
+ *
+ * v1.x uses plain PostgreSQL as backend (all platforms incl. Windows)
+ * v2.x uses postgresql-documentdb as backend (macOS/Linux only)
  */
 export const FERRETDB_VERSION_MAP: Record<string, string> = {
-  // 1-part: major version -> latest
+  // v1: uses plain PostgreSQL backend
+  '1': '1.24.2',
+  '1.24': '1.24.2',
+  '1.24.2': '1.24.2',
+  // v2: uses postgresql-documentdb backend
   '2': '2.7.0',
-  // 2-part: major.minor -> latest patch
   '2.7': '2.7.0',
-  // 3-part: exact version (identity mapping)
   '2.7.0': '2.7.0',
 }
 
@@ -45,13 +55,31 @@ export const DOCUMENTDB_VERSION_MAP: Record<string, string> = {
  * Supported major FerretDB versions (1-part format).
  * Used for grouping and display purposes.
  */
-export const SUPPORTED_MAJOR_VERSIONS = ['2']
+export const SUPPORTED_MAJOR_VERSIONS = ['1', '2']
 
 /**
- * Default postgresql-documentdb version to use with FerretDB
+ * Default postgresql-documentdb version to use with FerretDB v2
  */
 export const DEFAULT_DOCUMENTDB_VERSION = '17-0.107.0'
 
+/**
+ * Default PostgreSQL version to use as backend for FerretDB v1
+ * v1 uses plain PostgreSQL (no DocumentDB extension needed)
+ */
+export const DEFAULT_V1_POSTGRESQL_VERSION = '17'
+
+/**
+ * Check if a FerretDB version is v1.x (uses plain PostgreSQL backend)
+ * vs v2.x (uses postgresql-documentdb backend)
+ *
+ * @param version - Version string (can be major, major.minor, or full)
+ * @returns true if the version is v1.x
+ */
+export function isV1(version: string): boolean {
+  const normalized = normalizeVersion(version)
+  return normalized.startsWith('1.')
+}
+
 /**
  * Fallback map of major versions to stable patch versions
  * Used when hostdb repository is unreachable.

package/engines/index.ts

@@ -23,10 +23,9 @@ import type { EngineInfo } from '../types'
 
 // Engines not supported on Windows
 // These engines either don't have Windows binaries or have issues running on Windows
-const WINDOWS_UNSUPPORTED_ENGINES = new Set([
-  Engine.ClickHouse,
-  Engine.FerretDB,
-])
+// Note: FerretDB v1 supports Windows (v2 does not), so it's not blanket-blocked here.
+// Version-specific platform checks are handled by the engine itself.
+const WINDOWS_UNSUPPORTED_ENGINES = new Set([Engine.ClickHouse])
 
 // Registry of available database engines
 export const engines: Record<string, BaseEngine> = {

package/engines/influxdb/binary-urls.ts

@@ -36,7 +36,7 @@ export function getHostdbPlatform(
 /**
  * Build the download URL for InfluxDB binaries from hostdb
  *
- * Format: https://github.com/robertjbass/hostdb/releases/download/influxdb-{version}/influxdb-{version}-{platform}-{arch}.{ext}
+ * Format: https://registry.layerbase.host/influxdb-{version}/influxdb-{version}-{platform}-{arch}.{ext}
  *
  * @param version - InfluxDB version (e.g., '3', '3.8.0')
  * @param platform - Platform identifier (e.g., 'darwin', 'linux', 'win32')

package/engines/mariadb/binary-urls.ts

@@ -32,8 +32,8 @@ export function getHostdbPlatform(
 /**
  * Build the download URL for MariaDB binaries from hostdb
  *
- * Format: https://github.com/robertjbass/hostdb/releases/download/mariadb-{version}/mariadb-{version}-{platform}-{arch}.tar.gz
- * Windows: https://github.com/robertjbass/hostdb/releases/download/mariadb-{version}/mariadb-{version}-{platform}-{arch}.zip
+ * Format: https://registry.layerbase.host/mariadb-{version}/mariadb-{version}-{platform}-{arch}.tar.gz
+ * Windows: https://registry.layerbase.host/mariadb-{version}/mariadb-{version}-{platform}-{arch}.zip
  *
  * @param version - MariaDB version (e.g., '11.8', '11.8.5')
  * @param platform - Platform identifier (e.g., 'darwin', 'linux')

package/engines/meilisearch/binary-urls.ts

@@ -36,7 +36,7 @@ export function getHostdbPlatform(
 /**
  * Build the download URL for Meilisearch binaries from hostdb
  *
- * Format: https://github.com/robertjbass/hostdb/releases/download/meilisearch-{version}/meilisearch-{version}-{platform}-{arch}.{ext}
+ * Format: https://registry.layerbase.host/meilisearch-{version}/meilisearch-{version}-{platform}-{arch}.{ext}
  *
  * @param version - Meilisearch version (e.g., '1', '1.33.1')
  * @param platform - Platform identifier (e.g., 'darwin', 'linux', 'win32')

package/engines/mysql/binary-urls.ts

@@ -36,8 +36,8 @@ export function getHostdbPlatform(
 /**
  * Build the download URL for MySQL binaries from hostdb
  *
- * Format: https://github.com/robertjbass/hostdb/releases/download/mysql-{version}/mysql-{version}-{platform}-{arch}.tar.gz
- * Windows: https://github.com/robertjbass/hostdb/releases/download/mysql-{version}/mysql-{version}-{platform}-{arch}.zip
+ * Format: https://registry.layerbase.host/mysql-{version}/mysql-{version}-{platform}-{arch}.tar.gz
+ * Windows: https://registry.layerbase.host/mysql-{version}/mysql-{version}-{platform}-{arch}.zip
  *
  * @param version - MySQL version (e.g., '8.0', '8.0.40')
  * @param platform - Platform identifier (e.g., 'darwin', 'linux')

package/engines/postgresql/binary-urls.ts

@@ -34,7 +34,7 @@ export function getHostdbPlatform(
 /**
  * Build the download URL for PostgreSQL binaries from hostdb
  *
- * Format: https://github.com/robertjbass/hostdb/releases/download/postgresql-{version}/postgresql-{version}-{platform}-{arch}.tar.gz
+ * Format: https://registry.layerbase.host/postgresql-{version}/postgresql-{version}-{platform}-{arch}.tar.gz
  *
  * @param version - PostgreSQL version (e.g., '17', '17.7.0')
  * @param platform - Platform identifier (e.g., 'darwin', 'linux')

package/engines/qdrant/binary-urls.ts

@@ -37,7 +37,7 @@ export function getHostdbPlatform(
 /**
  * Build the download URL for Qdrant binaries from hostdb
  *
- * Format: https://github.com/robertjbass/hostdb/releases/download/qdrant-{version}/qdrant-{version}-{platform}-{arch}.{ext}
+ * Format: https://registry.layerbase.host/qdrant-{version}/qdrant-{version}-{platform}-{arch}.{ext}
  *
  * @param version - Qdrant version (e.g., '1', '1.16.3')
  * @param platform - Platform identifier (e.g., 'darwin', 'linux', 'win32')

package/engines/questdb/binary-manager.ts

@@ -24,12 +24,10 @@ import { existsSync } from 'fs'
 import { join, dirname, relative } from 'path'
 import { chmod, symlink, readdir } from 'fs/promises'
 import { logDebug } from '../../core/error-handler'
+import { getReleasesUrls } from '../../core/hostdb-client'
 import { moveEntry } from '../../core/fs-error-utils'
 import { paths } from '../../config/paths'
 
-const RELEASES_URL =
-  'https://raw.githubusercontent.com/robertjbass/hostdb/main/releases.json'
-
 class QuestDBBinaryManager extends BaseBinaryManager {
   protected readonly config: BinaryManagerConfig = {
     engine: Engine.QuestDB,
@@ -251,11 +249,20 @@ class QuestDBBinaryManager extends BaseBinaryManager {
    */
   private async checkHostdbAvailability(): Promise<boolean> {
     try {
-      // Use 10-second timeout to avoid hanging on slow/unresponsive networks
-      const response = await fetch(RELEASES_URL, {
-        signal: AbortSignal.timeout(10000),
-      })
-      if (!response.ok) return false
+      // Try layerbase first, fall back to GitHub
+      let response: Response | null = null
+      for (const url of getReleasesUrls()) {
+        try {
+          response = await fetch(url, {
+            signal: AbortSignal.timeout(10000),
+          })
+          if (response.ok) break
+          response = null
+        } catch {
+          // Try next URL
+        }
+      }
+      if (!response || !response.ok) return false
 
       const releases = (await response.json()) as {
         databases?: Record<string, unknown>
@@ -287,7 +294,7 @@ class QuestDBBinaryManager extends BaseBinaryManager {
           `To use QuestDB now, you can:\n` +
           `  1. Wait for the next hostdb release with QuestDB binaries\n` +
           `  2. Download QuestDB manually from https://questdb.io/get-questdb/\n\n` +
-          `Check https://github.com/robertjbass/hostdb/releases for updates.`,
+          `Check https://registry.layerbase.host for updates.`,
       )
     }
 

package/engines/questdb/binary-urls.ts

@@ -1,18 +1,16 @@
 /**
  * QuestDB Binary URLs
  *
- * Constructs download URLs for QuestDB binaries from hostdb.
+ * Constructs download URLs for QuestDB binaries from the layerbase registry.
  * QuestDB archives are self-contained with bundled JRE.
  *
  * URL pattern:
- * https://github.com/robertjbass/hostdb/releases/download/questdb-{version}/questdb-{version}-{platform}-{arch}.tar.gz
+ * https://registry.layerbase.host/questdb-{version}/questdb-{version}-{platform}-{arch}.tar.gz
  */
 
 import { FALLBACK_VERSION_MAP } from './version-maps'
-import { type Platform, type Arch } from '../../types'
-
-const HOSTDB_BASE_URL =
-  'https://github.com/robertjbass/hostdb/releases/download'
+import { Engine, type Platform, type Arch } from '../../types'
+import { buildHostdbUrl } from '../../core/hostdb-client'
 
 /**
  * Get the binary download URL for a specific version and platform
@@ -25,11 +23,12 @@ export function getBinaryUrl(
   // Resolve to full version
   const fullVersion = FALLBACK_VERSION_MAP[version] || version
 
-  // Construct platform key (e.g., 'darwin-arm64', 'linux-x64', 'win32-x64')
-  const platformKey = `${platform}-${arch}`
-
   // Windows uses .zip, Unix uses .tar.gz
   const ext = platform === 'win32' ? 'zip' : 'tar.gz'
 
-  return `${HOSTDB_BASE_URL}/questdb-${fullVersion}/questdb-${fullVersion}-${platformKey}.${ext}`
+  return buildHostdbUrl(Engine.QuestDB, {
+    version: fullVersion,
+    hostdbPlatform: `${platform}-${arch}`,
+    extension: ext,
+  })
 }

package/engines/questdb/hostdb-releases.ts

@@ -1,101 +1,23 @@
 /**
- * QuestDB hostdb Releases
+ * hostdb Releases Module for QuestDB
  *
- * Fetches available QuestDB versions from hostdb releases.json
- * Falls back to local version-maps.ts if fetch fails.
+ * Fetches QuestDB binary information from the hostdb repository at
+ * https://github.com/robertjbass/hostdb
  */
 
-import { logDebug } from '../../core/error-handler'
-import { SUPPORTED_MAJOR_VERSIONS, FALLBACK_VERSION_MAP } from './version-maps'
-
-const RELEASES_URL =
-  'https://raw.githubusercontent.com/robertjbass/hostdb/main/releases.json'
-
-// Cache for fetched versions (5-minute TTL)
-let cachedVersions: Record<string, string[]> | null = null
-let cacheTimestamp = 0
-const CACHE_TTL_MS = 5 * 60 * 1000 // 5 minutes
-
-type ReleaseInfo = {
-  version: string
-  platforms: string[]
-}
-
-type ReleasesJson = {
-  [engine: string]: ReleaseInfo[]
-}
-
-/**
- * Fetch available QuestDB versions from hostdb
- * Returns a map of major version to available full versions
- */
-export async function fetchAvailableVersions(): Promise<
-  Record<string, string[]>
-> {
-  // Return cached result if still valid
-  const now = Date.now()
-  if (cachedVersions && now - cacheTimestamp < CACHE_TTL_MS) {
-    return cachedVersions
-  }
-
-  try {
-    const response = await fetch(RELEASES_URL)
-    if (!response.ok) {
-      throw new Error(`HTTP ${response.status}`)
-    }
-
-    const releases = (await response.json()) as ReleasesJson
-    const questdbReleases = releases.questdb || []
-
-    // Group versions by major version
-    const versionMap: Record<string, string[]> = {}
-
-    for (const release of questdbReleases) {
-      const version = release.version
-      // Extract major version (e.g., '9' from '9.2.3')
-      const majorMatch = version.match(/^(\d+)/)
-      if (!majorMatch) continue
-
-      const major = majorMatch[1]
-
-      // Only include supported major versions
-      if (!SUPPORTED_MAJOR_VERSIONS.includes(major)) continue
-
-      if (!versionMap[major]) {
-        versionMap[major] = []
-      }
-      versionMap[major].push(version)
-    }
-
-    // Sort versions within each major (newest first)
-    for (const major of Object.keys(versionMap)) {
-      versionMap[major].sort((a, b) => {
-        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 diff = (partsB[i] || 0) - (partsA[i] || 0)
-          if (diff !== 0) return diff
-        }
-        return 0
-      })
-    }
-
-    // Cache the result
-    cachedVersions = versionMap
-    cacheTimestamp = now
-
-    return versionMap
-  } catch (error) {
-    logDebug(`Failed to fetch QuestDB versions from hostdb: ${error}`)
-
-    // Fall back to local version map
-    const fallbackMap: Record<string, string[]> = {}
-    for (const major of SUPPORTED_MAJOR_VERSIONS) {
-      const fullVersion = FALLBACK_VERSION_MAP[major]
-      if (fullVersion) {
-        fallbackMap[major] = [fullVersion]
-      }
-    }
-    return fallbackMap
-  }
-}
+import { createHostdbReleases } from '../../core/hostdb-releases-factory'
+import { QUESTDB_VERSION_MAP, SUPPORTED_MAJOR_VERSIONS } from './version-maps'
+import { questdbBinaryManager } from './binary-manager'
+import { Engine } from '../../types'
+
+const hostdbReleases = createHostdbReleases({
+  engine: Engine.QuestDB,
+  displayName: 'QuestDB',
+  versionMap: QUESTDB_VERSION_MAP,
+  supportedMajorVersions: SUPPORTED_MAJOR_VERSIONS,
+  groupingStrategy: 'single-digit',
+  listInstalled: () => questdbBinaryManager.listInstalled(),
+})
+
+export const fetchAvailableVersions = hostdbReleases.fetchAvailableVersions
+export const getLatestVersion = hostdbReleases.getLatestVersion

package/engines/questdb/version-maps.ts

@@ -1,8 +1,8 @@
 /**
  * QuestDB Version Maps
  *
- * IMPORTANT: Keep this in sync with hostdb releases.json:
- * https://github.com/robertjbass/hostdb/blob/main/releases.json
+ * IMPORTANT: Keep this in sync with hostdb databases.json:
+ * https://github.com/robertjbass/hostdb/blob/main/databases.json
  *
  * QuestDB uses standard semantic versioning (e.g., 9.2.3)
  */

package/engines/redis/binary-urls.ts

@@ -37,7 +37,7 @@ export function getHostdbPlatform(
 /**
  * Build the download URL for Redis binaries from hostdb
  *
- * Format: https://github.com/robertjbass/hostdb/releases/download/redis-{version}/redis-{version}-{platform}-{arch}.{ext}
+ * Format: https://registry.layerbase.host/redis-{version}/redis-{version}-{platform}-{arch}.{ext}
  *
  * @param version - Redis version (e.g., '7', '7.4.7')
  * @param platform - Platform identifier (e.g., 'darwin', 'linux', 'win32')
@@ -115,10 +115,3 @@ function normalizeVersion(
   )
   return version
 }
-
-/**
- * Get the full version string for a major version
- *
- * @param majorVersion - Major version (e.g., '7', '8')
- * @returns Full version string (e.g., '7.4.7') or null if not supported
- */

package/engines/sqlite/binary-urls.ts

@@ -12,7 +12,7 @@ import { Engine, type Platform, type Arch } from '../../types'
 /**
  * Build the download URL for SQLite binaries from hostdb
  *
- * Format: https://github.com/robertjbass/hostdb/releases/download/sqlite-{version}/sqlite-{version}-{platform}-{arch}.{ext}
+ * Format: https://registry.layerbase.host/sqlite-{version}/sqlite-{version}-{platform}-{arch}.{ext}
  *
  * @param version - SQLite version (e.g., '3', '3.51.2')
  * @param platform - Platform identifier (e.g., 'darwin', 'linux', 'win32')

package/engines/sqlite/index.ts

@@ -26,18 +26,10 @@ import { platformService } from '../../core/platform-service'
 import { paths } from '../../config/paths'
 import { sqliteBinaryManager } from './binary-manager'
 import { getBinaryUrl } from './binary-urls'
-import {
-  SUPPORTED_MAJOR_VERSIONS,
-  SQLITE_VERSION_MAP,
-  normalizeVersion,
-} from './version-maps'
-import {
-  fetchHostdbReleases,
-  getEngineReleases,
-} from '../../core/hostdb-client'
+import { SUPPORTED_MAJOR_VERSIONS, normalizeVersion } from './version-maps'
+import { fetchAvailableVersions } from './hostdb-releases'
 import { logDebug } from '../../core/error-handler'
 import {
-  Engine,
   type Platform,
   type Arch,
   type ContainerConfig,
@@ -517,7 +509,7 @@ export class SQLiteEngine extends BaseEngine {
           throw new Error(
             `File not found (404) at ${url}. ` +
               `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(
@@ -579,69 +571,7 @@ export class SQLiteEngine extends BaseEngine {
   }
 
   async fetchAvailableVersions(): Promise<Record<string, string[]>> {
-    // Try to fetch from hostdb first
-    try {
-      const releases = await fetchHostdbReleases()
-      const sqliteReleases = getEngineReleases(releases, Engine.SQLite)
-
-      if (sqliteReleases && Object.keys(sqliteReleases).length > 0) {
-        const result: Record<string, string[]> = {}
-
-        for (const major of SUPPORTED_MAJOR_VERSIONS) {
-          result[major] = []
-
-          // Find all versions matching this major version
-          for (const [, release] of Object.entries(sqliteReleases)) {
-            if (release.version.startsWith(`${major}.`)) {
-              result[major].push(release.version)
-            }
-          }
-
-          // Sort descending (latest first)
-          result[major].sort((a, b) => {
-            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 diff = (partsB[i] || 0) - (partsA[i] || 0)
-              if (diff !== 0) return diff
-            }
-            return 0
-          })
-        }
-
-        return result
-      }
-    } catch (error) {
-      logDebug('Failed to fetch SQLite versions from hostdb, checking local', {
-        error: error instanceof Error ? error.message : String(error),
-      })
-    }
-
-    // Offline fallback: return only locally installed versions
-    const installed = await sqliteBinaryManager.listInstalled()
-    if (installed.length > 0) {
-      const result: Record<string, string[]> = {}
-      for (const binary of installed) {
-        const major = binary.version.split('.')[0]
-        if (!result[major]) {
-          result[major] = []
-        }
-        if (!result[major].includes(binary.version)) {
-          result[major].push(binary.version)
-        }
-      }
-      return result
-    }
-
-    // Last resort: return hardcoded version map
-    const result: Record<string, string[]> = {}
-    for (const major of SUPPORTED_MAJOR_VERSIONS) {
-      const fullVersion = SQLITE_VERSION_MAP[major]
-      if (fullVersion) {
-        result[major] = [fullVersion]
-      }
-    }
-    return result
+    return fetchAvailableVersions()
   }
 
   // Helper to get sqlite3 path or throw a helpful error

package/engines/surrealdb/binary-urls.ts

@@ -1,19 +1,17 @@
 /**
  * SurrealDB binary URL generation
  *
- * Generates download URLs for SurrealDB binaries from hostdb.
+ * Generates download URLs for SurrealDB binaries from the layerbase registry.
  */
 
-import type { Platform, Arch } from '../../types'
+import { Engine, type Platform, type Arch } from '../../types'
 import { normalizeVersion } from './version-maps'
-
-const HOSTDB_BASE_URL =
-  'https://github.com/robertjbass/hostdb/releases/download'
+import { buildHostdbUrl } from '../../core/hostdb-client'
 
 /**
  * Get the binary download URL for a specific version and platform
  *
- * URL format: https://github.com/robertjbass/hostdb/releases/download/surrealdb-{version}/surrealdb-{version}-{platform}-{arch}.{ext}
+ * URL format: https://registry.layerbase.host/surrealdb-{version}/surrealdb-{version}-{platform}-{arch}.{ext}
  *
  * @param version - SurrealDB version (e.g., '2.3.2' or '2')
  * @param platform - Target platform (darwin, linux, win32)
@@ -27,7 +25,11 @@ export function getBinaryUrl(
   const fullVersion = normalizeVersion(version)
   const ext = platform === 'win32' ? 'zip' : 'tar.gz'
 
-  return `${HOSTDB_BASE_URL}/surrealdb-${fullVersion}/surrealdb-${fullVersion}-${platform}-${arch}.${ext}`
+  return buildHostdbUrl(Engine.SurrealDB, {
+    version: fullVersion,
+    hostdbPlatform: `${platform}-${arch}`,
+    extension: ext,
+  })
 }
 
 /**