heroku 9.0.0-alpha.0 → 9.0.0-alpha.2

package/lib/commands/pg/copy.js

@@ -0,0 +1,86 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const color_1 = require("@heroku-cli/color");
+const command_1 = require("@heroku-cli/command");
+const core_1 = require("@oclif/core");
+const host_1 = require("../../lib/pg/host");
+const backups_1 = require("../../lib/pg/backups");
+const fetcher_1 = require("../../lib/pg/fetcher");
+const util_1 = require("../../lib/pg/util");
+const confirmCommand_1 = require("../../lib/confirmCommand");
+const getAttachmentInfo = async function (heroku, db, app) {
+    if (db.match(/^postgres:\/\//)) {
+        const conn = (0, util_1.parsePostgresConnectionString)(db);
+        const host = `${conn.host}:${conn.port}`;
+        return {
+            name: conn.database ? `database ${conn.database} on ${host}` : `database on ${host}`,
+            url: db,
+            confirm: conn.database || conn.host,
+        };
+    }
+    const attachment = await (0, fetcher_1.getAttachment)(heroku, app, db);
+    if (!attachment)
+        throw new Error(`${db} not found on ${color_1.default.magenta(app)}`);
+    const { body: addon } = await heroku.get(`/addons/${attachment.addon.name}`);
+    const { body: config } = await heroku.get(`/apps/${attachment.app.name}/config-vars`);
+    const formattedConfig = Object.fromEntries(Object.entries(config).map(([k, v]) => [k.toUpperCase(), v]));
+    return {
+        name: attachment.name.replace(/^HEROKU_POSTGRESQL_/, '')
+            .replace(/_URL$/, ''),
+        url: formattedConfig[attachment.name.toUpperCase() + '_URL'],
+        attachment: Object.assign(Object.assign({}, attachment), { addon }),
+        confirm: app,
+    };
+};
+class Copy extends command_1.Command {
+    async run() {
+        var _a;
+        const { flags, args } = await this.parse(Copy);
+        const { 'wait-interval': waitInterval, verbose, confirm, app } = flags;
+        const pgbackups = (0, backups_1.default)(app, this.heroku);
+        const interval = Math.max(3, Number.parseInt(waitInterval || '0')) || 3;
+        const [source, target] = await Promise.all([getAttachmentInfo(this.heroku, args.source, app), getAttachmentInfo(this.heroku, args.target, app)]);
+        if (source.url === target.url)
+            throw new Error('Cannot copy database onto itself');
+        await (0, confirmCommand_1.default)(target.confirm || args.target, confirm, `WARNING: Destructive action\nThis command will remove all data from ${color_1.default.yellow(target.name)}\nData from ${color_1.default.yellow(source.name)} will then be transferred to ${color_1.default.yellow(target.name)}`);
+        core_1.ux.action.start(`Starting copy of ${color_1.default.yellow(source.name)} to ${color_1.default.yellow(target.name)}`);
+        const attachment = target.attachment || source.attachment;
+        if (!attachment) {
+            throw new Error('Heroku PostgreSQL database must be source or target');
+        }
+        const { body: copy } = await this.heroku.post(`/client/v11/databases/${attachment.addon.id}/transfers`, {
+            body: {
+                from_name: source.name, from_url: source.url, to_name: target.name, to_url: target.url,
+            },
+            hostname: (0, host_1.default)(),
+        });
+        core_1.ux.action.stop();
+        if (source.attachment) {
+            const { body: credentials } = await this.heroku.get(`/postgres/v0/databases/${source.attachment.addon.name}/credentials`, {
+                hostname: (0, host_1.default)(),
+                headers: {
+                    Authorization: `Basic ${Buffer.from(`:${this.heroku.auth}`).toString('base64')}`,
+                },
+            });
+            if (credentials.length > 1) {
+                core_1.ux.warn('pg:copy will only copy your default credential and the data it has access to. Any additional credentials and data that only they can access will not be copied.');
+            }
+        }
+        await pgbackups.wait('Copying', copy.uuid, interval, verbose, ((_a = attachment.addon.app) === null || _a === void 0 ? void 0 : _a.name) || app);
+    }
+}
+exports.default = Copy;
+Copy.topic = 'pg';
+Copy.description = 'copy all data from source db to target';
+Copy.help = 'at least one of the databases must be a Heroku PostgreSQL DB';
+Copy.flags = {
+    'wait-interval': command_1.flags.string(),
+    verbose: command_1.flags.boolean(),
+    confirm: command_1.flags.string(),
+    app: command_1.flags.app({ required: true }),
+    remote: command_1.flags.remote(),
+};
+Copy.args = {
+    source: core_1.Args.string({ required: true }),
+    target: core_1.Args.string({ required: true }),
+};

package/lib/commands/pg/credentials/create.d.ts

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

package/lib/commands/pg/credentials/create.js

@@ -0,0 +1,40 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const color_1 = require("@heroku-cli/color");
+const command_1 = require("@heroku-cli/command");
+const core_1 = require("@oclif/core");
+const tsheredoc_1 = require("tsheredoc");
+const fetcher_1 = require("../../../lib/pg/fetcher");
+const host_1 = require("../../../lib/pg/host");
+const util_1 = require("../../../lib/pg/util");
+class Create extends command_1.Command {
+    async run() {
+        const { flags, args } = await this.parse(Create);
+        const { app, name } = flags;
+        const { addon: db } = await (0, fetcher_1.getAttachment)(this.heroku, app, args.database);
+        if ((0, util_1.essentialPlan)(db)) {
+            throw new Error("You can't create a custom credential on Essential-tier databases.");
+        }
+        const data = { name };
+        core_1.ux.action.start(`Creating credential ${color_1.default.cyan.bold(name)}`);
+        await this.heroku.post(`/postgres/v0/databases/${db.name}/credentials`, { hostname: (0, host_1.default)(), body: data });
+        core_1.ux.action.stop();
+        const attachCmd = `heroku addons:attach ${db.name} --credential ${name} -a ${app}`;
+        const psqlCmd = `heroku pg:psql ${db.name} -a ${app}`;
+        core_1.ux.log((0, tsheredoc_1.default)(`
+
+      Please attach the credential to the apps you want to use it in by running ${color_1.default.cyan.bold(attachCmd)}.
+      Please define the new grants for the credential within Postgres: ${color_1.default.cyan.bold(psqlCmd)}.`));
+    }
+}
+exports.default = Create;
+Create.topic = 'pg';
+Create.description = 'create credential within database\nExample:\n\n    heroku pg:credentials:create postgresql-something-12345 --name new-cred-name\n';
+Create.flags = {
+    name: command_1.flags.string({ char: 'n', required: true, description: 'name of the new credential within the database' }),
+    app: command_1.flags.app({ required: true }),
+    remote: command_1.flags.remote(),
+};
+Create.args = {
+    database: core_1.Args.string(),
+};

package/lib/commands/pg/credentials/destroy.d.ts

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

package/lib/commands/pg/credentials/destroy.js

@@ -0,0 +1,48 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const color_1 = require("@heroku-cli/color");
+const command_1 = require("@heroku-cli/command");
+const core_1 = require("@oclif/core");
+const util_1 = require("../../../lib/pg/util");
+const fetcher_1 = require("../../../lib/pg/fetcher");
+const host_1 = require("../../../lib/pg/host");
+const confirmCommand_1 = require("../../../lib/confirmCommand");
+class Destroy extends command_1.Command {
+    async run() {
+        const { flags, args } = await this.parse(Destroy);
+        const { database } = args;
+        const { app, name, confirm } = flags;
+        if (name === 'default') {
+            throw new Error('Default credential cannot be destroyed.');
+        }
+        const db = await (0, fetcher_1.getAddon)(this.heroku, app, database);
+        if ((0, util_1.essentialPlan)(db)) {
+            throw new Error("You can't destroy the default credential on Essential-tier databases.");
+        }
+        const { body: attachments } = await this.heroku.get(`/addons/${db.name}/addon-attachments`);
+        const credAttachments = attachments.filter(a => a.namespace === `credential:${name}`);
+        const credAttachmentApps = Array.from(new Set(credAttachments.map(a => { var _a; return (_a = a.app) === null || _a === void 0 ? void 0 : _a.name; })));
+        if (credAttachmentApps.length > 0)
+            throw new Error(`Credential ${name} must be detached from the app${credAttachmentApps.length > 1 ? 's' : ''} ${credAttachmentApps.map(appName => color_1.default.app(appName || ''))
+                .join(', ')} before destroying.`);
+        await (0, confirmCommand_1.default)(app, confirm);
+        core_1.ux.action.start(`Destroying credential ${color_1.default.cyan.bold(name)}`);
+        await this.heroku.delete(`/postgres/v0/databases/${db.name}/credentials/${encodeURIComponent(name)}`, { hostname: (0, host_1.default)() });
+        core_1.ux.action.stop();
+        core_1.ux.log(`The credential has been destroyed within ${db.name}.`);
+        core_1.ux.log(`Database objects owned by ${name} will be assigned to the default credential.`);
+    }
+}
+exports.default = Destroy;
+Destroy.topic = 'pg';
+Destroy.description = 'destroy credential within database';
+Destroy.example = '$ heroku pg:credentials:destroy postgresql-transparent-56874 --name cred-name -a woodstock-production';
+Destroy.flags = {
+    name: command_1.flags.string({ char: 'n', required: true, description: 'unique identifier for the credential' }),
+    confirm: command_1.flags.string({ char: 'c' }),
+    app: command_1.flags.app({ required: true }),
+    remote: command_1.flags.remote(),
+};
+Destroy.args = {
+    database: core_1.Args.string(),
+};

package/lib/commands/pg/credentials/repair-default.d.ts

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

package/lib/commands/pg/credentials/repair-default.js

@@ -0,0 +1,39 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const command_1 = require("@heroku-cli/command");
+const core_1 = require("@oclif/core");
+const fetcher_1 = require("../../../lib/pg/fetcher");
+const util_1 = require("../../../lib/pg/util");
+const confirmCommand_1 = require("../../../lib/confirmCommand");
+const tsheredoc_1 = require("tsheredoc");
+const host_1 = require("../../../lib/pg/host");
+class RepairDefault extends command_1.Command {
+    async run() {
+        const { flags, args } = await this.parse(RepairDefault);
+        const { app, confirm } = flags;
+        const { database } = args;
+        const db = await (0, fetcher_1.getAddon)(this.heroku, app, database);
+        if ((0, util_1.essentialPlan)(db))
+            throw new Error("You can't perform this operation on Essential-tier databases.");
+        await (0, confirmCommand_1.default)(app, confirm, (0, tsheredoc_1.default)(`
+      Destructive Action
+      Ownership of all database objects owned by additional credentials will be transferred to the default credential.
+      This command will also grant the default credential admin option for all additional credentials.
+    `));
+        core_1.ux.action.start('Resetting permissions and object ownership for default role to factory settings');
+        await this.heroku.post(`/postgres/v0/databases/${db.name}/repair-default`, { hostname: (0, host_1.default)() });
+        core_1.ux.action.stop();
+    }
+}
+exports.default = RepairDefault;
+RepairDefault.topic = 'pg';
+RepairDefault.description = 'repair the permissions of the default credential within database';
+RepairDefault.example = '$ heroku pg:credentials:repair-default postgresql-something-12345';
+RepairDefault.flags = {
+    confirm: command_1.flags.string({ char: 'c' }),
+    app: command_1.flags.app({ required: true }),
+    remote: command_1.flags.remote(),
+};
+RepairDefault.args = {
+    database: core_1.Args.string(),
+};

package/lib/commands/pg/credentials/rotate.d.ts

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

package/lib/commands/pg/credentials/rotate.js

@@ -0,0 +1,82 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const color_1 = require("@heroku-cli/color");
+const command_1 = require("@heroku-cli/command");
+const core_1 = require("@oclif/core");
+const confirmCommand_1 = require("../../../lib/confirmCommand");
+const fetcher_1 = require("../../../lib/pg/fetcher");
+const host_1 = require("../../../lib/pg/host");
+const util_1 = require("../../../lib/pg/util");
+class Rotate extends command_1.Command {
+    async run() {
+        const { flags, args } = await this.parse(Rotate);
+        const { app, all, confirm, name, force } = flags;
+        const { addon: db } = await (0, fetcher_1.getAttachment)(this.heroku, app, args.database);
+        const warnings = [];
+        const cred = name || 'default';
+        if (all && name !== undefined) {
+            throw new Error('cannot pass both --all and --name');
+        }
+        if ((0, util_1.legacyEssentialPlan)(db) && cred !== 'default') {
+            throw new Error('Legacy Essential-tier databases do not support named credentials.');
+        }
+        if (all && force) {
+            warnings.push('This forces rotation on all credentials including the default credential.');
+        }
+        let { body: attachments } = await this.heroku.get(`/addons/${db.name}/addon-attachments`);
+        if (name) {
+            attachments = attachments.filter(a => a.namespace === `credential:${cred}`);
+        }
+        if (!all) {
+            warnings.push(`The password for the ${cred} credential will rotate.`);
+        }
+        if (all || force || cred === 'default') {
+            warnings.push('Connections will be reset and applications will be restarted.');
+        }
+        else {
+            warnings.push('Connections older than 30 minutes will be reset, and a temporary rotation username will be used during the process.');
+        }
+        if (force) {
+            warnings.push(`Any followers lagging in replication (see ${color_1.default.cyan.bold('heroku pg:info')}) will be inaccessible until caught up.`);
+        }
+        if (attachments.length > 0) {
+            const uniqueAttachments = [...new Set(attachments.map(attachment => color_1.default.app(attachment.app.name || '')))]
+                .sort()
+                .join(', ');
+            warnings.push(`This command will affect the app${(attachments.length > 1) ? 's' : ''} ${uniqueAttachments}.`);
+        }
+        await (0, confirmCommand_1.default)(app, confirm, `Destructive Action\n${warnings.join('\n')}`);
+        const options = {
+            hostname: (0, host_1.default)(),
+            body: { forced: force !== null && force !== void 0 ? force : undefined },
+            headers: {
+                Authorization: `Basic ${Buffer.from(`:${this.heroku.auth}`).toString('base64')}`,
+            },
+        };
+        if (all) {
+            core_1.ux.action.start(`Rotating all credentials on ${color_1.default.yellow(db.name)}`);
+            await this.heroku.post(`/postgres/v0/databases/${db.name}/credentials_rotation`, options);
+        }
+        else {
+            core_1.ux.action.start(`Rotating ${cred} on ${color_1.default.yellow(db.name)}`);
+            await this.heroku.post(`/postgres/v0/databases/${db.name}/credentials/${encodeURIComponent(cred)}/credentials_rotation`, options);
+        }
+        core_1.ux.action.stop();
+    }
+}
+exports.default = Rotate;
+Rotate.topic = 'pg';
+Rotate.description = 'rotate the database credentials';
+Rotate.flags = {
+    name: command_1.flags.string({
+        char: 'n',
+        description: 'which credential to rotate (default credentials if not specified and --all is not used)',
+    }),
+    all: command_1.flags.boolean({ description: 'rotate all credentials', exclusive: ['name'] }),
+    confirm: command_1.flags.string({ char: 'c' }),
+    force: command_1.flags.boolean({ description: 'forces rotating the targeted credentials' }),
+    app: command_1.flags.app({ required: true }),
+};
+Rotate.args = {
+    database: core_1.Args.string(),
+};

package/lib/commands/pg/credentials/url.d.ts

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

package/lib/commands/pg/credentials/url.js

@@ -0,0 +1,64 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const color_1 = require("@heroku-cli/color");
+const command_1 = require("@heroku-cli/command");
+const core_1 = require("@oclif/core");
+const util_1 = require("../../../lib/pg/util");
+const fetcher_1 = require("../../../lib/pg/fetcher");
+const host_1 = require("../../../lib/pg/host");
+const url_1 = require("url");
+const tsheredoc_1 = require("tsheredoc");
+class Url extends command_1.Command {
+    async run() {
+        const { flags, args } = await this.parse(Url);
+        const { app, name } = flags;
+        const { database } = args;
+        const db = await (0, fetcher_1.getAddon)(this.heroku, app, database);
+        if ((0, util_1.legacyEssentialPlan)(db) && name !== 'default') {
+            core_1.ux.error('Legacy Essential-tier databases do not support named credentials.');
+        }
+        const { body: credInfo } = await this.heroku.get(`/postgres/v0/databases/${db.name}/credentials/${encodeURIComponent(name)}`, {
+            hostname: (0, host_1.default)(),
+            headers: {
+                Authorization: `Basic ${Buffer.from(`:${this.heroku.auth}`).toString('base64')}`,
+            },
+        });
+        const activeCreds = credInfo.credentials.find(c => c.state === 'active');
+        if (!activeCreds) {
+            core_1.ux.error(`Could not find any active credentials for ${name}`, { exit: 1 });
+        }
+        const creds = Object.assign({}, db, {
+            database: credInfo.database, host: credInfo.host, port: credInfo.port,
+        }, {
+            user: activeCreds === null || activeCreds === void 0 ? void 0 : activeCreds.user, password: activeCreds === null || activeCreds === void 0 ? void 0 : activeCreds.password,
+        });
+        const connUrl = new url_1.URL(`postgres://${creds.host}/${creds.database}`);
+        connUrl.port = creds.port.toString();
+        if (creds.user && creds.password) {
+            connUrl.username = creds.user;
+            connUrl.password = creds.password;
+        }
+        core_1.ux.log((0, tsheredoc_1.default)(`
+      Connection information for ${color_1.default.yellow(name)} credential.
+      Connection info string:
+        "dbname=${creds.database} host=${creds.host} port=${creds.port} user=${creds.user} password=${creds.password} sslmode=require"
+      Connection URL:
+        ${connUrl}
+    `));
+    }
+}
+exports.default = Url;
+Url.topic = 'pg';
+Url.description = 'show information on a database credential';
+Url.flags = {
+    name: command_1.flags.string({
+        char: 'n',
+        description: 'which credential to show (default credentials if not specified)',
+        default: 'default',
+    }),
+    app: command_1.flags.app({ required: true }),
+    remote: command_1.flags.remote(),
+};
+Url.args = {
+    database: core_1.Args.string(),
+};

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

@@ -0,0 +1,16 @@
+import { Command } from '@heroku-cli/command';
+import { CredentialInfo, CredentialsInfo } from '../../lib/pg/types';
+export default class Credentials extends Command {
+    static topic: string;
+    static description: string;
+    static flags: {
+        app: import("@oclif/core/lib/interfaces").OptionFlag<string, import("@oclif/core/lib/interfaces/parser").CustomOptions>;
+        remote: import("@oclif/core/lib/interfaces").OptionFlag<string | undefined, import("@oclif/core/lib/interfaces/parser").CustomOptions>;
+    };
+    static args: {
+        database: import("@oclif/core/lib/interfaces/parser").Arg<string | undefined, Record<string, unknown>>;
+    };
+    run(): Promise<void>;
+    protected sortByDefaultAndName(credentials: CredentialsInfo): CredentialsInfo;
+    protected isDefaultCredential(cred: CredentialInfo): boolean;
+}

package/lib/commands/pg/credentials.js

@@ -0,0 +1,61 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const command_1 = require("@heroku-cli/command");
+const core_1 = require("@oclif/core");
+const host_1 = require("../../lib/pg/host");
+const fetcher_1 = require("../../lib/pg/fetcher");
+const util_1 = require("../../lib/pg/util");
+class Credentials extends command_1.Command {
+    async run() {
+        const { flags, args } = await this.parse(Credentials);
+        const { app } = flags;
+        const { database } = args;
+        const addon = await (0, fetcher_1.getAddon)(this.heroku, app, database);
+        const { body: credentials } = await this.heroku.get(`/postgres/v0/databases/${addon.id}/credentials`, {
+            hostname: (0, host_1.default)(),
+            headers: {
+                Authorization: `Basic ${Buffer.from(`:${this.heroku.auth}`).toString('base64')}`,
+            },
+        });
+        const sortedCredentials = this.sortByDefaultAndName(credentials);
+        const { body: attachments } = await this.heroku.get(`/addons/${addon.id}/addon-attachments`);
+        const presentCredential = (cred) => {
+            let credAttachments = [];
+            if (cred.name === 'default') {
+                credAttachments = attachments.filter(a => a.namespace === null);
+            }
+            else {
+                credAttachments = attachments.filter(a => a.namespace === `credential:${cred.name}`);
+            }
+            return (0, util_1.presentCredentialAttachments)(app, credAttachments, sortedCredentials, cred.name);
+        };
+        core_1.ux.table(credentials, {
+            Credential: {
+                get: presentCredential,
+            },
+            State: {
+                get: cred => cred.state,
+            },
+        });
+    }
+    sortByDefaultAndName(credentials) {
+        return credentials.sort((a, b) => {
+            const isDefaultA = this.isDefaultCredential(a);
+            const isDefaultB = this.isDefaultCredential(b);
+            return isDefaultB < isDefaultA ? -1 : (isDefaultA < isDefaultB ? 1 : a.name.localeCompare(b.name));
+        });
+    }
+    isDefaultCredential(cred) {
+        return cred.name === 'default';
+    }
+}
+exports.default = Credentials;
+Credentials.topic = 'pg';
+Credentials.description = 'show information on credentials in the database';
+Credentials.flags = {
+    app: command_1.flags.app({ required: true }),
+    remote: command_1.flags.remote(),
+};
+Credentials.args = {
+    database: core_1.Args.string(),
+};

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

@@ -0,0 +1,18 @@
+import { Command } from '@heroku-cli/command';
+export default class Diagnose extends Command {
+    static topic: string;
+    static description: string;
+    static flags: {
+        json: import("@oclif/core/lib/interfaces").BooleanFlag<boolean>;
+        app: import("@oclif/core/lib/interfaces").OptionFlag<string, import("@oclif/core/lib/interfaces/parser").CustomOptions>;
+        remote: import("@oclif/core/lib/interfaces").OptionFlag<string | undefined, import("@oclif/core/lib/interfaces/parser").CustomOptions>;
+    };
+    static args: {
+        'DATABASE|REPORT_ID': import("@oclif/core/lib/interfaces/parser").Arg<string | undefined, Record<string, unknown>>;
+    };
+    run(): Promise<void>;
+    private displayReport;
+    private display;
+    private generateParams;
+    private generateReport;
+}

package/lib/commands/pg/diagnose.js

@@ -0,0 +1,109 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const command_1 = require("@heroku-cli/command");
+const core_1 = require("@oclif/core");
+const util_1 = require("@oclif/core/lib/util");
+const tsheredoc_1 = require("tsheredoc");
+const fetcher_1 = require("../../lib/pg/fetcher");
+const host_1 = require("../../lib/pg/host");
+const util_2 = require("../../lib/pg/util");
+const color_1 = require("@heroku-cli/color");
+const uuid_validate_1 = require("../../lib/utils/uuid-validate");
+const PGDIAGNOSE_HOST = process.env.PGDIAGNOSE_URL || 'pgdiagnose.herokai.com';
+class Diagnose extends command_1.Command {
+    async run() {
+        const { flags, args } = await this.parse(Diagnose);
+        const id = args['DATABASE|REPORT_ID'];
+        let report;
+        if (id && (0, uuid_validate_1.uuidValidate)(id)) {
+            ({ body: report } = await this.heroku.get(`/reports/${encodeURIComponent(id)}`, { hostname: PGDIAGNOSE_HOST }));
+        }
+        else {
+            report = await this.generateReport(id, flags.app);
+        }
+        this.displayReport(report, flags.json);
+    }
+    displayReport(report, json) {
+        if (json) {
+            core_1.ux.styledJSON(report);
+            return;
+        }
+        core_1.ux.log(`Report ${report.id} for ${report.app}::${report.database}\navailable for one month after creation on ${report.created_at}\n`);
+        this.display(report.checks.filter(c => c.status === 'red'));
+        this.display(report.checks.filter(c => c.status === 'yellow'));
+        this.display(report.checks.filter(c => c.status === 'green'));
+        this.display(report.checks.filter(c => !['red', 'yellow', 'green'].includes(c.status)));
+    }
+    display(checks) {
+        checks.forEach(check => {
+            var _a;
+            const colorFn = color_1.default[check.status] || ((txt) => txt);
+            core_1.ux.log(colorFn(`${check.status.toUpperCase()}: ${check.name}`));
+            const isNonEmptyArray = Array.isArray(check.results) && check.results.length > 0;
+            const resultsKeys = Object.keys((_a = check.results) !== null && _a !== void 0 ? _a : {});
+            if (check.status === 'green' || (!isNonEmptyArray && resultsKeys.length === 0)) {
+                return;
+            }
+            if (isNonEmptyArray) {
+                const keys = Object.keys(check.results[0]);
+                const cols = {};
+                keys.forEach(key => {
+                    cols[(0, util_1.capitalize)(key)] = {
+                        get: (row) => row[key],
+                    };
+                });
+                core_1.ux.table(check.results, cols);
+            }
+            else {
+                const [key] = resultsKeys;
+                core_1.ux.log(`${key.split('_')
+                    .map(s => (0, util_1.capitalize)(s))
+                    .join(' ')} ${check.results[key]}`);
+            }
+        });
+    }
+    async generateParams(url, db, dbName) {
+        const base_params = {
+            url,
+            plan: db.plan.name.split(':')[1],
+            app: db.app.name,
+            database: dbName,
+        };
+        if (!(0, util_2.essentialPlan)(db)) {
+            const { body: metrics } = await this.heroku.get(`/client/v11/databases/${db.id}/metrics`, { hostname: (0, host_1.default)() });
+            base_params.metrics = metrics;
+            const { body: burstData } = await this.heroku.get(`/client/v11/databases/${db.id}/burst_status`, { hostname: (0, host_1.default)() });
+            if (burstData && Object.keys(burstData).length > 0) {
+                base_params.burst_data_present = true;
+                base_params.burst_status = burstData.burst_status;
+            }
+        }
+        return base_params;
+    }
+    async generateReport(database, app) {
+        const attachment = await (0, fetcher_1.getAttachment)(this.heroku, app, database);
+        const { addon: db } = attachment;
+        const { body: config } = await this.heroku.get(`/apps/${app}/config-vars`);
+        const { url } = (0, util_2.getConnectionDetails)(attachment, config);
+        const dbName = (0, util_2.getConfigVarNameFromAttachment)(attachment, config);
+        const body = await this.generateParams(url, db, dbName);
+        const { body: report } = await this.heroku.post('/reports', { hostname: PGDIAGNOSE_HOST, body });
+        return report;
+    }
+}
+exports.default = Diagnose;
+Diagnose.topic = 'pg';
+Diagnose.description = (0, tsheredoc_1.default)(`
+    run or view diagnostics report
+    defaults to DATABASE_URL database if no DATABASE is specified
+    if REPORT_ID is specified instead, a previous report is displayed
+
+    `);
+Diagnose.flags = {
+    json: command_1.flags.boolean({ description: 'format output as JSON' }),
+    app: command_1.flags.app({ required: true }),
+    remote: command_1.flags.remote(),
+};
+Diagnose.args = {
+    'DATABASE|REPORT_ID': core_1.Args.string(),
+};