heroku 10.13.2 → 11.0.0-alpha.2

package/lib/oldCommands/pg/credentials/url.js

@@ -0,0 +1,75 @@
+export {};
+/*
+import color from '@heroku-cli/color'
+import {Command, flags} from '@heroku-cli/command'
+import {Args, ux} from '@oclif/core'
+import {legacyEssentialPlan} from '../../../lib/pg/util'
+import {getAddon} from '../../../lib/pg/fetcher'
+import pgHost from '../../../lib/pg/host'
+import {URL} from 'url'
+import type {CredentialInfo} from '../../../lib/pg/types'
+import heredoc from 'tsheredoc'
+import {nls} from '../../../nls'
+
+export default class Url extends Command {
+  static topic = 'pg'
+  static description = 'show information on a database credential'
+  static flags = {
+    name: flags.string({
+      char: 'n',
+      description: 'which credential to show (default credentials if not specified)',
+      default: 'default',
+    }),
+    app: flags.app({required: true}),
+    remote: flags.remote(),
+  }
+
+  static args = {
+    database: Args.string({description: `${nls('pg:database:arg:description')} ${nls('pg:database:arg:description:default:suffix')}`}),
+  }
+
+  public async run(): Promise<void> {
+    const {flags, args} = await this.parse(Url)
+    const {app, name} = flags
+    const {database} = args
+    const db = await getAddon(this.heroku, app, database)
+    if (legacyEssentialPlan(db) && name !== 'default') {
+      ux.error('Legacy Essential-tier databases do not support named credentials.')
+    }
+
+    const {body: credInfo} = await this.heroku.get<CredentialInfo>(
+      `/postgres/v0/databases/${db.name}/credentials/${encodeURIComponent(name)}`,
+      {
+        hostname: pgHost(),
+        headers: {
+          Authorization: `Basic ${Buffer.from(`:${this.heroku.auth}`).toString('base64')}`,
+        },
+      },
+    )
+    const activeCreds = credInfo.credentials.find(c => c.state === 'active')
+    if (!activeCreds) {
+      ux.error(`Could not find any active credentials for ${name}`, {exit: 1})
+    }
+
+    const creds = Object.assign({}, db, {
+      database: credInfo.database, host: credInfo.host, port: credInfo.port,
+    }, {
+      user: activeCreds?.user, password: activeCreds?.password,
+    })
+    const connUrl = new URL(`postgres://${creds.host}/${creds.database}`)
+    connUrl.port = creds.port.toString()
+    if (creds.user && creds.password) {
+      connUrl.username = creds.user
+      connUrl.password = creds.password
+    }
+
+    ux.log(heredoc(`
+      Connection information for ${color.yellow(name)} credential.
+      Connection info string:
+        "dbname=${creds.database} host=${creds.host} port=${creds.port} user=${creds.user} password=${creds.password} sslmode=require"
+      Connection URL:
+        ${connUrl}
+    `))
+  }
+}
+*/

package/lib/oldCommands/pg/credentials.d.ts

@@ -0,0 +1 @@
+export {};

package/lib/oldCommands/pg/credentials.js

@@ -0,0 +1,77 @@
+export {};
+/*
+import {Command, flags} from '@heroku-cli/command'
+import {Args} from '@oclif/core'
+import {hux} from '@heroku/heroku-cli-util'
+import * as Heroku from '@heroku-cli/schema'
+import pghost from '../../lib/pg/host'
+import {getAddon} from '../../lib/pg/fetcher'
+import {CredentialInfo, CredentialsInfo} from '../../lib/pg/types'
+import {presentCredentialAttachments} from '../../lib/pg/util'
+import {nls} from '../../nls'
+
+export default class Credentials extends Command {
+  static topic = 'pg'
+  static description = 'show information on credentials in the database'
+  static flags = {
+    app: flags.app({required: true}),
+    remote: flags.remote(),
+  }
+
+  static args = {
+    database: Args.string({description: `${nls('pg:database:arg:description')} ${nls('pg:database:arg:description:default:suffix')}`}),
+  }
+
+  public async run(): Promise<void> {
+    const {flags, args} = await this.parse(Credentials)
+    const {app} = flags
+    const {database} = args
+    const addon = await getAddon(this.heroku, app, database)
+
+    const {body: credentials} = await this.heroku.get<CredentialsInfo>(
+      `/postgres/v0/databases/${addon.id}/credentials`,
+      {
+        hostname: pghost(),
+        headers: {
+          Authorization: `Basic ${Buffer.from(`:${this.heroku.auth}`).toString('base64')}`,
+        },
+      },
+    )
+    const sortedCredentials = this.sortByDefaultAndName(credentials)
+    const {body: attachments} = await this.heroku.get<Required<Heroku.AddOnAttachment>[]>(`/addons/${addon.id}/addon-attachments`)
+
+    const presentCredential = (cred: CredentialInfo): string => {
+      let credAttachments = [] as Required<Heroku.AddOnAttachment>[]
+      if (cred.name === 'default') {
+        credAttachments = attachments.filter(a => a.namespace === null)
+      } else {
+        credAttachments = attachments.filter(a => a.namespace === `credential:${cred.name}`)
+      }
+
+      return presentCredentialAttachments(app, credAttachments, sortedCredentials, cred.name)
+    }
+
+    hux.table(credentials, {
+      Credential: {
+        get: presentCredential,
+      },
+      State: {
+        get: cred => cred.state,
+      },
+    })
+  }
+
+  protected sortByDefaultAndName(credentials: CredentialsInfo) {
+    return credentials.sort((a, b) => {
+      const isDefaultA = this.isDefaultCredential(a)
+      const isDefaultB = this.isDefaultCredential(b)
+
+      return isDefaultB < isDefaultA ? -1 : (isDefaultA < isDefaultB ? 1 : a.name.localeCompare(b.name))
+    })
+  }
+
+  protected isDefaultCredential(cred: CredentialInfo): boolean {
+    return cred.name === 'default'
+  }
+}
+*/

package/lib/oldCommands/pg/diagnose.d.ts

@@ -0,0 +1 @@
+export {};

package/lib/oldCommands/pg/diagnose.js

@@ -0,0 +1,136 @@
+export {};
+/*
+import {Command, flags} from '@heroku-cli/command'
+import {Args, ux} from '@oclif/core'
+import {hux} from '@heroku/heroku-cli-util'
+import {table} from '@oclif/core/lib/cli-ux/styled/table'
+import {capitalize} from '@oclif/core/lib/util'
+import heredoc from 'tsheredoc'
+import {getAttachment} from '../../lib/pg/fetcher'
+import host from '../../lib/pg/host'
+import type {
+  AddOnAttachmentWithConfigVarsAndPlan,
+  PGDiagnoseCheck, PGDiagnoseRequest,
+  PGDiagnoseResponse,
+  PGDiagnoseResult,
+} from '../../lib/pg/types'
+import {
+  essentialPlan,
+  getConfigVarNameFromAttachment,
+  getConnectionDetails,
+} from '../../lib/pg/util'
+import color from '@heroku-cli/color'
+import {uuidValidate} from '../../lib/utils/uuid-validate'
+
+const PGDIAGNOSE_HOST = process.env.PGDIAGNOSE_URL || 'pgdiagnose.herokai.com'
+
+export default class Diagnose extends Command {
+  static topic = 'pg'
+  static description = heredoc(`
+    run or view diagnostics report
+    defaults to DATABASE_URL database if no DATABASE is specified
+    if REPORT_ID is specified instead, a previous report is displayed
+
+    `)
+
+  static flags = {
+    json: flags.boolean({description: 'format output as JSON'}),
+    app: flags.app({required: true}),
+    remote: flags.remote(),
+  }
+
+  static args = {
+    'DATABASE|REPORT_ID': Args.string({description: 'config var exposed to the owning app containing the database URL or the report ID'}),
+  }
+
+  public async run(): Promise<void> {
+    const {flags, args} = await this.parse(Diagnose)
+
+    const id = args['DATABASE|REPORT_ID']
+    let report: PGDiagnoseResponse
+    if (id && uuidValidate(id)) {
+      ({body: report} = await this.heroku.get<PGDiagnoseResponse>(`/reports/${encodeURIComponent(id)}`, {hostname: PGDIAGNOSE_HOST}))
+    } else {
+      report = await this.generateReport(id, flags.app)
+    }
+
+    this.displayReport(report, flags.json)
+  }
+
+  private displayReport(report: PGDiagnoseResponse, json: boolean) {
+    if (json) {
+      hux.styledJSON(report)
+      return
+    }
+
+    ux.log(`Report ${report.id} for ${report.app}::${report.database}\navailable for one month after creation on ${report.created_at}\n`)
+
+    this.display(report.checks.filter(c => c.status === 'red'))
+    this.display(report.checks.filter(c => c.status === 'yellow'))
+    this.display(report.checks.filter(c => c.status === 'green'))
+    this.display(report.checks.filter(c => !['red', 'yellow', 'green'].includes(c.status)))
+  }
+
+  private display(checks: PGDiagnoseCheck[]) {
+    checks.forEach(check => {
+      const colorFn = color[check.status] || ((txt: string) => txt)
+      ux.log(colorFn(`${check.status.toUpperCase()}: ${check.name}`))
+      const isNonEmptyArray = Array.isArray(check.results) && check.results.length > 0
+      const resultsKeys = Object.keys(check.results ?? {})
+      if (check.status === 'green' || (!isNonEmptyArray && resultsKeys.length === 0)) {
+        return
+      }
+
+      if (isNonEmptyArray) {
+        const keys = Object.keys(check.results[0]) as (keyof PGDiagnoseResult)[]
+        const cols = {} as Record<string, Partial<table.Column<PGDiagnoseResult>>>
+        keys.forEach(key => {
+          cols[capitalize(key)] = {
+            get: (row: PGDiagnoseResult): string => row[key],
+          }
+        })
+        hux.table(check.results, cols)
+      } else {
+        const [key] = resultsKeys
+        ux.log(`${key.split('_')
+          .map(s => capitalize(s))
+          .join(' ')} ${check.results[key as keyof PGDiagnoseResult]}`)
+      }
+    })
+  }
+
+  private async generateParams(url: string, db: AddOnAttachmentWithConfigVarsAndPlan, dbName: string): Promise<PGDiagnoseRequest> {
+    const base_params: PGDiagnoseRequest = {
+      url,
+      plan: db.plan.name.split(':')[1],
+      app: db.app.name as string,
+      database: dbName,
+    }
+    if (!essentialPlan(db)) {
+      const {body: metrics} = await this.heroku.get<unknown[]>(`/client/v11/databases/${db.id}/metrics`, {hostname: host()})
+      base_params.metrics = metrics
+      const {body: burstData} = await this.heroku.get<{
+        burst_status: string
+      }>(`/client/v11/databases/${db.id}/burst_status`, {hostname: host()})
+      if (burstData && Object.keys(burstData).length > 0) {
+        base_params.burst_data_present = true
+        base_params.burst_status = burstData.burst_status
+      }
+    }
+
+    return base_params
+  }
+
+  private async generateReport(database: string | undefined, app: string) {
+    const attachment = await getAttachment(this.heroku, app, database)
+    const {addon: db} = attachment
+    const {body: config} = await this.heroku.get<Record<string, string>>(`/apps/${app}/config-vars`)
+    const {url} = getConnectionDetails(attachment, config)
+    const dbName = getConfigVarNameFromAttachment(attachment, config)
+    const body = await this.generateParams(url, db, dbName)
+    const {body: report} = await this.heroku.post<PGDiagnoseResponse>('/reports', {hostname: PGDIAGNOSE_HOST, body})
+
+    return report
+  }
+}
+*/

package/lib/oldCommands/pg/info.d.ts

@@ -0,0 +1 @@
+export {};

package/lib/oldCommands/pg/info.js

@@ -0,0 +1,110 @@
+export {};
+/*
+import color from '@heroku-cli/color'
+import {Command, flags} from '@heroku-cli/command'
+import {Args, ux} from '@oclif/core'
+import {hux} from '@heroku/heroku-cli-util'
+import * as Heroku from '@heroku-cli/schema'
+import pghost from '../../lib/pg/host'
+import {getAddon, all} from '../../lib/pg/fetcher'
+import {configVarNamesFromValue, databaseNameFromUrl} from '../../lib/pg/util'
+import {AddOnAttachmentWithConfigVarsAndPlan, AddOnWithRelatedData, PgDatabaseTenant} from '../../lib/pg/types'
+import {nls} from '../../nls'
+
+type DBObject = {
+  addon: AddOnAttachmentWithConfigVarsAndPlan | AddOnWithRelatedData,
+  configVars?: string[],
+  dbInfo: PgDatabaseTenant | null,
+  config: Heroku.ConfigVars,
+}
+
+function displayDB(db: DBObject, app: string) {
+  if (db.addon.attachment_names) {
+    hux.styledHeader(db.addon.attachment_names.map((c: string) => color.green(c + '_URL'))
+      .join(', '))
+  } else {
+    hux.styledHeader(db.configVars?.map(c => color.green(c))
+      .join(', ') || '')
+  }
+
+  if (db.addon.app.name && db.addon.app.name !== app) {
+    db.dbInfo?.info.push({name: 'Billing App', values: [color.cyan(db.addon.app.name)]})
+  }
+
+  db.dbInfo?.info.push({name: 'Add-on', values: [color.yellow(db.addon.name)]})
+  const info: Record<string, never> | Record<string, string> = {}
+  db.dbInfo?.info.forEach(infoObject => {
+    if (infoObject.values.length > 0) {
+      let valuesArray: string[]
+      if (infoObject.resolve_db_name) {
+        valuesArray = infoObject.values.map(v => databaseNameFromUrl(v, db.config))
+      } else {
+        valuesArray = infoObject.values
+      }
+
+      info[infoObject.name] = valuesArray.join(', ')
+    }
+  })
+  const keys = db.dbInfo?.info.map(i => i.name)
+  hux.styledObject(info, keys)
+  ux.log()
+}
+
+export default class Info extends Command {
+    static topic = 'pg';
+    static description = 'show database information';
+    static flags = {
+      app: flags.app({required: true}),
+      remote: flags.remote(),
+    };
+
+    static args = {
+      database: Args.string({description: `${nls('pg:database:arg:description')} ${nls('pg:database:arg:description:all-dbs:suffix')}`}),
+    };
+
+    static aliases = ['pg']
+
+    public async run(): Promise<void> {
+      const {flags, args} = await this.parse(Info)
+      const {app} = flags
+      const {sortBy} = require('lodash')
+      const {database: db} = args
+      let addons: AddOnAttachmentWithConfigVarsAndPlan[] | AddOnWithRelatedData[]
+      const {body: config} = await this.heroku.get<Heroku.ConfigVars>(`/apps/${app}/config-vars`)
+      if (db) {
+        addons = await Promise.all([getAddon(this.heroku, app, db)])
+      } else {
+        addons = await all(this.heroku, app)
+        if (addons.length === 0) {
+          ux.log(`${color.magenta(app)} has no heroku-postgresql databases.`)
+          return
+        }
+      }
+
+      let dbs: DBObject[] = await Promise.all(addons.map(async addon => {
+        const pgResponse = await this.heroku.get<PgDatabaseTenant>(
+          `/client/v11/databases/${addon.id}`,
+          {
+            hostname: pghost(),
+          })
+          .catch(error => {
+            if (error.statusCode !== 404)
+              throw error
+            ux.warn(`${color.yellow(addon.name)} is not yet provisioned.\nRun ${color.cyan.bold('heroku addons:wait')} to wait until the db is provisioned.`)
+          })
+        const {body: dbInfo} = pgResponse || {body: null}
+        return {
+          addon,
+          config,
+          dbInfo,
+        }
+      }))
+      dbs = dbs.filter(db => db.dbInfo)
+      dbs.forEach(db => {
+        db.configVars = configVarNamesFromValue(db.config, db.dbInfo?.resource_url || '')
+      })
+      dbs = sortBy(dbs, (db: DBObject) => db.configVars && db.configVars[0] !== 'DATABASE_URL', 'configVars[0]')
+      dbs.forEach(db => displayDB(db, app))
+    }
+}
+*/

package/lib/oldCommands/pg/kill.d.ts

@@ -0,0 +1 @@
+export {};

package/lib/oldCommands/pg/kill.js

@@ -0,0 +1,37 @@
+export {};
+/*
+import {Command, flags} from '@heroku-cli/command'
+import {Args, ux} from '@oclif/core'
+import {database} from '../../lib/pg/fetcher'
+import {exec} from '../../lib/pg/psql'
+import heredoc from 'tsheredoc'
+import {nls} from '../../nls'
+
+export default class Kill extends Command {
+  static topic = 'pg';
+  static description = 'kill a query';
+  static flags = {
+    force: flags.boolean({char: 'f'}),
+    app: flags.app({required: true}),
+    remote: flags.remote(),
+  };
+
+  static args = {
+    pid: Args.string({required: true, description: 'ID of the process'}),
+    database: Args.string({description: `${nls('pg:database:arg:description')} ${nls('pg:database:arg:description:default:suffix')}`}),
+  };
+
+  public async run(): Promise<void> {
+    const {flags, args} = await this.parse(Kill)
+    const {app, force} = flags
+    const {pid} = args
+
+    const db = await database(this.heroku, app, args.database)
+    const query = heredoc`
+      SELECT ${force ? 'pg_terminate_backend' : 'pg_cancel_backend'}(${Number.parseInt(pid, 10)});
+    `
+    const output = await exec(db, query)
+    ux.log(output)
+  }
+}
+*/

package/lib/oldCommands/pg/killall.d.ts

@@ -0,0 +1 @@
+export {};

package/lib/oldCommands/pg/killall.js

@@ -0,0 +1,31 @@
+export {};
+/*
+import {Command, flags} from '@heroku-cli/command'
+import {Args, ux} from '@oclif/core'
+import {getAddon} from '../../lib/pg/fetcher'
+import pghost from '../../lib/pg/host'
+import {nls} from '../../nls'
+
+export default class Killall extends Command {
+  static topic = 'pg'
+  static description = 'terminates all connections for all credentials'
+  static flags = {
+    app: flags.app({required: true}),
+    remote: flags.remote(),
+  }
+
+  static args = {
+    database: Args.string({description: `${nls('pg:database:arg:description')} ${nls('pg:database:arg:description:default:suffix')}`}),
+  }
+
+  public async run(): Promise<void> {
+    const {flags, args} = await this.parse(Killall)
+    const {app} = flags
+
+    ux.action.start('Terminating connections for all credentials')
+    const database = await getAddon(this.heroku, app, args.database)
+    await this.heroku.post(`/client/v11/databases/${database.id}/connection_reset`, {hostname: pghost()})
+    ux.action.stop()
+  }
+}
+*/

package/lib/oldCommands/pg/links/create.d.ts

@@ -0,0 +1 @@
+export {};

package/lib/oldCommands/pg/links/create.js

@@ -0,0 +1,70 @@
+export {};
+/*
+import color from '@heroku-cli/color'
+import {Command, flags} from '@heroku-cli/command'
+import {Args, ux} from '@oclif/core'
+import heredoc from 'tsheredoc'
+import {addonResolver} from '../../../lib/addons/resolve'
+import {getAddon} from '../../../lib/pg/fetcher'
+import host from '../../../lib/pg/host'
+import type {AddOnAttachmentWithConfigVarsAndPlan, Link} from '../../../lib/pg/types'
+import {essentialPlan} from '../../../lib/pg/util'
+import {nls} from '../../../nls'
+
+export default class Create extends Command {
+  static topic = 'pg'
+  static description = heredoc(`
+  create a link between data stores
+  Example:
+  heroku pg:links:create HEROKU_REDIS_RED HEROKU_POSTGRESQL_CERULEAN
+  `)
+
+  static flags = {
+    as: flags.string({description: 'name of link to create'}),
+    app: flags.app({required: true}),
+    remote: flags.remote(),
+  }
+
+  static args = {
+    remote: Args.string({required: true, description: nls('pg:database:arg:description')}),
+    database: Args.string({required: true, description: nls('pg:database:arg:description')}),
+  }
+
+  public async run(): Promise<void> {
+    const {flags, args} = await this.parse(Create)
+    const {app} = flags
+
+    const service = async (remoteId: string) => {
+      const addon = await addonResolver(this.heroku, app, remoteId)
+      if (!addon.plan.name.match(/^heroku-(redis|postgresql)/))
+        throw new Error('Remote database must be heroku-redis or heroku-postgresql')
+      return addon
+    }
+
+    const [db, target] = await Promise.all([
+      getAddon(this.heroku, app, args.database),
+      service(args.remote),
+    ]) as [AddOnAttachmentWithConfigVarsAndPlan, AddOnAttachmentWithConfigVarsAndPlan]
+
+    if (essentialPlan(db))
+      throw new Error('pg:links isn’t available for Essential-tier databases.')
+    if (essentialPlan(target))
+      throw new Error('pg:links isn’t available for Essential-tier databases.')
+
+    ux.action.start(`Adding link from ${color.yellow(target.name)} to ${color.yellow(db.name)}`)
+    const {body: link} = await this.heroku.post<Link>(`/client/v11/databases/${db.id}/links`, {
+      body: {
+        target: target.name,
+        as: flags.as,
+      },
+      hostname: host(),
+    })
+
+    if (link.message) {
+      throw new Error(link.message)
+    }
+
+    ux.action.stop(`done, ${color.cyan(link.name)}`)
+  }
+}
+*/

package/lib/oldCommands/pg/links/destroy.d.ts

@@ -0,0 +1 @@
+export {};

package/lib/oldCommands/pg/links/destroy.js

@@ -0,0 +1,51 @@
+export {};
+/*
+import color from '@heroku-cli/color'
+import {Command, flags} from '@heroku-cli/command'
+import {Args, ux} from '@oclif/core'
+import {getAddon} from '../../../lib/pg/fetcher'
+import {essentialPlan} from '../../../lib/pg/util'
+import confirmCommand from '../../../lib/confirmCommand'
+import heredoc from 'tsheredoc'
+import pgHost from '../../../lib/pg/host'
+import {nls} from '../../../nls'
+
+export default class Destroy extends Command {
+  static topic = 'pg';
+  static description = 'destroys a link between data stores';
+  static example = '$ heroku pg:links:destroy HEROKU_POSTGRESQL_CERULEAN redis-symmetrical-100';
+
+  static flags = {
+    app: flags.app({required: true}),
+    confirm: flags.string({char: 'c'}),
+    remote: flags.remote(),
+  };
+
+  static args = {
+    database: Args.string({required: true, description: nls('pg:database:arg:description')}),
+    link: Args.string({required: true, description: 'name of the linked data store'}),
+  };
+
+  public async run(): Promise<void> {
+    const {flags, args} = await this.parse(Destroy)
+    const {app, confirm} = flags
+    const {database, link} = args
+    const db = await getAddon(this.heroku, app, database)
+    if (essentialPlan(db))
+      throw new Error('pg:links isn’t available for Essential-tier databases.')
+    await confirmCommand(app, confirm, heredoc(`
+      Destructive action
+      This command will affect the database ${color.yellow(db.name)}
+      This will delete ${color.cyan(link)} along with the tables and views created within it.
+      This may have adverse effects for software written against the ${color.cyan(link)} schema.
+    `))
+
+    ux.action.start(`Destroying link ${color.cyan(link)} from ${color.yellow(db.name)}`)
+    await this.heroku.delete(
+      `/client/v11/databases/${db.id}/links/${encodeURIComponent(link)}`,
+      {hostname: pgHost()},
+    )
+    ux.action.stop()
+  }
+}
+*/

package/lib/oldCommands/pg/links/index.d.ts

@@ -0,0 +1 @@
+export {};

package/lib/oldCommands/pg/links/index.js

@@ -0,0 +1,64 @@
+export {};
+/*
+import color from '@heroku-cli/color'
+import {Command, flags} from '@heroku-cli/command'
+import {Args, ux} from '@oclif/core'
+import {hux} from '@heroku/heroku-cli-util'
+import {getAddon, all} from '../../../lib/pg/fetcher'
+import pgHost from '../../../lib/pg/host'
+import type {Link} from '../../../lib/pg/types'
+import {nls} from '../../../nls'
+
+export default class Index extends Command {
+  static topic = 'pg';
+  static description = 'lists all databases and information on link';
+  static flags = {
+    app: flags.app({required: true}),
+    remote: flags.remote(),
+  };
+
+  static args = {
+    database: Args.string({description: `${nls('pg:database:arg:description')} ${nls('pg:database:arg:description:default:suffix')}`}),
+  };
+
+  public async run(): Promise<void> {
+    const {flags, args} = await this.parse(Index)
+    const {app} = flags
+    const {database} = args
+    let dbs
+    if (database)
+      dbs = await Promise.all([getAddon(this.heroku, app, database)])
+    else
+      dbs = await all(this.heroku, app)
+    if (dbs.length === 0)
+      throw new Error(`No databases on ${color.app(app)}`)
+    dbs = await Promise.all(dbs.map(async db => {
+      const {body: links} = await this.heroku.get<Link[]>(`/client/v11/databases/${db.id}/links`, {hostname: pgHost()})
+      db.links = links
+      return db
+    }))
+    let once: boolean
+    dbs.forEach(db => {
+      if (once)
+        ux.log()
+      else
+        once = true
+      hux.styledHeader(color.yellow(db.name))
+      if (db.links.message)
+        return ux.log(db.links.message)
+      if (db.links.length === 0)
+        return ux.log('No data sources are linked into this database')
+      db.links.forEach((link: Link) => {
+        ux.log(` * ${color.cyan(link.name)}`)
+        const remoteAttachmentName = link.remote?.attachment_name || ''
+        const remoteName = link.remote?.name || ''
+        const remoteLinkText = `${color.green(remoteAttachmentName)} (${color.yellow(remoteName)})`
+        hux.styledObject({
+          created_at: link.created_at,
+          remote: remoteLinkText,
+        })
+      })
+    })
+  }
+}
+*/