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

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);

package/lib/lib/addons/resolve.js

@@ -6,8 +6,8 @@ const addonHeaders = {
 };
 export const appAddon = async function (heroku, app, id, options = {}) {
     const response = await heroku.post('/actions/addons/resolve', {
+        body: { addon: id, addon_service: options.addon_service, app },
         headers: addonHeaders,
-        body: { app: app, addon: id, addon_service: options.addon_service },
     });
     return singularize('addon', options.namespace)(response?.body);
 };
@@ -20,8 +20,8 @@ const handleNotFound = function (err, resource) {
 export const addonResolver = async (heroku, app, id, options) => {
     const getAddon = async (addonId) => {
         const response = await heroku.post('/actions/addons/resolve', {
+            body: { addon: addonId, addon_service: options?.addon_service, app: null },
             headers: addonHeaders,
-            body: { app: null, addon: addonId, addon_service: options?.addon_service },
         });
         return singularize('addon', options?.namespace || '')(response?.body);
     };
@@ -43,14 +43,12 @@ export const addonResolver = async (heroku, app, id, options) => {
 // originating from `packages/addons-v5/lib/resolve.js`
 // -----------------------------------------------------
 const filter = function (app, addonService) {
-    return (attachments) => {
-        return attachments.filter(attachment => {
-            if (attachment?.app?.name !== app) {
-                return false;
-            }
-            return !(addonService && attachment?.addon_service?.name !== addonService);
-        });
-    };
+    return (attachments) => attachments.filter(attachment => {
+        if (attachment?.app?.name !== app) {
+            return false;
+        }
+        return !(addonService && attachment?.addon_service?.name !== addonService);
+    });
 };
 const attachmentHeaders = {
     Accept: 'application/vnd.heroku+json; version=3.sdk',
@@ -58,7 +56,7 @@ const attachmentHeaders = {
 };
 export const appAttachment = async (heroku, app, id, options = {}) => {
     const result = await heroku.post('/actions/addon-attachments/resolve', {
-        headers: attachmentHeaders, body: { app, addon_attachment: id, addon_service: options.addon_service },
+        body: { addon_attachment: id, addon_service: options.addon_service, app }, headers: attachmentHeaders,
     });
     return singularize('addon_attachment', options.namespace)(result.body);
 };
@@ -66,7 +64,7 @@ export const attachmentResolver = async (heroku, app, id, options = {}) => {
     async function getAttachment(id) {
         try {
             const result = await heroku.post('/actions/addon-attachments/resolve', {
-                headers: attachmentHeaders, body: { app: null, addon_attachment: id, addon_service: options.addon_service },
+                body: { addon_attachment: id, addon_service: options.addon_service, app: null }, headers: attachmentHeaders,
             });
             return singularize('addon_attachment', options.namespace || '')(result.body);
         }
@@ -129,16 +127,16 @@ export async function resolveAddon(...args) {
 }
 resolveAddon.cache = addonResolverMap;
 export class NotFound extends Error {
-    statusCode = 404;
     id = 'not_found';
     message = 'Couldn\'t find that addon.';
+    statusCode = 404;
 }
 export class AmbiguousError extends Error {
     matches;
     type;
-    statusCode = 422;
-    message;
     body;
+    message;
+    statusCode = 422;
     constructor(matches, type) {
         super();
         this.matches = matches;
@@ -157,12 +155,15 @@ function singularize(type, namespace) {
             matches = matches.filter(m => !Reflect.has(m, 'namespace') || m.namespace === null);
         }
         switch (matches.length) {
-            case 0:
+            case 0: {
                 throw new NotFound();
-            case 1:
+            }
+            case 1: {
                 return matches[0];
-            default:
+            }
+            default: {
                 throw new AmbiguousError(matches, type ?? '');
+            }
         }
     };
 }

package/lib/lib/addons/util.d.ts

@@ -1,8 +1,8 @@
 import * as Heroku from '@heroku-cli/schema';
 export declare const trapConfirmationRequired: <T>(app: string, confirm: string | undefined, fn: (confirmed?: string) => Promise<T>) => Promise<T>;
-export declare const formatPrice: ({ price, hourly }: {
-    price: Heroku.AddOn['price'] | number;
+export declare const formatPrice: ({ hourly, price }: {
     hourly?: boolean | undefined;
+    price: Heroku.AddOn['price'] | number;
 }) => string | undefined;
 export declare const formatPriceText: (price: Heroku.AddOn['price']) => string;
 export declare const grandfatheredPrice: (addon: Heroku.AddOn) => any;

package/lib/lib/addons/util.js

@@ -1,6 +1,6 @@
-import ConfirmCommand from '../confirmCommand.js';
-import { color } from '@heroku-cli/color';
+import { color } from '@heroku/heroku-cli-util';
 import printf from 'printf';
+import ConfirmCommand from '../confirmCommand.js';
 const confirmCommand = new ConfirmCommand();
 export const trapConfirmationRequired = async (app, confirm, fn) => {
     try {
@@ -20,7 +20,7 @@ function isHttpError(error) {
 // This function assumes that price.cents will reflect price per month.
 // If the API returns any unit other than month
 // this function will need to be updated.
-export const formatPrice = function ({ price, hourly }) {
+export const formatPrice = function ({ hourly, price }) {
     if (!price)
         return;
     if (price.contract)
@@ -36,37 +36,44 @@ export const formatPrice = function ({ price, hourly }) {
     return printf(fmt, price.cents / 100, price.unit);
 };
 export const formatPriceText = function (price) {
-    const priceHourly = formatPrice({ price, hourly: true });
-    const priceMonthly = formatPrice({ price, hourly: false });
+    const priceHourly = formatPrice({ hourly: true, price });
+    const priceMonthly = formatPrice({ hourly: false, price });
     if (!priceHourly)
         return '';
     if (priceHourly === 'free' || priceHourly === 'contract' || priceHourly === 'metered')
-        return `${color.green(priceHourly)}`;
-    return `${color.green(priceHourly)} (max ${priceMonthly})`;
+        return `${color.info(priceHourly)}`;
+    return `${color.info(priceHourly)} (max ${priceMonthly})`;
 };
 export const grandfatheredPrice = function (addon) {
     const price = addon.plan?.price;
-    return Object.assign({}, price, {
+    return {
+        ...price,
         cents: addon.billed_price?.cents,
         contract: addon.billed_price?.contract,
-    });
+    };
 };
 export const formatState = function (state) {
     switch (state) {
-        case 'provisioned':
+        case 'provisioned': {
             state = 'created';
             break;
-        case 'provisioning':
+        }
+        case 'provisioning': {
             state = 'creating';
             break;
-        case 'deprovisioning':
+        }
+        case 'deprovisioning': {
             state = 'destroying';
             break;
-        case 'deprovisioned':
+        }
+        case 'deprovisioned': {
             state = 'errored';
             break;
-        default:
+        }
+        default: {
             state = '';
+            break;
+        }
     }
     return state;
 };

package/lib/lib/api.d.ts

@@ -22,8 +22,8 @@ export declare function getTeam(heroku: APIClient, teamId: any): Promise<import(
 export declare function getAccountInfo(heroku: APIClient, id?: string): Promise<import("@heroku/http-call").HTTP<Heroku.Account>>;
 export declare function getAppSetup(heroku: APIClient, buildId: any): Promise<import("@heroku/http-call").HTTP<Heroku.AppSetup>>;
 export interface AppWithPipelineCoupling extends App {
-    pipelineCoupling: PipelineCoupling;
     [k: string]: unknown;
+    pipelineCoupling: PipelineCoupling;
 }
 export declare function listPipelineApps(heroku: APIClient, pipelineId: string): Promise<Array<AppWithPipelineCoupling>>;
 export declare function patchCoupling(heroku: APIClient, id: string, stage: string): Promise<import("@heroku/http-call").HTTP<Heroku.PipelineCoupling>>;

package/lib/lib/api.js

@@ -16,9 +16,9 @@ export function createCoupling(heroku, pipeline, app, stage) {
 }
 export function createPipeline(heroku, name, owner, generationName = 'cedar') {
     return heroku.request('/pipelines', {
-        method: 'POST',
+        body: { generation: { name: generationName }, name, owner },
         headers: { Accept: PIPELINES_HEADER },
-        body: { name, owner, generation: { name: generationName } },
+        method: 'POST',
     });
 }
 export function createPipelineTransfer(heroku, pipeline) {
@@ -31,15 +31,15 @@ function deleteCoupling(heroku, id) {
 }
 export function destroyPipeline(heroku, name, pipelineId) {
     return heroku.request(`/pipelines/${pipelineId}`, {
-        method: 'DELETE',
-        headers: { Accept: PIPELINES_HEADER },
         body: { name },
+        headers: { Accept: PIPELINES_HEADER },
+        method: 'DELETE',
     });
 }
 export function findPipelineByName(heroku, idOrName) {
     return heroku.request(`/pipelines?eq[name]=${idOrName}`, {
-        method: 'GET',
         headers: { Accept: PIPELINES_HEADER },
+        method: 'GET',
     });
 }
 export function getCoupling(heroku, app) {
@@ -49,8 +49,8 @@ export function getCoupling(heroku, app) {
 }
 export function getPipeline(heroku, id) {
     return heroku.request(`/pipelines/${id}`, {
-        method: 'GET',
         headers: { Accept: PIPELINES_HEADER },
+        method: 'GET',
     });
 }
 export function updatePipeline(heroku, id, body) {
@@ -63,9 +63,9 @@ export function getTeam(heroku, teamId) {
 }
 function getAppFilter(heroku, appIds) {
     return heroku.request('/filters/apps', {
-        method: 'POST',
-        headers: { Accept: FILTERS_HEADER, Range: 'id ..; max=1000;' },
         body: { in: { id: appIds } },
+        headers: { Accept: FILTERS_HEADER, Range: 'id ..; max=1000;' },
+        method: 'POST',
     });
 }
 export function getAccountInfo(heroku, id = '~') {
@@ -83,21 +83,17 @@ export async function listPipelineApps(heroku, pipelineId) {
     const { body: couplings } = await listCouplings(heroku, pipelineId);
     const appIds = couplings.map(coupling => coupling.app.id || '');
     const { body: apps } = await getAppFilter(heroku, appIds);
-    return apps.map(app => {
-        return {
-            ...app,
-            pipelineCoupling: couplings.find(coupling => coupling.app.id === app.id),
-        };
-    });
+    return apps.map(app => ({
+        ...app,
+        pipelineCoupling: couplings.find(coupling => coupling.app.id === app.id),
+    }));
 }
 export function patchCoupling(heroku, id, stage) {
     return heroku.patch(`/pipeline-couplings/${id}`, { body: { stage } });
 }
 export function removeCoupling(heroku, app) {
     return getCoupling(heroku, app)
-        .then(({ body }) => {
-        return deleteCoupling(heroku, body.id);
-    });
+        .then(({ body }) => deleteCoupling(heroku, body.id));
 }
 export function updateCoupling(heroku, app, stage) {
     return getCoupling(heroku, app)
@@ -111,16 +107,16 @@ export function getReleases(heroku, appId) {
 }
 export function getPipelineConfigVars(heroku, pipelineID) {
     return heroku.request(`/pipelines/${pipelineID}/stage/test/config-vars`, {
-        method: 'GET',
         headers: { Accept: PIPELINES_HEADER },
+        method: 'GET',
     });
 }
 export function setPipelineConfigVars(heroku, pipelineID, body) {
     return heroku.request(`/pipelines/${pipelineID}/stage/test/config-vars`, {
-        method: 'PATCH',
+        body,
         headers: { Accept: PIPELINES_HEADER },
+        method: 'PATCH',
         path: `/pipelines/${pipelineID}/stage/test/config-vars`,
-        body,
     });
 }
 export async function createTestRun(heroku, body) {
@@ -128,25 +124,25 @@ export async function createTestRun(heroku, body) {
         Accept: CI_HEADER,
     };
     return heroku.request('/test-runs', {
+        body,
         headers,
         method: 'POST',
-        body,
     });
 }
 export async function getTestNodes(heroku, testRunIdD) {
     return heroku.request(`/test-runs/${testRunIdD}/test-nodes`, {
         headers: {
-            Authorization: `Bearer ${heroku.auth}`,
             Accept: CI_HEADER,
+            Authorization: `Bearer ${heroku.auth}`,
         },
     });
 }
 export function updateTestRun(heroku, id, body) {
     return heroku.request(`/test-runs/${id}`, {
         body,
-        method: 'PATCH',
         headers: {
             Accept: CI_HEADER,
         },
+        method: 'PATCH',
     });
 }

package/lib/lib/apps/app-transfer.d.ts

@@ -1,10 +1,10 @@
 import { APIClient } from '@heroku-cli/command';
 declare type Options = {
-    heroku: APIClient;
     appName: string;
-    recipient: string;
-    personalToPersonal: boolean;
     bulk: boolean;
+    heroku: APIClient;
+    personalToPersonal: boolean;
+    recipient: string;
 };
 export declare const appTransfer: (options: Options) => Promise<void>;
 export {};

package/lib/lib/apps/app-transfer.js

@@ -1,30 +1,30 @@
-import { color } from '@heroku-cli/color';
+import { color } from '@heroku/heroku-cli-util';
 import { ux } from '@oclif/core';
 const getRequestOpts = (options) => {
-    const { appName, bulk, recipient, personalToPersonal } = options;
+    const { appName, bulk, personalToPersonal, recipient } = options;
     const isPersonalToPersonal = personalToPersonal || personalToPersonal === undefined;
-    const requestOpts = isPersonalToPersonal ?
-        {
+    const requestOpts = isPersonalToPersonal
+        ? {
             body: { app: appName, recipient },
-            transferMsg: `Initiating transfer of ${color.app(appName)}`,
-            path: '/account/app-transfers',
             method: 'POST',
+            path: '/account/app-transfers',
+            transferMsg: `Initiating transfer of ${color.app(appName)}`,
         } : {
         body: { owner: recipient },
-        transferMsg: `Transferring ${color.app(appName)}`,
-        path: `/teams/apps/${appName}`,
         method: 'PATCH',
+        path: `/teams/apps/${appName}`,
+        transferMsg: `Transferring ${color.app(appName)}`,
     };
     if (!bulk)
-        requestOpts.transferMsg += ` to ${color.magenta(recipient)}`;
+        requestOpts.transferMsg += ` to ${isPersonalToPersonal ? color.user(recipient) : color.team(recipient)}`;
     return requestOpts;
 };
 export const appTransfer = async (options) => {
-    const { body, transferMsg, path, method } = getRequestOpts(options);
+    const { body, method, path, transferMsg } = getRequestOpts(options);
     ux.action.start(transferMsg);
     const { body: request } = await options.heroku.request(path, {
-        method,
         body,
+        method,
     });
     const message = request.state === 'pending' ? 'email sent' : undefined;
     ux.action.stop(message);

package/lib/lib/autocomplete/base.d.ts

@@ -1 +1,11 @@
-export {};
+import { Command } from '@heroku-cli/command';
+import type { Completion } from '../types/completion.js';
+export declare abstract class AutocompleteBase extends Command {
+    get acLogfilePath(): string;
+    get autocompleteCacheDir(): string;
+    get completionsCacheDir(): string;
+    errorIfNotSupportedShell(shell: string): void;
+    errorIfWindows(): void;
+    protected findCompletion(cmdId: string, name: string, description?: string): Completion | undefined;
+    writeLogFile(msg: string): Promise<void>;
+}