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

package/lib/commands/pg/connection-pooling/attach.js

@@ -0,0 +1,38 @@
+import { color, utils } from '@heroku/heroku-cli-util';
+import { Command, flags } from '@heroku-cli/command';
+import { Args, ux } from '@oclif/core';
+import tsheredoc from 'tsheredoc';
+import { essentialPlan } from '../../../lib/pg/util.js';
+import { nls } from '../../../nls.js';
+const heredoc = tsheredoc.default;
+export default class Attach extends Command {
+    static args = {
+        database: Args.string({ description: `${nls('pg:database:arg:description')} ${nls('pg:database:arg:description:default:suffix')}` }),
+    };
+    static description = 'add an attachment to a database using connection pooling';
+    static examples = [heredoc `
+      ${color.command('heroku pg:connection-pooling:attach postgresql-something-12345')}
+    `];
+    static flags = {
+        app: flags.app({ required: true }),
+        as: flags.string({ description: 'name for add-on attachment' }),
+        remote: flags.remote(),
+    };
+    static topic = 'pg';
+    async run() {
+        const { args, flags } = await this.parse(Attach);
+        const { app } = flags;
+        const dbResolver = new utils.pg.DatabaseResolver(this.heroku);
+        const { addon: db } = await dbResolver.getAttachment(app, args.database);
+        if (essentialPlan(db))
+            ux.error('You can\'t perform this operation on Essential-tier databases.');
+        ux.action.start(`Enabling Connection Pooling on ${color.datastore(db.name)} to ${color.app(app)}`);
+        const { body: attachment } = await this.heroku.post(`/client/v11/databases/${encodeURIComponent(db.name)}/connection-pooling`, {
+            body: { app, credential: 'default', name: flags.as }, hostname: utils.pg.host(),
+        });
+        ux.action.stop();
+        ux.action.start(`Setting ${color.attachment(attachment.name)} config vars and restarting ${color.app(app)}`);
+        const { body: releases } = await this.heroku.get(`/apps/${app}/releases`, { headers: { Range: 'version ..; max=1, order=desc' }, partial: true });
+        ux.action.stop(`done, v${releases[0].version}`);
+    }
+}

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

@@ -0,0 +1,18 @@
+import { Command } from '@heroku-cli/command';
+export default class Copy extends Command {
+    static args: {
+        source: import("@oclif/core/interfaces").Arg<string, Record<string, unknown>>;
+        target: import("@oclif/core/interfaces").Arg<string, Record<string, unknown>>;
+    };
+    static description: string;
+    static flags: {
+        app: import("@oclif/core/interfaces").OptionFlag<string, import("@oclif/core/interfaces").CustomOptions>;
+        confirm: import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
+        remote: import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
+        verbose: import("@oclif/core/interfaces").BooleanFlag<boolean>;
+        'wait-interval': import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
+    };
+    static help: string;
+    static topic: string;
+    run(): Promise<void>;
+}

package/lib/commands/pg/copy.js

@@ -0,0 +1,83 @@
+import { color, utils } from '@heroku/heroku-cli-util';
+import { Command, flags } from '@heroku-cli/command';
+import { Args, ux } from '@oclif/core';
+import ConfirmCommand from '../../lib/confirmCommand.js';
+import backupsFactory from '../../lib/pg/backups.js';
+const getAttachmentInfo = async function (heroku, db, app) {
+    const dbResolver = new utils.pg.DatabaseResolver(heroku);
+    if (db.match(/^postgres:\/\//)) {
+        const conn = utils.pg.DatabaseResolver.parsePostgresConnectionString(db);
+        const host = `${conn.host}:${conn.port}`;
+        return {
+            confirm: conn.database || conn.host,
+            name: conn.database ? `database ${conn.database} on ${host}` : `database on ${host}`,
+            url: db,
+        };
+    }
+    const attachment = await dbResolver.getAttachment(app, db);
+    if (!attachment)
+        throw new Error(`${db} not found on ${color.app(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 {
+        attachment: {
+            ...attachment,
+            addon,
+        },
+        confirm: app,
+        name: attachment.name.replace(/^HEROKU_POSTGRESQL_/, '')
+            .replace(/_URL$/, ''),
+        url: formattedConfig[attachment.name.toUpperCase() + '_URL'],
+    };
+};
+export default class Copy extends Command {
+    static args = {
+        source: Args.string({ description: 'config var exposed to the owning app containing the source database URL', required: true }),
+        target: Args.string({ description: 'config var exposed to the owning app containing the target database URL', required: true }),
+    };
+    static description = 'copy all data from source db to target';
+    static flags = {
+        app: flags.app({ required: true }),
+        confirm: flags.string(),
+        remote: flags.remote(),
+        verbose: flags.boolean(),
+        'wait-interval': flags.string(),
+    };
+    static help = 'at least one of the databases must be a Heroku PostgreSQL DB';
+    static topic = 'pg';
+    async run() {
+        const { args, flags } = await this.parse(Copy);
+        const { app, confirm, verbose, 'wait-interval': waitInterval } = flags;
+        const pgbackups = backupsFactory(app, this.heroku);
+        const interval = Math.max(3, Number.parseInt(waitInterval || '0', 10)) || 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 new ConfirmCommand().confirm(target.confirm || args.target, confirm, `WARNING: Destructive action\nThis command will remove all data from ${color.yellow(target.name)}\nData from ${color.yellow(source.name)} will then be transferred to ${color.yellow(target.name)}`);
+        ux.action.start(`Starting copy of ${color.yellow(source.name)} to ${color.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: utils.pg.host(),
+        });
+        ux.action.stop();
+        if (source.attachment) {
+            const { body: credentials } = await this.heroku.get(`/postgres/v0/databases/${source.attachment.addon.name}/credentials`, {
+                headers: {
+                    Authorization: `Basic ${Buffer.from(`:${this.heroku.auth}`).toString('base64')}`,
+                },
+                hostname: utils.pg.host(),
+            });
+            if (credentials.length > 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, attachment.addon.app?.name || app);
+    }
+}

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

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

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

@@ -0,0 +1,39 @@
+import { color, utils } from '@heroku/heroku-cli-util';
+import { Command, flags } from '@heroku-cli/command';
+import { Args, ux } from '@oclif/core';
+import tsheredoc from 'tsheredoc';
+import { essentialPlan } from '../../../lib/pg/util.js';
+import { nls } from '../../../nls.js';
+const heredoc = tsheredoc.default;
+export default class Create extends Command {
+    static args = {
+        database: Args.string({ description: `${nls('pg:database:arg:description')} ${nls('pg:database:arg:description:default:suffix')}` }),
+    };
+    static description = 'create credential within database';
+    static example = `${color.command('heroku pg:credentials:create postgresql-something-12345 --name new-cred-name')}`;
+    static flags = {
+        app: flags.app({ required: true }),
+        name: flags.string({ char: 'n', description: 'name of the new credential within the database', required: true }),
+        remote: flags.remote(),
+    };
+    static topic = 'pg';
+    async run() {
+        const { args, flags } = await this.parse(Create);
+        const { app, name } = flags;
+        const dbResolver = new utils.pg.DatabaseResolver(this.heroku);
+        const { addon: db } = await dbResolver.getAttachment(app, args.database);
+        if (essentialPlan(db)) {
+            throw new Error("You can't create a custom credential on Essential-tier databases.");
+        }
+        const data = { name };
+        ux.action.start(`Creating credential ${color.cyan.bold(name)}`);
+        await this.heroku.post(`/postgres/v0/databases/${db.name}/credentials`, { hostname: utils.pg.host(), body: data });
+        ux.action.stop();
+        const attachCmd = `heroku addons:attach ${db.name} --credential ${name} -a ${app}`;
+        const psqlCmd = `heroku pg:psql ${db.name} -a ${app}`;
+        ux.stdout(heredoc(`
+
+      Please attach the credential to the apps you want to use it in by running ${color.cyan.bold(attachCmd)}.
+      Please define the new grants for the credential within Postgres: ${color.cyan.bold(psqlCmd)}.`));
+    }
+}

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 args: {
+        database: import("@oclif/core/interfaces").Arg<string | undefined, Record<string, unknown>>;
+    };
+    static description: string;
+    static example: string;
+    static flags: {
+        app: import("@oclif/core/interfaces").OptionFlag<string, import("@oclif/core/interfaces").CustomOptions>;
+        confirm: import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
+        name: import("@oclif/core/interfaces").OptionFlag<string, import("@oclif/core/interfaces").CustomOptions>;
+        remote: import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
+    };
+    static topic: string;
+    run(): Promise<void>;
+}

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

@@ -0,0 +1,45 @@
+import { color, utils } from '@heroku/heroku-cli-util';
+import { Command, flags } from '@heroku-cli/command';
+import { Args, ux } from '@oclif/core';
+import ConfirmCommand from '../../../lib/confirmCommand.js';
+import { essentialPlan } from '../../../lib/pg/util.js';
+import { nls } from '../../../nls.js';
+export default class Destroy extends Command {
+    static args = {
+        database: Args.string({ description: `${nls('pg:database:arg:description')} ${nls('pg:database:arg:description:default:suffix')}` }),
+    };
+    static description = 'destroy credential within database';
+    static example = `${color.command('heroku pg:credentials:destroy postgresql-transparent-56874 --name cred-name -a woodstock-production')}`;
+    static flags = {
+        app: flags.app({ required: true }),
+        confirm: flags.string({ char: 'c', description: 'set to app name to bypass confirm prompt' }),
+        name: flags.string({ char: 'n', description: 'unique identifier for the credential', required: true }),
+        remote: flags.remote(),
+    };
+    static topic = 'pg';
+    async run() {
+        const { args, flags } = await this.parse(Destroy);
+        const { database } = args;
+        const { app, confirm, name } = flags;
+        if (name === 'default') {
+            throw new Error('Default credential cannot be destroyed.');
+        }
+        const dbResolver = new utils.pg.DatabaseResolver(this.heroku);
+        const { addon: db } = await dbResolver.getAttachment(app, database);
+        if (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 => a.app?.name)));
+        if (credAttachmentApps.length > 0)
+            throw new Error(`Credential ${name} must be detached from the app${credAttachmentApps.length > 1 ? 's' : ''} ${credAttachmentApps.map(appName => color.app(appName || ''))
+                .join(', ')} before destroying.`);
+        await new ConfirmCommand().confirm(app, confirm);
+        ux.action.start(`Destroying credential ${color.cyan.bold(name)}`);
+        await this.heroku.delete(`/postgres/v0/databases/${db.name}/credentials/${encodeURIComponent(name)}`, { hostname: utils.pg.host() });
+        ux.action.stop();
+        ux.stdout(`The credential has been destroyed within ${db.name}.`);
+        ux.stdout(`Database objects owned by ${name} will be assigned to the default credential.`);
+    }
+}

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 args: {
+        database: import("@oclif/core/interfaces").Arg<string | undefined, Record<string, unknown>>;
+    };
+    static description: string;
+    static example: string;
+    static flags: {
+        app: import("@oclif/core/interfaces").OptionFlag<string, import("@oclif/core/interfaces").CustomOptions>;
+        confirm: import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
+        remote: import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
+    };
+    static topic: string;
+    run(): Promise<void>;
+}

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

@@ -0,0 +1,38 @@
+import { color, utils } from '@heroku/heroku-cli-util';
+import { Command, flags } from '@heroku-cli/command';
+import { Args, ux } from '@oclif/core';
+import tsheredoc from 'tsheredoc';
+import ConfirmCommand from '../../../lib/confirmCommand.js';
+import { essentialPlan } from '../../../lib/pg/util.js';
+import { nls } from '../../../nls.js';
+const heredoc = tsheredoc.default;
+export default class RepairDefault extends Command {
+    static args = {
+        database: Args.string({ description: `${nls('pg:database:arg:description')} ${nls('pg:database:arg:description:default:suffix')}` }),
+    };
+    static description = 'repair the permissions of the default credential within database';
+    static example = `${color.command('heroku pg:credentials:repair-default postgresql-something-12345')}`;
+    static flags = {
+        app: flags.app({ required: true }),
+        confirm: flags.string({ char: 'c', description: 'set to app name to bypass confirm prompt' }),
+        remote: flags.remote(),
+    };
+    static topic = 'pg';
+    async run() {
+        const { args, flags } = await this.parse(RepairDefault);
+        const { app, confirm } = flags;
+        const { database } = args;
+        const dbResolver = new utils.pg.DatabaseResolver(this.heroku);
+        const { addon: db } = await dbResolver.getAttachment(app, database);
+        if (essentialPlan(db))
+            throw new Error("You can't perform this operation on Essential-tier databases.");
+        await new ConfirmCommand().confirm(app, confirm, heredoc(`
+      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.
+    `));
+        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: utils.pg.host() });
+        ux.action.stop();
+    }
+}

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

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

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

@@ -0,0 +1,79 @@
+import { color, utils } from '@heroku/heroku-cli-util';
+import { Command, flags } from '@heroku-cli/command';
+import { Args, ux } from '@oclif/core';
+import ConfirmCommand from '../../../lib/confirmCommand.js';
+import { nls } from '../../../nls.js';
+export default class Rotate extends Command {
+    static args = {
+        database: Args.string({ description: `${nls('pg:database:arg:description')} ${nls('pg:database:arg:description:default:suffix')}` }),
+    };
+    static description = 'rotate the database credentials';
+    static flags = {
+        all: flags.boolean({ description: 'rotate all credentials', exclusive: ['name'] }),
+        app: flags.app({ required: true }),
+        confirm: flags.string({ char: 'c', description: 'set to app name to bypass confirm prompt' }),
+        force: flags.boolean({ description: 'forces rotating the targeted credentials' }),
+        name: flags.string({
+            char: 'n',
+            description: 'which credential to rotate (default credentials if not specified and --all is not used)',
+        }),
+        remote: flags.remote(),
+    };
+    static topic = 'pg';
+    async run() {
+        const { args, flags } = await this.parse(Rotate);
+        const { all, app, confirm, force, name } = flags;
+        const dbResolver = new utils.pg.DatabaseResolver(this.heroku);
+        const { addon: db } = await dbResolver.getAttachment(app, args.database);
+        const warnings = [];
+        const cred = name || 'default';
+        if (all && name !== undefined) {
+            throw new Error('cannot pass both --all and --name');
+        }
+        if (utils.pg.isLegacyEssentialDatabase(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.cyan.bold('heroku pg:info')}) will be inaccessible until caught up.`);
+        }
+        if (attachments.length > 0) {
+            const uniqueAppNames = [...new Set(attachments.map(attachment => color.app(attachment.app.name || '')))]
+                .sort()
+                .join(', ');
+            warnings.push(`This command will affect the app${(uniqueAppNames.length > 1) ? 's' : ''} ${uniqueAppNames}.`);
+        }
+        await new ConfirmCommand().confirm(app, confirm, `Destructive Action\n${warnings.join('\n')}`);
+        const options = {
+            body: { forced: force ?? undefined },
+            headers: {
+                Authorization: `Basic ${Buffer.from(`:${this.heroku.auth}`).toString('base64')}`,
+            },
+            hostname: utils.pg.host(),
+        };
+        if (all) {
+            ux.action.start(`Rotating all credentials on ${color.datastore(db.name)}`);
+            await this.heroku.post(`/postgres/v0/databases/${db.name}/credentials_rotation`, options);
+        }
+        else {
+            ux.action.start(`Rotating ${cred} on ${color.datastore(db.name)}`);
+            await this.heroku.post(`/postgres/v0/databases/${db.name}/credentials/${encodeURIComponent(cred)}/credentials_rotation`, options);
+        }
+        ux.action.stop();
+    }
+}

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 args: {
+        database: import("@oclif/core/interfaces").Arg<string | undefined, Record<string, unknown>>;
+    };
+    static description: string;
+    static flags: {
+        app: import("@oclif/core/interfaces").OptionFlag<string, import("@oclif/core/interfaces").CustomOptions>;
+        name: import("@oclif/core/interfaces").OptionFlag<string, import("@oclif/core/interfaces").CustomOptions>;
+        remote: import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
+    };
+    static topic: string;
+    run(): Promise<void>;
+}

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

@@ -0,0 +1,59 @@
+import { color, utils } from '@heroku/heroku-cli-util';
+import { Command, flags } from '@heroku-cli/command';
+import { Args, ux } from '@oclif/core';
+import tsheredoc from 'tsheredoc';
+import { URL } from 'url';
+import { nls } from '../../../nls.js';
+const heredoc = tsheredoc.default;
+export default class Url extends Command {
+    static args = {
+        database: Args.string({ description: `${nls('pg:database:arg:description')} ${nls('pg:database:arg:description:default:suffix')}` }),
+    };
+    static description = 'show information on a database credential';
+    static flags = {
+        app: flags.app({ required: true }),
+        name: flags.string({
+            char: 'n',
+            default: 'default',
+            description: 'which credential to show (default credentials if not specified)',
+        }),
+        remote: flags.remote(),
+    };
+    static topic = 'pg';
+    async run() {
+        const { args, flags } = await this.parse(Url);
+        const { app, name } = flags;
+        const { database } = args;
+        const dbResolver = new utils.pg.DatabaseResolver(this.heroku);
+        const { addon: db } = await dbResolver.getAttachment(app, database);
+        if (utils.pg.isLegacyEssentialDatabase(db) && name !== 'default') {
+            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)}`, {
+            headers: {
+                Authorization: `Basic ${Buffer.from(`:${this.heroku.auth}`).toString('base64')}`,
+            },
+            hostname: utils.pg.host(),
+        });
+        const activeCreds = credInfo.credentials.find(c => c.state === 'active');
+        if (!activeCreds) {
+            ux.error(`Could not find any active credentials for ${name}`, { exit: 1 });
+        }
+        const creds = {
+            ...db, database: credInfo.database, host: credInfo.host, password: activeCreds?.password, port: credInfo.port, user: activeCreds?.user,
+        };
+        const connUrl = new URL(`postgres://${creds.host}/${creds.database}`);
+        connUrl.port = creds.port.toString();
+        if (creds.user && creds.password) {
+            connUrl.username = creds.user;
+            connUrl.password = creds.password;
+        }
+        ux.stdout(heredoc(`
+      Connection information for ${color.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}
+    `));
+    }
+}

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

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

package/lib/commands/pg/credentials.js

@@ -0,0 +1,61 @@
+import { hux, utils } from '@heroku/heroku-cli-util';
+import { Command, flags } from '@heroku-cli/command';
+import { Args } from '@oclif/core';
+import { presentCredentialAttachments } from '../../lib/pg/util.js';
+import { nls } from '../../nls.js';
+export default class Credentials extends Command {
+    static args = {
+        database: Args.string({ description: `${nls('pg:database:arg:description')} ${nls('pg:database:arg:description:default:suffix')}` }),
+    };
+    static description = 'show information on credentials in the database';
+    static flags = {
+        app: flags.app({ required: true }),
+        remote: flags.remote(),
+    };
+    static topic = 'pg';
+    isDefaultCredential(cred) {
+        return cred.name === 'default';
+    }
+    async run() {
+        const { args, flags } = await this.parse(Credentials);
+        const { app } = flags;
+        const { database } = args;
+        const dbResolver = new utils.pg.DatabaseResolver(this.heroku);
+        const { addon } = await dbResolver.getAttachment(app, database);
+        const { body: credentials } = await this.heroku.get(`/postgres/v0/databases/${addon.id}/credentials`, {
+            headers: {
+                Authorization: `Basic ${Buffer.from(`:${this.heroku.auth}`).toString('base64')}`,
+            },
+            hostname: utils.pg.host(),
+        });
+        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 presentCredentialAttachments(app, credAttachments, sortedCredentials, cred.name);
+        };
+        hux.table(credentials, {
+            Credential: {
+                get: presentCredential,
+            },
+            State: {
+                get: cred => cred.state,
+            },
+        }, {
+            overflow: 'wrap',
+        });
+    }
+    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));
+        });
+    }
+}

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/interfaces").BooleanFlag<boolean>;
+        app: import("@oclif/core/interfaces").OptionFlag<string, import("@oclif/core/interfaces").CustomOptions>;
+        remote: import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
+    };
+    static args: {
+        'DATABASE|REPORT_ID': import("@oclif/core/interfaces").Arg<string | undefined, Record<string, unknown>>;
+    };
+    run(): Promise<void>;
+    private displayReport;
+    private display;
+    private generateParams;
+    private generateReport;
+}