heroku 10.13.2 → 11.0.0-alpha.10

package/lib/oldCommands/autocomplete/script.js

@@ -0,0 +1,35 @@
+export {};
+/*
+import {Args} from '@oclif/core'
+import * as path from 'path'
+
+import {AutocompleteBase} from '../../lib/autocomplete/base'
+
+export default class Script extends AutocompleteBase {
+  static description = 'display autocomplete setup script for shell'
+
+  static hidden = true
+
+  static args = {
+    shell: Args.string({description: 'shell type', required: false}),
+  }
+
+  async run() {
+    const {args} = await this.parse(Script)
+    const shell = args.shell || this.config.shell
+    this.errorIfNotSupportedShell(shell)
+
+    const shellUpcase = shell.toUpperCase()
+    this.log(
+      `${this.prefix}HEROKU_AC_${shellUpcase}_SETUP_PATH=${path.join(
+        this.autocompleteCacheDir,
+        `${shell}_setup`,
+      )} && test -f $HEROKU_AC_${shellUpcase}_SETUP_PATH && source $HEROKU_AC_${shellUpcase}_SETUP_PATH;`,
+    )
+  }
+
+  private get prefix(): string {
+    return `\n# ${this.config.bin} autocomplete setup\n`
+  }
+}
+*/

package/lib/oldCommands/pg/backups/cancel.d.ts

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

package/lib/oldCommands/pg/backups/cancel.js

@@ -0,0 +1,56 @@
+export {};
+/*
+import {Command, flags} from '@heroku-cli/command'
+import {Args, ux} from '@oclif/core'
+import host from '../../../lib/pg/host'
+import backupsFactory from '../../../lib/pg/backups'
+import {BackupTransfer} from '../../../lib/pg/types'
+
+export default class Cancel extends Command {
+  static topic = 'pg'
+  static description = 'cancel an in-progress backup or restore (default newest)'
+  static flags = {
+    app: flags.app({required: true}),
+    remote: flags.remote(),
+  }
+
+  static args = {
+    backup_id: Args.string({description: 'ID of the backup. If omitted, we use the last unfinished backup ID.'}),
+  }
+
+  public async run(): Promise<void> {
+    const {flags, args} = await this.parse(Cancel)
+    const {app} = flags
+    const {backup_id} = args
+    const pgbackups = backupsFactory(app, this.heroku)
+
+    let transfer: BackupTransfer | undefined
+
+    if (backup_id) {
+      const num = await pgbackups.num(backup_id)
+      if (!num) {
+        ux.error(`Invalid Backup: ${backup_id}`)
+      }
+
+      ({body: transfer} = await this.heroku.get<BackupTransfer>(`/client/v11/apps/${app}/transfers/${num}`, {hostname: host()}))
+    } else {
+      const {body: transfers} = await this.heroku.get<BackupTransfer[]>(`/client/v11/apps/${app}/transfers`, {hostname: host()})
+      transfer = this.sortByCreatedAtDesc(transfers).find(t => !t.finished_at)
+    }
+
+    if (transfer) {
+      ux.action.start(`Cancelling ${pgbackups.name(transfer)}`)
+      this.heroku.post(`/client/v11/apps/${app}/transfers/${transfer.uuid}/actions/cancel`, {hostname: host()})
+      ux.action.stop()
+    } else {
+      ux.error('No active backups/transfers')
+    }
+  }
+
+  protected sortByCreatedAtDesc(transfers: BackupTransfer[]): BackupTransfer[] {
+    return transfers.sort((a, b) => {
+      return new Date(a.created_at).getTime() - new Date(b.created_at).getTime()
+    })
+  }
+}
+*/

package/lib/oldCommands/pg/backups/capture.d.ts

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

package/lib/oldCommands/pg/backups/capture.js

@@ -0,0 +1,77 @@
+export {};
+/*
+import color from '@heroku-cli/color'
+import {Command, flags} from '@heroku-cli/command'
+import {Args, ux} from '@oclif/core'
+import backupsApi from '../../../lib/pg/backups'
+import {BackupTransfer, PgDatabase} from '../../../lib/pg/types'
+import {getAddon} from '../../../lib/pg/fetcher'
+import pgHost from '../../../lib/pg/host'
+import heredoc from 'tsheredoc'
+import {HTTPError} from '@heroku/http-call'
+import {nls} from '../../../nls'
+
+export default class Capture extends Command {
+  static topic = 'pg';
+  static description = 'capture a new backup';
+  static flags = {
+    'wait-interval': flags.string(),
+    verbose: flags.boolean({char: 'v'}),
+    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(Capture)
+    const {app, 'wait-interval': waitInterval, verbose} = flags
+    const {database} = args
+
+    const interval = Math.max(3, Number.parseInt(waitInterval || '3', 10))
+    const db = await getAddon(this.heroku, app, database)
+    const pgBackupsApi = backupsApi(app, this.heroku)
+
+    try {
+      const {body: dbInfo} = await this.heroku.get<PgDatabase>(`/client/v11/databases/${db.id}`, {hostname: pgHost()})
+      const dbProtected = /On/.test(dbInfo.info.find(attribute => attribute.name === 'Continuous Protection')?.values[0] || '')
+      if (dbProtected) {
+        ux.warn('Continuous protection is already enabled for this database. Logical backups of large databases are likely to fail.')
+        ux.warn('See https://devcenter.heroku.com/articles/heroku-postgres-data-safety-and-continuous-protection#physical-backups-on-heroku-postgres.')
+      }
+    } catch (error: unknown) {
+      const httpError = error as HTTPError
+      if (httpError.statusCode !== 404)
+        throw httpError
+      ux.error(
+        heredoc`
+          ${color.yellow(db.name)} is not yet provisioned.
+          Run ${color.cmd('heroku addons:wait')} to wait until the db is provisioned.
+        `,
+        {exit: 1},
+      )
+    }
+
+    ux.action.start(`Starting backup of ${color.yellow(db.name)}`)
+    const {body: backup} = await this.heroku.post<BackupTransfer>(`/client/v11/databases/${db.id}/backups`, {hostname: pgHost()})
+    ux.action.stop()
+    ux.log(heredoc`
+
+      Use Ctrl-C at any time to stop monitoring progress; the backup will continue running.
+      Use ${color.cmd('heroku pg:backups:info')} to check progress.
+      Stop a running backup with ${color.cmd('heroku pg:backups:cancel')}.
+    `)
+
+    if (app !== db.app.name) {
+      ux.log(heredoc`
+        HINT: You are running this command with a non-billing application.
+        Use ${color.cmd('heroku pg:backups -a ' + db.app.name)} to check the list of backups.
+      `)
+    }
+
+    await pgBackupsApi.wait(`Backing up ${color.green(backup.from_name)} to ${color.cyan(pgBackupsApi.name(backup))}`, backup.uuid, interval, verbose, db.app.name || app)
+  }
+}
+*/

package/lib/oldCommands/pg/backups/delete.d.ts

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

package/lib/oldCommands/pg/backups/delete.js

@@ -0,0 +1,45 @@
+export {};
+/*
+import color from '@heroku-cli/color'
+import {Command, flags} from '@heroku-cli/command'
+import {Args, ux} from '@oclif/core'
+import confirmCommand from '../../../lib/confirmCommand'
+import host from '../../../lib/pg/host'
+import backupsFactory from '../../../lib/pg/backups'
+
+export default class Delete extends Command {
+  static topic = 'pg'
+  static description = 'delete a backup'
+  static flags = {
+    confirm: flags.string({char: 'c'}),
+    app: flags.app({required: true}),
+    remote: flags.remote(),
+  }
+
+  static args = {
+    backup_id: Args.string({required: true, description: 'ID of the backup'}),
+  }
+
+  static examples = [
+    '$ heroku pg:backup:delete --app APP_ID BACKUP_ID',
+  ]
+
+  public async run(): Promise<void> {
+    const {flags, args} = await this.parse(Delete)
+    const {app, confirm} = flags
+    const {backup_id} = args
+    const pgbackups = backupsFactory(app, this.heroku)
+
+    await confirmCommand(app, confirm)
+    ux.action.start(`Deleting backup ${color.cyan(backup_id)} on ${color.app(app)}`)
+
+    const num = await pgbackups.num(backup_id)
+    if (!num) {
+      throw new Error(`Invalid Backup: ${backup_id}`)
+    }
+
+    await this.heroku.delete(`/client/v11/apps/${app}/transfers/${num}`, {hostname: host()})
+    ux.action.stop()
+  }
+}
+*/

package/lib/oldCommands/pg/backups/download.d.ts

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

package/lib/oldCommands/pg/backups/download.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 pgHost from '../../../lib/pg/host'
+import pgBackupsApi from '../../../lib/pg/backups'
+import {sortBy} from 'lodash'
+import download from '../../../lib/pg/download'
+import * as fs from 'fs-extra'
+import type {BackupTransfer, PublicUrlResponse} from '../../../lib/pg/types'
+
+function defaultFilename() {
+  let f = 'latest.dump'
+  if (!fs.existsSync(f))
+    return f
+  let i = 1
+  do
+    f = `latest.dump.${i++}`
+  while (fs.existsSync(f))
+  return f
+}
+
+export default class Download extends Command {
+  static topic = 'pg';
+  static description = 'downloads database backup';
+  static flags = {
+    output: flags.string({char: 'o', description: 'location to download to. Defaults to latest.dump'}),
+    app: flags.app({required: true}),
+    remote: flags.remote(),
+  };
+
+  static args = {
+    backup_id: Args.string({description: 'ID of the backup. If omitted, we use the last backup ID.'}),
+  };
+
+  public async run(): Promise<void> {
+    const {flags, args} = await this.parse(Download)
+    const {backup_id} = args
+    const {app} = flags
+    const output = flags.output || defaultFilename()
+    let num
+    ux.action.start(`Getting backup from ${color.magenta(app)}`)
+    if (backup_id) {
+      num = await pgBackupsApi(app, this.heroku).num(backup_id)
+      if (!num)
+        throw new Error(`Invalid Backup: ${backup_id}`)
+    } else {
+      const {body: transfers} = await this.heroku.get<BackupTransfer[]>(`/client/v11/apps/${app}/transfers`, {hostname: pgHost()})
+      const lastBackup = sortBy(transfers.filter(t => t.succeeded && t.to_type === 'gof3r'), 'created_at')
+        .pop()
+      if (!lastBackup)
+        throw new Error(`No backups on ${color.magenta(app)}. Capture one with ${color.cyan.bold('heroku pg:backups:capture')}`)
+      num = lastBackup.num
+    }
+
+    ux.action.status = `fetching url of #${num}`
+    const {body: info} = await this.heroku.post<PublicUrlResponse>(`/client/v11/apps/${app}/transfers/${num}/actions/public-url`, {hostname: pgHost()})
+
+    ux.action.stop(`done, #${num}`)
+    await download(info.url, output, {progress: true})
+  }
+}
+*/

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

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

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

@@ -0,0 +1,141 @@
+export {};
+/*
+import color from '@heroku-cli/color'
+import {Command, flags} from '@heroku-cli/command'
+import {ux} from '@oclif/core'
+import {hux} from '@heroku/heroku-cli-util'
+import backupsFactory from '../../../lib/pg/backups'
+import host from '../../../lib/pg/host'
+import type {BackupTransfer} from '../../../lib/pg/types'
+
+export default class Index extends Command {
+  static topic = 'pg'
+  static description = 'list database backups'
+  static strict = false
+  static flags = {
+    verbose: flags.boolean({char: 'v', hidden: true}),
+    confirm: flags.string({char: 'c', hidden: true}),
+    output: flags.string({char: 'o', hidden: true}),
+    'wait-interval': flags.string({hidden: true}),
+    at: flags.string({hidden: true}),
+    quiet: flags.boolean({char: 'q', hidden: true}),
+    app: flags.app({required: true}),
+    remote: flags.remote(),
+  }
+
+  public async run(): Promise<void> {
+    const {flags: {app}} = await this.parse(Index)
+
+    const {body: transfers} = await this.heroku.get<BackupTransfer[]>(`/client/v11/apps/${app}/transfers`, {hostname: host()})
+    // NOTE that the sort order is descending
+    transfers.sort((transferA, transferB) => {
+      if (transferA.created_at > transferB.created_at) {
+        return -1
+      }
+
+      if (transferB.created_at > transferA.created_at) {
+        return 1
+      }
+
+      return 0
+    })
+
+    this.displayBackups(transfers, app)
+    this.displayRestores(transfers, app)
+    this.displayCopies(transfers, app)
+  }
+
+  private displayBackups(transfers: BackupTransfer[], app: string) {
+    const backups = transfers.filter(backupTransfer => backupTransfer.from_type === 'pg_dump' && backupTransfer.to_type === 'gof3r')
+    const {name, status, filesize} = backupsFactory(app, this.heroku)
+    hux.styledHeader('Backups')
+    if (backups.length === 0) {
+      ux.log(`No backups. Capture one with ${color.cyan.bold('heroku pg:backups:capture')}`)
+    } else {
+      hux.table<BackupTransfer>(backups, {
+        ID: {
+          get: (transfer: BackupTransfer) => color.cyan(name(transfer)),
+        },
+        'Created at': {
+          get: (transfer: BackupTransfer) => transfer.created_at,
+        },
+        Status: {
+          get: (transfer: BackupTransfer) => status(transfer),
+        },
+        Size: {
+          get: (transfer: BackupTransfer) => filesize(transfer.processed_bytes),
+        },
+        Database: {
+          get: (transfer: BackupTransfer) => color.green(transfer.from_name) || 'UNKNOWN',
+        },
+      })
+    }
+
+    ux.log()
+  }
+
+  private displayRestores(transfers: BackupTransfer[], app: string) {
+    const restores = transfers
+      .filter(t => t.from_type !== 'pg_dump' && t.to_type === 'pg_restore')
+      .slice(0, 10) // first 10 only
+    const {name, status, filesize} = backupsFactory(app, this.heroku)
+    hux.styledHeader('Restores')
+    if (restores.length === 0) {
+      ux.log(`No restores found. Use ${color.cyan.bold('heroku pg:backups:restore')} to restore a backup`)
+    } else {
+      hux.table(restores, {
+        ID: {
+          get: (transfer: BackupTransfer) => color.cyan(name(transfer)),
+        },
+        'Started at': {
+          get: (transfer: BackupTransfer) => transfer.created_at,
+        },
+        Status: {
+          get: (transfer: BackupTransfer) => status(transfer),
+        },
+        Size: {
+          get: (transfer: BackupTransfer) => filesize(transfer.processed_bytes),
+        },
+        Database: {
+          get: (transfer: BackupTransfer) => color.green(transfer.to_name) || 'UNKNOWN',
+        },
+      })
+    }
+
+    ux.log()
+  }
+
+  private displayCopies(transfers: BackupTransfer[], app: string) {
+    const {name, status, filesize} = backupsFactory(app, this.heroku)
+    const copies = transfers.filter(t => t.from_type === 'pg_dump' && t.to_type === 'pg_restore').slice(0, 10)
+    hux.styledHeader('Copies')
+    if (copies.length === 0) {
+      ux.log(`No copies found. Use ${color.cyan.bold('heroku pg:copy')} to copy a database to another`)
+    } else {
+      hux.table(copies, {
+        ID: {
+          get: (transfer: BackupTransfer) => color.cyan(name(transfer)),
+        },
+        'Started at': {
+          get: (transfer: BackupTransfer) => transfer.created_at,
+        },
+        Status: {
+          get: (transfer: BackupTransfer) => status(transfer),
+        },
+        Size: {
+          get: (transfer: BackupTransfer) => filesize(transfer.processed_bytes),
+        },
+        From: {
+          get: (transfer: BackupTransfer) => color.green(transfer.from_name) || 'UNKNOWN',
+        },
+        To: {
+          get: (transfer: BackupTransfer) => color.green(transfer.to_name) || 'UNKNOWN',
+        },
+      })
+    }
+
+    ux.log()
+  }
+}
+
+*/

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

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

package/lib/oldCommands/pg/backups/info.js

@@ -0,0 +1,102 @@
+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 pgHost from '../../../lib/pg/host'
+import pgBackupsApi from '../../../lib/pg/backups'
+import {sortBy} from 'lodash'
+import type {BackupTransfer} from '../../../lib/pg/types'
+
+function status(backup: BackupTransfer) {
+  if (backup.succeeded) {
+    if (backup.warnings > 0)
+      return `Finished with ${backup.warnings} warnings`
+    return 'Completed'
+  }
+
+  if (backup.canceled_at)
+    return 'Canceled'
+  if (backup.finished_at)
+    return 'Failed'
+  if (backup.started_at)
+    return 'Running'
+  return 'Pending'
+}
+
+function compression(compressed: number, total: number) {
+  let pct = 0
+  if (compressed > 0) {
+    pct = Math.round((total - compressed) / total * 100)
+    pct = Math.max(0, pct)
+  }
+
+  return ` (${pct}% compression)`
+}
+
+export default class Info extends Command {
+  static topic = 'pg';
+  static description = 'get information about a specific backup';
+  static flags = {
+    app: flags.app({required: true}),
+    remote: flags.remote(),
+  };
+
+  static args = {
+    backup_id: Args.string({description: 'ID of the backup. If omitted, we use the last backup ID.'}),
+  };
+
+  getBackup = async (id: string | undefined, app: string) => {
+    let backupID
+    if (id) {
+      const {num} = pgBackupsApi(app, this.heroku)
+      backupID = await num(id)
+      if (!backupID)
+        throw new Error(`Invalid ID: ${id}`)
+    } else {
+      let {body: transfers} = await this.heroku.get<BackupTransfer[]>(`/client/v11/apps/${app}/transfers`, {hostname: pgHost()})
+      transfers = sortBy(transfers, 'created_at')
+      const backups = transfers.filter(t => t.from_type === 'pg_dump' && t.to_type === 'gof3r')
+      const lastBackup = backups.pop()
+      if (!lastBackup)
+        throw new Error(`No backups. Capture one with ${color.cyan.bold('heroku pg:backups:capture')}`)
+      backupID = lastBackup.num
+    }
+
+    const {body: backup} = await this.heroku.get<BackupTransfer>(`/client/v11/apps/${app}/transfers/${backupID}?verbose=true`, {hostname: pgHost()})
+    return backup
+  }
+
+  displayBackup = (backup: BackupTransfer, app: string) => {
+    const {filesize, name} = pgBackupsApi(app, this.heroku)
+    hux.styledHeader(`Backup ${color.cyan(name(backup))}`)
+    hux.styledObject({
+      Database: color.green(backup.from_name),
+      'Started at': backup.started_at,
+      'Finished at': backup.finished_at,
+      Status: status(backup),
+      Type: backup.schedule ? 'Scheduled' : 'Manual', 'Original DB Size': filesize(backup.source_bytes),
+      'Backup Size': `${filesize(backup.processed_bytes)}${backup.finished_at ? compression(backup.processed_bytes, backup.source_bytes) : ''}`,
+    }, ['Database', 'Started at', 'Finished at', 'Status', 'Type', 'Original DB Size', 'Backup Size'])
+    ux.log()
+  }
+
+  displayLogs = (backup: BackupTransfer) => {
+    hux.styledHeader('Backup Logs')
+    for (const log of backup.logs)
+      ux.log(`${log.created_at} ${log.message}`)
+    ux.log()
+  }
+
+  public async run(): Promise<void> {
+    const {flags, args} = await this.parse(Info)
+    const {app} = flags
+    const {backup_id} = args
+
+    const backup = await this.getBackup(backup_id, app)
+    this.displayBackup(backup, app)
+    this.displayLogs(backup)
+  }
+}
+*/

package/lib/oldCommands/pg/backups/restore.d.ts

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