heroku 10.13.2 → 11.0.0-alpha.10

package/lib/oldCommands/pg/copy.js

@@ -0,0 +1,104 @@
+export {};
+/*
+import color from '@heroku-cli/color'
+import {APIClient, Command, flags} from '@heroku-cli/command'
+import {Args, ux} from '@oclif/core'
+import * as Heroku from '@heroku-cli/schema'
+import pghost from '../../lib/pg/host'
+import backupsFactory from '../../lib/pg/backups'
+import {getAttachment} from '../../lib/pg/fetcher'
+import {parsePostgresConnectionString} from '../../lib/pg/util'
+import confirmCommand from '../../lib/confirmCommand'
+import {BackupTransfer, CredentialsInfo} from '../../lib/pg/types'
+
+const getAttachmentInfo = async function (heroku: APIClient, db: string, app: string) {
+  if (db.match(/^postgres:\/\//)) {
+    const conn = parsePostgresConnectionString(db)
+    const host = `${conn.host}:${conn.port}`
+    return {
+      name: conn.database ? `database ${conn.database} on ${host}` : `database on ${host}`,
+      url: db,
+      confirm: conn.database || conn.host,
+    }
+  }
+
+  const attachment = await getAttachment(heroku, app, db)
+  if (!attachment)
+    throw new Error(`${db} not found on ${color.magenta(app)}`)
+
+  const {body: addon} = await heroku.get<Heroku.AddOnAttachment>(`/addons/${attachment.addon.name}`)
+  const {body: config} = await heroku.get<Heroku.ConfigVars>(`/apps/${attachment.app.name}/config-vars`)
+  const formattedConfig = Object.fromEntries(Object.entries(config).map(([k, v]) => [k.toUpperCase(), v]))
+
+  return {
+    name: attachment.name.replace(/^HEROKU_POSTGRESQL_/, '')
+      .replace(/_URL$/, ''),
+    url: formattedConfig[attachment.name.toUpperCase() + '_URL'],
+    attachment: {
+      ...attachment,
+      addon,
+    },
+    confirm: app,
+  }
+}
+
+export default class Copy extends Command {
+    static topic = 'pg';
+    static description = 'copy all data from source db to target';
+    static help = 'at least one of the databases must be a Heroku PostgreSQL DB';
+    static flags = {
+      'wait-interval': flags.string(),
+      verbose: flags.boolean(),
+      confirm: flags.string(),
+      app: flags.app({required: true}),
+      remote: flags.remote(),
+    };
+
+    static args = {
+      source: Args.string({required: true, description: 'config var exposed to the owning app containing the source database URL'}),
+      target: Args.string({required: true, description: 'config var exposed to the owning app containing the target database URL'}),
+    };
+
+    public async run(): Promise<void> {
+      const {flags, args} = await this.parse(Copy)
+      const {'wait-interval': waitInterval, verbose, confirm, app} = flags
+      const pgbackups = backupsFactory(app, this.heroku)
+      const interval = Math.max(3, Number.parseInt(waitInterval || '0', 10)) || 3
+
+      const [source, target] = await Promise.all([getAttachmentInfo(this.heroku, args.source, app), getAttachmentInfo(this.heroku, args.target, app)])
+      if (source.url === target.url)
+        throw new Error('Cannot copy database onto itself')
+
+      await confirmCommand(target.confirm || args.target, confirm, `WARNING: Destructive action\nThis command will remove all data from ${color.yellow(target.name)}\nData from ${color.yellow(source.name)} will then be transferred to ${color.yellow(target.name)}`)
+      ux.action.start(`Starting copy of ${color.yellow(source.name)} to ${color.yellow(target.name)}`)
+      const attachment = target.attachment || source.attachment
+      if (!attachment) {
+        throw new Error('Heroku PostgreSQL database must be source or target')
+      }
+
+      const {body: copy} = await this.heroku.post<BackupTransfer>(`/client/v11/databases/${attachment.addon.id}/transfers`, {
+        body: {
+          from_name: source.name, from_url: source.url, to_name: target.name, to_url: target.url,
+        },
+        hostname: pghost(),
+      })
+      ux.action.stop()
+
+      if (source.attachment) {
+        const {body: credentials} = await this.heroku.get<CredentialsInfo>(
+          `/postgres/v0/databases/${source.attachment.addon.name}/credentials`,
+          {
+            hostname: pghost(),
+            headers: {
+              Authorization: `Basic ${Buffer.from(`:${this.heroku.auth}`).toString('base64')}`,
+            },
+          })
+        if (credentials.length > 1) {
+          ux.warn('pg:copy will only copy your default credential and the data it has access to. Any additional credentials and data that only they can access will not be copied.')
+        }
+      }
+
+      await pgbackups.wait('Copying', copy.uuid, interval, verbose, attachment.addon.app?.name || app)
+    }
+}
+*/

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

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

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

@@ -0,0 +1,47 @@
+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 {getAttachment} from '../../../lib/pg/fetcher'
+import host from '../../../lib/pg/host'
+import {essentialPlan} from '../../../lib/pg/util'
+import {nls} from '../../../nls'
+
+export default class Create extends Command {
+    static topic = 'pg'
+    static description = 'create credential within database\nExample:\n\n    heroku pg:credentials:create postgresql-something-12345 --name new-cred-name\n'
+    static flags = {
+      name: flags.string({char: 'n', required: true, description: 'name of the new credential within the database'}),
+      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(Create)
+      const {app, name} = flags
+      const {addon: db} = await getAttachment(this.heroku, app as string, args.database)
+      if (essentialPlan(db)) {
+        throw new Error("You can't create a custom credential on Essential-tier databases.")
+      }
+
+      const data = {name}
+      ux.action.start(`Creating credential ${color.cyan.bold(name)}`)
+
+      await this.heroku.post(`/postgres/v0/databases/${db.name}/credentials`, {hostname: host(), body: data})
+      ux.action.stop()
+
+      const attachCmd = `heroku addons:attach ${db.name} --credential ${name} -a ${app}`
+      const psqlCmd = `heroku pg:psql ${db.name} -a ${app}`
+      ux.log(heredoc(`
+
+      Please attach the credential to the apps you want to use it in by running ${color.cyan.bold(attachCmd)}.
+      Please define the new grants for the credential within Postgres: ${color.cyan.bold(psqlCmd)}.`))
+    }
+}
+*/

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

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

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

@@ -0,0 +1,56 @@
+export {};
+/*
+import color from '@heroku-cli/color'
+import {Command, flags} from '@heroku-cli/command'
+import {Args, ux} from '@oclif/core'
+import * as Heroku from '@heroku-cli/schema'
+import {essentialPlan} from '../../../lib/pg/util'
+import {getAddon} from '../../../lib/pg/fetcher'
+import pgHost from '../../../lib/pg/host'
+import confirmCommand from '../../../lib/confirmCommand'
+import {nls} from '../../../nls'
+
+export default class Destroy extends Command {
+  static topic = 'pg';
+  static description = 'destroy credential within database';
+  static example = '$ heroku pg:credentials:destroy postgresql-transparent-56874 --name cred-name -a woodstock-production';
+  static flags = {
+    name: flags.string({char: 'n', required: true, description: 'unique identifier for the credential'}),
+    confirm: flags.string({char: 'c'}),
+    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(Destroy)
+    const {database} = args
+    const {app, name, confirm} = flags
+    if (name === 'default') {
+      throw new Error('Default credential cannot be destroyed.')
+    }
+
+    const db = await getAddon(this.heroku, app, database)
+    if (essentialPlan(db)) {
+      throw new Error("You can't destroy the default credential on Essential-tier databases.")
+    }
+
+    const {body: attachments} = await this.heroku.get<Heroku.AddOnAttachment[]>(`/addons/${db.name}/addon-attachments`)
+    const credAttachments = attachments.filter(a => a.namespace === `credential:${name}`)
+    const credAttachmentApps = Array.from(new Set(credAttachments.map(a => a.app?.name)))
+    if (credAttachmentApps.length > 0)
+      throw new Error(`Credential ${name} must be detached from the app${credAttachmentApps.length > 1 ? 's' : ''} ${credAttachmentApps.map(appName => color.app(appName || ''))
+        .join(', ')} before destroying.`)
+
+    await confirmCommand(app, confirm)
+    ux.action.start(`Destroying credential ${color.cyan.bold(name)}`)
+    await this.heroku.delete(`/postgres/v0/databases/${db.name}/credentials/${encodeURIComponent(name)}`, {hostname: pgHost()})
+    ux.action.stop()
+    ux.log(`The credential has been destroyed within ${db.name}.`)
+    ux.log(`Database objects owned by ${name} will be assigned to the default credential.`)
+  }
+}
+*/

package/lib/oldCommands/pg/credentials/repair-default.d.ts

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

package/lib/oldCommands/pg/credentials/repair-default.js

@@ -0,0 +1,43 @@
+export {};
+/*
+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 RepairDefault extends Command {
+  static topic = 'pg';
+  static description = 'repair the permissions of the default credential within database';
+  static example = '$ heroku pg:credentials:repair-default postgresql-something-12345';
+  static flags = {
+    confirm: flags.string({char: 'c'}),
+    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(RepairDefault)
+    const {app, confirm} = flags
+    const {database} = args
+    const db = await getAddon(this.heroku, app, database)
+    if (essentialPlan(db))
+      throw new Error("You can't perform this operation on Essential-tier databases.")
+    await confirmCommand(app, confirm, heredoc(`
+      Destructive Action
+      Ownership of all database objects owned by additional credentials will be transferred to the default credential.
+      This command will also grant the default credential admin option for all additional credentials.
+    `))
+    ux.action.start('Resetting permissions and object ownership for default role to factory settings')
+    await this.heroku.post(`/postgres/v0/databases/${db.name}/repair-default`, {hostname: pgHost()})
+    ux.action.stop()
+  }
+}
+*/

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

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

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

@@ -0,0 +1,97 @@
+export {};
+/*
+import color from '@heroku-cli/color'
+import {Command, flags} from '@heroku-cli/command'
+import {APIClient} from '@heroku-cli/command/lib/api-client'
+import type {AddOnAttachment} from '@heroku-cli/schema'
+import {Args, ux} from '@oclif/core'
+import confirmCommand from '../../../lib/confirmCommand'
+import {getAttachment} from '../../../lib/pg/fetcher'
+import host from '../../../lib/pg/host'
+import {legacyEssentialPlan} from '../../../lib/pg/util'
+import {nls} from '../../../nls'
+
+export default class Rotate extends Command {
+  static topic = 'pg'
+  static description = 'rotate the database credentials'
+  static flags = {
+    name: flags.string({
+      char: 'n',
+      description: 'which credential to rotate (default credentials if not specified and --all is not used)',
+    }),
+    all: flags.boolean({description: 'rotate all credentials', exclusive: ['name']}),
+    confirm: flags.string({char: 'c'}),
+    force: flags.boolean({description: 'forces rotating the targeted credentials'}),
+    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(Rotate)
+    const {app, all, confirm, name, force} = flags
+    const {addon: db} = await getAttachment(this.heroku, app, args.database)
+    const warnings: string[] = []
+    const cred = name || 'default'
+    if (all && name !== undefined) {
+      throw new Error('cannot pass both --all and --name')
+    }
+
+    if (legacyEssentialPlan(db) && cred !== 'default') {
+      throw new Error('Legacy Essential-tier databases do not support named credentials.')
+    }
+
+    if (all && force) {
+      warnings.push('This forces rotation on all credentials including the default credential.')
+    }
+
+    let {body: attachments} = await this.heroku.get<Required<AddOnAttachment>[]>(`/addons/${db.name}/addon-attachments`)
+    if (name) {
+      attachments = attachments.filter(a => a.namespace === `credential:${cred}`)
+    }
+
+    if (!all) {
+      warnings.push(`The password for the ${cred} credential will rotate.`)
+    }
+
+    if (all || force || cred === 'default') {
+      warnings.push('Connections will be reset and applications will be restarted.')
+    } else {
+      warnings.push('Connections older than 30 minutes will be reset, and a temporary rotation username will be used during the process.')
+    }
+
+    if (force) {
+      warnings.push(`Any followers lagging in replication (see ${color.cyan.bold('heroku pg:info')}) will be inaccessible until caught up.`)
+    }
+
+    if (attachments.length > 0) {
+      const uniqueAttachments = [...new Set(attachments.map(attachment => color.app(attachment.app.name || '')))]
+        .sort()
+        .join(', ')
+
+      warnings.push(`This command will affect the app${(attachments.length > 1) ? 's' : ''} ${uniqueAttachments}.`)
+    }
+
+    await confirmCommand(app, confirm, `Destructive Action\n${warnings.join('\n')}`)
+    const options: APIClient.Options = {
+      hostname: host(),
+      body: {forced: force ?? undefined},
+      headers: {
+        Authorization: `Basic ${Buffer.from(`:${this.heroku.auth}`).toString('base64')}`,
+      },
+    }
+    if (all) {
+      ux.action.start(`Rotating all credentials on ${color.yellow(db.name)}`)
+      await this.heroku.post(`/postgres/v0/databases/${db.name}/credentials_rotation`, options)
+    } else {
+      ux.action.start(`Rotating ${cred} on ${color.yellow(db.name)}`)
+      await this.heroku.post(`/postgres/v0/databases/${db.name}/credentials/${encodeURIComponent(cred)}/credentials_rotation`, options)
+    }
+
+    ux.action.stop()
+  }
+}
+*/

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

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

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 {};