sealos-cli 1.1.1 → 1.1.3

package/src/commands/database/index.ts

@@ -1,6 +1,7 @@
 import { Command } from 'commander'
 import chalk from 'chalk'
-import { createDatabaseClient } from '../../lib/api-client.ts'
+import { createDatabaseClient, resolveDbproviderHost } from '../../lib/api-client.ts'
+import { DEFAULT_SEALOS_REGION, loadAuth } from '../../lib/auth.ts'
 import { type ApiErrorBody, mapApiError } from '../../lib/errors.ts'
 import { outputJson, outputTable } from '../../lib/output.ts'
 import { withAuth, withErrorHandling } from '../../lib/with-auth.ts'
@@ -37,6 +38,46 @@ type DatabaseType = typeof SUPPORTED_DATABASE_TYPES[number]
 type LogDbType = typeof SUPPORTED_LOG_DB_TYPES[number]
 type LogType = typeof SUPPORTED_LOG_TYPES[number]
 
+interface LegacyApiResponse<T> {
+  code: number
+  message?: string
+  data?: T
+  error?: unknown
+}
+
+interface SecretResponse {
+  username: string
+  password: string
+  host: string
+  port: string
+  connection: string
+}
+
+interface ClientAppConfigResponse {
+  domain?: string
+}
+
+interface ServiceResponse {
+  spec?: {
+    ports?: Array<{
+      nodePort?: number
+      port?: number
+    }>
+  }
+}
+
+interface ConnectionDetails {
+  privateConnection?: {
+    endpoint?: string
+    host?: string
+    port?: string
+    username?: string
+    password?: string
+    connectionString?: string
+  } | null
+  publicConnection?: string | null
+}
+
 export function collectOption (value: string, previous: string[]): string[] {
   return [...previous, value]
 }
@@ -70,6 +111,52 @@ export function normalizeDatabaseType (type: string): DatabaseType {
   return resolved
 }
 
+function getDatabaseConnectScheme (type: string): string {
+  const databaseType = normalizeDatabaseType(type)
+  const schemes: Record<DatabaseType, string> = {
+    postgresql: 'postgresql',
+    mongodb: 'mongodb',
+    'apecloud-mysql': 'mysql',
+    mysql: 'mysql',
+    redis: 'redis',
+    kafka: 'kafka',
+    qdrant: 'qdrant',
+    nebula: 'nebula',
+    weaviate: 'weaviate',
+    milvus: 'milvus',
+    pulsar: 'pulsar',
+    clickhouse: 'clickhouse'
+  }
+
+  return schemes[databaseType]
+}
+
+export function buildConsolePublicConnection (options: {
+  dbType: string
+  username?: string
+  password?: string
+  domain?: string
+  nodePort?: number | string | null
+}): string | null {
+  if (!options.domain || !options.nodePort) return null
+
+  const scheme = getDatabaseConnectScheme(options.dbType)
+  const port = String(options.nodePort)
+
+  if (scheme === 'kafka' || scheme === 'milvus') {
+    return `${options.domain}:${port}`
+  }
+
+  if (!options.username || !options.password) return null
+
+  let connection = `${scheme}://${options.username}:${options.password}@${options.domain}:${port}`
+  if (scheme === 'mongodb' || scheme === 'postgresql') {
+    connection += '/?directConnection=true'
+  }
+
+  return connection
+}
+
 export function normalizeLogDbType (type: string): LogDbType {
   const normalized = normalizeDatabaseType(type)
   if (!SUPPORTED_LOG_DB_TYPES.includes(normalized as LogDbType)) {
@@ -260,6 +347,103 @@ function printConnectionDetail (connection: any): void {
   outputTable(rows)
 }
 
+function buildPublicAccessResult (action: 'enable-public' | 'disable-public', name: string, connection?: ConnectionDetails | null): Record<string, unknown> {
+  return {
+    success: true,
+    action,
+    resource: 'database',
+    name,
+    status: action === 'enable-public' ? 'enabled' : 'disabled',
+    publicConnection: connection?.publicConnection ?? null,
+    connection: connection ?? null
+  }
+}
+
+function getDatabaseProviderHost (): string {
+  const override = process.env.SEALOS_DATABASE_HOST?.trim()
+  if (override) {
+    return override.replace(/\/+$/, '')
+  }
+
+  let authRegion: string | undefined
+  try {
+    authRegion = loadAuth().region
+  } catch {
+    authRegion = undefined
+  }
+
+  return resolveDbproviderHost(process.env.SEALOS_REGION || authRegion || DEFAULT_SEALOS_REGION)
+}
+
+async function getLegacyApiData<T> (path: string, headers: { Authorization: string }): Promise<T> {
+  const url = new URL(path, getDatabaseProviderHost())
+  const response = await fetch(url, {
+    headers: {
+      Authorization: headers.Authorization
+    }
+  })
+  const body = await response.json() as LegacyApiResponse<T>
+
+  if (!response.ok || body.code !== 200) {
+    throw new Error(body.message || `Request failed: ${url.pathname}`)
+  }
+
+  return body.data as T
+}
+
+async function fetchConsoleConnectionDetails (
+  name: string,
+  dbType: string,
+  fallbackConnection: ConnectionDetails | null | undefined,
+  headers: { Authorization: string }
+): Promise<ConnectionDetails> {
+  const [secret, service, config] = await Promise.all([
+    getLegacyApiData<SecretResponse>(`/api/getSecretByName?dbName=${encodeURIComponent(name)}&dbType=${encodeURIComponent(dbType)}&mock=false`, headers),
+    getLegacyApiData<ServiceResponse>(`/api/getServiceByName?name=${encodeURIComponent(`${name}-export`)}`, headers).catch(() => null),
+    getLegacyApiData<ClientAppConfigResponse>('/api/platform/getClientAppConfig', headers).catch(() => null)
+  ])
+
+  const nodePort = service?.spec?.ports?.find(port => port.nodePort)?.nodePort
+  const publicConnection = buildConsolePublicConnection({
+    dbType,
+    username: secret.username,
+    password: secret.password,
+    domain: config?.domain,
+    nodePort
+  }) ?? fallbackConnection?.publicConnection ?? null
+
+  return {
+    privateConnection: {
+      endpoint: `${secret.host}:${secret.port}`,
+      host: secret.host,
+      port: secret.port,
+      username: secret.username,
+      password: secret.password,
+      connectionString: secret.connection
+    },
+    publicConnection
+  }
+}
+
+async function loadDatabaseConnectionDetails (
+  name: string,
+  headers: { Authorization: string }
+): Promise<ConnectionDetails | null> {
+  const client = createDatabaseClient()
+  const { data, error, response } = await client.GET('/databases/{databaseName}', {
+    headers,
+    params: {
+      path: { databaseName: name }
+    }
+  })
+
+  if (error) throw mapApiError(response.status, error as ApiErrorBody)
+
+  if (!data.type) return data.connection ?? null
+
+  return await fetchConsoleConnectionDetails(name, data.type, data.connection, headers)
+}
+
 export function createDatabaseCommand (): Command {
   const dbCmd = new Command('database')
     .alias('db')
@@ -268,7 +452,7 @@ export function createDatabaseCommand (): Command {
   dbCmd
     .command('list')
     .description('List databases')
-    .option('-o, --output <format>', 'Output format (json|table)', 'table')
+    .option('-o, --output <format>', 'Output format (json|table)', 'json')
     .action(withAuth({ spinnerText: 'Loading databases...' }, async (ctx, options: { output: string }) => {
       const client = createDatabaseClient()
       const { data, error, response } = await client.GET('/databases', {
@@ -319,7 +503,7 @@ export function createDatabaseCommand (): Command {
   dbCmd
     .command('versions')
     .description('List supported database versions (public endpoint)')
-    .option('-o, --output <format>', 'Output format (json|table)', 'table')
+    .option('-o, --output <format>', 'Output format (json|table)', 'json')
     .option('--host <host>', 'Sealos region host for public version lookup, e.g. https://gzg.sealos.run')
     .option('--type <type>', 'Filter versions by database type')
     .action(withErrorHandling({ spinnerText: 'Loading versions...' }, async (ctx, options: { output: string; host?: string; type?: string }) => {
@@ -384,7 +568,7 @@ export function createDatabaseCommand (): Command {
     .option('--backup-save-time <count>', 'Retention count')
     .option('--backup-save-type <type>', 'Retention unit (days|hours|weeks|months)')
     .option('--param <KEY=VALUE>', 'Database parameter override', collectOption, [] as string[])
-    .option('-o, --output <format>', 'Output format (json|table)', 'table')
+    .option('-o, --output <format>', 'Output format (json|table)', 'json')
     .action(withAuth({
       spinnerText: 'Creating database...'
     }, async (
@@ -452,7 +636,7 @@ export function createDatabaseCommand (): Command {
     .command('get <name>')
     .alias('describe')
     .description('Get database details')
-    .option('-o, --output <format>', 'Output format (json|table)', 'table')
+    .option('-o, --output <format>', 'Output format (json|table)', 'json')
     .action(withAuth({ spinnerText: 'Loading database...' }, async (ctx, name: string, options: { output: string }) => {
       const client = createDatabaseClient()
       const { data, error, response } = await client.GET('/databases/{databaseName}', {
@@ -477,26 +661,18 @@ export function createDatabaseCommand (): Command {
   dbCmd
     .command('connection <name>')
     .description('Show database connection details')
-    .option('-o, --output <format>', 'Output format (json|table)', 'table')
+    .option('-o, --output <format>', 'Output format (json|table)', 'json')
     .action(withAuth({ spinnerText: 'Loading connection details...' }, async (ctx, name: string, options: { output: string }) => {
-      const client = createDatabaseClient()
-      const { data, error, response } = await client.GET('/databases/{databaseName}', {
-        headers: ctx.auth,
-        params: {
-          path: { databaseName: name }
-        }
-      })
-
-      if (error) throw mapApiError(response.status, error as ApiErrorBody)
+      const connection = await loadDatabaseConnectionDetails(name, ctx.auth)
 
       ctx.spinner.stop()
 
       if (options.output === 'json') {
-        outputJson(data.connection ?? null)
+        outputJson(connection)
         return
       }
 
-      printConnectionDetail(data.connection)
+      printConnectionDetail(connection)
     }))
 
   dbCmd
@@ -506,12 +682,13 @@ export function createDatabaseCommand (): Command {
     .option('--memory <memory>', 'Memory in GB per replica')
     .option('--storage <storage>', 'Storage in GB per replica')
     .option('--replicas <replicas>', 'Replica count')
+    .option('-o, --output <format>', 'Output format (json|table)', 'json')
     .action(withAuth({
       spinnerText: 'Updating database...'
     }, async (
       ctx,
       name: string,
-      options: { cpu?: string; memory?: string; storage?: string; replicas?: string }
+      options: { cpu?: string; memory?: string; storage?: string; replicas?: string; output: string }
     ) => {
       const quota = buildQuota(options)
       if (Object.keys(quota).length === 0) {
@@ -529,13 +706,25 @@ export function createDatabaseCommand (): Command {
 
       if (error) throw mapApiError(response.status, error as ApiErrorBody)
 
+      if (options.output === 'json') {
+        ctx.spinner.stop()
+        outputJson({
+          success: true,
+          action: 'update',
+          resource: 'database',
+          name,
+          status: 'requested'
+        })
+        return
+      }
       ctx.spinner.succeed(`Database "${name}" update requested`)
     }))
 
   dbCmd
     .command('start <name>')
     .description('Start a database')
-    .action(withAuth({ spinnerText: 'Starting database...' }, async (ctx, name: string) => {
+    .option('-o, --output <format>', 'Output format (json|table)', 'json')
+    .action(withAuth({ spinnerText: 'Starting database...' }, async (ctx, name: string, options: { output: string }) => {
       const client = createDatabaseClient()
       const { error, response } = await client.POST('/databases/{databaseName}/start', {
         headers: ctx.auth,
@@ -545,6 +734,17 @@ export function createDatabaseCommand (): Command {
       })
 
       if (error) throw mapApiError(response.status, error as ApiErrorBody)
+      if (options.output === 'json') {
+        ctx.spinner.stop()
+        outputJson({
+          success: true,
+          action: 'start',
+          resource: 'database',
+          name,
+          status: 'requested'
+        })
+        return
+      }
       ctx.spinner.succeed(`Database "${name}" start requested`)
     }))
 
@@ -552,7 +752,8 @@ export function createDatabaseCommand (): Command {
     .command('pause <name>')
     .alias('stop')
     .description('Pause a database')
-    .action(withAuth({ spinnerText: 'Pausing database...' }, async (ctx, name: string) => {
+    .option('-o, --output <format>', 'Output format (json|table)', 'json')
+    .action(withAuth({ spinnerText: 'Pausing database...' }, async (ctx, name: string, options: { output: string }) => {
       const client = createDatabaseClient()
       const { error, response } = await client.POST('/databases/{databaseName}/pause', {
         headers: ctx.auth,
@@ -562,13 +763,25 @@ export function createDatabaseCommand (): Command {
       })
 
       if (error) throw mapApiError(response.status, error as ApiErrorBody)
+      if (options.output === 'json') {
+        ctx.spinner.stop()
+        outputJson({
+          success: true,
+          action: 'pause',
+          resource: 'database',
+          name,
+          status: 'requested'
+        })
+        return
+      }
       ctx.spinner.succeed(`Database "${name}" pause requested`)
     }))
 
   dbCmd
     .command('restart <name>')
     .description('Restart a database')
-    .action(withAuth({ spinnerText: 'Restarting database...' }, async (ctx, name: string) => {
+    .option('-o, --output <format>', 'Output format (json|table)', 'json')
+    .action(withAuth({ spinnerText: 'Restarting database...' }, async (ctx, name: string, options: { output: string }) => {
       const client = createDatabaseClient()
       const { error, response } = await client.POST('/databases/{databaseName}/restart', {
         headers: ctx.auth,
@@ -578,6 +791,17 @@ export function createDatabaseCommand (): Command {
       })
 
       if (error) throw mapApiError(response.status, error as ApiErrorBody)
+      if (options.output === 'json') {
+        ctx.spinner.stop()
+        outputJson({
+          success: true,
+          action: 'restart',
+          resource: 'database',
+          name,
+          status: 'requested'
+        })
+        return
+      }
       ctx.spinner.succeed(`Database "${name}" restart requested`)
     }))
 
@@ -585,7 +809,8 @@ export function createDatabaseCommand (): Command {
     .command('delete <name>')
     .description('Delete a database')
     .option('-f, --force', 'Delete without confirmation')
-    .action(withAuth({ spinnerText: 'Deleting database...' }, async (ctx, name: string) => {
+    .option('-o, --output <format>', 'Output format (json|table)', 'json')
+    .action(withAuth({ spinnerText: 'Deleting database...' }, async (ctx, name: string, options: { output: string }) => {
       const client = createDatabaseClient()
       const { error, response } = await client.DELETE('/databases/{databaseName}', {
         headers: ctx.auth,
@@ -595,13 +820,24 @@ export function createDatabaseCommand (): Command {
       })
 
       if (error) throw mapApiError(response.status, error as ApiErrorBody)
+      if (options.output === 'json') {
+        ctx.spinner.stop()
+        outputJson({
+          success: true,
+          action: 'delete',
+          resource: 'database',
+          name,
+          status: 'requested'
+        })
+        return
+      }
       ctx.spinner.succeed(`Database "${name}" delete requested`)
     }))
 
   dbCmd
     .command('backups <name>')
     .description('List backups for a database')
-    .option('-o, --output <format>', 'Output format (json|table)', 'table')
+    .option('-o, --output <format>', 'Output format (json|table)', 'json')
     .action(withAuth({ spinnerText: 'Loading backups...' }, async (ctx, name: string, options: { output: string }) => {
       const client = createDatabaseClient()
       const { data, error, response } = await client.GET('/databases/{databaseName}/backups', {
@@ -649,12 +885,13 @@ export function createDatabaseCommand (): Command {
     .description('Create a database backup')
     .option('--name <backupName>', 'Backup name')
     .option('--description <description>', 'Backup description')
+    .option('-o, --output <format>', 'Output format (json|table)', 'json')
     .action(withAuth({
       spinnerText: 'Creating backup...'
     }, async (
       ctx,
       name: string,
-      options: { name?: string; description?: string }
+      options: { name?: string; description?: string; output: string }
     ) => {
       const client = createDatabaseClient()
       const body: Record<string, string> = {}
@@ -670,15 +907,28 @@ export function createDatabaseCommand (): Command {
       })
 
       if (error) throw mapApiError(response.status, error as ApiErrorBody)
+      if (options.output === 'json') {
+        ctx.spinner.stop()
+        outputJson({
+          success: true,
+          action: 'backup',
+          resource: 'database',
+          name,
+          backupName: options.name ?? null,
+          status: 'requested'
+        })
+        return
+      }
       ctx.spinner.succeed(`Backup requested for database "${name}"`)
     }))
 
   dbCmd
     .command('backup-delete <databaseName> <backupName>')
     .description('Delete a database backup')
+    .option('-o, --output <format>', 'Output format (json|table)', 'json')
     .action(withAuth({
       spinnerText: 'Deleting backup...'
-    }, async (ctx, databaseName: string, backupName: string) => {
+    }, async (ctx, databaseName: string, backupName: string, options: { output: string }) => {
       const client = createDatabaseClient()
       const { error, response } = await client.DELETE('/databases/{databaseName}/backups/{backupName}', {
         headers: ctx.auth,
@@ -688,6 +938,18 @@ export function createDatabaseCommand (): Command {
       })
 
       if (error) throw mapApiError(response.status, error as ApiErrorBody)
+      if (options.output === 'json') {
+        ctx.spinner.stop()
+        outputJson({
+          success: true,
+          action: 'backup-delete',
+          resource: 'database-backup',
+          databaseName,
+          backupName,
+          status: 'deleted'
+        })
+        return
+      }
       ctx.spinner.succeed(`Backup "${backupName}" deleted`)
     }))
 
@@ -697,12 +959,13 @@ export function createDatabaseCommand (): Command {
     .requiredOption('--from <backupName>', 'Backup name to restore from')
     .option('--name <name>', 'Name for the restored database')
     .option('--replicas <replicas>', 'Replica count for the restored database')
+    .option('-o, --output <format>', 'Output format (json|table)', 'json')
     .action(withAuth({
       spinnerText: 'Restoring database...'
     }, async (
       ctx,
       databaseName: string,
-      options: { from: string; name?: string; replicas?: string }
+      options: { from: string; name?: string; replicas?: string; output: string }
     ) => {
       const client = createDatabaseClient()
       const body: Record<string, unknown> = {}
@@ -718,13 +981,28 @@ export function createDatabaseCommand (): Command {
       })
 
       if (error) throw mapApiError(response.status, error as ApiErrorBody)
+      if (options.output === 'json') {
+        ctx.spinner.stop()
+        outputJson({
+          success: true,
+          action: 'restore',
+          resource: 'database',
+          databaseName,
+          backupName: options.from,
+          restoredName: options.name ?? null,
+          status: 'requested'
+        })
+        return
+      }
       ctx.spinner.succeed(`Restore requested from backup "${options.from}"`)
     }))
 
   dbCmd
     .command('enable-public <name>')
+    .alias('expose')
     .description('Enable public access for a database')
-    .action(withAuth({ spinnerText: 'Enabling public access...' }, async (ctx, name: string) => {
+    .option('-o, --output <format>', 'Output format (json|table)', 'json')
+    .action(withAuth({ spinnerText: 'Enabling public access...' }, async (ctx, name: string, options: { output: string }) => {
       const client = createDatabaseClient()
       const { error, response } = await client.POST('/databases/{databaseName}/enable-public', {
         headers: ctx.auth,
@@ -734,13 +1012,23 @@ export function createDatabaseCommand (): Command {
       })
 
       if (error) throw mapApiError(response.status, error as ApiErrorBody)
+      const connection = await loadDatabaseConnectionDetails(name, ctx.auth)
+
+      if (options.output === 'json') {
+        ctx.spinner.stop()
+        outputJson(buildPublicAccessResult('enable-public', name, connection))
+        return
+      }
       ctx.spinner.succeed(`Public access enabled for "${name}"`)
+      printConnectionDetail(connection)
     }))
 
   dbCmd
     .command('disable-public <name>')
+    .alias('unexpose')
     .description('Disable public access for a database')
-    .action(withAuth({ spinnerText: 'Disabling public access...' }, async (ctx, name: string) => {
+    .option('-o, --output <format>', 'Output format (json|table)', 'json')
+    .action(withAuth({ spinnerText: 'Disabling public access...' }, async (ctx, name: string, options: { output: string }) => {
       const client = createDatabaseClient()
       const { error, response } = await client.POST('/databases/{databaseName}/disable-public', {
         headers: ctx.auth,
@@ -750,6 +1038,11 @@ export function createDatabaseCommand (): Command {
       })
 
       if (error) throw mapApiError(response.status, error as ApiErrorBody)
+      if (options.output === 'json') {
+        ctx.spinner.stop()
+        outputJson(buildPublicAccessResult('disable-public', name))
+        return
+      }
       ctx.spinner.succeed(`Public access disabled for "${name}"`)
     }))
 
@@ -761,7 +1054,7 @@ export function createDatabaseCommand (): Command {
     .requiredOption('--log-path <path>', 'Log path to read. Use "log-files" first to discover valid paths')
     .option('--page <page>', 'Page number', '1')
     .option('--page-size <pageSize>', 'Page size', '200')
-    .option('-o, --output <format>', 'Output format (plain|json|table)', 'plain')
+    .option('-o, --output <format>', 'Output format (json|table|plain)', 'json')
     .action(withAuth({
       spinnerText: 'Loading logs...'
     }, async (
@@ -820,7 +1113,7 @@ export function createDatabaseCommand (): Command {
     .description('List database log files for a pod')
     .requiredOption('--db-type <type>', 'Database type used by the log service')
     .requiredOption('--log-type <type>', 'Log type used by the log service')
-    .option('-o, --output <format>', 'Output format (json|table)', 'table')
+    .option('-o, --output <format>', 'Output format (json|table)', 'json')
     .action(withAuth({
       spinnerText: 'Loading log files...'
     }, async (
@@ -877,5 +1170,27 @@ export function createDatabaseCommand (): Command {
       outputTable(rows)
     }))
 
+  dbCmd
+    .command('* [args...]', { hidden: true })
+    .option('-o, --output <format>', 'Output format (json|table)', 'json')
+    .allowUnknownOption()
+    .action(async (args: string[], options: { output: string }) => {
+      const [name, operation, ...rest] = args
+      const aliases: Record<string, string> = {
+        connection: 'connection',
+        connect: 'connection',
+        'enable-public': 'enable-public',
+        expose: 'expose',
+        'disable-public': 'disable-public',
+        unexpose: 'unexpose'
+      }
+      const command = operation ? aliases[operation] : undefined
+      if (!name || !command) {
+        throw new Error('Unknown database command. Use "sealos-cli database --help" to list supported commands.')
+      }
+
+      await dbCmd.parseAsync([command, name, ...rest, '--output', options.output], { from: 'user' })
+    })
+
   return dbCmd
 }