spindb 0.37.2 → 0.38.0

package/engines/typedb/restore.ts

@@ -1,377 +0,0 @@
-/**
- * TypeDB restore module
- * Supports TypeQL-based restores using typedb console import
- */
-
-import { spawn } from 'child_process'
-import { open } from 'fs/promises'
-import { existsSync, statSync } from 'fs'
-import { logDebug } from '../../core/error-handler'
-import {
-  requireTypeDBConsolePath,
-  getConsoleBaseArgs,
-  validateTypeDBIdentifier,
-} from './cli-utils'
-import type { BackupFormat, RestoreResult } from '../../types'
-
-/**
- * TypeQL keywords that indicate a TypeDB backup
- */
-const TYPEQL_KEYWORDS = [
-  'DEFINE',
-  'MATCH',
-  'INSERT',
-  'DELETE',
-  'PUT',
-  'UNDEFINE',
-  'RULE',
-  'TYPE',
-  'ENTITY',
-  'RELATION',
-  'ATTRIBUTE',
-  'OWNS',
-  'PLAYS',
-  'RELATES',
-  'SUB',
-  'ISA',
-  'HAS',
-]
-
-/**
- * Check if file content looks like TypeQL
- * Only reads first 8KB to avoid loading large files into memory
- */
-async function looksLikeTypeQL(filePath: string): Promise<boolean> {
-  try {
-    const HEADER_SIZE = 8192
-    const buffer = Buffer.alloc(HEADER_SIZE)
-
-    const fd = await open(filePath, 'r')
-    let bytesRead: number
-    try {
-      const result = await fd.read(buffer, 0, HEADER_SIZE, 0)
-      bytesRead = result.bytesRead
-    } finally {
-      await fd.close()
-    }
-
-    const content = buffer.toString('utf-8', 0, bytesRead)
-    const lines = content.split(/\r?\n/)
-
-    let typeqlStatementsFound = 0
-    const linesToCheck = 20
-    let checkedLines = 0
-
-    for (const line of lines) {
-      if (checkedLines >= linesToCheck) break
-
-      const trimmed = line.trim().toUpperCase()
-
-      // Skip empty lines and comments
-      if (!trimmed || trimmed.startsWith('#') || trimmed.startsWith('//'))
-        continue
-
-      checkedLines++
-
-      // Check for TypeQL keywords
-      for (const keyword of TYPEQL_KEYWORDS) {
-        if (trimmed.startsWith(keyword) || trimmed.includes(` ${keyword} `)) {
-          typeqlStatementsFound++
-          break
-        }
-      }
-
-      if (typeqlStatementsFound >= 2) {
-        return true
-      }
-    }
-
-    return typeqlStatementsFound > 0
-  } catch {
-    return false
-  }
-}
-
-/**
- * Check if a .typeql backup path has companion schema/data pair files
- */
-function hasSchemaDataPair(filePath: string): boolean {
-  return (
-    filePath.endsWith('.typeql') &&
-    (existsSync(filePath.replace(/\.typeql$/, '-schema.typeql')) ||
-      existsSync(filePath.replace(/\.typeql$/, '-data.typeql')))
-  )
-}
-
-/**
- * Detect backup format from file
- * Supports:
- * - TypeQL: Schema + data statements
- */
-export async function detectBackupFormat(
-  filePath: string,
-): Promise<BackupFormat> {
-  // TypeDB backup creates schema/data pair files (-schema.typeql, -data.typeql)
-  // rather than a single file, so also check for those variants
-  const hasPair = hasSchemaDataPair(filePath)
-
-  if (!existsSync(filePath) && !hasPair) {
-    throw new Error(`Backup file not found: ${filePath}`)
-  }
-
-  // If schema/data pair exists, it's a TypeQL backup
-  if (hasPair) {
-    return {
-      format: 'typeql',
-      description: 'TypeDB TypeQL backup (schema + data pair)',
-      restoreCommand:
-        'Import TypeQL via typedb console (spindb restore handles this)',
-    }
-  }
-
-  const stats = statSync(filePath)
-
-  if (stats.isDirectory()) {
-    return {
-      format: 'unknown',
-      description: 'Directory found - TypeDB restore expects TypeQL files',
-      restoreCommand: 'TypeDB requires .typeql files for restore',
-    }
-  }
-
-  // Check file extension first for .typeql files
-  if (filePath.endsWith('.typeql') || filePath.endsWith('.tql')) {
-    return {
-      format: 'typeql',
-      description: 'TypeDB TypeQL backup',
-      restoreCommand:
-        'Import TypeQL via typedb console (spindb restore handles this)',
-    }
-  }
-
-  // Content-based detection
-  if (await looksLikeTypeQL(filePath)) {
-    return {
-      format: 'typeql',
-      description: 'TypeDB TypeQL backup (detected by content)',
-      restoreCommand:
-        'Import TypeQL via typedb console (spindb restore handles this)',
-    }
-  }
-
-  return {
-    format: 'unknown',
-    description: 'Unknown backup format',
-    restoreCommand: 'Use .typeql file with TypeQL statements',
-  }
-}
-
-// Restore options for TypeDB
-export type RestoreOptions = {
-  containerName: string
-  port: number
-  database?: string
-  version?: string
-}
-
-/**
- * Restore from TypeQL backup using typedb console import
- *
- * TypeDB import expects schema and data files.
- * We check for both `-schema.typeql` and `-data.typeql` variants.
- */
-async function restoreTypeQLBackup(
-  backupPath: string,
-  port: number,
-  database: string,
-  version?: string,
-): Promise<RestoreResult> {
-  validateTypeDBIdentifier(database)
-  const consolePath = await requireTypeDBConsolePath(version)
-
-  // Derive base name by stripping optional -schema/-data suffix and extension
-  const baseName = backupPath
-    .replace(/\.(typeql|tql)$/, '')
-    .replace(/-(schema|data)$/, '')
-  const schemaPath = `${baseName}-schema.typeql`
-  const dataPath = `${baseName}-data.typeql`
-
-  const hasSchema = existsSync(schemaPath)
-  const hasData = existsSync(dataPath)
-
-  if (hasSchema || hasData) {
-    // Import schema and data separately
-    // NOTE: Do NOT quote paths here. TypeDB console's --command parser treats
-    // double quotes as literal characters, not delimiters. Quoting breaks all imports.
-    const paths = [
-      ...(hasSchema ? [schemaPath] : []),
-      ...(hasData ? [dataPath] : []),
-    ]
-    const command = `database import ${database} ${paths.join(' ')}`
-
-    return runConsoleCommand(consolePath, port, command)
-  }
-
-  // Single file import - treat as schema
-  const command = `database import ${database} ${backupPath}`
-  return runConsoleCommand(consolePath, port, command)
-}
-
-/**
- * Run a TypeDB console command and return the result
- */
-async function runConsoleCommand(
-  consolePath: string,
-  port: number,
-  command: string,
-  timeoutMs = 30 * 60 * 1000,
-): Promise<RestoreResult> {
-  return new Promise<RestoreResult>((resolve, reject) => {
-    const args = [...getConsoleBaseArgs(port), '--command', command]
-
-    const sanitizedArgs = args.map((a, i) =>
-      args[i - 1] === '--password' ? '***' : a,
-    )
-    logDebug(`Running: typedb_console_bin ${sanitizedArgs.join(' ')}`)
-
-    const proc = spawn(consolePath, args, {
-      stdio: ['ignore', 'pipe', 'pipe'],
-    })
-
-    let stdout = ''
-    let stderr = ''
-    let settled = false
-
-    const timer = setTimeout(() => {
-      if (settled) return
-      settled = true
-      proc.kill()
-      reject(
-        new Error(
-          `typedb console timed out after ${Math.round(timeoutMs / 1000)}s running: ${command}`,
-        ),
-      )
-    }, timeoutMs)
-
-    proc.stdout.on('data', (data: Buffer) => {
-      stdout += data.toString()
-    })
-
-    proc.stderr.on('data', (data: Buffer) => {
-      stderr += data.toString()
-    })
-
-    proc.on('close', (code) => {
-      if (settled) return
-      settled = true
-      clearTimeout(timer)
-      if (code === 0) {
-        resolve({
-          format: 'typeql',
-          stdout: stdout || 'TypeQL statements imported successfully',
-          stderr: stderr || undefined,
-          code: 0,
-        })
-      } else {
-        reject(
-          new Error(
-            `typedb console exited with code ${code}${stderr ? `: ${stderr}` : ''}`,
-          ),
-        )
-      }
-    })
-
-    proc.on('error', (error) => {
-      if (settled) return
-      settled = true
-      clearTimeout(timer)
-      reject(new Error(`Failed to spawn typedb console: ${error.message}`))
-    })
-  })
-}
-
-/**
- * Restore from backup
- * Supports:
- * - TypeQL: Import via typedb console
- */
-export async function restoreBackup(
-  backupPath: string,
-  options: RestoreOptions,
-): Promise<RestoreResult> {
-  const { port, database = 'default', version } = options
-
-  // TypeDB backup creates schema/data pair files (-schema.typeql, -data.typeql)
-  // rather than a single file at backupPath, so check for those too
-  if (!existsSync(backupPath) && !hasSchemaDataPair(backupPath)) {
-    throw new Error(`Backup file not found: ${backupPath}`)
-  }
-
-  // Detect backup format
-  const format = await detectBackupFormat(backupPath)
-  logDebug(`Detected backup format: ${format.format}`)
-
-  if (format.format === 'typeql') {
-    return restoreTypeQLBackup(backupPath, port, database, version)
-  }
-
-  throw new Error(
-    `Invalid backup format: ${format.format}. Use .typeql file with TypeQL statements.`,
-  )
-}
-
-/**
- * Parse TypeDB connection string
- * Format: typedb://host[:port][/database]
- */
-export function parseConnectionString(connectionString: string): {
-  host: string
-  port: number
-  database: string
-} {
-  if (!connectionString || typeof connectionString !== 'string') {
-    throw new Error(
-      'Invalid TypeDB connection string: expected a non-empty string',
-    )
-  }
-
-  let url: URL
-  try {
-    url = new URL(connectionString)
-  } catch (error) {
-    throw new Error(
-      `Invalid TypeDB connection string: "${connectionString}". ` +
-        `Expected format: typedb://host[:port][/database]`,
-      { cause: error },
-    )
-  }
-
-  // Validate protocol
-  if (url.protocol !== 'typedb:') {
-    throw new Error(
-      `Invalid TypeDB connection string: unsupported protocol "${url.protocol}". ` +
-        `Expected "typedb://"`,
-    )
-  }
-
-  const host = url.hostname || '127.0.0.1'
-
-  let port = 1729
-  if (url.port) {
-    const parsed = Number(url.port)
-    if (!Number.isInteger(parsed) || parsed < 1 || parsed > 65535) {
-      throw new Error(
-        `Invalid TypeDB connection string: invalid port '${url.port}'`,
-      )
-    }
-    port = parsed
-  }
-
-  const database = url.pathname.replace(/^\//, '') || 'default'
-
-  return {
-    host,
-    port,
-    database,
-  }
-}

package/engines/typedb/version-maps.ts

@@ -1,48 +0,0 @@
-/**
- * TypeDB version mapping
- *
- * Maps short version aliases to full versions from hostdb releases.
- * MUST stay in sync with hostdb databases.json
- */
-
-import { logDebug } from '../../core/error-handler'
-
-// Full version map for TypeDB
-export const TYPEDB_VERSION_MAP: Record<string, string> = {
-  '3': '3.8.0',
-  '3.8': '3.8.0',
-  '3.8.0': '3.8.0',
-}
-
-// Supported major versions (for CLI display)
-export const SUPPORTED_MAJOR_VERSIONS = ['3']
-
-// Default version
-export const DEFAULT_VERSION = '3'
-
-/**
- * Normalize a version string to its full version
- * e.g., '3' -> '3.8.0', '3.8' -> '3.8.0'
- */
-export function normalizeVersion(version: string): string {
-  if (!TYPEDB_VERSION_MAP[version]) {
-    logDebug(
-      `TypeDB version "${version}" not found in TYPEDB_VERSION_MAP (available: ${Object.keys(TYPEDB_VERSION_MAP).join(', ')}), using as-is`,
-    )
-  }
-  return TYPEDB_VERSION_MAP[version] || version
-}
-
-/**
- * Check if a version is supported
- */
-export function isVersionSupported(version: string): boolean {
-  return Object.hasOwn(TYPEDB_VERSION_MAP, version)
-}
-
-/**
- * Get the latest patch version for a major version
- */
-export function getLatestPatch(majorVersion: string): string | undefined {
-  return TYPEDB_VERSION_MAP[majorVersion]
-}

package/engines/typedb/version-validator.ts

@@ -1,127 +0,0 @@
-/**
- * TypeDB version validation utilities
- * Handles version parsing, comparison, and compatibility checking
- */
-
-import { SUPPORTED_MAJOR_VERSIONS } from './version-maps'
-
-/**
- * Parse a TypeDB version string into components
- * Handles formats like "3.8.0", "3.8", "v3.8.0"
- * Rejects pre-release suffixes (e.g., "3.8.0-beta") and extra segments (e.g., "3.8.0.1")
- */
-export function parseVersion(versionString: string): {
-  major: number
-  minor: number
-  patch: number
-  raw: string
-} | null {
-  const cleaned = versionString.replace(/^v/, '').trim()
-
-  // Reject versions with pre-release suffixes or metadata
-  if (/[-+]/.test(cleaned)) return null
-
-  const parts = cleaned.split('.')
-
-  // Only allow 1-3 segments (major, major.minor, major.minor.patch)
-  if (parts.length > 3) return null
-
-  // Reject segments that aren't purely numeric (e.g., "3b", "8rc1")
-  if (parts.some((p) => !/^\d+$/.test(p))) return null
-
-  const major = parseInt(parts[0], 10)
-  const minor = parts[1] ? parseInt(parts[1], 10) : 0
-  const patch = parts[2] ? parseInt(parts[2], 10) : 0
-
-  return { major, minor, patch, raw: cleaned }
-}
-
-/**
- * Check if a TypeDB version is supported by SpinDB
- * Minimum supported version: 3.0.0 (v3 is the Rust rewrite)
- */
-export function isVersionSupported(version: string): boolean {
-  const parsed = parseVersion(version)
-  if (!parsed) return false
-
-  return SUPPORTED_MAJOR_VERSIONS.includes(String(parsed.major))
-}
-
-/**
- * Get major version from full version string
- * e.g., "3.8.0" -> "3"
- * Returns null if the version string cannot be parsed.
- */
-export function getMajorVersion(version: string): string | null {
-  const parsed = parseVersion(version)
-  return parsed ? String(parsed.major) : null
-}
-
-/**
- * Compare two TypeDB versions
- * Returns: -1 if a < b, 0 if a == b, 1 if a > b, null if either version cannot be parsed
- */
-export function compareVersions(a: string, b: string): number | null {
-  const parsedA = parseVersion(a)
-  const parsedB = parseVersion(b)
-
-  if (!parsedA || !parsedB) {
-    return null
-  }
-
-  if (parsedA.major !== parsedB.major) {
-    return parsedA.major < parsedB.major ? -1 : 1
-  }
-  if (parsedA.minor !== parsedB.minor) {
-    return parsedA.minor < parsedB.minor ? -1 : 1
-  }
-  if (parsedA.patch !== parsedB.patch) {
-    return parsedA.patch < parsedB.patch ? -1 : 1
-  }
-  return 0
-}
-
-/**
- * Check if a backup version is compatible with the restore version
- * TypeDB backups are generally compatible within major versions
- */
-export function isVersionCompatible(
-  backupVersion: string,
-  restoreVersion: string,
-): { compatible: boolean; warning?: string } {
-  const backup = parseVersion(backupVersion)
-  const restore = parseVersion(restoreVersion)
-
-  if (!backup || !restore) {
-    return {
-      compatible: false,
-      warning:
-        'Could not parse versions, refusing to proceed without valid version information',
-    }
-  }
-
-  // Cannot restore newer backup to older server
-  if (backup.major > restore.major) {
-    return {
-      compatible: false,
-      warning: `Cannot restore TypeDB ${backupVersion} backup to ${restoreVersion} server. The backup is from a newer major version.`,
-    }
-  }
-
-  // Allow same major version
-  if (backup.major === restore.major) {
-    return { compatible: true }
-  }
-
-  // TypeDB disallows cross-major restores (major versions have incompatible formats)
-  return {
-    compatible: false,
-    warning: `Cannot restore TypeDB ${backupVersion} backup to ${restoreVersion} server. Cross-major version restores are not supported. Use TypeDB Export/Import for version migration.`,
-  }
-}
-
-// Validate that a version string matches supported format
-export function isValidVersionFormat(version: string): boolean {
-  const parsed = parseVersion(version)
-  return parsed !== null
-}