spindb 0.37.2 → 0.38.0

package/engines/clickhouse/binary-urls.ts

@@ -1,125 +0,0 @@
-import { CLICKHOUSE_VERSION_MAP } from './version-maps'
-import { buildHostdbUrl } from '../../core/hostdb-client'
-import { logDebug } from '../../core/error-handler'
-import { Engine, type Platform, type Arch } from '../../types'
-
-/**
- * Supported platform identifiers for hostdb downloads.
- * Note: ClickHouse on hostdb doesn't support Windows currently.
- */
-const SUPPORTED_PLATFORMS = new Set([
-  'darwin-arm64',
-  'darwin-x64',
-  'linux-arm64',
-  'linux-x64',
-])
-
-/**
- * Get the hostdb platform identifier
- *
- * hostdb uses standard platform naming that matches Node.js identifiers directly.
- * This function validates the platform/arch combination is supported.
- *
- * @param platform - Node.js platform (e.g., 'darwin', 'linux', 'win32')
- * @param arch - Node.js architecture (e.g., 'arm64', 'x64')
- * @returns hostdb platform identifier or null if unsupported
- */
-export function getHostdbPlatform(
-  platform: Platform,
-  arch: Arch,
-): string | null {
-  const key = `${platform}-${arch}`
-  return SUPPORTED_PLATFORMS.has(key) ? key : null
-}
-
-/**
- * Build the download URL for ClickHouse binaries from hostdb
- *
- * Format: https://registry.layerbase.host/clickhouse-{version}/clickhouse-{version}-{platform}-{arch}.tar.gz
- *
- * @param version - ClickHouse version (e.g., '25.12', '25.12.3.21')
- * @param platform - Platform identifier (e.g., 'darwin', 'linux')
- * @param arch - Architecture identifier (e.g., 'arm64', 'x64')
- * @returns Download URL for the binary
- */
-export function getBinaryUrl(
-  version: string,
-  platform: Platform,
-  arch: Arch,
-): string {
-  const platformKey = `${platform}-${arch}`
-  const hostdbPlatform = getHostdbPlatform(platform, arch)
-  if (!hostdbPlatform) {
-    const supported = Array.from(SUPPORTED_PLATFORMS).join(', ')
-    throw new Error(
-      `Unsupported platform: ${platformKey}. Supported platforms: ${supported}`,
-    )
-  }
-
-  // Normalize version (handles major version lookup)
-  const fullVersion = normalizeVersion(version, CLICKHOUSE_VERSION_MAP)
-
-  // ClickHouse on hostdb uses tar.gz for all platforms (no Windows support)
-  return buildHostdbUrl(Engine.ClickHouse, {
-    version: fullVersion,
-    hostdbPlatform,
-    extension: 'tar.gz',
-  })
-}
-
-/**
- * Normalize version string to full version format
- *
- * @param version - Version string (e.g., '25.12', '25.12.3', '25.12.3.21')
- * @param versionMap - Optional version map for version lookup
- * @returns Normalized version (e.g., '25.12.3.21')
- */
-function normalizeVersion(
-  version: string,
-  versionMap: Record<string, string> = CLICKHOUSE_VERSION_MAP,
-): string {
-  // Check if it's an exact key in the map
-  if (versionMap[version]) {
-    return versionMap[version]
-  }
-
-  const parts = version.split('.')
-
-  // If it's already a full version (4 parts), return as-is
-  if (parts.length === 4) {
-    return version
-  }
-
-  // For partial versions, try to find a match
-  if (parts.length === 3) {
-    // Try YY.MM.X format
-    const threePart = `${parts[0]}.${parts[1]}.${parts[2]}`
-    if (versionMap[threePart]) {
-      return versionMap[threePart]
-    }
-  }
-
-  if (parts.length === 2) {
-    // Try YY.MM format
-    const twoPart = `${parts[0]}.${parts[1]}`
-    if (versionMap[twoPart]) {
-      return versionMap[twoPart]
-    }
-  }
-
-  // Unknown version format - log and return as-is
-  logDebug(
-    `ClickHouse version '${version}' not in version map, may not be available in hostdb`,
-  )
-  return version
-}
-
-/**
- * Get the full version string for a version
- *
- * Supports partial version lookups (e.g., '25.12' -> '25.12.3.21')
- * by delegating to normalizeVersion for consistent behavior.
- *
- * @param version - Version (e.g., '25.12', '25.12.3.21')
- * @returns Full version string (e.g., '25.12.3.21') or null if not in version map
- */

package/engines/clickhouse/cli-utils.ts

@@ -1,176 +0,0 @@
-/**
- * ClickHouse CLI utilities
- * Shared utilities for interacting with the clickhouse binary
- */
-
-import { existsSync } from 'fs'
-import { join } from 'path'
-import { configManager } from '../../core/config-manager'
-import { paths } from '../../config/paths'
-import { platformService } from '../../core/platform-service'
-import { normalizeVersion } from './version-maps'
-
-export const CLICKHOUSE_NOT_FOUND_ERROR =
-  'ClickHouse binary not found. Run: spindb engines download clickhouse <version>'
-
-/**
- * Validate a ClickHouse identifier (database name, table name, etc.)
- * ClickHouse identifiers must:
- * - Start with a letter or underscore
- * - Contain only letters, digits, and underscores
- * - Not be a reserved word (basic check)
- *
- * @param identifier - The identifier to validate
- * @param type - Type of identifier for error messages (e.g., 'database', 'table')
- * @returns The validated identifier
- * @throws Error if the identifier is invalid
- */
-export function validateClickHouseIdentifier(
-  identifier: string,
-  type: string = 'identifier',
-): string {
-  if (!identifier || typeof identifier !== 'string') {
-    throw new Error(`Invalid ${type}: must be a non-empty string`)
-  }
-
-  // ClickHouse identifier rules:
-  // - Must start with a letter (a-z, A-Z) or underscore
-  // - Can contain letters, digits, and underscores
-  // - Maximum length of 255 characters
-  const validPattern = /^[a-zA-Z_][a-zA-Z0-9_]*$/
-
-  if (!validPattern.test(identifier)) {
-    throw new Error(
-      `Invalid ${type} "${identifier}": must start with a letter or underscore ` +
-        `and contain only letters, digits, and underscores`,
-    )
-  }
-
-  if (identifier.length > 255) {
-    throw new Error(
-      `Invalid ${type} "${identifier}": maximum length is 255 characters`,
-    )
-  }
-
-  // Basic reserved word check (ClickHouse system databases)
-  const reserved = ['system', 'information_schema']
-  if (reserved.includes(identifier.toLowerCase())) {
-    throw new Error(
-      `Invalid ${type} "${identifier}": "${identifier}" is a reserved system name`,
-    )
-  }
-
-  return identifier
-}
-
-/**
- * Escape a ClickHouse identifier for use in SQL queries
- * Uses backticks for escaping (ClickHouse supports both backticks and double quotes)
- *
- * @param identifier - The identifier to escape
- * @returns The escaped identifier wrapped in backticks
- */
-export function escapeClickHouseIdentifier(identifier: string): string {
-  // Replace any backticks in the identifier with escaped backticks
-  const escaped = identifier.replace(/`/g, '``')
-  return `\`${escaped}\``
-}
-
-/**
- * Get the path to the clickhouse binary
- * Checks config cache first, then falls back to downloaded binary path
- *
- * @param version - Optional version to look up specific binary
- * @returns Path to clickhouse binary, or null if not found
- */
-export async function getClickHousePath(
-  version?: string,
-): Promise<string | null> {
-  // Check config cache first
-  const cached = await configManager.getBinaryPath('clickhouse')
-  if (cached && existsSync(cached)) {
-    return cached
-  }
-
-  // If version provided, look for downloaded binary
-  if (version) {
-    const { platform, arch } = platformService.getPlatformInfo()
-    const fullVersion = normalizeVersion(version)
-    const binPath = paths.getBinaryPath({
-      engine: 'clickhouse',
-      version: fullVersion,
-      platform,
-      arch,
-    })
-    const clickhousePath = join(binPath, 'bin', 'clickhouse')
-    if (existsSync(clickhousePath)) {
-      return clickhousePath
-    }
-  }
-
-  return null
-}
-
-/**
- * Get the path to the clickhouse binary, throwing if not found
- *
- * @param version - Optional version to look up specific binary
- * @returns Path to clickhouse binary
- * @throws Error if binary not found
- */
-export async function requireClickHousePath(version?: string): Promise<string> {
-  const path = await getClickHousePath(version)
-  if (!path) {
-    throw new Error(CLICKHOUSE_NOT_FOUND_ERROR)
-  }
-  return path
-}
-
-/**
- * Build a clickhouse client command for executing SQL
- *
- * @param clickhousePath - Path to clickhouse binary
- * @param port - Port to connect to
- * @param database - Database to use
- * @returns Array of command arguments
- */
-export function buildClickHouseClientArgs(
-  port: number,
-  database: string,
-): string[] {
-  return [
-    'client',
-    '--host',
-    '127.0.0.1',
-    '--port',
-    String(port),
-    '--database',
-    database,
-  ]
-}
-
-/**
- * Build clickhouse client command for executing a query
- *
- * @param port - Port to connect to
- * @param database - Database to use
- * @param query - SQL query to execute
- * @returns Array of command arguments
- */
-export function buildClickHouseQueryArgs(
-  port: number,
-  database: string,
-  query: string,
-): string[] {
-  return [
-    'client',
-    '--host',
-    '127.0.0.1',
-    '--port',
-    String(port),
-    '--database',
-    database,
-    '--query',
-    query,
-  ]
-}

package/engines/clickhouse/hostdb-releases.ts

@@ -1,30 +0,0 @@
-/**
- * hostdb Releases Module for ClickHouse
- *
- * Fetches ClickHouse binary information from the hostdb repository at
- * https://github.com/robertjbass/hostdb
- *
- * ClickHouse uses YY.MM versioning (e.g., 25.12.3.21), so major version is YY.MM.
- */
-
-import { createHostdbReleases } from '../../core/hostdb-releases-factory'
-import {
-  CLICKHOUSE_VERSION_MAP,
-  SUPPORTED_MAJOR_VERSIONS,
-  getMajorVersion,
-} from './version-maps'
-import { clickhouseBinaryManager } from './binary-manager'
-import { Engine } from '../../types'
-
-const hostdbReleases = createHostdbReleases({
-  engine: Engine.ClickHouse,
-  displayName: 'ClickHouse',
-  versionMap: CLICKHOUSE_VERSION_MAP,
-  supportedMajorVersions: SUPPORTED_MAJOR_VERSIONS,
-  groupingStrategy: 'xy-format',
-  listInstalled: () => clickhouseBinaryManager.listInstalled(),
-  getMajorVersion,
-})
-
-export const fetchAvailableVersions = hostdbReleases.fetchAvailableVersions
-export const getLatestVersion = hostdbReleases.getLatestVersion