heroku 11.0.0-alpha.11 → 11.0.0-alpha.13

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

@@ -0,0 +1,13 @@
+import { PGSettingsCommand } from '../../../lib/pg/setter.js';
+import type { Setting, SettingKey } from '../../../lib/pg/types.js';
+export default class LogLockWaits extends PGSettingsCommand {
+    static topic: string;
+    static description: string;
+    static args: {
+        database: import("@oclif/core/interfaces").Arg<string | undefined, Record<string, unknown>>;
+        value: import("@oclif/core/interfaces").Arg<string | undefined, Record<string, unknown>>;
+    };
+    protected settingKey: SettingKey;
+    protected convertValue(val: unknown): boolean;
+    protected explain(setting: Setting<unknown>): "When a deadlock is detected, a log message will be emitted in your application's logs." | "When a deadlock is detected, no log message will be emitted in your application's logs.";
+}

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

@@ -0,0 +1,27 @@
+import { Args } from '@oclif/core';
+import tsheredoc from 'tsheredoc';
+import { booleanConverter, PGSettingsCommand } from '../../../lib/pg/setter.js';
+import { nls } from '../../../nls.js';
+const heredoc = tsheredoc.default;
+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' }),
+    };
+    settingKey = 'log_lock_waits';
+    convertValue(val) {
+        return booleanConverter(val);
+    }
+    explain(setting) {
+        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/commands/pg/settings/log-min-duration-statement.d.ts

@@ -0,0 +1,12 @@
+import { PGSettingsCommand } from '../../../lib/pg/setter.js';
+import type { Setting, SettingKey } from '../../../lib/pg/types.js';
+export default class LogMinDurationStatement extends PGSettingsCommand {
+    static description: string;
+    static args: {
+        database: import("@oclif/core/interfaces").Arg<string | undefined, Record<string, unknown>>;
+        value: import("@oclif/core/interfaces").Arg<string | undefined, Record<string, unknown>>;
+    };
+    protected settingKey: SettingKey;
+    protected convertValue(val: unknown): number;
+    protected explain(setting: Setting<unknown>): string;
+}

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

@@ -0,0 +1,29 @@
+import { Args } from '@oclif/core';
+import tsheredoc from 'tsheredoc';
+import { PGSettingsCommand } from '../../../lib/pg/setter.js';
+import { nls } from '../../../nls.js';
+const heredoc = tsheredoc.default;
+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' }),
+    };
+    settingKey = 'log_min_duration_statement';
+    convertValue(val) {
+        return Number.parseInt(val, 10);
+    }
+    explain(setting) {
+        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/commands/pg/settings/log-min-error-statement.d.ts

@@ -0,0 +1,12 @@
+import { PGSettingsCommand } from '../../../lib/pg/setter.js';
+import type { Setting, SettingKey } from '../../../lib/pg/types.js';
+export default class LogMinErrorStatement extends PGSettingsCommand {
+    static description: string;
+    static args: {
+        database: import("@oclif/core/interfaces").Arg<string | undefined, Record<string, unknown>>;
+        value: import("@oclif/core/interfaces").Arg<string | undefined, Record<string, unknown>>;
+    };
+    protected settingKey: SettingKey;
+    protected convertValue(val: string): string;
+    protected explain(setting: Setting<string>): string;
+}

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

@@ -0,0 +1,23 @@
+import { Args } from '@oclif/core';
+import tsheredoc from 'tsheredoc';
+import { PGSettingsCommand } from '../../../lib/pg/setter.js';
+import { nls } from '../../../nls.js';
+const heredoc = tsheredoc.default;
+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 statements 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'] }),
+    };
+    settingKey = 'log_min_error_statement';
+    convertValue(val) {
+        return val;
+    }
+    explain(setting) {
+        return setting.values[setting.value];
+    }
+}

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

@@ -0,0 +1,12 @@
+import { PGSettingsCommand } from '../../../lib/pg/setter.js';
+import type { Setting, SettingKey } from '../../../lib/pg/types.js';
+export default class LogStatement extends PGSettingsCommand {
+    static description: string;
+    static args: {
+        database: import("@oclif/core/interfaces").Arg<string | undefined, Record<string, unknown>>;
+        value: import("@oclif/core/interfaces").Arg<string | undefined, Record<string, unknown>>;
+    };
+    protected settingKey: SettingKey;
+    protected convertValue(val: string): string;
+    protected explain(setting: Setting<string>): string;
+}

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

@@ -0,0 +1,26 @@
+import { Args } from '@oclif/core';
+import tsheredoc from 'tsheredoc';
+import { PGSettingsCommand } from '../../../lib/pg/setter.js';
+import { nls } from '../../../nls.js';
+const heredoc = tsheredoc.default;
+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>' }),
+    };
+    settingKey = 'log_statement';
+    convertValue(val) {
+        return val;
+    }
+    explain(setting) {
+        return setting.values[setting.value];
+    }
+}

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

@@ -0,0 +1,12 @@
+import { PGSettingsCommand } from '../../../lib/pg/setter.js';
+import type { Setting, SettingKey } from '../../../lib/pg/types.js';
+export default class TrackFunctions extends PGSettingsCommand {
+    static description: string;
+    static args: {
+        database: import("@oclif/core/interfaces").Arg<string | undefined, Record<string, unknown>>;
+        value: import("@oclif/core/interfaces").Arg<string | undefined, Record<string, unknown>>;
+    };
+    protected settingKey: SettingKey;
+    protected convertValue(val: unknown): unknown;
+    protected explain(setting: Setting<keyof Setting<unknown>['value']>): string;
+}

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

@@ -0,0 +1,25 @@
+import { Args } from '@oclif/core';
+import tsheredoc from 'tsheredoc';
+import { PGSettingsCommand } from '../../../lib/pg/setter.js';
+import { nls } from '../../../nls.js';
+const heredoc = tsheredoc.default;
+// 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>' }),
+    };
+    settingKey = 'track_functions';
+    convertValue(val) {
+        return val;
+    }
+    explain(setting) {
+        return setting.values[setting.value];
+    }
+}

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

@@ -0,0 +1,14 @@
+import { Command } from '@heroku-cli/command';
+export default class Unfollow extends Command {
+    static topic: string;
+    static description: string;
+    static flags: {
+        confirm: import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
+        app: import("@oclif/core/interfaces").OptionFlag<string, import("@oclif/core/interfaces").CustomOptions>;
+        remote: import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
+    };
+    static args: {
+        database: import("@oclif/core/interfaces").Arg<string, Record<string, unknown>>;
+    };
+    run(): Promise<void>;
+}

package/lib/commands/pg/unfollow.js

@@ -0,0 +1,38 @@
+import { Command, flags } from '@heroku-cli/command';
+import { Args, ux } from '@oclif/core';
+import { utils, color } from '@heroku/heroku-cli-util';
+import { databaseNameFromUrl } from '../../lib/pg/util.js';
+import ConfirmCommand from '../../lib/confirmCommand.js';
+import tsheredoc from 'tsheredoc';
+import { nls } from '../../nls.js';
+const heredoc = tsheredoc.default;
+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') }),
+    };
+    async run() {
+        const { flags, args } = await this.parse(Unfollow);
+        const { app, confirm } = flags;
+        const dbResolver = new utils.pg.DatabaseResolver(this.heroku);
+        const { addon: db } = await dbResolver.getAttachment(app, args.database);
+        const { body: replica } = await this.heroku.get(`/client/v11/databases/${db.id}`, { hostname: utils.pg.host() });
+        if (!replica.following)
+            ux.error(`${color.addon(db.name)} is not a follower`);
+        const { body: configVars } = await this.heroku.get(`/apps/${app}/config-vars`);
+        const origin = databaseNameFromUrl(replica.following, configVars);
+        await new ConfirmCommand().confirm(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: utils.pg.host() });
+        ux.action.stop();
+    }
+}

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

@@ -0,0 +1,13 @@
+import { Command } from '@heroku-cli/command';
+export default class Upgrade extends Command {
+    static args: {
+        database: import("@oclif/core/interfaces").Arg<string | undefined, Record<string, unknown>>;
+    };
+    static description: string;
+    static flags: {
+        app: import("@oclif/core/interfaces").OptionFlag<string, import("@oclif/core/interfaces").CustomOptions>;
+        confirm: import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
+    };
+    static topic: string;
+    run(): Promise<void>;
+}

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

@@ -0,0 +1,50 @@
+import { color, utils } from '@heroku/heroku-cli-util';
+import { Command, flags } from '@heroku-cli/command';
+import { Args, ux } from '@oclif/core';
+import tsheredoc from 'tsheredoc';
+import ConfirmCommand from '../../../lib/confirmCommand.js';
+import { formatResponseWithCommands } from '../../../lib/pg/util.js';
+import { nls } from '../../../nls.js';
+const heredoc = tsheredoc.default;
+export default class Upgrade extends Command {
+    static args = {
+        database: Args.string({ description: `${nls('pg:database:arg:description')} ${nls('pg:database:arg:description:default:suffix')}` }),
+    };
+    static description = heredoc(`
+    cancels a scheduled upgrade. You can't cancel a version upgrade that's in progress.
+  `);
+    static flags = {
+        app: flags.app({ required: true }),
+        confirm: flags.string({ char: 'c' }),
+    };
+    static topic = 'pg';
+    async run() {
+        const { args, flags } = await this.parse(Upgrade);
+        const { app, confirm } = flags;
+        const { database } = args;
+        const dbResolver = new utils.pg.DatabaseResolver(this.heroku);
+        const { addon: db } = await dbResolver.getAttachment(app, database);
+        if (utils.pg.isLegacyEssentialDatabase(db))
+            ux.error(`You can only use ${color.code('pg:upgrade:*')} commands on Essential-* and higher plans.`);
+        if (utils.pg.isEssentialDatabase(db))
+            ux.error(`You can't use ${color.code('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(`/client/v11/databases/${db.id}`, { hostname: utils.pg.host() });
+        if (replica.following)
+            ux.error(`You can't use ${color.code('pg:upgrade:cancel')} on follower databases. You can only use this command on Standard-tier and higher leader databases.`);
+        await new ConfirmCommand().confirm(app, confirm, heredoc(`
+      Destructive action
+      You're canceling the scheduled version upgrade for ${color.datastore(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(`/client/v11/databases/${db.id}/upgrade/cancel`, { body: {}, hostname: utils.pg.host() });
+            ux.action.stop('done\n' + formatResponseWithCommands(response.body.message));
+        }
+        catch (error) {
+            const response = error;
+            ux.error(formatResponseWithCommands(response.body.message) + `\n\nError ID: ${response.body.id}`);
+        }
+    }
+}

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

@@ -0,0 +1,14 @@
+import { Command } from '@heroku-cli/command';
+export default class Upgrade extends Command {
+    static args: {
+        database: import("@oclif/core/interfaces").Arg<string | undefined, Record<string, unknown>>;
+    };
+    static description: string;
+    static flags: {
+        app: import("@oclif/core/interfaces").OptionFlag<string, import("@oclif/core/interfaces").CustomOptions>;
+        confirm: import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
+        version: import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
+    };
+    static topic: string;
+    run(): Promise<void>;
+}

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

@@ -0,0 +1,50 @@
+import { color, utils } from '@heroku/heroku-cli-util';
+import { Command, flags } from '@heroku-cli/command';
+import { Args, ux } from '@oclif/core';
+import tsheredoc from 'tsheredoc';
+import ConfirmCommand from '../../../lib/confirmCommand.js';
+import { formatResponseWithCommands } from '../../../lib/pg/util.js';
+import { nls } from '../../../nls.js';
+const heredoc = tsheredoc.default;
+export default class Upgrade extends Command {
+    static args = {
+        database: Args.string({ description: `${nls('pg:database:arg:description')} ${nls('pg:database:arg:description:default:suffix')}` }),
+    };
+    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 = {
+        app: flags.app({ required: true }),
+        confirm: flags.string({ char: 'c' }),
+        version: flags.string({ char: 'v', description: 'Postgres version to upgrade to' }),
+    };
+    static topic = 'pg';
+    async run() {
+        const { args, flags } = await this.parse(Upgrade);
+        const { app, confirm, version } = flags;
+        const { database } = args;
+        const dbResolver = new utils.pg.DatabaseResolver(this.heroku);
+        const { addon: db } = await dbResolver.getAttachment(app, database);
+        if (utils.pg.isLegacyEssentialDatabase(db))
+            ux.error(`You can only use ${color.code('pg:upgrade:*')} commands on Essential-* and higher plans.`);
+        if (utils.pg.isEssentialDatabase(db))
+            ux.error(`You can't use ${color.code('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(`/client/v11/databases/${db.id}`, { hostname: utils.pg.host() });
+        if (replica.following)
+            ux.error(`You can't use ${color.code('pg:upgrade:dryrun')} on follower databases. You can only use this command on Standard-tier and higher leader databases.`);
+        await new ConfirmCommand().confirm(app, confirm, heredoc(`
+        This command starts a test upgrade for ${color.datastore(db.name)} to ${versionPhrase}.
+    `));
+        try {
+            const data = { version };
+            ux.action.start(`Starting a test upgrade on ${color.datastore(db.name)}`);
+            const response = await this.heroku.post(`/client/v11/databases/${db.id}/upgrade/dry_run`, { body: data, hostname: utils.pg.host() });
+            ux.action.stop('done\n' + formatResponseWithCommands(response.body.message));
+        }
+        catch (error) {
+            const response = error;
+            ux.error(formatResponseWithCommands(response.body.message) + `\n\nError ID: ${response.body.id}`);
+        }
+    }
+}

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

@@ -0,0 +1,15 @@
+import { Command } from '@heroku-cli/command';
+export default class Upgrade extends Command {
+    static args: {
+        database: import("@oclif/core/interfaces").Arg<string | undefined, Record<string, unknown>>;
+    };
+    static description: string;
+    static flags: {
+        app: import("@oclif/core/interfaces").OptionFlag<string, import("@oclif/core/interfaces").CustomOptions>;
+        confirm: import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
+        remote: import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
+        version: import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
+    };
+    static topic: string;
+    run(): Promise<void>;
+}

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

@@ -0,0 +1,73 @@
+import { color, utils } from '@heroku/heroku-cli-util';
+import { Command, flags } from '@heroku-cli/command';
+import { Args, ux } from '@oclif/core';
+import tsheredoc from 'tsheredoc';
+import ConfirmCommand from '../../../lib/confirmCommand.js';
+import { databaseNameFromUrl, formatResponseWithCommands } from '../../../lib/pg/util.js';
+import { nls } from '../../../nls.js';
+const heredoc = tsheredoc.default;
+export default class Upgrade extends Command {
+    static args = {
+        database: Args.string({ description: `${nls('pg:database:arg:description')} ${nls('pg:database:arg:description:default:suffix')}` }),
+    };
+    static description = heredoc(`
+    We're deprecating this command. To upgrade your database's Postgres version, use the new ${color.code('pg:upgrade:*')} subcommands. See ${color.info('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 = {
+        app: flags.app({ required: true }),
+        confirm: flags.string({ char: 'c' }),
+        remote: flags.remote(),
+        version: flags.string({ char: 'v', description: 'Postgres version to upgrade to' }),
+    };
+    static topic = 'pg';
+    async run() {
+        const { args, flags } = await this.parse(Upgrade);
+        const { app, confirm, version } = flags;
+        const { database } = args;
+        const dbResolver = new utils.pg.DatabaseResolver(this.heroku);
+        const { addon: db } = await dbResolver.getAttachment(app, database);
+        if (utils.pg.isLegacyEssentialDatabase(db))
+            ux.error(`You can only use ${color.code('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(`/client/v11/databases/${db.id}`, { hostname: utils.pg.host() });
+        if (replica.following) {
+            const { body: configVars } = await this.heroku.get(`/apps/${app}/config-vars`);
+            const origin = databaseNameFromUrl(replica.following, configVars);
+            await new ConfirmCommand().confirm(app, confirm, heredoc(`
+        We're deprecating this command. To upgrade your database's Postgres version, use the new ${color.code('pg:upgrade:*')} subcommands. See ${color.info('https://devcenter.heroku.com/changelog-items/3179')}.
+
+        Destructive action
+        You're upgrading ${color.datastore(db.name)} to ${versionPhrase}. The database will stop following ${color.datastore(origin)} and become writable.
+
+        You can't undo this action.
+      `));
+        }
+        else if (utils.pg.isEssentialDatabase(db)) {
+            await new ConfirmCommand().confirm(app, confirm, heredoc(`
+        We're deprecating this command. To upgrade your database's Postgres version, use the new ${color.code('pg:upgrade:*')} subcommands. See ${color.info('https://devcenter.heroku.com/changelog-items/3179')}.
+
+        Destructive action
+        You're upgrading ${color.datastore(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.code('pg:upgrade:*')} subcommands. See ${color.info('https://devcenter.heroku.com/changelog-items/3179')}.`));
+            ux.error(`You can only use ${color.code('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.datastore(db.name)}`);
+            const response = await this.heroku.post(`/client/v11/databases/${db.id}/upgrade`, { body: data, hostname: utils.pg.host() });
+            ux.action.stop(heredoc(`done\n${formatResponseWithCommands(response.body.message)}`));
+        }
+        catch (error) {
+            const response = error;
+            ux.error(heredoc(`${formatResponseWithCommands(response.body.message)}\n\nError ID: ${response.body.id}`));
+        }
+    }
+}

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

@@ -0,0 +1,14 @@
+import { Command } from '@heroku-cli/command';
+export default class Upgrade extends Command {
+    static args: {
+        database: import("@oclif/core/interfaces").Arg<string | undefined, Record<string, unknown>>;
+    };
+    static description: string;
+    static flags: {
+        app: import("@oclif/core/interfaces").OptionFlag<string, import("@oclif/core/interfaces").CustomOptions>;
+        confirm: import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
+        version: import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
+    };
+    static topic: string;
+    run(): Promise<void>;
+}

package/lib/commands/pg/upgrade/prepare.js

@@ -0,0 +1,51 @@
+import { color, utils } from '@heroku/heroku-cli-util';
+import { Command, flags } from '@heroku-cli/command';
+import { Args, ux } from '@oclif/core';
+import tsheredoc from 'tsheredoc';
+import ConfirmCommand from '../../../lib/confirmCommand.js';
+import { formatResponseWithCommands } from '../../../lib/pg/util.js';
+import { nls } from '../../../nls.js';
+const heredoc = tsheredoc.default;
+export default class Upgrade extends Command {
+    static args = {
+        database: Args.string({ description: `${nls('pg:database:arg:description')} ${nls('pg:database:arg:description:default:suffix')}` }),
+    };
+    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.code('heroku pg:upgrade:run')} instead.
+  `);
+    static flags = {
+        app: flags.app({ required: true }),
+        confirm: flags.string({ char: 'c' }),
+        version: flags.string({ char: 'v', description: 'Postgres version to upgrade to' }),
+    };
+    static topic = 'pg';
+    async run() {
+        const { args, flags } = await this.parse(Upgrade);
+        const { app, confirm, version } = flags;
+        const { database } = args;
+        const dbResolver = new utils.pg.DatabaseResolver(this.heroku);
+        const { addon: db } = await dbResolver.getAttachment(app, database);
+        if (utils.pg.isLegacyEssentialDatabase(db))
+            ux.error(`You can only use ${color.code('pg:upgrade:*')} commands on Essential-* and higher plans.`);
+        if (utils.pg.isEssentialDatabase(db))
+            ux.error(`You can only use ${color.code('heroku pg:upgrade:prepare')} on Standard-tier and higher leader databases. For Essential-tier databases, use ${color.code('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(`/client/v11/databases/${db.id}`, { hostname: utils.pg.host() });
+        if (replica.following)
+            ux.error(`You can only use ${color.code('heroku pg:upgrade:prepare')} on Standard-tier and higher leader databases. For follower databases, use ${color.code('heroku pg:upgrade:run')} instead.`);
+        await new ConfirmCommand().confirm(app, confirm, heredoc(`
+        Destructive action
+        This command prepares the upgrade for ${color.datastore(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(`/client/v11/databases/${db.id}/upgrade/prepare`, { hostname: utils.pg.host(), body: data });
+            ux.action.stop(heredoc(`done\n${formatResponseWithCommands(response.body.message)}`));
+        }
+        catch (error) {
+            const response = error;
+            ux.error(heredoc(`${formatResponseWithCommands(response.body.message)}\n\nError ID: ${response.body.id}`));
+        }
+    }
+}

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

@@ -0,0 +1,16 @@
+import { Command } from '@heroku-cli/command';
+export default class Upgrade extends Command {
+    static args: {
+        database: import("@oclif/core/interfaces").Arg<string | undefined, Record<string, unknown>>;
+    };
+    static description: string;
+    static examples: string[];
+    static flags: {
+        app: import("@oclif/core/interfaces").OptionFlag<string, import("@oclif/core/interfaces").CustomOptions>;
+        confirm: import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
+        remote: import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
+        version: import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
+    };
+    static topic: string;
+    run(): Promise<void>;
+}