hostdb 0.30.0 → 0.31.0

package/lib/checksums.ts

@@ -1,98 +0,0 @@
-/**
- * Shared checksum utilities for fetching and parsing checksums.txt files
- */
-
-type GitHubAsset = {
-  id: number
-  name: string
-  browser_download_url: string
-}
-
-type GitHubRelease = {
-  assets: GitHubAsset[]
-}
-
-/**
- * Parse checksums.txt content into a record of filename -> hash
- */
-export function parseChecksums(content: string): Record<string, string> {
-  const checksums: Record<string, string> = {}
-
-  for (const line of content.split('\n')) {
-    // Format: "hash  filename" or "hash *filename" (binary mode)
-    const match = line.match(/^([a-f0-9]{64})\s+\*?(.+)$/)
-    if (match) {
-      checksums[match[2]] = match[1]
-    }
-  }
-
-  return checksums
-}
-
-/**
- * Fetch checksums.txt from a GitHub release using the API (avoids CDN caching issues)
- *
- * @param repo - Repository in "owner/repo" format
- * @param tag - Release tag name
- * @returns Record of filename -> SHA256 hash, or empty object if not found
- */
-export async function fetchChecksums(
-  repo: string,
-  tag: string,
-): Promise<Record<string, string>> {
-  // First try to get the asset URL from the API
-  const apiUrl = `https://api.github.com/repos/${repo}/releases/tags/${tag}`
-  const apiResponse = await fetch(apiUrl, {
-    headers: {
-      Accept: 'application/vnd.github.v3+json',
-      'User-Agent': 'hostdb-checksums',
-      ...(process.env.GITHUB_TOKEN
-        ? { Authorization: `Bearer ${process.env.GITHUB_TOKEN}` }
-        : {}),
-    },
-  })
-
-  if (!apiResponse.ok) {
-    return {}
-  }
-
-  const release = (await apiResponse.json()) as GitHubRelease
-  const checksumAsset = release.assets.find((a) => a.name === 'checksums.txt')
-
-  if (!checksumAsset) {
-    return {}
-  }
-
-  // Use API asset download (works for both private and public repos)
-  const assetApiUrl = `https://api.github.com/repos/${repo}/releases/assets/${checksumAsset.id}`
-  const assetApiResponse = await fetch(assetApiUrl, {
-    headers: {
-      Accept: 'application/octet-stream',
-      'User-Agent': 'hostdb-checksums',
-      ...(process.env.GITHUB_TOKEN
-        ? { Authorization: `Bearer ${process.env.GITHUB_TOKEN}` }
-        : {}),
-    },
-    redirect: 'follow',
-  })
-
-  if (assetApiResponse.ok) {
-    const content = await assetApiResponse.text()
-    return parseChecksums(content)
-  }
-
-  // Fallback: try browser_download_url (only works for public repos)
-  if (!process.env.GITHUB_TOKEN) {
-    const browserResponse = await fetch(checksumAsset.browser_download_url, {
-      headers: { 'User-Agent': 'hostdb-checksums' },
-      redirect: 'follow',
-    })
-
-    if (browserResponse.ok) {
-      const content = await browserResponse.text()
-      return parseChecksums(content)
-    }
-  }
-
-  return {}
-}

package/lib/databases.ts

@@ -1,341 +0,0 @@
-import { readFileSync, writeFileSync, existsSync } from 'node:fs'
-import { dirname, join } from 'node:path'
-import { fileURLToPath } from 'node:url'
-import { parse as parseYaml } from 'yaml'
-
-const __dirname = dirname(fileURLToPath(import.meta.url))
-const ROOT = join(__dirname, '..')
-
-// Canonical platform type
-export type Platform =
-  | 'linux-x64'
-  | 'linux-arm64'
-  | 'darwin-x64'
-  | 'darwin-arm64'
-  | 'win32-x64'
-
-// All supported platforms
-export const ALL_PLATFORMS: Platform[] = [
-  'linux-x64',
-  'linux-arm64',
-  'darwin-x64',
-  'darwin-arm64',
-  'win32-x64',
-]
-
-// Runtime dependency on another database engine
-export type Dependency = {
-  database: string
-  cascadeDelete: boolean
-  note?: string
-}
-
-// CLI tools configuration
-export type CliTools = {
-  server: string | null
-  client: string | null
-  utilities: string[]
-  enhanced: string[]
-  note?: string
-}
-
-// Per-platform overrides within a version
-export type PlatformConfig = {
-  dependencies?: Dependency[]
-  cliTools?: CliTools
-}
-
-// A platform entry in the version platforms map: true (inherit) or config overrides
-export type PlatformEntry = true | PlatformConfig
-
-// Version config with overrides (when version entry is an object)
-export type VersionConfig = {
-  enabled?: boolean
-  deprecated?: boolean
-  note?: string
-  dependencies?: Dependency[]
-  platforms?: Platform[] | Record<string, PlatformEntry>
-  cliTools?: CliTools
-}
-
-// A version entry is either a simple boolean or a config object
-export type VersionEntry = boolean | VersionConfig
-
-// Database entry from databases.json
-export type DatabaseEntry = {
-  displayName: string
-  description: string
-  type: string
-  sourceRepo: string
-  license: string
-  commercialUse: boolean
-  hostedServiceAllowed: boolean
-  protocol: string | null
-  note?: string
-  dependencies?: Dependency[]
-  spindbStatus: 'completed' | 'in-progress'
-  versions: Record<string, VersionEntry>
-  platforms: Platform[]
-  cliTools: CliTools
-  connection: {
-    runtime: 'server' | 'embedded'
-    defaultPort: number | null
-    scheme: string | null
-    defaultDatabase: string | null
-    defaultUser: string | null
-    queryLanguage: string
-  }
-}
-
-// databases.json structure
-export type DatabasesJson = {
-  $schema?: string
-  _generated?: string
-  databases: Record<string, DatabaseEntry>
-}
-
-// Platform asset from releases.json
-export type PlatformAsset = {
-  url: string
-  sha256: string
-  size: number
-}
-
-// Version release from releases.json
-export type VersionRelease = {
-  version: string
-  releaseTag: string
-  releasedAt: string
-  deprecated?: boolean
-  platforms: Partial<Record<Platform, PlatformAsset>>
-}
-
-// releases.json structure
-export type ReleasesJson = {
-  $schema?: string
-  repository: string
-  databases: Record<string, Record<string, VersionRelease>>
-}
-
-export function loadDatabasesJson(): DatabasesJson {
-  const filePath = join(ROOT, 'databases.json')
-  return JSON.parse(readFileSync(filePath, 'utf-8')) as DatabasesJson
-}
-
-export function loadReleasesJson(): ReleasesJson {
-  const filePath = join(ROOT, 'releases.json')
-  return JSON.parse(readFileSync(filePath, 'utf-8')) as ReleasesJson
-}
-
-// --- Internal helpers ---
-
-/** Get the version's platforms field, handling both array and object forms */
-function getVersionPlatformsRaw(versionEntry: VersionConfig): {
-  list: Platform[]
-  map: Record<string, PlatformEntry> | null
-} {
-  if (!versionEntry.platforms) {
-    return { list: [], map: null }
-  }
-
-  if (Array.isArray(versionEntry.platforms)) {
-    return { list: versionEntry.platforms as Platform[], map: null }
-  }
-
-  // Object form: keys are platforms
-  const map = versionEntry.platforms as Record<string, PlatformEntry>
-  return { list: Object.keys(map) as Platform[], map }
-}
-
-// --- Resolver helpers ---
-
-/** Check if a version entry is enabled */
-export function isVersionEnabled(entry: VersionEntry): boolean {
-  if (typeof entry === 'boolean') return entry
-  return entry.enabled !== false
-}
-
-/** Check if a version entry is deprecated */
-export function isVersionDeprecated(entry: VersionEntry): boolean {
-  if (typeof entry === 'boolean') return false
-  return entry.deprecated === true
-}
-
-/** Get set of enabled version strings for a database */
-export function getEnabledVersions(database: string): Set<string> {
-  try {
-    const data = loadDatabasesJson()
-    const dbEntry = data.databases[database]
-    if (!dbEntry) return new Set()
-
-    return new Set(
-      Object.entries(dbEntry.versions)
-        .filter(([, entry]) => isVersionEnabled(entry))
-        .map(([version]) => version),
-    )
-  } catch {
-    return new Set()
-  }
-}
-
-/** Get effective platforms for a version (version overrides or engine defaults) */
-export function getVersionPlatforms(
-  engine: DatabaseEntry,
-  version: string,
-): Platform[] {
-  const versionEntry = engine.versions[version]
-  if (!versionEntry || typeof versionEntry === 'boolean') {
-    return [...engine.platforms]
-  }
-
-  const { list } = getVersionPlatformsRaw(versionEntry)
-  return list.length > 0 ? [...list] : [...engine.platforms]
-}
-
-/**
- * Get effective dependencies for a version+platform.
- *
- * Resolution order (each level fully replaces):
- * 1. Engine-level dependencies
- * 2. Version-level dependencies (if specified)
- * 3. Platform-level dependencies within version (if platforms is object form and platform entry has dependencies)
- */
-export function getVersionDependencies(
-  engine: DatabaseEntry,
-  version: string,
-  platform?: Platform,
-): Dependency[] {
-  const versionEntry = engine.versions[version]
-  if (!versionEntry || typeof versionEntry === 'boolean') {
-    return engine.dependencies ?? []
-  }
-
-  // Version-level replaces engine-level
-  let resolved = versionEntry.dependencies ?? engine.dependencies ?? []
-
-  // Platform-level replaces version-level
-  if (platform) {
-    const { map } = getVersionPlatformsRaw(versionEntry)
-    if (map) {
-      const platformEntry = map[platform]
-      if (
-        platformEntry &&
-        typeof platformEntry === 'object' &&
-        platformEntry.dependencies
-      ) {
-        resolved = platformEntry.dependencies
-      }
-    }
-  }
-
-  return resolved
-}
-
-/**
- * Get effective CLI tools for a version+platform.
- *
- * Resolution order (each level fully replaces):
- * 1. Engine-level cliTools
- * 2. Version-level cliTools (if specified)
- * 3. Platform-level cliTools within version (if platforms is object form and platform entry has cliTools)
- */
-export function getVersionCliTools(
-  engine: DatabaseEntry,
-  version: string,
-  platform?: Platform,
-): CliTools {
-  const versionEntry = engine.versions[version]
-  if (!versionEntry || typeof versionEntry === 'boolean') {
-    return engine.cliTools
-  }
-
-  // Version-level replaces engine-level
-  let resolved = versionEntry.cliTools ?? engine.cliTools
-
-  // Platform-level replaces version-level
-  if (platform) {
-    const { map } = getVersionPlatformsRaw(versionEntry)
-    if (map) {
-      const platformEntry = map[platform]
-      if (
-        platformEntry &&
-        typeof platformEntry === 'object' &&
-        platformEntry.cliTools
-      ) {
-        resolved = platformEntry.cliTools
-      }
-    }
-  }
-
-  return resolved
-}
-
-// --- databases.json generation from databases.yml ---
-
-/** Convert a snake_case string to camelCase */
-function snakeToCamel(str: string): string {
-  return str.replace(/_([a-z0-9])/g, (_, char: string) => char.toUpperCase())
-}
-
-/** Recursively convert all object keys from snake_case to camelCase */
-function transformKeys(obj: unknown): unknown {
-  if (Array.isArray(obj)) {
-    return obj.map(transformKeys)
-  }
-  if (obj !== null && typeof obj === 'object') {
-    const result: Record<string, unknown> = {}
-    for (const [key, value] of Object.entries(obj as Record<string, unknown>)) {
-      result[snakeToCamel(key)] = transformKeys(value)
-    }
-    return result
-  }
-  return obj
-}
-
-/**
- * Generate databases.json from databases.yml
- *
- * @returns true if the file was changed/created (or needs updating in check mode), false if already up-to-date
- */
-export function generateDatabasesJson(options?: {
-  checkOnly?: boolean
-  rootDir?: string
-}): boolean {
-  const { checkOnly = false, rootDir = ROOT } = options ?? {}
-  const yamlPath = join(rootDir, 'databases.yml')
-  const jsonPath = join(rootDir, 'databases.json')
-
-  if (!existsSync(yamlPath)) {
-    return false
-  }
-
-  const yamlContent = readFileSync(yamlPath, 'utf-8')
-  const parsed = parseYaml(yamlContent) as Record<string, unknown>
-
-  const transformed = transformKeys(parsed) as Record<string, unknown>
-
-  const output = {
-    _generated:
-      'DO NOT EDIT. Generated from databases.yml by pnpm prep. Edit databases.yml instead.',
-    $schema: './schemas/databases.schema.json',
-    ...transformed,
-  }
-
-  const newJson = JSON.stringify(output, null, 2) + '\n'
-
-  let currentJson = ''
-  if (existsSync(jsonPath)) {
-    currentJson = readFileSync(jsonPath, 'utf-8')
-  }
-
-  if (currentJson === newJson) {
-    return false
-  }
-
-  if (checkOnly) {
-    return true
-  }
-
-  writeFileSync(jsonPath, newJson)
-  return true
-}

package/lib/r2.ts

@@ -1,208 +0,0 @@
-/**
- * Shared Cloudflare R2 client utilities.
- *
- * R2 is S3-compatible, so we use the AWS SDK with a custom endpoint.
- */
-
-import {
-  S3Client,
-  PutObjectCommand,
-  HeadObjectCommand,
-  DeleteObjectCommand,
-  ListObjectsV2Command,
-} from '@aws-sdk/client-s3'
-import { readFileSync } from 'node:fs'
-import { resolve } from 'node:path'
-
-export type R2Config = {
-  accountId: string
-  accessKeyId: string
-  secretAccessKey: string
-  bucket: string
-}
-
-export function loadR2Config(): R2Config {
-  const accountId = process.env.R2_ACCOUNT_ID
-  const accessKeyId = process.env.R2_ACCESS_KEY_ID
-  const secretAccessKey = process.env.R2_SECRET_ACCESS_KEY
-  const bucket = process.env.R2_BUCKET_NAME
-
-  if (!accountId || !accessKeyId || !secretAccessKey || !bucket) {
-    const missing = [
-      !accountId && 'R2_ACCOUNT_ID',
-      !accessKeyId && 'R2_ACCESS_KEY_ID',
-      !secretAccessKey && 'R2_SECRET_ACCESS_KEY',
-      !bucket && 'R2_BUCKET_NAME',
-    ].filter(Boolean)
-    throw new Error(`Missing required R2 env vars: ${missing.join(', ')}`)
-  }
-
-  return { accountId, accessKeyId, secretAccessKey, bucket }
-}
-
-export function createR2Client(config: R2Config): S3Client {
-  return new S3Client({
-    region: 'auto',
-    endpoint: `https://${config.accountId}.r2.cloudflarestorage.com`,
-    credentials: {
-      accessKeyId: config.accessKeyId,
-      secretAccessKey: config.secretAccessKey,
-    },
-  })
-}
-
-export async function uploadToR2(options: {
-  client: S3Client
-  bucket: string
-  key: string
-  body: Buffer | Uint8Array | ReadableStream
-  contentType?: string
-  cacheControl?: string
-}): Promise<void> {
-  const { client, bucket, key, body, contentType, cacheControl } = options
-
-  await client.send(
-    new PutObjectCommand({
-      Bucket: bucket,
-      Key: key,
-      Body: body,
-      ContentType: contentType ?? 'application/octet-stream',
-      CacheControl: cacheControl ?? 'public, max-age=31536000, immutable',
-    }),
-  )
-}
-
-export async function objectExists(options: {
-  client: S3Client
-  bucket: string
-  key: string
-}): Promise<boolean> {
-  const { client, bucket, key } = options
-
-  try {
-    await client.send(
-      new HeadObjectCommand({
-        Bucket: bucket,
-        Key: key,
-      }),
-    )
-    return true
-  } catch (error: unknown) {
-    const code =
-      error instanceof Error && 'name' in error ? error.name : undefined
-    if (code === 'NotFound' || code === '404') {
-      return false
-    }
-    throw error
-  }
-}
-
-export async function deleteFromR2(options: {
-  client: S3Client
-  bucket: string
-  key: string
-}): Promise<void> {
-  const { client, bucket, key } = options
-
-  await client.send(
-    new DeleteObjectCommand({
-      Bucket: bucket,
-      Key: key,
-    }),
-  )
-}
-
-export async function listR2Objects(options: {
-  client: S3Client
-  bucket: string
-  prefix: string
-}): Promise<string[]> {
-  const { client, bucket, prefix } = options
-
-  const result = await client.send(
-    new ListObjectsV2Command({
-      Bucket: bucket,
-      Prefix: prefix,
-    }),
-  )
-
-  return (result.Contents ?? [])
-    .map((obj) => obj.Key)
-    .filter((key): key is string => key !== undefined)
-}
-
-export async function publishJsonToR2(options: {
-  client: S3Client
-  bucket: string
-  rootDir: string
-  filename: string
-  cacheControl?: string
-}): Promise<void> {
-  const { client, bucket, rootDir, filename, cacheControl } = options
-  const body = readFileSync(resolve(rootDir, filename))
-
-  await uploadToR2({
-    client,
-    bucket,
-    key: filename,
-    body,
-    contentType: 'application/json',
-    cacheControl: cacheControl ?? 'public, max-age=60',
-  })
-}
-
-export async function publishReleasesJson(options: {
-  client: S3Client
-  bucket: string
-  rootDir: string
-}): Promise<void> {
-  await publishJsonToR2({ ...options, filename: 'releases.json' })
-}
-
-/**
- * Purge Cloudflare CDN cache for specific URLs.
- *
- * Required env vars: CLOUDFLARE_API_TOKEN, CLOUDFLARE_ZONE_ID
- * If not set, logs a warning and returns (no-op).
- */
-export async function purgeCloudflareCache(
-  urls: string[],
-): Promise<{ purged: boolean; count: number }> {
-  const apiToken = process.env.CLOUDFLARE_API_TOKEN
-  const zoneId = process.env.CLOUDFLARE_ZONE_ID
-
-  if (!apiToken || !zoneId) {
-    return { purged: false, count: 0 }
-  }
-
-  // Cloudflare allows max 30 URLs per purge request
-  const BATCH_SIZE = 30
-  let totalPurged = 0
-
-  for (let i = 0; i < urls.length; i += BATCH_SIZE) {
-    const batch = urls.slice(i, i + BATCH_SIZE)
-
-    const response = await fetch(
-      `https://api.cloudflare.com/client/v4/zones/${zoneId}/purge_cache`,
-      {
-        method: 'POST',
-        headers: {
-          Authorization: `Bearer ${apiToken}`,
-          'Content-Type': 'application/json',
-        },
-        body: JSON.stringify({ files: batch }),
-      },
-    )
-
-    if (!response.ok) {
-      const body = await response.text()
-      throw new Error(
-        `Cloudflare cache purge failed: ${response.status} ${body}`,
-      )
-    }
-
-    totalPurged += batch.length
-  }
-
-  return { purged: true, count: totalPurged }
-}

package/lib/registry.ts

@@ -1,17 +0,0 @@
-/**
- * Configurable registry base URL for binary downloads.
- *
- * Switch between providers by changing REGISTRY_BASE_URL:
- *   R2:     https://registry.layerbase.host
- *   GitHub: https://github.com/robertjbass/hostdb/releases/download
- */
-
-const REGISTRY_BASE_URL = 'https://registry.layerbase.host'
-
-export function getDownloadUrl(tag: string, filename: string): string {
-  return `${REGISTRY_BASE_URL}/${tag}/${filename}`
-}
-
-export function getRegistryBaseUrl(): string {
-  return REGISTRY_BASE_URL
-}