heroku 11.0.0-alpha.11 → 11.0.0-alpha.12

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

@@ -1,150 +0,0 @@
-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

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

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

@@ -1,107 +0,0 @@
-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

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

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

@@ -1,34 +0,0 @@
-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

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

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

@@ -1,60 +0,0 @@
-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

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

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

@@ -1,46 +0,0 @@
-export {};
-/*
-import color from '@heroku-cli/color'
-import {Command, flags} from '@heroku-cli/command'
-import {Args, ux} from '@oclif/core'
-import host from '../../../lib/pg/host'
-import pgBackupsApi from '../../../lib/pg/backups'
-import {sortBy} from 'lodash'
-import type {BackupTransfer, PublicUrlResponse} from '../../../lib/pg/types'
-
-export default class Url extends Command {
-    static topic = 'pg';
-    static description = 'get secret but publicly accessible URL of a 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.'}),
-    };
-
-    public async run(): Promise<void> {
-      const {flags, args} = await this.parse(Url)
-      const {backup_id} = args
-      const {app} = flags
-
-      let num
-      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: host()})
-        const lastBackup = sortBy(transfers.filter(t => t.succeeded && t.to_type === 'gof3r'), 'created_at')
-          .pop()
-        if (!lastBackup)
-          throw new Error(`No backups on ${color.app(app)}. Capture one with ${color.cyan.bold('heroku pg:backups:capture')}`)
-        num = lastBackup.num
-      }
-
-      const {body: info} = await this.heroku.post<PublicUrlResponse>(`/client/v11/apps/${app}/transfers/${num}/actions/public-url`, {hostname: host()})
-      ux.log(info.url)
-    }
-}
-*/

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

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

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

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

package/lib/oldCommands/pg/blocking.js

@@ -1,48 +0,0 @@
-export {};
-/*
-import {Command, flags} from '@heroku-cli/command'
-import {Args, ux} from '@oclif/core'
-import heredoc from 'tsheredoc'
-import {database} from '../../lib/pg/fetcher'
-import {exec} from '../../lib/pg/psql'
-import {nls} from '../../nls'
-
-export default class Blocking extends Command {
-    static topic = 'pg'
-    static description = 'display queries holding locks other queries are waiting to be released'
-    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(Blocking)
-      const {app} = flags
-      const query = heredoc`
-        SELECT bl.pid AS blocked_pid,
-          ka.query AS blocking_statement,
-          now() - ka.query_start AS blocking_duration,
-          kl.pid AS blocking_pid,
-          a.query AS blocked_statement,
-          now() - a.query_start AS blocked_duration
-        FROM pg_catalog.pg_locks bl
-        JOIN pg_catalog.pg_stat_activity a
-          ON bl.pid = a.pid
-        JOIN pg_catalog.pg_locks kl
-          JOIN pg_catalog.pg_stat_activity ka
-            ON kl.pid = ka.pid
-        ON bl.transactionid = kl.transactionid AND bl.pid != kl.pid
-        WHERE NOT bl.granted
-      `
-
-      const db = await database(this.heroku, app, args.database)
-      const output = await exec(db, query)
-
-      ux.log(output)
-    }
-}
-*/

package/lib/oldCommands/pg/connection-pooling/attach.d.ts

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

package/lib/oldCommands/pg/connection-pooling/attach.js

@@ -1,53 +0,0 @@
-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 pghost from '../../../lib/pg/host'
-import heredoc from 'tsheredoc'
-import {essentialPlan} from '../../../lib/pg/util'
-import {getAddon} from '../../../lib/pg/fetcher'
-import {nls} from '../../../nls'
-
-export default class Attach extends Command {
-    static topic = 'pg'
-    static description = 'add an attachment to a database using connection pooling'
-    static examples = [heredoc`
-      $ heroku pg:connection-pooling:attach postgresql-something-12345
-    `]
-
-    static flags = {
-      as: flags.string({description: 'name for add-on attachment'}),
-      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(Attach)
-      const {app} = flags
-      const db = await getAddon(this.heroku, app, args.database)
-      const {body: addon} = await this.heroku.get<Required<Heroku.AddOn>>(`/addons/${encodeURIComponent(db.name)}`)
-
-      if (essentialPlan(db))
-        ux.error('You can’t perform this operation on Essential-tier databases.')
-
-      ux.action.start(`Enabling Connection Pooling on ${color.yellow(addon.name)} to ${color.magenta(app)}`)
-      const {body: attachment} = await this.heroku.post<Required<Heroku.AddOnAttachment>>(`/client/v11/databases/${encodeURIComponent(db.name)}/connection-pooling`, {
-        body: {name: flags.as, credential: 'default', app: app}, hostname: pghost(),
-      })
-      ux.action.stop()
-
-      ux.action.start(`Setting ${color.cyan(attachment.name)} config vars and restarting ${color.magenta(app)}`)
-      const {body: releases} = await this.heroku.get<Required<Heroku.Release>[]>(
-        `/apps/${app}/releases`,
-        {partial: true, headers: {Range: 'version ..; max=1, order=desc'}},
-      )
-      ux.action.stop(`done, v${releases[0].version}`)
-    }
-}
-*/

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

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

package/lib/oldCommands/pg/copy.js

@@ -1,104 +0,0 @@
-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

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