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

package/lib/commands/webhooks/deliveries/info.d.ts

@@ -0,0 +1,14 @@
+import BaseCommand from '../../../lib/webhooks/base.js';
+export default class DeliveriesInfo extends BaseCommand {
+    static description: string;
+    static examples: 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>;
+        pipeline: import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
+    };
+    static args: {
+        id: import("@oclif/core/interfaces").Arg<string, Record<string, unknown>>;
+    };
+    run(): Promise<void>;
+}

package/lib/commands/webhooks/deliveries/info.js

@@ -0,0 +1,40 @@
+import { flags } from '@heroku-cli/command';
+import { Args } from '@oclif/core';
+import { hux } from '@heroku/heroku-cli-util';
+import BaseCommand from '../../../lib/webhooks/base.js';
+export default class DeliveriesInfo extends BaseCommand {
+    static description = 'info for a webhook event on an app';
+    static examples = [
+        '$ heroku webhooks:deliveries:info 99999999-9999-9999-9999-999999999999',
+    ];
+    static flags = {
+        app: flags.app(),
+        remote: flags.remote(),
+        pipeline: flags.pipeline({ char: 'p', description: 'pipeline on which to list', hidden: true }),
+    };
+    static args = {
+        id: Args.string({ required: true, description: 'ID of the webhook event' }),
+    };
+    async run() {
+        const { flags, args } = await this.parse(DeliveriesInfo);
+        const { path } = this.webhookType(flags);
+        const { body: delivery } = await this.webhooksClient.get(`${path}/webhook-deliveries/${args.id}`);
+        const { body: event } = await this.webhooksClient.get(`${path}/webhook-events/${delivery.event.id}`);
+        const obj = {
+            Created: delivery.created_at,
+            Event: delivery.event.id,
+            Webhook: delivery.webhook.id,
+            Status: delivery.status,
+            Include: delivery.event.include,
+            Level: delivery.webhook.level,
+            Attempts: delivery.num_attempts,
+            Code: delivery.last_attempt && delivery.last_attempt.code,
+            Error: delivery.last_attempt && delivery.last_attempt.error_class,
+            'Next Attempt': delivery.next_attempt_at,
+        };
+        hux.styledHeader(delivery.id);
+        hux.styledObject(obj);
+        hux.styledHeader('Event Payload');
+        hux.styledJSON(event.payload);
+    }
+}

package/lib/commands/webhooks/index.d.ts

@@ -0,0 +1,11 @@
+import BaseCommand from '../../lib/webhooks/base.js';
+export default class Webhooks extends BaseCommand {
+    static description: string;
+    static examples: 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>;
+        pipeline: import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
+    };
+    run(): Promise<void>;
+}

package/lib/commands/webhooks/index.js

@@ -0,0 +1,42 @@
+import { color, hux } from '@heroku/heroku-cli-util';
+import { flags } from '@heroku-cli/command';
+import { ux } from '@oclif/core';
+import BaseCommand from '../../lib/webhooks/base.js';
+export default class Webhooks extends BaseCommand {
+    static description = 'list webhooks on an app';
+    static examples = ['$ heroku webhooks'];
+    static flags = {
+        app: flags.app(),
+        remote: flags.remote(),
+        pipeline: flags.pipeline({
+            char: 'p',
+            description: 'pipeline on which to list',
+            hidden: true,
+        }),
+    };
+    async run() {
+        const { flags } = await this.parse(Webhooks);
+        const { path, display } = this.webhookType(flags);
+        const { body: webhooks } = await this.webhooksClient.get(`${path}/webhooks`);
+        if (webhooks.length === 0) {
+            ux.stdout(`${display} has no webhooks\nUse ${color.command('heroku webhooks:add')} to add one.`);
+            return;
+        }
+        webhooks.sort((a, b) => Date.parse(a.created_at) - Date.parse(b.created_at));
+        hux.table(webhooks, {
+            id: {
+                header: 'Webhook ID',
+            },
+            url: {
+                header: 'URL',
+            },
+            include: {
+                header: 'Include',
+                get: (row) => row.include.join(','),
+            },
+            level: {
+                header: 'Level',
+            },
+        });
+    }
+}

package/lib/commands/webhooks/info.d.ts

@@ -0,0 +1,14 @@
+import BaseCommand from '../../lib/webhooks/base.js';
+export default class WebhooksInfo extends BaseCommand {
+    static description: string;
+    static examples: 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>;
+        pipeline: import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
+    };
+    static args: {
+        id: import("@oclif/core/interfaces").Arg<string, Record<string, unknown>>;
+    };
+    run(): Promise<void>;
+}

package/lib/commands/webhooks/info.js

@@ -0,0 +1,29 @@
+import { flags } from '@heroku-cli/command';
+import { Args } from '@oclif/core';
+import { hux } from '@heroku/heroku-cli-util';
+import BaseCommand from '../../lib/webhooks/base.js';
+export default class WebhooksInfo extends BaseCommand {
+    static description = 'info for a webhook on an app';
+    static examples = ['$ heroku webhooks:info 99999999-9999-9999-9999-999999999999'];
+    static flags = {
+        app: flags.app(),
+        remote: flags.remote(),
+        pipeline: flags.pipeline({ char: 'p', description: 'pipeline on which to list', hidden: true }),
+    };
+    static args = {
+        id: Args.string({ required: true, description: 'ID of the webhook' }),
+    };
+    async run() {
+        const { flags, args } = await this.parse(WebhooksInfo);
+        const { path } = this.webhookType(flags);
+        const { body: webhook } = await this.webhooksClient.get(`${path}/webhooks/${args.id}`);
+        const obj = {
+            'Webhook ID': webhook.id,
+            URL: webhook.url,
+            Include: webhook.include.join(','),
+            Level: webhook.level,
+        };
+        hux.styledHeader(webhook.id);
+        hux.styledObject(obj);
+    }
+}

package/lib/commands/webhooks/remove.d.ts

@@ -0,0 +1,14 @@
+import BaseCommand from '../../lib/webhooks/base.js';
+export default class WebhooksRemove extends BaseCommand {
+    static description: string;
+    static examples: 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>;
+        pipeline: import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
+    };
+    static args: {
+        id: import("@oclif/core/interfaces").Arg<string, Record<string, unknown>>;
+    };
+    run(): Promise<void>;
+}

package/lib/commands/webhooks/remove.js

@@ -0,0 +1,24 @@
+import { flags } from '@heroku-cli/command';
+import { Args, ux } from '@oclif/core';
+import BaseCommand from '../../lib/webhooks/base.js';
+export default class WebhooksRemove extends BaseCommand {
+    static description = 'removes a webhook from an app';
+    static examples = [
+        '$ heroku webhooks:remove 99999999-9999-9999-9999-999999999999',
+    ];
+    static flags = {
+        app: flags.app(),
+        remote: flags.remote(),
+        pipeline: flags.pipeline({ char: 'p', description: 'pipeline on which to list', hidden: true }),
+    };
+    static args = {
+        id: Args.string({ description: 'id of webhook to remove', required: true }),
+    };
+    async run() {
+        const { flags, args } = await this.parse(WebhooksRemove);
+        const { path, display } = this.webhookType(flags);
+        ux.action.start(`Removing webhook ${args.id} from ${display}`);
+        await this.webhooksClient.delete(`${path}/webhooks/${args.id}`);
+        ux.action.stop();
+    }
+}

package/lib/commands/webhooks/update.d.ts

@@ -0,0 +1,19 @@
+import BaseCommand from '../../lib/webhooks/base.js';
+export default class WebhooksUpdate extends BaseCommand {
+    static description: string;
+    static examples: 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>;
+        pipeline: import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
+        include: import("@oclif/core/interfaces").OptionFlag<string, import("@oclif/core/interfaces").CustomOptions>;
+        level: import("@oclif/core/interfaces").OptionFlag<string, import("@oclif/core/interfaces").CustomOptions>;
+        secret: import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
+        authorization: import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
+        url: import("@oclif/core/interfaces").OptionFlag<string, import("@oclif/core/interfaces").CustomOptions>;
+    };
+    static args: {
+        id: import("@oclif/core/interfaces").Arg<string, Record<string, unknown>>;
+    };
+    run(): Promise<void>;
+}

package/lib/commands/webhooks/update.js

@@ -0,0 +1,36 @@
+import { flags } from '@heroku-cli/command';
+import { Args, ux } from '@oclif/core';
+import BaseCommand from '../../lib/webhooks/base.js';
+export default class WebhooksUpdate extends BaseCommand {
+    static description = 'updates a webhook in an app';
+    static examples = [
+        '$ heroku webhooks:update 99999999-9999-9999-9999-999999999999 -i dyno -l notify -s 09928c40bf1b191b645174a19f7053d16a180da37332e719ef0998f4c0a2 -u https://example.com/hooks',
+    ];
+    static flags = {
+        app: flags.app(),
+        remote: flags.remote(),
+        pipeline: flags.pipeline({ char: 'p', description: 'pipeline on which to list', hidden: true }),
+        include: flags.string({ char: 'i', description: 'comma delimited event types your server will receive ', required: true }),
+        level: flags.string({ char: 'l', description: 'notify does not retry, sync will retry until successful or timeout', required: true }),
+        secret: flags.string({ char: 's', description: 'value to sign delivery with in Heroku-Webhook-Hmac-SHA256 header' }),
+        authorization: flags.string({ char: 't', description: 'authorization header to send with webhooks' }),
+        url: flags.string({ char: 'u', description: 'URL for receiver', required: true }),
+    };
+    static args = {
+        id: Args.string({ required: true, description: 'ID of the webhook' }),
+    };
+    async run() {
+        const { flags, args } = await this.parse(WebhooksUpdate);
+        const { path, display } = this.webhookType(flags);
+        ux.action.start(`Updating webhook ${args.id} for ${display}`);
+        await this.webhooksClient.patch(`${path}/webhooks/${args.id}`, {
+            body: {
+                include: flags.include && flags.include.split(',').map((s) => s.trim()),
+                level: flags.level,
+                secret: flags.secret,
+                url: flags.url,
+            },
+        });
+        ux.action.stop();
+    }
+}

package/lib/global_telemetry.d.ts

@@ -56,7 +56,7 @@ export declare function reportCmdNotFound(config: any): {
     };
     isVersionOrHelp: boolean;
 };
-export declare function sendTelemetry(currentTelemetry: any, rollbarCb?: () => void): Promise<void>;
+export declare function sendTelemetry(currentTelemetry: any): Promise<void>;
 export declare function sendToHoneycomb(data: Telemetry | CLIError): Promise<void>;
-export declare function sendToRollbar(data: CLIError, rollbarCb?: () => void): Promise<unknown>;
+export declare function sendToSentry(data: CLIError): Promise<void>;
 export {};

package/lib/global_telemetry.js

@@ -1,7 +1,11 @@
-import Rollbar from 'rollbar';
 import { APIClient } from '@heroku-cli/command';
 import { Config } from '@oclif/core';
 import opentelemetry, { SpanStatusCode } from '@opentelemetry/api';
+import * as Sentry from '@sentry/node';
+import { SentryPropagator, SentrySampler, } from '@sentry/opentelemetry';
+import { GDPR_FIELDS, HEROKU_FIELDS, PCI_FIELDS } from './lib/data-scrubber/presets.js';
+import { Scrubber } from './lib/data-scrubber/scrubber.js';
+import { PII_PATTERNS } from './lib/data-scrubber/patterns.js';
 import { Resource } from '@opentelemetry/resources';
 import { SemanticResourceAttributes } from '@opentelemetry/semantic-conventions';
 import { registerInstrumentations } from '@opentelemetry/instrumentation';
@@ -21,21 +25,29 @@ async function getVersion() {
     const pkg = JSON.parse(await fs.readFile(root, 'utf8'));
     return pkg.version;
 }
+const version = await getVersion();
 function getToken() {
     const config = new Config({ root });
     const heroku = new APIClient(config);
     return heroku.auth;
 }
-const rollbar = new Rollbar({
-    accessToken: '20783109b0064dbb85be0b2c5a5a5f79',
-    captureUncaught: true,
-    captureUnhandledRejections: true,
-    environment: isDev ? 'development' : 'production',
-    codeVersion: undefined, // will be set later
-});
 registerInstrumentations({
     instrumentations: [],
 });
+const scrubber = new Scrubber({
+    fields: [...HEROKU_FIELDS, ...GDPR_FIELDS, ...PCI_FIELDS],
+    patterns: [...PII_PATTERNS],
+});
+const sentryClient = Sentry.init({
+    dsn: 'https://76530569188e7ee2961373f37951d916@o4508609692368896.ingest.us.sentry.io/4508767754846208',
+    environment: isDev ? 'development' : 'production',
+    release: version,
+    tracesSampleRate: 1,
+    beforeSend(event) {
+        return scrubber.scrub(event).data;
+    },
+    skipOpenTelemetrySetup: true, // needed since we have our own OTEL setup
+});
 const resource = Resource
     .default()
     .merge(new Resource({
@@ -44,6 +56,7 @@ const resource = Resource
 }));
 const provider = new NodeTracerProvider({
     resource,
+    sampler: sentryClient ? new SentrySampler(sentryClient) : undefined,
 });
 // eslint-disable-next-line no-negated-condition, unicorn/no-negated-condition
 const headers = { Authorization: `Bearer ${process.env.IS_HEROKU_TEST_ENV !== 'true' ? getToken() : ''}` };
@@ -55,7 +68,11 @@ const exporter = new OTLPTraceExporter({
 export const processor = new BatchSpanProcessor(exporter);
 provider.addSpanProcessor(processor);
 export function initializeInstrumentation() {
-    provider.register();
+    provider.register({
+        propagator: new SentryPropagator(),
+        contextManager: new Sentry.SentryContextManager(),
+    });
+    // provider.register()
 }
 export function setupTelemetry(config, opts) {
     const now = new Date();
@@ -116,16 +133,16 @@ export function reportCmdNotFound(config) {
         isVersionOrHelp: false,
     };
 }
-export async function sendTelemetry(currentTelemetry, rollbarCb) {
-    // send telemetry to honeycomb and rollbar
+export async function sendTelemetry(currentTelemetry) {
+    // send telemetry to honeycomb
     if (isTelemetryDisabled) {
         return;
     }
     const telemetry = currentTelemetry;
     if (telemetry instanceof Error) {
         await Promise.all([
-            sendToRollbar(telemetry, rollbarCb),
             sendToHoneycomb(telemetry),
+            sendToSentry(telemetry),
         ]);
     }
     else {
@@ -134,7 +151,6 @@ export async function sendTelemetry(currentTelemetry, rollbarCb) {
 }
 export async function sendToHoneycomb(data) {
     try {
-        const version = await getVersion();
         const tracer = opentelemetry.trace.getTracer('heroku-cli', version);
         const span = tracer.startSpan('node_app_execution');
         if (data instanceof Error) {
@@ -158,37 +174,19 @@ export async function sendToHoneycomb(data) {
             span.setAttribute('heroku_client.lifecycle_hook.command_not_found', data.lifecycleHookCompletion.command_not_found);
         }
         span.end();
-        processor.forceFlush();
+        await processor.forceFlush();
     }
     catch {
         debug('could not send telemetry');
     }
 }
-export async function sendToRollbar(data, rollbarCb) {
-    // Make this awaitable so we can wait for it to finish before exiting
-    let promiseResolve;
-    const rollbarPromise = new Promise((resolve, reject) => {
-        promiseResolve = () => {
-            if (rollbarCb) {
-                try {
-                    rollbarCb();
-                }
-                catch (error) {
-                    reject(error);
-                }
-            }
-            resolve(null);
-        };
-    });
-    const rollbarError = { name: data.name, message: data.message, stack: data.stack, cli_run_duration: data.cliRunDuration };
+export async function sendToSentry(data) {
     try {
-        // send data to rollbar
-        rollbar.error('Failed to complete execution', rollbarError, promiseResolve);
+        Sentry.captureException(data);
+        // ensures all events are sent to Sentry before exiting.
+        await Sentry.flush();
     }
     catch {
         debug('Could not send error report');
-        // eslint-disable-next-line unicorn/no-useless-promise-resolve-reject
-        return Promise.reject();
     }
-    return rollbarPromise;
 }

package/lib/lib/addons/addons_wait.d.ts

@@ -1,5 +1,5 @@
-import * as Heroku from '@heroku-cli/schema';
 import { APIClient } from '@heroku-cli/command';
+import * as Heroku from '@heroku-cli/schema';
 export declare const waitForAddonProvisioning: (api: APIClient, addon: Heroku.AddOn, interval: number) => Promise<{
     [x: string]: any;
     actions?: {

package/lib/lib/addons/addons_wait.js

@@ -1,5 +1,5 @@
+import { color } from '@heroku/heroku-cli-util';
 import { ux } from '@oclif/core';
-import { color } from '@heroku-cli/color';
 export const waitForAddonProvisioning = async function (api, addon, interval) {
     const app = addon.app?.name || '';
     const addonName = addon.name;
@@ -33,7 +33,7 @@ export const waitForAddonDeprovisioning = async function (api, addon, interval)
             headers: { 'Accept-Expansion': 'addon_service,plan' },
         }).then(response => {
             addonResponse = response?.body;
-        }).catch(function (error) {
+        }).catch(error => {
             // Not ideal, but API deletes the record returning a 404 when deprovisioned.
             if (error.statusCode === 404 || error.http?.statusCode === 404) {
                 addonResponse.state = 'deprovisioned';

package/lib/lib/addons/create_addon.d.ts

@@ -1,7 +1,9 @@
-import * as Heroku from '@heroku-cli/schema';
 import { APIClient } from '@heroku-cli/command';
+import * as Heroku from '@heroku-cli/schema';
 export default function (heroku: APIClient, app: string, plan: string, confirm: string | undefined, wait: boolean, options: {
-    name?: string;
-    config: Record<string, string | boolean>;
+    actionStartMessage?: string;
+    actionStopMessage?: string;
     as?: string;
+    config: Record<string, boolean | string>;
+    name?: string;
 }): Promise<Heroku.AddOn>;

package/lib/lib/addons/create_addon.js

@@ -1,25 +1,24 @@
+import { color, utils } from '@heroku/heroku-cli-util';
 import { ux } from '@oclif/core';
-import { color } from '@heroku-cli/color';
-import * as util from './util.js';
 import { waitForAddonProvisioning } from './addons_wait.js';
+import * as util from './util.js';
 function formatConfigVarsMessage(addon) {
     const configVars = addon.config_vars || [];
     if (configVars.length > 0) {
-        return `Created ${color.addon(addon.name || '')} as ${configVars.map((c) => color.configVar(c)).join(', ')}`;
+        return `Created ${color.addon(addon.name || '')} as ${configVars.map((c) => color.name(c)).join(', ')}`;
     }
     return `Created ${color.addon(addon.name || '')}`;
 }
-// eslint-disable-next-line max-params
 export default async function (heroku, app, plan, confirm, wait, options) {
     async function createAddonRequest(confirmed) {
         const body = {
+            attachment: { name: options.as },
+            config: options.config,
             confirm: confirmed,
             name: options.name,
-            config: options.config,
             plan: { name: plan },
-            attachment: { name: options.as },
         };
-        ux.action.start(`Creating ${plan} on ${color.app(app)}`);
+        ux.action.start(options.actionStartMessage || `Creating ${plan} on ${color.app(app)}`);
         const { body: addon } = await heroku.post(`/apps/${app}/addons`, {
             body,
             headers: {
@@ -27,7 +26,7 @@ export default async function (heroku, app, plan, confirm, wait, options) {
                 'x-heroku-legacy-provider-messages': 'true',
             },
         });
-        ux.action.stop(color.green(util.formatPriceText(addon.plan?.price || '')));
+        ux.action.stop(options.actionStopMessage || color.green(util.formatPriceText(addon.plan?.price || '')));
         return addon;
     }
     let addon = await util.trapConfirmationRequired(app, confirm, confirm => (createAddonRequest(confirm)));
@@ -42,7 +41,11 @@ export default async function (heroku, app, plan, confirm, wait, options) {
         }
         else {
             ux.stdout(`${color.addon(addon.name || '')} is being created in the background. The app will restart when complete...`);
-            ux.stdout(`Use ${color.cmd('heroku addons:info ' + addon.name)} to check creation progress`);
+            // eslint-disable-next-line @typescript-eslint/no-explicit-any
+            if (utils.pg.isAdvancedDatabase(addon))
+                ux.stdout(`Run ${color.code('heroku data:pg:info ' + addon.name + ' -a ' + addon.app.name)} to check creation progress.`);
+            else
+                ux.stdout(`Run ${color.code('heroku addons:info ' + addon.name)} to check creation progress.`);
         }
     }
     else if (addon.state === 'deprovisioned') {

package/lib/lib/addons/destroy_addon.js

@@ -1,25 +1,27 @@
-import { waitForAddonDeprovisioning } from './addons_wait.js';
-import { color } from '@heroku-cli/color';
+import { color, utils } from '@heroku/heroku-cli-util';
 import { ux } from '@oclif/core';
+import { waitForAddonDeprovisioning } from './addons_wait.js';
 export default async function (heroku, addon, force = false, wait = false) {
     const addonName = addon.name || '';
     async function destroyAddonRequest() {
         ux.action.start(`Destroying ${color.addon(addonName)} on ${color.app(addon.app?.name || '')}`);
         const { body: addonDelete } = await heroku.delete(`/apps/${addon.app?.id}/addons/${addon.id}`, {
-            headers: { 'Accept-Expansion': 'plan' },
             body: { force },
+            headers: { 'Accept-Expansion': 'plan' },
         }).catch(error => {
-            if (error.body && error.body.message) {
-                throw new Error(`The add-on was unable to be destroyed: ${error.body.message}.`);
+            const errorMessage = error.body?.message || error;
+            // eslint-disable-next-line @typescript-eslint/no-explicit-any
+            if (utils.pg.isAdvancedDatabase(addon)) {
+                throw new Error(`We can't destroy your database due to an error: ${errorMessage}. Try again or open a ticket with Heroku Support: https://help.heroku.com/`);
             }
             else {
-                throw new Error(`The add-on was unable to be destroyed: ${error}.`);
+                throw new Error(`The add-on was unable to be destroyed: ${errorMessage}.`);
             }
         });
         // eslint-disable-next-line @typescript-eslint/ban-ts-comment
         // @ts-ignore
         if (addonDelete.state === 'deprovisioning') {
-            ux.action.stop(color.yellow('pending'));
+            ux.action.stop(color.info('pending'));
         }
         ux.action.stop();
         return addonDelete;
@@ -34,11 +36,17 @@ export default async function (heroku, addon, force = false, wait = false) {
         }
         else {
             ux.stdout(`${color.addon(addonName)} is being destroyed in the background. The app will restart when complete...`);
-            ux.stdout(`Use ${color.cmd('heroku addons:info ' + addonName)} to check destruction progress`);
+            ux.stdout(`Run ${color.code('heroku addons:info ' + addonName)} to check destruction progress`);
         }
     }
     else if (addonResponse.state !== 'deprovisioned') {
-        throw new Error(`The add-on was unable to be destroyed, with status ${addonResponse.state}.`);
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        if (utils.pg.isAdvancedDatabase(addonResponse)) {
+            throw new Error(`You can't destroy a database with a ${addonResponse.state} status.`);
+        }
+        else {
+            throw new Error(`The add-on was unable to be destroyed, with status ${addonResponse.state}.`);
+        }
     }
     return addonResponse;
 }

package/lib/lib/addons/resolve.d.ts

@@ -1,38 +1,37 @@
-import { APIClient } from '@heroku-cli/command';
+import type { pg } from '@heroku/heroku-cli-util';
 import type { AddOnAttachment } from '@heroku-cli/schema';
-import type { AddOnAttachmentWithConfigVarsAndPlan } from '../pg/types.js';
-export declare const appAddon: (heroku: APIClient, app: string, id: string, options?: AddOnAttachment) => Promise<AddOnAttachmentWithConfigVarsAndPlan>;
-export declare const addonResolver: (heroku: APIClient, app: string | undefined, id: string, options?: AddOnAttachment) => Promise<AddOnAttachmentWithConfigVarsAndPlan>;
+import { APIClient } from '@heroku-cli/command';
+import type { ExtendedAddon } from '../pg/types.js';
+export declare const appAddon: (heroku: APIClient, app: string, id: string, options?: AddOnAttachment) => Promise<ExtendedAddon>;
+export declare const addonResolver: (heroku: APIClient, app: string | undefined, id: string, options?: AddOnAttachment) => Promise<ExtendedAddon>;
 export declare const appAttachment: (heroku: APIClient, app: string | undefined, id: string, options?: {
     addon_service?: string;
     namespace?: string;
-}) => Promise<AddOnAttachment & {
-    addon: AddOnAttachmentWithConfigVarsAndPlan;
-}>;
+}) => Promise<pg.ExtendedAddonAttachment>;
 export declare const attachmentResolver: (heroku: APIClient, app: string | undefined, id: string, options?: {
     addon_service?: string;
     namespace?: string;
 }) => Promise<void | AddOnAttachment>;
 export declare function resolveAddon(...args: Parameters<typeof addonResolver>): ReturnType<typeof addonResolver>;
 export declare namespace resolveAddon {
-    var cache: Map<string, Promise<AddOnAttachmentWithConfigVarsAndPlan>>;
+    var cache: Map<string, Promise<ExtendedAddon>>;
 }
 export declare class NotFound extends Error {
-    readonly statusCode = 404;
     readonly id = "not_found";
     readonly message = "Couldn't find that addon.";
+    readonly statusCode = 404;
 }
 export declare class AmbiguousError extends Error {
     readonly matches: {
         name?: string;
     }[];
     readonly type: string;
-    readonly statusCode = 422;
-    readonly message: string;
     readonly body: {
         id: string;
         message: string;
     };
+    readonly message: string;
+    readonly statusCode = 422;
     constructor(matches: {
         name?: string;
     }[], type: string);