heroku 10.13.2 → 11.0.0-alpha.2

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

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

@@ -0,0 +1,150 @@
+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 confirmCommand from '../../../lib/confirmCommand'
+import backupsFactory from '../../../lib/pg/backups'
+import {getAttachment} from '../../../lib/pg/fetcher'
+import host from '../../../lib/pg/host'
+import type {BackupTransfer} from '../../../lib/pg/types'
+import {nls} from '../../../nls'
+
+function dropboxURL(url: string) {
+  if (url.match(/^https?:\/\/www\.dropbox\.com/) && !url.endsWith('dl=1')) {
+    if (url.endsWith('dl=0'))
+      url = url.replace('dl=0', 'dl=1')
+    else if (url.includes('?'))
+      url += '&dl=1'
+    else
+      url += '?dl=1'
+  }
+
+  return url
+}
+
+export default class Restore extends Command {
+  static topic = 'pg'
+  static description = 'restore a backup (default latest) to a database'
+  static flags = {
+    'wait-interval': flags.integer({default: 3}),
+    extensions: flags.string({
+      char: 'e',
+      description: heredoc(`
+        comma-separated list of extensions to pre-install in the default
+        public schema or an optional custom schema
+        (for example: hstore or myschema.hstore)
+      `),
+    }),
+    verbose: flags.boolean({char: 'v'}),
+    confirm: flags.string({char: 'c'}),
+    app: flags.app({required: true}),
+    remote: flags.remote(),
+  }
+
+  static args = {
+    backup: Args.string({description: 'URL or backup ID from another app'}),
+    database: Args.string({description: `${nls('pg:database:arg:description')} ${nls('pg:database:arg:description:default:suffix')}`}),
+  }
+
+  static examples = [
+    heredoc(`
+    # Basic Restore from Backup ID
+    $ heroku pg:backups:restore b101 DATABASE_URL --app my-heroku-app
+    `),
+    heredoc(`
+    # Restore from Another App
+    $ heroku pg:backups:restore example-app::b101 DATABASE_URL --app my-heroku-app
+    `),
+    heredoc(`
+    # Restore from a Public URL
+    $ heroku pg:backups:restore 'https://s3.amazonaws.com/my-bucket/mydb.dump' DATABASE_URL --app my-heroku-app
+    `),
+    heredoc(`
+    # Verbose Output
+    $ heroku pg:backups:restore b101 DATABASE_URL --app my-heroku-app --verbose
+    `),
+    heredoc(`
+    # Restore with Confirmation Prompt
+    $ heroku pg:backups:restore b101 DATABASE_URL --app my-heroku-app --confirm my-heroku-app
+    `),
+    heredoc(`
+    # Restore with a Specific Database Name
+    $ heroku pg:backups:restore b101 HEROKU_POSTGRESQL_PINK --app my-heroku-app
+    `),
+  ]
+
+  public async run(): Promise<void> {
+    const {flags, args} = await this.parse(Restore)
+    const {app, 'wait-interval': waitInterval, extensions, confirm, verbose} = flags
+    const interval = Math.max(3, waitInterval)
+    const {addon: db} = await getAttachment(this.heroku, app as string, args.database)
+    const {name, wait} = backupsFactory(app, this.heroku)
+    let backupURL
+    let backupName = args.backup
+
+    if (backupName && backupName.match(/^https?:\/\//)) {
+      backupURL = dropboxURL(backupName)
+    } else {
+      let backupApp
+      if (backupName && backupName.match(/::/)) {
+        [backupApp, backupName] = backupName.split('::')
+      } else {
+        backupApp = app
+      }
+
+      const {body: transfers} = await this.heroku.get<BackupTransfer[]>(`/client/v11/apps/${backupApp}/transfers`, {hostname: host()})
+      const backups = transfers.filter(t => t.from_type === 'pg_dump' && t.to_type === 'gof3r')
+
+      let backup
+      if (backupName) {
+        backup = backups.find(b => name(b) === backupName)
+        if (!backup)
+          throw new Error(`Backup ${color.cyan(backupName)} not found for ${color.app(backupApp)}`)
+        if (!backup.succeeded)
+          throw new Error(`Backup ${color.cyan(backupName)} for ${color.app(backupApp)} did not complete successfully`)
+      } else {
+        backup = backups.filter(b => b.succeeded).sort((a, b) => {
+          if (a.finished_at < b.finished_at) {
+            return -1
+          }
+
+          if (a.finished_at > b.finished_at) {
+            return 1
+          }
+
+          return 0
+        }).pop()
+        if (!backup) {
+          throw new Error(`No backups for ${color.app(backupApp)}. Capture one with ${color.cyan.bold('heroku pg:backups:capture')}`)
+        }
+
+        backupName = name(backup)
+      }
+
+      backupURL = backup.to_url
+    }
+
+    await confirmCommand(app, confirm)
+    ux.action.start(`Starting restore of ${color.cyan(backupName)} to ${color.yellow(db.name)}`)
+    ux.log(heredoc(`
+
+    Use Ctrl-C at any time to stop monitoring progress; the backup will continue restoring.
+    Use ${color.cyan.bold('heroku pg:backups')} to check progress.
+    Stop a running restore with ${color.cyan.bold('heroku pg:backups:cancel')}.
+    `))
+
+    const {body: restore} = await this.heroku.post<{uuid: string}>(`/client/v11/databases/${db.id}/restores`, {
+      body: {backup_url: backupURL, extensions: this.getSortedExtensions(extensions as string)}, hostname: host(),
+    })
+
+    ux.action.stop()
+    await wait('Restoring', restore.uuid, interval, verbose, db.app.id as string)
+  }
+
+  protected getSortedExtensions(extensions: string | null | undefined): string[] | undefined {
+    return extensions?.split(',').map(ext => ext.trim().toLowerCase()).sort()
+  }
+}
+*/

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

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

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

@@ -0,0 +1,107 @@
+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 {getAttachment} from '../../../lib/pg/fetcher'
+import {PgDatabase} from '../../../lib/pg/types'
+import {HTTPError} from '@heroku/http-call'
+import {nls} from '../../../nls'
+
+type Timezone = {
+  PST: string
+  PDT: string
+  MST: string
+  MDT: string
+  CST: string
+  CDT: string
+  EST: string
+  EDT: string
+  Z: string
+  GMT: string
+  BST: string
+  CET: string
+  CEST: string
+}
+
+const TZ: Timezone = {
+  PST: 'America/Los_Angeles',
+  PDT: 'America/Los_Angeles',
+  MST: 'America/Boise',
+  MDT: 'America/Boise',
+  CST: 'America/Chicago',
+  CDT: 'America/Chicago',
+  EST: 'America/New_York',
+  EDT: 'America/New_York',
+  Z: 'UTC',
+  GMT: 'Europe/London',
+  BST: 'Europe/London',
+  CET: 'Europe/Paris',
+  CEST: 'Europe/Paris',
+}
+
+type BackupSchedule = {
+  hour: string
+  timezone: string
+  schedule_name?: string
+}
+
+export default class Schedule extends Command {
+  static topic = 'pg'
+  static description = 'schedule daily backups for given database'
+  static flags = {
+    at: flags.string({required: true, description: "at a specific (24h) hour in the given timezone. Defaults to UTC. --at '[HOUR]:00 [TIMEZONE]'"}),
+    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')}`}),
+  }
+
+  parseDate = function (at: string): BackupSchedule {
+    const m = at.match(/^(0?\d|1\d|2[0-3]):00 ?(\S*)$/)
+
+    if (m) {
+      const [, hour, timezone] = m
+      return {hour, timezone: TZ[timezone.toUpperCase() as keyof Timezone] || timezone || 'UTC'}
+    }
+
+    return ux.error("Invalid schedule format: expected --at '[HOUR]:00 [TIMEZONE]'", {exit: 1})
+  }
+
+  public async run(): Promise<void> {
+    const {flags, args} = await this.parse(Schedule)
+    const {app} = flags
+    const {database} = args
+
+    const schedule = this.parseDate(flags.at)
+    const attachment = await getAttachment(this.heroku, app, database)
+    const db = attachment.addon
+    const at = color.cyan(`${schedule.hour}:00 ${schedule.timezone}`)
+
+    const pgResponse = await this.heroku.get<PgDatabase>(`/client/v11/databases/${db.id}`, {hostname: pgHost()})
+      .catch((error: HTTPError) => {
+        if (error.statusCode !== 404)
+          throw error
+        ux.error(`${color.yellow(db.name)} is not yet provisioned.\nRun ${color.cyan.bold('heroku addons:wait')} to wait until the db is provisioned.`, {exit: 1})
+      })
+    const {body: dbInfo} = pgResponse || {body: null}
+    if (dbInfo) {
+      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.')
+      }
+    }
+
+    ux.action.start(`Scheduling automatic daily backups of ${color.yellow(db.name)} at ${at}`)
+    schedule.schedule_name = attachment.name + '_URL'
+    await this.heroku.post(`/client/v11/databases/${db.id}/transfer-schedules`, {
+      body: schedule, hostname: pgHost(),
+    })
+    ux.action.stop()
+  }
+}
+*/

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

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

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

@@ -0,0 +1,34 @@
+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 pgHost from '../../../lib/pg/host'
+import {arbitraryAppDB} from '../../../lib/pg/fetcher'
+import type {TransferSchedule} from '../../../lib/pg/types'
+
+export default class Schedules extends Command {
+  static topic = 'pg';
+  static description = 'list backup schedule';
+  static flags = {
+    app: flags.app({required: true}),
+    remote: flags.remote(),
+  };
+
+  public async run(): Promise<void> {
+    const {flags} = await this.parse(Schedules)
+    const {app} = flags
+    const db = await arbitraryAppDB(this.heroku, app)
+    const {body: schedules} = await this.heroku.get<TransferSchedule[]>(`/client/v11/databases/${db.id}/transfer-schedules`, {hostname: pgHost()})
+    if (schedules.length === 0) {
+      ux.warn(`No backup schedules found on ${color.app(app)}\nUse ${color.cyan.bold('heroku pg:backups:schedule')} to set one up`)
+    } else {
+      hux.styledHeader('Backup Schedules')
+      for (const s of schedules) {
+        ux.log(`${color.green(s.name)}: daily at ${s.hour}:00 ${s.timezone}`)
+      }
+    }
+  }
+}
+*/

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

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

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

@@ -0,0 +1,60 @@
+export {};
+/*
+import color from '@heroku-cli/color'
+import {Command, flags} from '@heroku-cli/command'
+import {Args, ux} from '@oclif/core'
+import {arbitraryAppDB, getAddon} from '../../../lib/pg/fetcher'
+import {TransferSchedule} from '../../../lib/pg/types'
+import pgHost from '../../../lib/pg/host'
+import {nls} from '../../../nls'
+
+export default class Unschedule extends Command {
+  static topic = 'pg';
+  static description = 'stop daily backups';
+  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:arbitrary:suffix')}`}),
+  };
+
+  public async run(): Promise<void> {
+    const {flags, args} = await this.parse(Unschedule)
+    const {app} = flags
+    const {database} = args
+    let db = database
+    if (!db) {
+      const appDB = await arbitraryAppDB(this.heroku, app)
+      const {body: schedules} = await this.heroku.get<TransferSchedule[]>(
+        `/client/v11/databases/${appDB.id}/transfer-schedules`,
+        {hostname: pgHost()},
+      )
+      if (schedules.length === 0)
+        throw new Error(`No schedules on ${color.app(app)}`)
+      if (schedules.length > 1) {
+        throw new Error(`Specify schedule on ${color.app(app)}. Existing schedules: ${schedules.map(s => color.green(s.name))
+          .join(', ')}`)
+      }
+
+      db = schedules[0].name
+    }
+
+    ux.action.start(`Unscheduling ${color.green(db)} daily backups`)
+    const addon = await getAddon(this.heroku, app, db)
+    const {body: schedules} = await this.heroku.get<TransferSchedule[]>(
+      `/client/v11/databases/${addon.id}/transfer-schedules`,
+      {hostname: pgHost()},
+    )
+    const schedule = schedules.find(s => s.name.match(new RegExp(`${db}`, 'i')))
+    if (!schedule)
+      throw new Error(`No daily backups found for ${color.yellow(addon.name)}`)
+    await this.heroku.delete(
+      `/client/v11/databases/${addon.id}/transfer-schedules/${schedule.uuid}`,
+      {hostname: pgHost()},
+    )
+    ux.action.stop()
+  }
+}
+*/

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

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