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

package/lib/commands/pg/backups/info.js

@@ -0,0 +1,86 @@
+import { color, hux, utils } from '@heroku/heroku-cli-util';
+import { Command, flags } from '@heroku-cli/command';
+import { Args, ux } from '@oclif/core';
+import pgBackupsApi from '../../../lib/pg/backups.js';
+function status(backup) {
+    if (backup.succeeded) {
+        if (backup.warnings > 0)
+            return `Finished with ${backup.warnings} warnings`;
+        return 'Completed';
+    }
+    if (backup.canceled_at)
+        return 'Canceled';
+    if (backup.finished_at)
+        return 'Failed';
+    if (backup.started_at)
+        return 'Running';
+    return 'Pending';
+}
+function compression(compressed, total) {
+    let pct = 0;
+    if (compressed > 0) {
+        pct = Math.round((total - compressed) / total * 100);
+        pct = Math.max(0, pct);
+    }
+    return ` (${pct}% compression)`;
+}
+export default class Info extends Command {
+    static args = {
+        backup_id: Args.string({ description: 'ID of the backup. If omitted, we use the last backup ID.' }),
+    };
+    static description = 'get information about a specific backup';
+    static flags = {
+        app: flags.app({ required: true }),
+        remote: flags.remote(),
+    };
+    static topic = 'pg';
+    displayBackup = (backup, app) => {
+        const pgbackups = pgBackupsApi(app, this.heroku);
+        hux.styledHeader(`Backup ${color.name(pgbackups.name(backup))}`);
+        /* eslint-disable perfectionist/sort-objects */
+        hux.styledObject({
+            Database: color.datastore(backup.from_name),
+            'Started at': backup.started_at,
+            'Finished at': backup.finished_at,
+            Status: status(backup),
+            Type: backup.schedule ? 'Scheduled' : 'Manual', 'Original DB Size': pgbackups.filesize(backup.source_bytes),
+            'Backup Size': `${pgbackups.filesize(backup.processed_bytes)}${backup.finished_at ? compression(backup.processed_bytes, backup.source_bytes) : ''}`,
+        }, ['Database', 'Started at', 'Finished at', 'Status', 'Type', 'Original DB Size', 'Backup Size']);
+        /* eslint-enable perfectionist/sort-objects */
+        ux.stdout('\n');
+    };
+    displayLogs = (backup) => {
+        hux.styledHeader('Backup Logs');
+        for (const log of backup.logs)
+            ux.stdout(`${log.created_at} ${log.message}\n`);
+        ux.stdout('\n');
+    };
+    getBackup = async (id, app) => {
+        let backupID;
+        if (id) {
+            const pgbackups = pgBackupsApi(app, this.heroku);
+            backupID = await pgbackups.num(id);
+            if (!backupID)
+                throw new Error(`Invalid ID: ${id}`);
+        }
+        else {
+            const { body: transfers } = await this.heroku.get(`/client/v11/apps/${app}/transfers`, { hostname: utils.pg.host() });
+            transfers.sort((a, b) => a.created_at.localeCompare(b.created_at));
+            const backups = transfers.filter(t => t.from_type === 'pg_dump' && t.to_type === 'gof3r');
+            const lastBackup = backups.pop();
+            if (!lastBackup)
+                throw new Error(`No backups. Capture one with ${color.code('heroku pg:backups:capture')}`);
+            backupID = lastBackup.num;
+        }
+        const { body: backup } = await this.heroku.get(`/client/v11/apps/${app}/transfers/${backupID}?verbose=true`, { hostname: utils.pg.host() });
+        return backup;
+    };
+    async run() {
+        const { args, flags } = await this.parse(Info);
+        const { app } = flags;
+        const { backup_id } = args;
+        const backup = await this.getBackup(backup_id, app);
+        this.displayBackup(backup, app);
+        this.displayLogs(backup);
+    }
+}

package/lib/commands/pg/backups/restore.d.ts

@@ -0,0 +1,20 @@
+import { Command } from '@heroku-cli/command';
+export default class Restore extends Command {
+    static args: {
+        backup: import("@oclif/core/interfaces").Arg<string | undefined, Record<string, unknown>>;
+        database: import("@oclif/core/interfaces").Arg<string | undefined, Record<string, unknown>>;
+    };
+    static description: string;
+    static examples: 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>;
+        extensions: 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<number, import("@oclif/core/interfaces").CustomOptions>;
+    };
+    static topic: string;
+    protected getSortedExtensions(extensions: null | string | undefined): string[] | undefined;
+    run(): Promise<void>;
+}

package/lib/commands/pg/backups/restore.js

@@ -0,0 +1,134 @@
+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 backupsFactory from '../../../lib/pg/backups.js';
+import { nls } from '../../../nls.js';
+const heredoc = tsheredoc.default;
+function dropboxURL(url) {
+    if (url.match(/^https?:\/\/www\.dropbox\.com/) && !url.endsWith('dl=1')) {
+        if (url.endsWith('dl=0'))
+            url = url.replace('dl=0', 'dl=1');
+        else if (url.includes('?'))
+            url += '&dl=1';
+        else
+            url += '?dl=1';
+    }
+    return url;
+}
+export default class Restore extends Command {
+    static args = {
+        backup: Args.string({ description: 'URL or backup ID from another app' }),
+        database: Args.string({ description: `${nls('pg:database:arg:description')} ${nls('pg:database:arg:description:default:suffix')}` }),
+    };
+    static description = 'restore a backup (default latest) to a database';
+    static examples = [
+        heredoc(`
+    # Basic Restore from Backup ID
+    ${color.command('heroku pg:backups:restore b101 DATABASE_URL --app my-heroku-app')}
+    `),
+        heredoc(`
+    # Restore from Another App
+    ${color.command('heroku pg:backups:restore example-app::b101 DATABASE_URL --app my-heroku-app')}
+    `),
+        heredoc(`
+    # Restore from a Public URL
+    ${color.command('heroku pg:backups:restore "https://s3.amazonaws.com/my-bucket/mydb.dump" DATABASE_URL --app my-heroku-app')}
+    `),
+        heredoc(`
+    # Verbose Output
+    ${color.command('heroku pg:backups:restore b101 DATABASE_URL --app my-heroku-app --verbose')}
+    `),
+        heredoc(`
+    # Restore with Confirmation Prompt
+    ${color.command('heroku pg:backups:restore b101 DATABASE_URL --app my-heroku-app --confirm my-heroku-app')}
+    `),
+        heredoc(`
+    # Restore with a Specific Database Name
+    ${color.command('heroku pg:backups:restore b101 HEROKU_POSTGRESQL_PINK --app my-heroku-app')}
+    `),
+    ];
+    static flags = {
+        app: flags.app({ required: true }),
+        confirm: flags.string({ char: 'c' }),
+        extensions: flags.string({
+            char: 'e',
+            description: heredoc(`
+        comma-separated list of extensions to pre-install in the default
+        public schema or an optional custom schema
+        (for example: hstore or myschema.hstore)
+      `),
+        }),
+        remote: flags.remote(),
+        verbose: flags.boolean({ char: 'v' }),
+        'wait-interval': flags.integer({ default: 3 }),
+    };
+    static topic = 'pg';
+    getSortedExtensions(extensions) {
+        return extensions?.split(',').map(ext => ext.trim().toLowerCase()).sort();
+    }
+    async run() {
+        const { args, flags } = await this.parse(Restore);
+        const { app, confirm, extensions, verbose, 'wait-interval': waitInterval } = flags;
+        const interval = Math.max(3, waitInterval);
+        const dbResolver = new utils.pg.DatabaseResolver(this.heroku);
+        const { addon: db } = await dbResolver.getAttachment(app, args.database);
+        const pgbackups = backupsFactory(app, this.heroku);
+        let backupURL;
+        let backupName = args.backup;
+        if (backupName && backupName.match(/^https?:\/\//)) {
+            backupURL = dropboxURL(backupName);
+        }
+        else {
+            let backupApp;
+            if (backupName && backupName.match(/::/)) {
+                [backupApp, backupName] = backupName.split('::');
+            }
+            else {
+                backupApp = app;
+            }
+            const { body: transfers } = await this.heroku.get(`/client/v11/apps/${backupApp}/transfers`, { hostname: utils.pg.host() });
+            const backups = transfers.filter(t => t.from_type === 'pg_dump' && t.to_type === 'gof3r');
+            let backup;
+            if (backupName) {
+                backup = backups.find(b => pgbackups.name(b) === backupName);
+                if (!backup)
+                    throw new Error(`Backup ${color.cyan(backupName)} not found for ${color.app(backupApp)}`);
+                if (!backup.succeeded)
+                    throw new Error(`Backup ${color.cyan(backupName)} for ${color.app(backupApp)} did not complete successfully`);
+            }
+            else {
+                backup = backups.filter(b => b.succeeded).sort((a, b) => {
+                    if (a.finished_at && b.finished_at) {
+                        return a.finished_at.localeCompare(b.finished_at);
+                    }
+                    if (a.finished_at)
+                        return 1;
+                    if (b.finished_at)
+                        return -1;
+                    return 0;
+                }).pop();
+                if (!backup) {
+                    throw new Error(`No backups for ${color.app(backupApp)}. Capture one with ${color.cyan.bold('heroku pg:backups:capture')}`);
+                }
+                backupName = pgbackups.name(backup);
+            }
+            backupURL = backup.to_url;
+        }
+        const confirmCmd = new ConfirmCommand();
+        await confirmCmd.confirm(app, confirm);
+        ux.action.start(`Starting restore of ${color.cyan(backupName)} to ${color.datastore(db.name)}`);
+        ux.stdout(heredoc(`
+
+    Use Ctrl-C at any time to stop monitoring progress; the backup will continue restoring.
+    Use ${color.cyan.bold('heroku pg:backups')} to check progress.
+    Stop a running restore with ${color.cyan.bold('heroku pg:backups:cancel')}.
+    `));
+        const { body: restore } = await this.heroku.post(`/client/v11/databases/${db.id}/restores`, {
+            body: { backup_url: backupURL, extensions: this.getSortedExtensions(extensions) }, hostname: utils.pg.host(),
+        });
+        ux.action.stop();
+        await pgbackups.wait('Restoring', restore.uuid, interval, verbose, db.app.id);
+    }
+}

package/lib/commands/pg/backups/schedule.d.ts

@@ -0,0 +1,21 @@
+import { Command } from '@heroku-cli/command';
+declare type BackupSchedule = {
+    hour: string;
+    timezone: string;
+    schedule_name?: string;
+};
+export default class Schedule extends Command {
+    static topic: string;
+    static description: string;
+    static flags: {
+        at: import("@oclif/core/interfaces").OptionFlag<string, import("@oclif/core/interfaces").CustomOptions>;
+        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: import("@oclif/core/interfaces").Arg<string | undefined, Record<string, unknown>>;
+    };
+    parseDate: (at: string) => BackupSchedule;
+    run(): Promise<void>;
+}
+export {};

package/lib/commands/pg/backups/schedule.js

@@ -0,0 +1,69 @@
+import { color, utils } from '@heroku/heroku-cli-util';
+import { Command, flags } from '@heroku-cli/command';
+import { Args, ux } from '@oclif/core';
+import { nls } from '../../../nls.js';
+const TZ = {
+    PST: 'America/Los_Angeles',
+    PDT: 'America/Los_Angeles',
+    MST: 'America/Boise',
+    MDT: 'America/Boise',
+    CST: 'America/Chicago',
+    CDT: 'America/Chicago',
+    EST: 'America/New_York',
+    EDT: 'America/New_York',
+    Z: 'UTC',
+    GMT: 'Europe/London',
+    BST: 'Europe/London',
+    CET: 'Europe/Paris',
+    CEST: 'Europe/Paris',
+};
+export default class Schedule extends Command {
+    static topic = 'pg';
+    static description = 'schedule daily backups for given database';
+    static flags = {
+        at: flags.string({ required: true, description: "at a specific (24h) hour in the given timezone. Defaults to UTC. --at '[HOUR]:00 [TIMEZONE]'" }),
+        app: flags.app({ required: true }),
+        remote: flags.remote(),
+    };
+    static args = {
+        database: Args.string({ description: `${nls('pg:database:arg:description')} ${nls('pg:database:arg:description:default:suffix')}` }),
+    };
+    parseDate = function (at) {
+        const m = at.match(/^(0?\d|1\d|2[0-3]):00 ?(\S*)$/);
+        if (m) {
+            const [, hour, timezone] = m;
+            return { hour, timezone: TZ[timezone.toUpperCase()] || timezone || 'UTC' };
+        }
+        return ux.error("Invalid schedule format: expected --at '[HOUR]:00 [TIMEZONE]'", { exit: 1 });
+    };
+    async run() {
+        const { flags, args } = await this.parse(Schedule);
+        const { app } = flags;
+        const { database } = args;
+        const schedule = this.parseDate(flags.at);
+        const dbResolver = new utils.pg.DatabaseResolver(this.heroku);
+        const attachment = await dbResolver.getAttachment(app, database);
+        const { addon: db, name } = attachment;
+        const at = color.cyan(`${schedule.hour}:00 ${schedule.timezone}`);
+        const pgResponse = await this.heroku.get(`/client/v11/databases/${db.id}`, { hostname: utils.pg.host() })
+            .catch((error) => {
+            if (error.statusCode !== 404)
+                throw error;
+            ux.error(`${color.datastore(db.name)} is not yet provisioned.\nRun ${color.cyan.bold('heroku addons:wait')} to wait until the db is provisioned.`, { exit: 1 });
+        });
+        const { body: dbInfo } = pgResponse || { body: null };
+        if (dbInfo) {
+            const dbProtected = /On/.test(dbInfo.info.find(attribute => attribute.name === 'Continuous Protection')?.values[0] || '');
+            if (dbProtected) {
+                ux.warn('Continuous protection is already enabled for this database. Logical backups of large databases are likely to fail.');
+                ux.warn('See https://devcenter.heroku.com/articles/heroku-postgres-data-safety-and-continuous-protection#physical-backups-on-heroku-postgres.');
+            }
+        }
+        ux.action.start(`Scheduling automatic daily backups of ${color.datastore(db.name)} at ${at}`);
+        schedule.schedule_name = name + '_URL';
+        await this.heroku.post(`/client/v11/databases/${db.id}/transfer-schedules`, {
+            body: schedule, hostname: utils.pg.host(),
+        });
+        ux.action.stop();
+    }
+}

package/lib/commands/pg/backups/schedules.d.ts

@@ -0,0 +1,10 @@
+import { Command } from '@heroku-cli/command';
+export default class Schedules extends Command {
+    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;
+    run(): Promise<void>;
+}

package/lib/commands/pg/backups/schedules.js

@@ -0,0 +1,27 @@
+import { color, hux, utils } from '@heroku/heroku-cli-util';
+import { Command, flags } from '@heroku-cli/command';
+import { ux } from '@oclif/core';
+export default class Schedules extends Command {
+    static description = 'list backup schedule';
+    static flags = {
+        app: flags.app({ required: true }),
+        remote: flags.remote(),
+    };
+    static topic = 'pg';
+    async run() {
+        const { flags } = await this.parse(Schedules);
+        const { app } = flags;
+        const dbResolver = new utils.pg.DatabaseResolver(this.heroku);
+        const db = await dbResolver.getArbitraryLegacyDB(app);
+        const { body: schedules } = await this.heroku.get(`/client/v11/databases/${db.id}/transfer-schedules`, { hostname: utils.pg.host() });
+        if (schedules.length === 0) {
+            ux.warn(`No backup schedules found on ${color.app(app)}\nUse ${color.code('heroku pg:backups:schedule')} to set one up`);
+        }
+        else {
+            hux.styledHeader('Backup Schedules');
+            for (const s of schedules) {
+                ux.stdout(`${color.name(s.name)}: daily at ${s.hour}:00 ${s.timezone}\n`);
+            }
+        }
+    }
+}

package/lib/commands/pg/backups/unschedule.d.ts

@@ -0,0 +1,13 @@
+import { Command } from '@heroku-cli/command';
+export default class Unschedule 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;
+    run(): Promise<void>;
+}

package/lib/commands/pg/backups/unschedule.js

@@ -0,0 +1,42 @@
+import { color, utils } from '@heroku/heroku-cli-util';
+import { Command, flags } from '@heroku-cli/command';
+import { Args, ux } from '@oclif/core';
+import { nls } from '../../../nls.js';
+export default class Unschedule extends Command {
+    static args = {
+        database: Args.string({ description: `${nls('pg:database:arg:description')} ${nls('pg:database:arg:description:arbitrary:suffix')}` }),
+    };
+    static description = 'stop daily backups';
+    static flags = {
+        app: flags.app({ required: true }),
+        remote: flags.remote(),
+    };
+    static topic = 'pg';
+    async run() {
+        const { args, flags } = await this.parse(Unschedule);
+        const { app } = flags;
+        const { database } = args;
+        let db = database;
+        if (!db) {
+            const dbResolver = new utils.pg.DatabaseResolver(this.heroku);
+            const appDB = await dbResolver.getArbitraryLegacyDB(app);
+            const { body: schedules } = await this.heroku.get(`/client/v11/databases/${appDB.id}/transfer-schedules`, { hostname: utils.pg.host() });
+            if (schedules.length === 0)
+                throw new Error(`No schedules on ${color.app(app)}`);
+            if (schedules.length > 1) {
+                throw new Error(`Specify schedule on ${color.app(app)}. Existing schedules: ${schedules.map(s => color.datastore(s.name))
+                    .join(', ')}`);
+            }
+            db = schedules[0].name;
+        }
+        ux.action.start(`Unscheduling ${color.datastore(db)} daily backups`);
+        const dbResolver = new utils.pg.DatabaseResolver(this.heroku);
+        const { addon } = await dbResolver.getAttachment(app, db);
+        const { body: schedules } = await this.heroku.get(`/client/v11/databases/${addon.id}/transfer-schedules`, { hostname: utils.pg.host() });
+        const schedule = schedules.find(s => s.name.match(new RegExp(`${db}`, 'i')));
+        if (!schedule)
+            throw new Error(`No daily backups found for ${color.datastore(addon.name)}`);
+        await this.heroku.delete(`/client/v11/databases/${addon.id}/transfer-schedules/${schedule.uuid}`, { hostname: utils.pg.host() });
+        ux.action.stop();
+    }
+}

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

@@ -0,0 +1,13 @@
+import { Command } from '@heroku-cli/command';
+export default class Url extends Command {
+    static args: {
+        backup_id: 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;
+    run(): Promise<void>;
+}

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

@@ -0,0 +1,37 @@
+import { color, utils } from '@heroku/heroku-cli-util';
+import { Command, flags } from '@heroku-cli/command';
+import { Args, ux } from '@oclif/core';
+import pgBackupsApi from '../../../lib/pg/backups.js';
+export default class Url extends Command {
+    static args = {
+        backup_id: Args.string({ description: 'ID of the backup. If omitted, we use the last backup ID.' }),
+    };
+    static description = 'get secret but publicly accessible URL of a backup';
+    static flags = {
+        app: flags.app({ required: true }),
+        remote: flags.remote(),
+    };
+    static topic = 'pg';
+    async run() {
+        const { args, flags } = await this.parse(Url);
+        const { backup_id } = args;
+        const { app } = flags;
+        let num;
+        if (backup_id) {
+            num = await pgBackupsApi(app, this.heroku).num(backup_id);
+            if (!num)
+                throw new Error(`Invalid Backup: ${backup_id}`);
+        }
+        else {
+            const { body: transfers } = await this.heroku.get(`/client/v11/apps/${app}/transfers`, { hostname: utils.pg.host() });
+            const succeededBackups = transfers.filter(t => t.succeeded && t.to_type === 'gof3r');
+            succeededBackups.sort((a, b) => a.created_at.localeCompare(b.created_at));
+            const lastBackup = succeededBackups.pop();
+            if (!lastBackup)
+                throw new Error(`No backups on ${color.app(app)}. Capture one with ${color.cyan.bold('heroku pg:backups:capture')}`);
+            num = lastBackup.num;
+        }
+        const { body: info } = await this.heroku.post(`/client/v11/apps/${app}/transfers/${num}/actions/public-url`, { hostname: utils.pg.host() });
+        ux.stdout(info.url + '\n');
+    }
+}

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

@@ -0,0 +1,13 @@
+import { Command } from '@heroku-cli/command';
+export default class Bloat extends Command {
+    static description: string;
+    static topic: string;
+    static args: {
+        database: import("@oclif/core/interfaces").Arg<string | undefined, Record<string, unknown>>;
+    };
+    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>;
+    };
+    run(): Promise<void>;
+}

package/lib/{oldCommands → commands}/pg/bloat.js

@@ -1,11 +1,7 @@
-export {};
-/*
-import {Command, flags} from '@heroku-cli/command'
-import {Args} from '@oclif/core'
-import {database} from '../../lib/pg/fetcher'
-import {exec} from '../../lib/pg/psql'
-import {nls} from '../../nls'
-
+import { Command, flags } from '@heroku-cli/command';
+import { Args, ux } from '@oclif/core';
+import { utils } from '@heroku/heroku-cli-util';
+import { nls } from '../../nls.js';
 const query = `
 WITH constants AS (
   SELECT current_setting('block_size')::numeric AS bs, 23 AS hdr, 4 AS ma
@@ -67,27 +63,24 @@ SELECT
 FROM
   index_bloat) bloat_summary
 ORDER BY raw_waste DESC, bloat DESC
-`
-
+`;
 export default class Bloat extends Command {
-  static topic = 'pg';
-  static description = 'show table and index bloat in your database ordered by most wasteful';
-  static flags = {
-    app: flags.app({required: true}),
-    remote: flags.remote(),
-  };
-
-  static args = {
-    database: Args.string({description: `${nls('pg:database:arg:description')} ${nls('pg:database:arg:description:default:suffix')}`}),
-  };
-
-  public async run(): Promise<void> {
-    const {flags, args} = await this.parse(Bloat)
-    const {app} = flags
-    const db = await database(this.heroku, app, args.database)
-    const output = await exec(db, query)
-    process.stdout.write(output)
-  }
+    static description = 'show table and index bloat in your database ordered by most wasteful';
+    static topic = 'pg';
+    static args = {
+        database: Args.string({ description: `${nls('pg:database:arg:description')} ${nls('pg:database:arg:description:default:suffix')}` }),
+    };
+    static flags = {
+        app: flags.app({ required: true }),
+        remote: flags.remote(),
+    };
+    async run() {
+        const { flags, args } = await this.parse(Bloat);
+        const { app } = flags;
+        const dbResolver = new utils.pg.DatabaseResolver(this.heroku);
+        const db = await dbResolver.getDatabase(app, args.database);
+        const psqlService = new utils.pg.PsqlService(db);
+        const output = await psqlService.execQuery(query);
+        ux.stdout(output);
+    }
 }
-
-*/

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

@@ -0,0 +1,13 @@
+import { Command } from '@heroku-cli/command';
+export default class Blocking extends Command {
+    static description: string;
+    static topic: string;
+    static args: {
+        database: import("@oclif/core/interfaces").Arg<string | undefined, Record<string, unknown>>;
+    };
+    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>;
+    };
+    run(): Promise<void>;
+}

package/lib/commands/pg/blocking.js

@@ -0,0 +1,42 @@
+import { Command, flags } from '@heroku-cli/command';
+import { Args, ux } from '@oclif/core';
+import { utils } from '@heroku/heroku-cli-util';
+import tsheredoc from 'tsheredoc';
+import { nls } from '../../nls.js';
+const heredoc = tsheredoc.default;
+export default class Blocking extends Command {
+    static description = 'display queries holding locks other queries are waiting to be released';
+    static topic = 'pg';
+    static args = {
+        database: Args.string({ description: `${nls('pg:database:arg:description')} ${nls('pg:database:arg:description:default:suffix')}` }),
+    };
+    static flags = {
+        app: flags.app({ required: true }),
+        remote: flags.remote(),
+    };
+    async run() {
+        const { flags, args } = await this.parse(Blocking);
+        const { app } = flags;
+        const query = heredoc `
+      SELECT bl.pid AS blocked_pid,
+        ka.query AS blocking_statement,
+        now() - ka.query_start AS blocking_duration,
+        kl.pid AS blocking_pid,
+        a.query AS blocked_statement,
+        now() - a.query_start AS blocked_duration
+      FROM pg_catalog.pg_locks bl
+      JOIN pg_catalog.pg_stat_activity a
+        ON bl.pid = a.pid
+      JOIN pg_catalog.pg_locks kl
+        JOIN pg_catalog.pg_stat_activity ka
+          ON kl.pid = ka.pid
+      ON bl.transactionid = kl.transactionid AND bl.pid != kl.pid
+      WHERE NOT bl.granted
+    `;
+        const dbResolver = new utils.pg.DatabaseResolver(this.heroku);
+        const db = await dbResolver.getDatabase(app, args.database);
+        const psqlService = new utils.pg.PsqlService(db);
+        const output = await psqlService.execQuery(query);
+        ux.stdout(output);
+    }
+}

package/lib/commands/pg/connection-pooling/attach.d.ts

@@ -0,0 +1,15 @@
+import { Command } from '@heroku-cli/command';
+export default class Attach extends Command {
+    static args: {
+        database: import("@oclif/core/interfaces").Arg<string | undefined, Record<string, unknown>>;
+    };
+    static description: string;
+    static examples: string[];
+    static flags: {
+        app: import("@oclif/core/interfaces").OptionFlag<string, import("@oclif/core/interfaces").CustomOptions>;
+        as: 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>;
+}