heroku 11.3.1-beta.0 → 11.4.0

package/CHANGELOG.md

@@ -4,17 +4,19 @@ All notable changes to this project will be documented in this file.
 See [Conventional Commits](https://conventionalcommits.org) for commit guidelines.
 
 
-## [11.3.1-beta.0](https://github.com/heroku/cli/compare/v11.3.0...v11.3.1-beta.0) (2026-05-13)
+## [11.4.0](https://github.com/heroku/cli/compare/v11.3.0...v11.4.0) (2026-05-13)
 
 
 ### Features
 
+* 'data:pg:migrate' command implementation (W-21303011) ([#3546](https://github.com/heroku/cli/issues/3546)) ([127e682](https://github.com/heroku/cli/commit/127e682e23c2798346372528f55397563ad3e505))
 * multi-factor attachment support for Advanced dbs (W-21632630) ([#3655](https://github.com/heroku/cli/issues/3655)) ([87785e8](https://github.com/heroku/cli/commit/87785e809fae29cc23a9c29b44b3a6f285961861))
 
 
 ### Bug Fixes
 
 * align ps:type with customer-facing private/shield dyno names ([#3705](https://github.com/heroku/cli/issues/3705)) ([0b36a1f](https://github.com/heroku/cli/commit/0b36a1f3c0c5ab21b3a3887787f290f62135957f))
+* migrate release scripts from qqjs to script-exec helpers ([#3707](https://github.com/heroku/cli/issues/3707)) ([dcbaa1b](https://github.com/heroku/cli/commit/dcbaa1b153cab52b009811df30cac80aa93c98d9))
 * prevent unhandled promise rejection in apps:destroy ([#3679](https://github.com/heroku/cli/issues/3679)) ([3e4c838](https://github.com/heroku/cli/commit/3e4c838ec28276ed3b3e01dd76d5f6cb78c58f19)), closes [#3677](https://github.com/heroku/cli/issues/3677) [#3677](https://github.com/heroku/cli/issues/3677) [#3677](https://github.com/heroku/cli/issues/3677)
 * updates @heroku-cli/command to address 2FA token prompting bug ([#3690](https://github.com/heroku/cli/issues/3690)) ([eda4459](https://github.com/heroku/cli/commit/eda4459fb8b98442d0650c1612d215c74eb2250b))
 * validate HEROKU_HOST for container registry commands ([#3704](https://github.com/heroku/cli/issues/3704)) ([04df827](https://github.com/heroku/cli/commit/04df8275f933c2f055a384d7deaccd524bfa5220))

package/dist/commands/data/pg/create.d.ts

@@ -28,8 +28,5 @@ export default class DataPgCreate extends BaseCommand {
     run(): Promise<void>;
     runCommand(command: string, args: string[]): Promise<void>;
     private followerPoolConfigLoop;
-    private highAvailabilityStep;
-    private leaderConfirmationStep;
-    private leaderLevelStep;
     private leaderPoolConfig;
 }

package/dist/commands/data/pg/create.js

@@ -1,3 +1,4 @@
+/* eslint-disable no-await-in-loop */
 import { flags as Flags } from '@heroku-cli/command';
 import { color, utils } from '@heroku/heroku-cli-util';
 import { ux } from '@oclif/core/ux';
@@ -8,10 +9,10 @@ import BaseCommand from '../../../lib/data/base-command.js';
 import createPool from '../../../lib/data/create-pool.js';
 import { parseProvisionOpts } from '../../../lib/data/parse-provision-opts.js';
 import PoolConfig from '../../../lib/data/pool-config.js';
-import { fetchLevelsAndPricing, renderPricingInfo } from '../../../lib/data/utils.js';
+import { fetchLevelsAndPricing } from '../../../lib/data/utils.js';
 import notify from '../../../lib/notify.js';
 const heredoc = tsheredoc.default;
-const { prompt, Separator } = inquirer;
+const { prompt } = inquirer;
 export default class DataPgCreate extends BaseCommand {
     static baseFlags = BaseCommand.baseFlagsWithoutPrompt();
     static description = 'create a Postgres Advanced database';
@@ -178,64 +179,8 @@ export default class DataPgCreate extends BaseCommand {
             }
         } while (oneMore);
     }
-    async highAvailabilityStep() {
-        process.stderr.write('The leader pool has high availability enabled and includes a standby instance for redundancy.\n'
-            + 'If you disable high availability, you remove the standby and you won\'t have redundancy on your database.\n\n');
-        const leaderPricing = this.extendedLevelsInfo.find(level => level.name === this.leaderLevel)?.pricing;
-        const { action } = await this.prompt({
-            choices: [
-                { name: 'Keep high availability (HA)', value: 'keep' },
-                {
-                    name: 'Remove high availability' + (renderPricingInfo(leaderPricing) === 'free'
-                        ? ''
-                        : ` ${color.info(`-${renderPricingInfo(leaderPricing).replace('~', '')}`)}`),
-                    value: 'remove',
-                },
-                new Separator(),
-                { name: 'Go back', value: 'back' },
-            ],
-            message: 'Do you want to keep the high availability standby instance?',
-            name: 'action',
-            type: 'list',
-        });
-        process.stderr.write('\n');
-        return action;
-    }
-    async leaderConfirmationStep() {
-        const leaderLevelInfo = this.extendedLevelsInfo.find(level => level.name === this.leaderLevel);
-        const totalPrice = this.highAvailability
-            ? renderPricingInfo(leaderLevelInfo?.pricing, 2)
-            : renderPricingInfo(leaderLevelInfo?.pricing);
-        const instancePrice = renderPricingInfo(leaderLevelInfo?.pricing);
-        process.stderr.write(heredoc `
-      ${`${color.green('✓ Configure Leader Pool')} ${totalPrice}`}
-        ${color.gray(`${this.leaderLevel} ${leaderLevelInfo?.vcpu} ${color.ansis.inverse('vCPU')} `
-            + `${leaderLevelInfo?.memory_in_gb} GB ${color.ansis.inverse('MEM')} `
-            + instancePrice)}
-    `);
-        if (this.highAvailability) {
-            process.stderr.write(color.gray(`  Standby (High Availability) ${instancePrice}\n`));
-        }
-        process.stderr.write('\n');
-        const { action } = await this.prompt({
-            choices: [
-                { name: 'Confirm', value: 'confirm' },
-                { name: 'Go back', value: 'back' },
-            ],
-            message: 'Confirm provisioning?',
-            name: 'action',
-            type: 'list',
-        });
-        process.stderr.write('\n');
-        return action;
-    }
-    async leaderLevelStep() {
-        const poolConfig = new PoolConfig(this.extendedLevelsInfo, this.followerInstanceCount);
-        const level = await poolConfig.levelStep('Leader');
-        process.stderr.write('\n');
-        this.leaderLevel = level;
-    }
     async leaderPoolConfig() {
+        const poolConfig = new PoolConfig(this.extendedLevelsInfo, this.followerInstanceCount);
         process.stderr.write(heredoc `
 
       Create a Heroku Postgres Advanced database
@@ -246,48 +191,8 @@ export default class DataPgCreate extends BaseCommand {
       → Configure Leader Pool
       ${color.gray('  Configure Follower Pool(s)')}\n
     `);
-        let configReady = false;
-        let currentStep = 'leaderLevel';
-        while (!configReady) {
-            switch (currentStep) {
-                case 'confirmation': {
-                    switch (await this.leaderConfirmationStep()) {
-                        case 'back': {
-                            currentStep = 'highAvailability';
-                            break;
-                        }
-                        case 'confirm': {
-                            configReady = true;
-                            break;
-                        }
-                    }
-                    break;
-                }
-                case 'highAvailability': {
-                    switch (await this.highAvailabilityStep()) {
-                        case 'back': {
-                            currentStep = 'leaderLevel';
-                            break;
-                        }
-                        case 'keep': {
-                            this.highAvailability = true;
-                            currentStep = 'confirmation';
-                            break;
-                        }
-                        case 'remove': {
-                            this.highAvailability = false;
-                            currentStep = 'confirmation';
-                            break;
-                        }
-                    }
-                    break;
-                }
-                case 'leaderLevel': {
-                    await this.leaderLevelStep();
-                    currentStep = 'highAvailability';
-                    break;
-                }
-            }
-        }
+        const { highAvailability, level } = await poolConfig.leaderInteractiveConfig();
+        this.leaderLevel = level;
+        this.highAvailability = highAvailability;
     }
 }

package/dist/commands/data/pg/migrate.d.ts

@@ -0,0 +1,26 @@
+import * as Heroku from '@heroku-cli/schema';
+import inquirer from 'inquirer';
+import createAddon from '../../../lib/addons/create-addon.js';
+import BaseCommand from '../../../lib/data/base-command.js';
+export default class DataPgMigrate extends BaseCommand {
+    static description: string;
+    static flags: {
+        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>;
+    };
+    private advancedDatabases;
+    private appName;
+    private classicDatabases;
+    private extendedLevelsInfo;
+    private migrationTargets;
+    createAddon(...args: Parameters<typeof createAddon>): Promise<Heroku.AddOn>;
+    prompt<T extends inquirer.Answers>(...args: Parameters<typeof inquirer.prompt<T>>): Promise<T>;
+    run(): Promise<void>;
+    private actOnReadyMigration;
+    private configureMigration;
+    private createTargetDatabase;
+    private getAppDatabases;
+    private getMigrationTargetsAndInfo;
+    private isActiveMigration;
+    private loopMainMenu;
+}

package/dist/commands/data/pg/migrate.js

@@ -0,0 +1,440 @@
+/* eslint-disable no-await-in-loop */
+import { flags as Flags, HerokuAPIError } from '@heroku-cli/command';
+import { color, hux, utils, } from '@heroku/heroku-cli-util';
+import { ux } from '@oclif/core';
+import inquirer from 'inquirer';
+import tsheredoc from 'tsheredoc';
+import createAddon from '../../../lib/addons/create-addon.js';
+import BaseCommand from '../../../lib/data/base-command.js';
+import PoolConfig from '../../../lib/data/pool-config.js';
+import { DatabaseStatus, MigrationStatus, } from '../../../lib/data/types.js';
+import { fetchLevelsAndPricing } from '../../../lib/data/utils.js';
+import { getAttachmentNamesByAddon } from '../../../lib/pg/util.js';
+const heredoc = tsheredoc.default;
+const { prompt, Separator } = inquirer;
+export default class DataPgMigrate extends BaseCommand {
+    static description = 'migrate an existing classic Postgres database to an Advanced database';
+    static flags = {
+        app: Flags.app({ required: true }),
+        remote: Flags.remote(),
+    };
+    advancedDatabases = [];
+    appName;
+    classicDatabases = [];
+    extendedLevelsInfo;
+    migrationTargets = [];
+    async createAddon(...args) {
+        return createAddon(...args);
+    }
+    async prompt(...args) {
+        return prompt(...args);
+    }
+    async run() {
+        const { flags } = await this.parse(DataPgMigrate);
+        const { app } = flags;
+        this.appName = app;
+        ux.stdout(heredoc `
+
+      Migrate existing classic Heroku Postgres databases to Advanced databases
+      ${color.gray('Press Ctrl+C to cancel')}
+    `);
+        let action;
+        do {
+            action = await this.loopMainMenu(app);
+            switch (action) {
+                case '__cancel_migration': {
+                    await this.actOnReadyMigration('cancel');
+                    break;
+                }
+                case '__configure_migration': {
+                    await this.configureMigration();
+                    break;
+                }
+                case '__exit': {
+                    break;
+                }
+                case '__start_migration': {
+                    await this.actOnReadyMigration('start');
+                    break;
+                }
+            }
+        } while (action !== '__exit');
+    }
+    // eslint-disable-next-line complexity
+    async actOnReadyMigration(migrationAction) {
+        const readyMigrations = this.migrationTargets.filter(migration => migration.status === MigrationStatus.READY);
+        let currentStep = '__select_migration';
+        let selectedMigrationId;
+        while (currentStep !== '__exit') {
+            switch (currentStep) {
+                case '__confirm_action': {
+                    const selectedMigration = readyMigrations.find(migration => migration.id === selectedMigrationId);
+                    const sourceDatabase = this.classicDatabases.find(db => db.id === selectedMigration.source_id);
+                    const targetDatabase = this.advancedDatabases.find(db => db.id === selectedMigration.target_id);
+                    if (migrationAction === 'start') {
+                        ux.stdout(color.info(heredoc `
+
+            Your database ${color.datastore(sourceDatabase?.name ?? color.gray('unknown'))} will be unavailable after starting the migration until the migration is complete.
+            If there are any issues during the migration, we end the migration and make the source database available again.
+            The database ${color.datastore(sourceDatabase?.name ?? color.gray('unknown'))} can be offline for several hours during the migration.
+            You'll receive an email when the migration is complete.
+            You can't cancel the migration after starting it.
+
+          `));
+                    }
+                    else {
+                        ux.stdout(color.info(heredoc `
+
+            After canceling, you must create a new migration configuration and wait for the migration tooling to finish preparing to
+            migrate ${color.datastore(sourceDatabase?.name ?? color.gray('unknown'))} again.
+
+          `));
+                    }
+                    const { action } = await this.prompt({
+                        choices: [
+                            { name: 'Confirm', value: '__confirm' },
+                            { name: 'Go back', value: '__go_back' },
+                        ],
+                        message: `Confirm to ${migrationAction} migration:`,
+                        name: 'action',
+                        type: 'list',
+                    });
+                    if (action === '__go_back') {
+                        currentStep = '__select_migration';
+                    }
+                    else if (action === '__confirm') {
+                        ux.stdout();
+                        ux.action.start(`${migrationAction === 'start' ? 'Starting' : 'Canceling'} migration of ${color.datastore(sourceDatabase?.name ?? color.gray('unknown'))} `
+                            + `to ${color.datastore(targetDatabase?.name ?? color.gray('unknown'))}`);
+                        await this.dataApi.post(`/data/postgres/v1/${selectedMigration.target_id}/migrations/${migrationAction === 'start' ? 'run' : 'cancel'}`);
+                        ux.action.stop();
+                        currentStep = '__exit';
+                    }
+                    break;
+                }
+                case '__select_migration': {
+                    const choices = [];
+                    for (const migration of readyMigrations) {
+                        const sourceDatabase = this.classicDatabases.find(db => db.id === migration.source_id);
+                        const targetDatabase = this.advancedDatabases.find(db => db.id === migration.target_id);
+                        const name = `From ${color.datastore(sourceDatabase?.name ?? color.gray('unknown'))} to ${color.datastore(targetDatabase?.name ?? color.gray('unknown'))}`;
+                        choices.push({
+                            name,
+                            value: migration.id,
+                        });
+                    }
+                    choices.push(new Separator(), { name: 'Go back', value: '__go_back' });
+                    selectedMigrationId = (await this.prompt({
+                        choices,
+                        message: `Select the migration to ${migrationAction}:`,
+                        name: 'migration',
+                        type: 'list',
+                    })).migration;
+                    currentStep = selectedMigrationId === '__go_back' ? '__exit' : '__confirm_action';
+                    break;
+                }
+            }
+        }
+    }
+    async configureMigration() {
+        let currentStep = '__select_source';
+        let sourceDatabaseId;
+        let targetDatabaseId;
+        while (currentStep !== '__exit') {
+            switch (currentStep) {
+                case '__confirm_migration': {
+                    ux.stdout(color.info(heredoc `
+
+          By continuing, we prepare the necessary steps for the migration.
+          Your source database is available while we prepare the migration.
+          You'll receive an email when the preparation is complete or if there's an error.
+          You have 24 hours to begin migration after the preparation is complete.
+          Your source database will be unavailable during the migration.
+
+        `));
+                    const { action } = await this.prompt({
+                        choices: [
+                            { name: 'Confirm', value: '__confirm' },
+                            { name: 'Go back', value: '__go_back' },
+                        ],
+                        message: 'Confirm migration configuration:',
+                        name: 'action',
+                        type: 'list',
+                    });
+                    if (action === '__go_back') {
+                        currentStep = '__select_target';
+                    }
+                    else if (action === '__confirm') {
+                        ux.stdout('');
+                        ux.action.start('Configuring migration');
+                        await this.dataApi.post(`/data/postgres/v1/${targetDatabaseId}/migrations`, {
+                            body: { source_id: sourceDatabaseId },
+                        });
+                        ux.action.stop();
+                        currentStep = '__exit';
+                    }
+                    break;
+                }
+                case '__select_source': {
+                    const choices = [];
+                    for (const database of this.classicDatabases) {
+                        const name = `${color.datastore(database.name)} as ${database.attachment_names.map(name => color.attachment(name)).join(', ')}`;
+                        if (this.migrationTargets.some(migration => migration.source_id === database.id && this.isActiveMigration(migration))) {
+                            choices.push({
+                                disabled: 'already a source database for an active migration',
+                                name: color.gray(name),
+                                value: database.id,
+                            });
+                        }
+                        else {
+                            choices.push({
+                                name,
+                                value: database.id,
+                            });
+                        }
+                    }
+                    choices.push(new Separator(), { name: 'Go back', value: '__go_back' });
+                    sourceDatabaseId = (await this.prompt({
+                        choices,
+                        message: 'Select the source database:',
+                        name: 'database',
+                        type: 'list',
+                    })).database;
+                    currentStep = sourceDatabaseId === '__go_back' ? '__exit' : '__select_target';
+                    break;
+                }
+                case '__select_target': {
+                    const choices = [];
+                    for (const database of this.advancedDatabases) {
+                        const name = `${color.datastore(database.name)} as ${database.attachment_names.map(name => color.attachment(name)).join(', ')}`;
+                        if (this.migrationTargets.some(migration => migration.target_id === database.id && this.isActiveMigration(migration))) {
+                            choices.push({
+                                disabled: 'already a destination database for an active migration',
+                                name: color.gray(name),
+                                value: database.id,
+                            });
+                        }
+                        else if (database.info?.status === DatabaseStatus.AVAILABLE) {
+                            choices.push({
+                                name,
+                                value: database.id,
+                            });
+                        }
+                        else {
+                            choices.push({
+                                disabled: 'database isn\'t available',
+                                name: color.gray(name),
+                                value: database.id,
+                            });
+                        }
+                    }
+                    if (this.advancedDatabases.length === 0) {
+                        choices.push({
+                            disabled: true,
+                            name: color.gray(`No Heroku Postgres Advanced databases available for migration on ${color.app(this.appName)}`),
+                            value: '__no_advanced_databases',
+                        });
+                    }
+                    choices.push(new Separator(), { name: 'Create a new Advanced database', value: '__create_database' }, { name: 'Go back', value: '__go_back' });
+                    targetDatabaseId = (await this.prompt({
+                        choices,
+                        message: 'Select the destination database:',
+                        name: 'database',
+                        type: 'list',
+                    })).database;
+                    if (targetDatabaseId === '__go_back') {
+                        currentStep = '__select_source';
+                    }
+                    else if (targetDatabaseId === '__create_database') {
+                        const addon = await this.createTargetDatabase(sourceDatabaseId);
+                        if (addon) {
+                            targetDatabaseId = addon.id;
+                            currentStep = '__confirm_migration';
+                        }
+                        else {
+                            currentStep = '__select_target';
+                        }
+                    }
+                    else {
+                        currentStep = '__confirm_migration';
+                    }
+                    break;
+                }
+            }
+        }
+    }
+    async createTargetDatabase(sourceDatabaseId) {
+        let networking;
+        const sourceDatabase = this.classicDatabases.find(db => db.id === sourceDatabaseId);
+        if (sourceDatabase.plan.name.split(':')[1].startsWith('private')) {
+            networking = 'private';
+        }
+        else if (sourceDatabase.plan.name.split(':')[1].startsWith('shield')) {
+            networking = 'shield';
+        }
+        const plan = `advanced${networking ? `-${networking}` : ''}`;
+        const service = utils.pg.addonService();
+        const servicePlan = `${service}:${plan}`;
+        const { extendedLevelsInfo } = await fetchLevelsAndPricing(plan, this.dataApi);
+        this.extendedLevelsInfo = extendedLevelsInfo;
+        const poolConfig = new PoolConfig(this.extendedLevelsInfo, 0);
+        ux.stdout(heredoc `
+
+      → Configure Leader Pool
+
+    `);
+        const { action, highAvailability, level: leaderLevel } = await poolConfig.leaderInteractiveConfig(true);
+        if (action === '__go_back') {
+            return undefined;
+        }
+        // Database cluster provisioning (leader pool)
+        const config = {
+            from: sourceDatabaseId,
+            'high-availability': highAvailability,
+            level: leaderLevel,
+        };
+        let addon;
+        try {
+            addon = await this.createAddon(this.heroku, sourceDatabase.app.name, servicePlan, undefined, false, {
+                actionStartMessage: `Creating a ${color.info(leaderLevel)} database on ${color.app(sourceDatabase.app.name)}`,
+                actionStopMessage: 'done',
+                config,
+            });
+        }
+        catch (error) {
+            ux.action.stop();
+            throw error;
+        }
+        return addon;
+    }
+    async getAppDatabases(app) {
+        const { body: appAttachments } = await this.heroku.get(`/apps/${app}/addon-attachments`, {
+            headers: {
+                Accept: 'application/vnd.heroku+json; version=3.sdk',
+                'Accept-Inclusion': 'addon:plan,config_vars',
+            },
+        });
+        const ownedDatabaseAttachments = appAttachments.filter(a => utils.pg.isPostgresAddon(a.addon) && a.addon.app.name === app);
+        const ownedDatabaseAddons = [];
+        for (const attachment of ownedDatabaseAttachments) {
+            if (!ownedDatabaseAddons.some(a => a.id === attachment.addon.id)) {
+                ownedDatabaseAddons.push(attachment.addon);
+            }
+        }
+        const attachmentNamesByAddon = getAttachmentNamesByAddon(ownedDatabaseAttachments);
+        for (const addon of ownedDatabaseAddons) {
+            addon.attachment_names = attachmentNamesByAddon[addon.id];
+        }
+        this.classicDatabases = ownedDatabaseAddons.filter(db => utils.pg.isLegacyDatabase(db) && !utils.pg.isEssentialDatabase(db));
+        this.advancedDatabases = ownedDatabaseAddons.filter(db => utils.pg.isAdvancedDatabase(db));
+    }
+    async getMigrationTargetsAndInfo() {
+        const migrationPromises = Promise.allSettled(this.advancedDatabases.map(db => this.dataApi.get(`/data/postgres/v1/${db.id}/migrations`)));
+        const infoPromises = Promise.allSettled(this.advancedDatabases.map(db => this.dataApi.get(`/data/postgres/v1/${db.id}/info`)));
+        const [migrationResults, infoResults] = await Promise.all([migrationPromises, infoPromises]);
+        // 404 errors are expected for Advanced databases that are not a migration target (at least not yet)
+        const unexpectedError = [...migrationResults, ...infoResults]
+            .filter(queryResult => queryResult.status === 'rejected')
+            .find(queryResult => {
+            const error = queryResult.reason;
+            if (error instanceof HerokuAPIError) {
+                return error.http.statusCode !== 404;
+            }
+            return true;
+        });
+        if (unexpectedError) {
+            ux.error(unexpectedError.reason);
+        }
+        for (const infoResult of infoResults) {
+            if (infoResult.status === 'fulfilled') {
+                const db = this.advancedDatabases.find(db => db.id === infoResult.value.body.addon.id);
+                if (db) {
+                    db.info = infoResult.value.body;
+                }
+            }
+        }
+        this.migrationTargets = migrationResults
+            .filter(queryResult => queryResult.status === 'fulfilled')
+            .map(queryResult => queryResult.value.body);
+    }
+    isActiveMigration(migration) {
+        return migration.status === MigrationStatus.CREATING_TARGET
+            || migration.status === MigrationStatus.PREPARING
+            || migration.status === MigrationStatus.MIGRATING
+            || migration.status === MigrationStatus.PROMOTING
+            || migration.status === MigrationStatus.READY;
+    }
+    async loopMainMenu(app) {
+        // Update our database lists
+        await this.getAppDatabases(app);
+        await this.getMigrationTargetsAndInfo();
+        const pendingMigrations = this.classicDatabases.filter(db => !this.migrationTargets.some(migration => migration.source_id === db.id && this.isActiveMigration(migration)));
+        hux.styledHeader('Configured Migrations');
+        if (this.migrationTargets.length > 0) {
+            /* eslint-disable perfectionist/sort-objects */
+            hux.table(this.migrationTargets, {
+                source: {
+                    get: (migration) => color.datastore(this.classicDatabases.find(db => db.id === migration.source_id)?.name ?? color.gray('unknown')),
+                    header: 'Source Database',
+                },
+                destination: {
+                    get: (migration) => color.datastore(this.advancedDatabases.find(db => db.id === migration.target_id)?.name ?? color.gray('unknown')),
+                    header: 'Destination Database',
+                },
+                status: {
+                    get: (migration) => (migration.status === MigrationStatus.MIGRATING && migration.status_description)
+                        ? color.info(migration.status_description)
+                        : color.info(migration.status === MigrationStatus.CANCELLED ? 'Canceled' : hux.toTitleCase(migration.status)),
+                    header: 'Status',
+                },
+            });
+            /* eslint-enable perfectionist/sort-objects */
+        }
+        else {
+            ux.stdout(`You haven't configured any migrations for ${color.app(app)} yet.\n`);
+        }
+        const choices = [];
+        if (pendingMigrations.length > 0) {
+            choices.push({
+                name: 'Configure a database migration',
+                value: '__configure_migration',
+            });
+        }
+        else {
+            choices.push({
+                disabled: `no classic Postgres databases pending migration on ${color.app(app)}`,
+                name: color.gray('Configure a database migration'),
+                value: '__configure_migration',
+            });
+        }
+        if (this.migrationTargets.some(migration => migration.status === 'ready')) {
+            choices.push({
+                name: 'Start a migration',
+                value: '__start_migration',
+            }, {
+                name: 'Cancel a migration',
+                value: '__cancel_migration',
+            });
+        }
+        else {
+            const disabledReason = `no ready migrations on ${color.app(app)}`;
+            choices.push({
+                disabled: disabledReason,
+                name: color.gray('Start a migration'),
+                value: '__start_migration',
+            }, {
+                disabled: disabledReason,
+                name: color.gray('Cancel a migration'),
+                value: '__cancel_migration',
+            });
+        }
+        choices.push(new Separator(), { name: 'Exit', value: '__exit' });
+        const { action } = await this.prompt({
+            choices,
+            message: 'What do you want to do?:',
+            name: 'action',
+            type: 'list',
+        });
+        return action;
+    }
+}

package/dist/commands/data/pg/update.d.ts

@@ -25,28 +25,6 @@ export default class DataPgUpdate extends BaseCommand {
     prompt<T extends Answers>(...args: Parameters<typeof prompt<T>>): Promise<T>;
     run(): Promise<void>;
     private addFollowerPoolStage;
-    /**
-     * Helper function that attempts to find all Heroku Postgres Advanced-tier attachments on a given app.
-     *
-     * @param app - The name of the app to get the attachments for
-     * @returns Promise resolving to an array of all Heroku Postgres Advanced-tier attachments on the app
-     */
-    private allAdvancedDatabaseAttachments;
-    /**
-     * Return all Heroku Postgres databases on the Advanced-tier for a given app.
-     *
-     * @param app - The name of the app to get the databases for
-     * @returns Promise resolving to all Heroku Postgres databases
-     * @throws {Error} When no legacy database add-on exists on the app
-     */
-    private getAllAdvancedDatabases;
-    /**
-     * Helper function that groups attachment names by addon.
-     *
-     * @param attachments - The attachments to group by addon
-     * @returns A record of addon IDs with their attachment names
-     */
-    private getAttachmentNamesByAddon;
     private poolSelectionLoopStage;
     private poolSelectionStep;
     private renderDatabaseChoices;