heroku 10.13.2 → 11.0.0-alpha.2

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

@@ -0,0 +1,41 @@
+export {};
+/*
+import {Command, flags} from '@heroku-cli/command'
+import {Args, ux} from '@oclif/core'
+import {hux} from '@heroku/heroku-cli-util'
+import {SettingKey, SettingsResponse} from '../../../lib/pg/types'
+import {addonResolver} from '../../../lib/addons/resolve'
+import {essentialPlan} from '../../../lib/pg/util'
+import host from '../../../lib/pg/host'
+import {nls} from '../../../nls'
+
+export default class Index extends Command {
+  static topic = 'pg'
+  static description = 'show your current database settings'
+  static flags = {
+    app: flags.app({required: true}),
+    remote: flags.remote(),
+  }
+
+  static args = {
+    database: Args.string({description: `${nls('pg:database:arg:description')} ${nls('pg:database:arg:description:default:suffix')}`}),
+  }
+
+  public async run(): Promise<void> {
+    const {flags, args} = await this.parse(Index)
+    const {app} = flags
+    const {database} = args
+    const db = await addonResolver(this.heroku, app, database || 'DATABASE_URL')
+
+    if (essentialPlan(db)) ux.error('You can’t perform this operation on Essential-tier databases.')
+
+    const {body: settings} = await this.heroku.get<SettingsResponse>(`/postgres/v0/databases/${db.id}/config`, {hostname: host()})
+    hux.styledHeader(db.name)
+    const remapped: Record<string, unknown> = {}
+    Object.keys(settings).forEach(k => {
+      remapped[k.replace(/_/g, '-')] = settings[k as SettingKey].value
+    })
+    hux.styledObject(remapped)
+  }
+}
+*/

package/lib/oldCommands/pg/settings/log-connections.d.ts

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

package/lib/oldCommands/pg/settings/log-connections.js

@@ -0,0 +1,40 @@
+export {};
+/*
+import {flags} from '@heroku-cli/command'
+import {Args} from '@oclif/core'
+import heredoc from 'tsheredoc'
+import {type BooleanAsString, booleanConverter, PGSettingsCommand} from '../../../lib/pg/setter'
+import type {Setting, SettingKey} from '../../../lib/pg/types'
+import {nls} from '../../../nls'
+
+export default class LogConnections extends PGSettingsCommand {
+  static topic = 'pg'
+  static description = heredoc(`
+  Controls whether a log message is produced when a login attempt is made. Default is true.
+  Setting log_connections to false stops emitting log messages for all attempts to login to 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')}`}),
+    value: Args.string({description: 'boolean indicating if database login attempts get logged'}),
+  }
+
+  protected settingKey: SettingKey = 'log_connections'
+
+  protected convertValue(val: unknown): unknown {
+    return booleanConverter(val as BooleanAsString)
+  }
+
+  protected explain(setting: Setting<unknown>): string {
+    if (setting.value) {
+      return 'When login attempts are made, a log message will be emitted in your application\'s logs.'
+    }
+
+    return 'When login attempts are made, no log message will be emitted in your application\'s logs.'
+  }
+}
+*/

package/lib/oldCommands/pg/settings/log-lock-waits.d.ts

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

package/lib/oldCommands/pg/settings/log-lock-waits.js

@@ -0,0 +1,36 @@
+export {};
+/*
+import {Args} from '@oclif/core'
+import heredoc from 'tsheredoc'
+import {type BooleanAsString, booleanConverter, PGSettingsCommand} from '../../../lib/pg/setter'
+import type {Setting, SettingKey} from '../../../lib/pg/types'
+import {nls} from '../../../nls'
+
+export default class LogLockWaits extends PGSettingsCommand {
+  static topic = 'pg'
+  static description = heredoc(`
+    Controls whether a log message is produced when a session waits longer than the deadlock_timeout to acquire a lock. deadlock_timeout is set to 1 second
+    Delays due to lock contention occur when multiple transactions are trying to access the same resource at the same time.
+    Applications and their query patterns should try to avoid changes to many different tables within the same transaction.
+  `)
+
+  static args = {
+    database: Args.string({description: `${nls('pg:database:arg:description')} ${nls('pg:database:arg:description:default:suffix')}`}),
+    value: Args.string({description: 'boolean indicating if a message gets logged when a session waits longer than the deadlock_timeout to acquire a lock'}),
+  }
+
+  protected settingKey: SettingKey = 'log_lock_waits'
+
+  protected convertValue(val: unknown): boolean {
+    return booleanConverter(val as BooleanAsString)
+  }
+
+  protected explain(setting: Setting<unknown>) {
+    if (setting.value) {
+      return "When a deadlock is detected, a log message will be emitted in your application's logs."
+    }
+
+    return "When a deadlock is detected, no log message will be emitted in your application's logs."
+  }
+}
+*/

package/lib/oldCommands/pg/settings/log-min-duration-statement.d.ts

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

package/lib/oldCommands/pg/settings/log-min-duration-statement.js

@@ -0,0 +1,39 @@
+export {};
+/*
+import {Args} from '@oclif/core'
+import heredoc from 'tsheredoc'
+import {PGSettingsCommand} from '../../../lib/pg/setter'
+import type {Setting, SettingKey} from '../../../lib/pg/types'
+import {nls} from '../../../nls'
+
+export default class LogMinDurationStatement extends PGSettingsCommand {
+  static description = heredoc(`
+    The duration of each completed statement will be logged if the statement completes after the time specified by VALUE.
+    VALUE needs to specified as a whole number, in milliseconds.
+    Setting log_min_duration_statement to zero prints all statement durations and -1 will disable logging statement durations.
+  `)
+
+  static args = {
+    database: Args.string({description: `${nls('pg:database:arg:description')} ${nls('pg:database:arg:description:default:suffix')}`}),
+    value: Args.string({description: 'milliseconds to wait for a statement to complete before logging it'}),
+  }
+
+  protected settingKey:SettingKey = 'log_min_duration_statement'
+
+  protected convertValue(val: unknown): number {
+    return Number.parseInt(val as string, 10)
+  }
+
+  protected explain(setting: Setting<unknown>) {
+    if (setting.value === -1) {
+      return 'The duration of each completed statement will not be logged.'
+    }
+
+    if (setting.value === 0) {
+      return 'The duration of each completed statement will be logged.'
+    }
+
+    return `The duration of each completed statement will be logged if the statement ran for at least ${setting.value} milliseconds.`
+  }
+}
+*/

package/lib/oldCommands/pg/settings/log-min-error-statement.d.ts

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

package/lib/oldCommands/pg/settings/log-min-error-statement.js

@@ -0,0 +1,31 @@
+export {};
+/*
+import {Args} from '@oclif/core'
+import heredoc from 'tsheredoc'
+import {PGSettingsCommand} from '../../../lib/pg/setter'
+import type {Setting, SettingKey} from '../../../lib/pg/types'
+import {nls} from '../../../nls'
+
+export default class LogMinErrorStatement extends PGSettingsCommand {
+  static description = heredoc(`
+    log-min-error-statement controls the logging of SQL statements that cause an error at a specified severity level.
+    This setting is useful to prevent logging SQL queries that might contain sensitive information.
+    Use this setting to prevent logging SQL queries that contain sensitive information. Default is "error".
+  `)
+
+  static args = {
+    database: Args.string({description: `${nls('pg:database:arg:description')} ${nls('pg:database:arg:description:default:suffix')}`}),
+    value: Args.string({options: ['error', 'log', 'fatal', 'panic']}),
+  }
+
+  protected settingKey: SettingKey = 'log_min_error_statement'
+
+  protected convertValue(val: string): string {
+    return val
+  }
+
+  protected explain(setting: Setting<string>) {
+    return setting.values[setting.value]
+  }
+}
+*/

package/lib/oldCommands/pg/settings/log-statement.d.ts

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

package/lib/oldCommands/pg/settings/log-statement.js

@@ -0,0 +1,33 @@
+export {};
+/*
+import {Args} from '@oclif/core'
+import heredoc from 'tsheredoc'
+import {type Setting, type SettingKey} from '../../../lib/pg/types'
+import {PGSettingsCommand} from '../../../lib/pg/setter'
+import {nls} from '../../../nls'
+export default class LogStatement extends PGSettingsCommand {
+  static description = heredoc(`
+    log_statement controls which SQL statements are logged.
+    Valid values for VALUE:
+    none - No statements are logged
+    ddl  - All data definition statements, such as CREATE, ALTER and DROP will be logged
+    mod  - Includes all statements from ddl as well as data-modifying statements such as INSERT, UPDATE, DELETE, TRUNCATE, COPY
+    all  - All statements are logged
+  `)
+
+  static args = {
+    database: Args.string({description: `${nls('pg:database:arg:description')} ${nls('pg:database:arg:description:default:suffix')}`}),
+    value: Args.string({options: ['none', 'ddl', 'mod', 'all'], description: 'type of SQL statements to log\n<options: none|ddl|mod|all>'}),
+  }
+
+  protected settingKey: SettingKey = 'log_statement'
+
+  protected convertValue(val: string): string {
+    return val
+  }
+
+  protected explain(setting: Setting<string>) {
+    return setting.values[setting.value]
+  }
+}
+*/

package/lib/oldCommands/pg/settings/track-functions.d.ts

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

package/lib/oldCommands/pg/settings/track-functions.js

@@ -0,0 +1,33 @@
+export {};
+/*
+import {Args} from '@oclif/core'
+import heredoc from 'tsheredoc'
+import {PGSettingsCommand} from '../../../lib/pg/setter'
+import type {Setting, SettingKey} from '../../../lib/pg/types'
+import {nls} from '../../../nls'
+
+// ref: https://www.postgresql.org/docs/current/runtime-config-statistics.html#GUC-TRACK-FUNCTIONS
+export default class TrackFunctions extends PGSettingsCommand {
+  static description = heredoc(`
+    track_functions controls tracking of function call counts and time used. Default is none.
+    Valid values for VALUE:
+    none - No functions are tracked (default)
+    pl   - Only procedural language functions are tracked
+    all  - All functions, including SQL and C language functions, are tracked. Simple SQL-language that are inlined are not tracked`)
+
+  static args = {
+    database: Args.string({description: `${nls('pg:database:arg:description')} ${nls('pg:database:arg:description:default:suffix')}`}),
+    value: Args.string({options: ['none', 'pl', 'all'], description: 'function type to track\n<options: none|pl|all>'}),
+  }
+
+  protected settingKey: SettingKey = 'track_functions'
+
+  protected convertValue(val: unknown): unknown {
+    return val
+  }
+
+  protected explain(setting: Setting<keyof Setting<unknown>['value']>): string {
+    return setting.values[setting.value]
+  }
+}
+*/

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

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

package/lib/oldCommands/pg/unfollow.js

@@ -0,0 +1,46 @@
+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 {getAddon} from '../../lib/pg/fetcher'
+import pgHost from '../../lib/pg/host'
+import {databaseNameFromUrl} from '../../lib/pg/util'
+import confirmCommand from '../../lib/confirmCommand'
+import {PgDatabase} from '../../lib/pg/types'
+import heredoc from 'tsheredoc'
+import {nls} from '../../nls'
+
+export default class Unfollow extends Command {
+  static topic = 'pg';
+  static description = 'stop a replica from following and make it a writeable database';
+  static flags = {
+    confirm: flags.string({char: 'c'}),
+    app: flags.app({required: true}),
+    remote: flags.remote(),
+  }
+
+  static args = {
+    database: Args.string({required: true, description: nls('pg:database:arg:description')}),
+  }
+
+  public async run(): Promise<void> {
+    const {flags, args} = await this.parse(Unfollow)
+    const {app, confirm} = flags
+    const db = await getAddon(this.heroku, app, args.database)
+    const {body: replica} = await this.heroku.get<PgDatabase>(`/client/v11/databases/${db.id}`, {hostname: pgHost()})
+    if (!replica.following)
+      ux.error(`${color.addon(db.name)} is not a follower`)
+    const {body: configVars} = await this.heroku.get<Heroku.ConfigVars>(`/apps/${app}/config-vars`)
+    const origin = databaseNameFromUrl(replica.following as string, configVars)
+    await confirmCommand(app, confirm, heredoc(`
+      Destructive action
+      ${color.addon(db.name)} will become writeable and no longer follow ${origin}. This cannot be undone.
+    `))
+    ux.action.start(`${color.addon(db.name)} unfollowing`)
+    await this.heroku.put(`/client/v11/databases/${db.id}/unfollow`, {hostname: pgHost()})
+    ux.action.stop()
+  }
+}
+*/

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

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

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

@@ -0,0 +1,62 @@
+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 {getAddon} from '../../../lib/pg/fetcher'
+import pgHost from '../../../lib/pg/host'
+import {legacyEssentialPlan, essentialNumPlan, formatResponseWithCommands} from '../../../lib/pg/util'
+import {PgDatabase, PgUpgradeError, PgUpgradeResponse} from '../../../lib/pg/types'
+import confirmCommand from '../../../lib/confirmCommand'
+import {nls} from '../../../nls'
+
+export default class Upgrade extends Command {
+  static topic = 'pg';
+  static description = heredoc(`
+    cancels a scheduled upgrade. You can't cancel a version upgrade that's in progress.
+  `)
+
+  static flags = {
+    confirm: flags.string({char: 'c'}),
+    app: flags.app({required: true}),
+  }
+
+  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(Upgrade)
+    const {app, confirm} = flags
+    const {database} = args
+
+    const db = await getAddon(this.heroku, app, database)
+    if (legacyEssentialPlan(db))
+      ux.error(`You can only use ${color.cmd('pg:upgrade:*')} commands on Essential-* and higher plans.`)
+
+    if (essentialNumPlan(db))
+      ux.error(`You can't use ${color.cmd('pg:upgrade:cancel')} on Essential-tier databases. You can only use this command on Standard-tier and higher leader databases.`)
+
+    const {body: replica} = await this.heroku.get<PgDatabase>(`/client/v11/databases/${db.id}`, {hostname: pgHost()})
+    if (replica.following)
+      ux.error(`You can't use ${color.cmd('pg:upgrade:cancel')} on follower databases. You can only use this command on Standard-tier and higher leader databases.`)
+
+    await confirmCommand(app, confirm, heredoc(`
+      Destructive action
+      You're canceling the scheduled version upgrade for ${color.addon(db.name)}.
+
+      You can't undo this action.
+    `))
+
+    try {
+      ux.action.start(`Cancelling upgrade on ${color.addon(db.name)}`)
+      const response = await this.heroku.post<PgUpgradeResponse>(`/client/v11/databases/${db.id}/upgrade/cancel`, {hostname: pgHost(), body: {}})
+      ux.action.stop('done\n' + formatResponseWithCommands(response.body.message))
+    } catch (error) {
+      const response = error as PgUpgradeError
+      ux.error(formatResponseWithCommands(response.body.message) + `\n\nError ID: ${response.body.id}`)
+    }
+  }
+}
+*/

package/lib/oldCommands/pg/upgrade/dryrun.d.ts

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

package/lib/oldCommands/pg/upgrade/dryrun.js

@@ -0,0 +1,62 @@
+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 {getAddon} from '../../../lib/pg/fetcher'
+import pgHost from '../../../lib/pg/host'
+import {legacyEssentialPlan, essentialNumPlan, formatResponseWithCommands} from '../../../lib/pg/util'
+import {PgDatabase, PgUpgradeError, PgUpgradeResponse} from '../../../lib/pg/types'
+import confirmCommand from '../../../lib/confirmCommand'
+import {nls} from '../../../nls'
+
+export default class Upgrade extends Command {
+  static topic = 'pg';
+  static description = heredoc(`
+    simulates a Postgres version upgrade on a Standard-tier and higher leader database by creating and upgrading a follower database. Heroku sends the results of the test upgrade via email.
+  `)
+
+  static flags = {
+    confirm: flags.string({char: 'c'}),
+    version: flags.string({char: 'v', description: 'Postgres version to upgrade to'}),
+    app: flags.app({required: true}),
+  }
+
+  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(Upgrade)
+    const {app, version, confirm} = flags
+    const {database} = args
+
+    const db = await getAddon(this.heroku, app, database)
+    if (legacyEssentialPlan(db))
+      ux.error(`You can only use ${color.cmd('pg:upgrade:*')} commands on Essential-* and higher plans.`)
+
+    if (essentialNumPlan(db))
+      ux.error(`You can't use ${color.cmd('pg:upgrade:dryrun')} on Essential-tier databases. You can only use this command on Standard-tier and higher leader databases.`)
+
+    const versionPhrase = version ? heredoc(`Postgres version ${version}`) : heredoc('the latest supported Postgres version')
+    const {body: replica} = await this.heroku.get<PgDatabase>(`/client/v11/databases/${db.id}`, {hostname: pgHost()})
+    if (replica.following)
+      ux.error(`You can't use ${color.cmd('pg:upgrade:dryrun')} on follower databases. You can only use this command on Standard-tier and higher leader databases.`)
+
+    await confirmCommand(app, confirm, heredoc(`
+        This command starts a test upgrade for ${color.addon(db.name)} to ${versionPhrase}.
+    `))
+
+    try {
+      const data = {version}
+      ux.action.start(`Starting a test upgrade on ${color.addon(db.name)}`)
+      const response = await this.heroku.post<PgUpgradeResponse>(`/client/v11/databases/${db.id}/upgrade/dry_run`, {hostname: pgHost(), body: data})
+      ux.action.stop('done\n' + formatResponseWithCommands(response.body.message))
+    } catch (error) {
+      const response = error as PgUpgradeError
+      ux.error(formatResponseWithCommands(response.body.message) + `\n\nError ID: ${response.body.id}`)
+    }
+  }
+}
+*/

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

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

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

@@ -0,0 +1,85 @@
+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 {getAddon} from '../../../lib/pg/fetcher'
+import pgHost from '../../../lib/pg/host'
+import {legacyEssentialPlan, databaseNameFromUrl, essentialNumPlan, formatResponseWithCommands} from '../../../lib/pg/util'
+import {PgDatabase, PgUpgradeError, PgUpgradeResponse} from '../../../lib/pg/types'
+import * as Heroku from '@heroku-cli/schema'
+import confirmCommand from '../../../lib/confirmCommand'
+import {nls} from '../../../nls'
+
+export default class Upgrade extends Command {
+  static topic = 'pg';
+  static description = heredoc(`
+    We're deprecating this command. To upgrade your database's Postgres version, use the new ${color.cmd('pg:upgrade:*')} subcommands. See https://devcenter.heroku.com/changelog-items/3179.
+
+    For an Essential-tier plan, this command upgrades the database's Postgres version. For a Standard-tier and higher plan, this command unfollows the leader database before upgrading the Postgres version.
+    `)
+
+  static flags = {
+    confirm: flags.string({char: 'c'}),
+    version: flags.string({char: 'v', description: 'Postgres version to upgrade to'}),
+    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(Upgrade)
+    const {app, version, confirm} = flags
+    const {database} = args
+
+    const db = await getAddon(this.heroku, app, database)
+    if (legacyEssentialPlan(db))
+      ux.error(`You can only use ${color.cmd('heroku pg:upgrade')} on Essential-tier databases and follower databases on Standard-tier and higher plans.`)
+
+    const versionPhrase = version ? heredoc(`Postgres version ${version}`) : heredoc('the latest supported Postgres version')
+    const {body: replica} = await this.heroku.get<PgDatabase>(`/client/v11/databases/${db.id}`, {hostname: pgHost()})
+
+    if (replica.following) {
+      const {body: configVars} = await this.heroku.get<Heroku.ConfigVars>(`/apps/${app}/config-vars`)
+      const origin = databaseNameFromUrl(replica.following, configVars)
+
+      await confirmCommand(app, confirm, heredoc(`
+        We're deprecating this command. To upgrade your database's Postgres version, use the new ${color.cmd('pg:upgrade:*')} subcommands. See https://devcenter.heroku.com/changelog-items/3179.
+
+        Destructive action
+        You're upgrading ${color.addon(db.name)} to ${versionPhrase}. The database will stop following ${origin} and become writable.
+
+        You can't undo this action.
+      `))
+    } else if (essentialNumPlan(db)) {
+      await confirmCommand(app, confirm, heredoc(`
+        We're deprecating this command. To upgrade your database's Postgres version, use the new ${color.cmd('pg:upgrade:*')} subcommands. See https://devcenter.heroku.com/changelog-items/3179.
+
+        Destructive action
+        You're upgrading ${color.addon(db.name)} to ${versionPhrase}.
+
+        You can't undo this action.
+      `))
+    } else {
+      ux.warn(heredoc(`
+        We're deprecating this command. To upgrade your database's Postgres version, use the new ${color.cmd('pg:upgrade:*')} subcommands. See https://devcenter.heroku.com/changelog-items/3179.`,
+      ))
+      ux.error(`You can only use ${color.cmd('heroku pg:upgrade')} on Essential-tier databases and follower databases on Standard-tier and higher plans.`)
+    }
+
+    try {
+      const data = {version}
+      ux.action.start(`Starting upgrade on ${color.addon(db.name)}`)
+      const response = await this.heroku.post<PgUpgradeResponse>(`/client/v11/databases/${db.id}/upgrade`, {hostname: pgHost(), body: data})
+      ux.action.stop(heredoc(`done\n${formatResponseWithCommands(response.body.message)}`))
+    } catch (error) {
+      const response = error as PgUpgradeError
+      ux.error(heredoc(`${formatResponseWithCommands(response.body.message)}\n\nError ID: ${response.body.id}`))
+    }
+  }
+}
+*/

package/lib/oldCommands/pg/upgrade/prepare.d.ts

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

package/lib/oldCommands/pg/upgrade/prepare.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 heredoc from 'tsheredoc'
+import {getAddon} from '../../../lib/pg/fetcher'
+import pgHost from '../../../lib/pg/host'
+import {legacyEssentialPlan, essentialNumPlan, formatResponseWithCommands} from '../../../lib/pg/util'
+import {PgDatabase, PgUpgradeError, PgUpgradeResponse} from '../../../lib/pg/types'
+import confirmCommand from '../../../lib/confirmCommand'
+import {nls} from '../../../nls'
+
+export default class Upgrade extends Command {
+  static topic = 'pg';
+  static description = heredoc(`
+    prepares the upgrade for Standard-tier and higher leader databases and schedules it for the next available maintenance window. To start a version upgrade on Essential-tier and follower databases, use ${color.cmd('heroku pg:upgrade:run')} instead.
+  `)
+
+  static flags = {
+    confirm: flags.string({char: 'c'}),
+    version: flags.string({char: 'v', description: 'Postgres version to upgrade to'}),
+    app: flags.app({required: true}),
+  }
+
+  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(Upgrade)
+    const {app, version, confirm} = flags
+    const {database} = args
+
+    const db = await getAddon(this.heroku, app, database)
+    if (legacyEssentialPlan(db))
+      ux.error(`You can only use ${color.cmd('pg:upgrade:*')} commands on Essential-* and higher plans.`)
+
+    if (essentialNumPlan(db))
+      ux.error(`You can only use ${color.cmd('heroku pg:upgrade:prepare')} on Standard-tier and higher leader databases. For Essential-tier databases, use ${color.cmd('heroku pg:upgrade:run')} instead.`)
+
+    const versionPhrase = version ? heredoc(`Postgres version ${version}`) : heredoc('the latest supported Postgres version')
+    const {body: replica} = await this.heroku.get<PgDatabase>(`/client/v11/databases/${db.id}`, {hostname: pgHost()})
+
+    if (replica.following)
+      ux.error(`You can only use ${color.cmd('heroku pg:upgrade:prepare')} on Standard-tier and higher leader databases. For follower databases, use ${color.cmd('heroku pg:upgrade:run')} instead.`)
+
+    await confirmCommand(app, confirm, heredoc(`
+        Destructive action
+        This command prepares the upgrade for ${color.addon(db.name)} to ${versionPhrase} and schedules to upgrade it during the next available maintenance window.
+    `))
+
+    try {
+      const data = {version}
+      ux.action.start(`Preparing upgrade on ${color.addon(db.name)}`)
+      const response = await this.heroku.post<PgUpgradeResponse>(`/client/v11/databases/${db.id}/upgrade/prepare`, {hostname: pgHost(), body: data})
+      ux.action.stop(heredoc(`done\n${formatResponseWithCommands(response.body.message)}`))
+    } catch (error) {
+      const response = error as PgUpgradeError
+      ux.error(heredoc(`${formatResponseWithCommands(response.body.message)}\n\nError ID: ${response.body.id}`))
+    }
+  }
+}
+*/

package/lib/oldCommands/pg/upgrade/run.d.ts

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