heroku 9.0.0-alpha.1 → 9.0.0-alpha.3

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

@@ -0,0 +1,92 @@
+"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 lodash_1 = require("lodash");
+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)`;
+}
+class Info extends command_1.Command {
+    constructor() {
+        super(...arguments);
+        this.getBackup = async (id, app) => {
+            let backupID;
+            if (id) {
+                const { num } = (0, backups_1.default)(app, this.heroku);
+                backupID = await num(id);
+                if (!backupID)
+                    throw new Error(`Invalid ID: ${id}`);
+            }
+            else {
+                let { body: transfers } = await this.heroku.get(`/client/v11/apps/${app}/transfers`, { hostname: (0, host_1.default)() });
+                transfers = (0, lodash_1.sortBy)(transfers, '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_1.default.cyan.bold('heroku pg:backups:capture')}`);
+                backupID = lastBackup.num;
+            }
+            const { body: backup } = await this.heroku.get(`/client/v11/apps/${app}/transfers/${backupID}?verbose=true`, { hostname: (0, host_1.default)() });
+            return backup;
+        };
+        this.displayBackup = (backup, app) => {
+            const { filesize, name } = (0, backups_1.default)(app, this.heroku);
+            core_1.ux.styledHeader(`Backup ${color_1.default.cyan(name(backup))}`);
+            core_1.ux.styledObject({
+                Database: color_1.default.green(backup.from_name),
+                'Started at': backup.started_at,
+                'Finished at': backup.finished_at,
+                Status: status(backup),
+                Type: backup.schedule ? 'Scheduled' : 'Manual', 'Original DB Size': filesize(backup.source_bytes),
+                'Backup Size': `${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']);
+            core_1.ux.log();
+        };
+        this.displayLogs = (backup) => {
+            core_1.ux.styledHeader('Backup Logs');
+            for (const log of backup.logs)
+                core_1.ux.log(`${log.created_at} ${log.message}`);
+            core_1.ux.log();
+        };
+    }
+    async run() {
+        const { flags, args } = 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);
+    }
+}
+exports.default = Info;
+Info.topic = 'pg';
+Info.description = 'get information about a specific backup';
+Info.flags = {
+    app: command_1.flags.app({ required: true }),
+    remote: command_1.flags.remote(),
+};
+Info.args = {
+    backup_id: core_1.Args.string(),
+};

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

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

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

@@ -0,0 +1,107 @@
+"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 confirmCommand_1 = require("../../../lib/confirmCommand");
+const backups_1 = require("../../../lib/pg/backups");
+const fetcher_1 = require("../../../lib/pg/fetcher");
+const host_1 = require("../../../lib/pg/host");
+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;
+}
+class Restore extends command_1.Command {
+    async run() {
+        const { flags, args } = await this.parse(Restore);
+        const { app, 'wait-interval': waitInterval, extensions, confirm, verbose } = flags;
+        const interval = Math.max(3, waitInterval);
+        const { addon: db } = await (0, fetcher_1.getAttachment)(this.heroku, app, args.database);
+        const { name, wait } = (0, backups_1.default)(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: (0, host_1.default)() });
+            const backups = transfers.filter(t => t.from_type === 'pg_dump' && t.to_type === 'gof3r');
+            let backup;
+            if (backupName) {
+                backup = backups.find(b => name(b) === backupName);
+                if (!backup)
+                    throw new Error(`Backup ${color_1.default.cyan(backupName)} not found for ${color_1.default.app(backupApp)}`);
+                if (!backup.succeeded)
+                    throw new Error(`Backup ${color_1.default.cyan(backupName)} for ${color_1.default.app(backupApp)} did not complete successfully`);
+            }
+            else {
+                backup = backups.filter(b => b.succeeded).sort((a, b) => {
+                    if (a.finished_at < b.finished_at) {
+                        return -1;
+                    }
+                    if (a.finished_at > b.finished_at) {
+                        return 1;
+                    }
+                    return 0;
+                }).pop();
+                if (!backup) {
+                    throw new Error(`No backups for ${color_1.default.app(backupApp)}. Capture one with ${color_1.default.cyan.bold('heroku pg:backups:capture')}`);
+                }
+                backupName = name(backup);
+            }
+            backupURL = backup.to_url;
+        }
+        await (0, confirmCommand_1.default)(app, confirm);
+        core_1.ux.action.start(`Starting restore of ${color_1.default.cyan(backupName)} to ${color_1.default.yellow(db.name)}`);
+        core_1.ux.log((0, tsheredoc_1.default)(`
+
+    Use Ctrl-C at any time to stop monitoring progress; the backup will continue restoring.
+    Use ${color_1.default.cyan.bold('heroku pg:backups')} to check progress.
+    Stop a running restore with ${color_1.default.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: (0, host_1.default)(),
+        });
+        core_1.ux.action.stop();
+        await wait('Restoring', restore.uuid, interval, verbose, db.app.id);
+    }
+    getSortedExtensions(extensions) {
+        return extensions === null || extensions === void 0 ? void 0 : extensions.split(',').map(ext => ext.trim().toLowerCase()).sort();
+    }
+}
+exports.default = Restore;
+Restore.topic = 'pg';
+Restore.description = 'restore a backup (default latest) to a database';
+Restore.flags = {
+    'wait-interval': command_1.flags.integer({ default: 3 }),
+    extensions: command_1.flags.string({
+        char: 'e',
+        description: (0, tsheredoc_1.default)(`
+      comma-separated list of extensions to pre-install in the public schema
+      defaults to saving the latest database to DATABASE_URL
+      `),
+    }),
+    verbose: command_1.flags.boolean({ char: 'v' }),
+    confirm: command_1.flags.string({ char: 'c' }),
+    app: command_1.flags.app({ required: true }),
+    remote: command_1.flags.remote(),
+};
+Restore.args = {
+    backup: core_1.Args.string(),
+    database: core_1.Args.string(),
+};

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/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>>;
+    };
+    parseDate: (at: string) => BackupSchedule;
+    run(): Promise<void>;
+}
+export {};

package/lib/commands/pg/backups/schedule.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 host_1 = require("../../../lib/pg/host");
+const fetcher_1 = require("../../../lib/pg/fetcher");
+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',
+};
+class Schedule extends command_1.Command {
+    constructor() {
+        super(...arguments);
+        this.parseDate = function (at) {
+            const m = at.match(/^([0-2]?[0-9]):00 ?(\S*)$/);
+            if (!m)
+                throw new Error("Invalid schedule format: expected --at '[HOUR]:00 [TIMEZONE]'");
+            const [, hour, timezone] = m;
+            let scheduledTZ = TZ[timezone.toUpperCase()];
+            if (!scheduledTZ) {
+                scheduledTZ = 'UTC';
+                if (timezone) {
+                    core_1.ux.warn(`Unknown timezone ${color_1.default.yellow(timezone)}. Defaulting to UTC.`);
+                }
+            }
+            return { hour, timezone: scheduledTZ };
+        };
+    }
+    async run() {
+        var _a;
+        const { flags, args } = await this.parse(Schedule);
+        const { app } = flags;
+        const { database } = args;
+        const schedule = this.parseDate(flags.at);
+        const attachment = await (0, fetcher_1.getAttachment)(this.heroku, app, database);
+        const db = attachment.addon;
+        const at = color_1.default.cyan(`${schedule.hour}:00 ${schedule.timezone}`);
+        const pgResponse = await this.heroku.get(`/client/v11/databases/${db.id}`, { hostname: (0, host_1.default)() })
+            .catch(error => {
+            if (error.statusCode !== 404)
+                throw error;
+            core_1.ux.error(`${color_1.default.yellow(db.name)} is not yet provisioned.\nRun ${color_1.default.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(((_a = dbInfo.info.find(attribute => attribute.name === 'Continuous Protection')) === null || _a === void 0 ? void 0 : _a.values[0]) || '');
+            if (dbProtected) {
+                core_1.ux.warn('Continuous protection is already enabled for this database. Logical backups of large databases are likely to fail.');
+                core_1.ux.warn('See https://devcenter.heroku.com/articles/heroku-postgres-data-safety-and-continuous-protection#physical-backups-on-heroku-postgres.');
+            }
+        }
+        core_1.ux.action.start(`Scheduling automatic daily backups of ${color_1.default.yellow(db.name)} at ${at}`);
+        schedule.schedule_name = attachment.name + '_URL';
+        await this.heroku.post(`/client/v11/databases/${db.id}/transfer-schedules`, {
+            body: schedule, hostname: (0, host_1.default)(),
+        });
+        core_1.ux.action.stop();
+    }
+}
+exports.default = Schedule;
+Schedule.topic = 'pg';
+Schedule.description = 'schedule daily backups for given database';
+Schedule.flags = {
+    at: command_1.flags.string({ required: true, description: "at a specific (24h) hour in the given timezone. Defaults to UTC. --at '[HOUR]:00 [TIMEZONE]'" }),
+    app: command_1.flags.app({ required: true }),
+    remote: command_1.flags.remote(),
+};
+Schedule.args = {
+    database: core_1.Args.string(),
+};

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 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>;
+    };
+    run(): Promise<void>;
+}

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

@@ -0,0 +1,31 @@
+"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 fetcher_1 = require("../../../lib/pg/fetcher");
+class Schedules extends command_1.Command {
+    async run() {
+        const { flags } = await this.parse(Schedules);
+        const { app } = flags;
+        const db = await (0, fetcher_1.arbitraryAppDB)(this.heroku, app);
+        const { body: schedules } = await this.heroku.get(`/client/v11/databases/${db.id}/transfer-schedules`, { hostname: (0, host_1.default)() });
+        if (schedules.length === 0) {
+            core_1.ux.warn(`No backup schedules found on ${color_1.default.app(app)}\nUse ${color_1.default.cyan.bold('heroku pg:backups:schedule')} to set one up`);
+        }
+        else {
+            core_1.ux.styledHeader('Backup Schedules');
+            for (const s of schedules) {
+                core_1.ux.log(`${color_1.default.green(s.name)}: daily at ${s.hour}:00 ${s.timezone}`);
+            }
+        }
+    }
+}
+exports.default = Schedules;
+Schedules.topic = 'pg';
+Schedules.description = 'list backup schedule';
+Schedules.flags = {
+    app: command_1.flags.app({ required: true }),
+    remote: command_1.flags.remote(),
+};

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 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>;
+}

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

@@ -0,0 +1,44 @@
+"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 fetcher_1 = require("../../../lib/pg/fetcher");
+const host_1 = require("../../../lib/pg/host");
+class Unschedule extends command_1.Command {
+    async run() {
+        const { flags, args } = await this.parse(Unschedule);
+        const { app } = flags;
+        const { database } = args;
+        let db = database;
+        if (!db) {
+            const appDB = await (0, fetcher_1.arbitraryAppDB)(this.heroku, app);
+            const { body: schedules } = await this.heroku.get(`/client/v11/databases/${appDB.id}/transfer-schedules`, { hostname: (0, host_1.default)() });
+            if (schedules.length === 0)
+                throw new Error(`No schedules on ${color_1.default.app(app)}`);
+            if (schedules.length > 1) {
+                throw new Error(`Specify schedule on ${color_1.default.app(app)}. Existing schedules: ${schedules.map(s => color_1.default.green(s.name))
+                    .join(', ')}`);
+            }
+            db = schedules[0].name;
+        }
+        core_1.ux.action.start(`Unscheduling ${color_1.default.green(db)} daily backups`);
+        const addon = await (0, fetcher_1.getAddon)(this.heroku, app, db);
+        const { body: schedules } = await this.heroku.get(`/client/v11/databases/${addon.id}/transfer-schedules`, { hostname: (0, host_1.default)() });
+        const schedule = schedules.find(s => s.name.match(new RegExp(`${db}`, 'i')));
+        if (!schedule)
+            throw new Error(`No daily backups found for ${color_1.default.yellow(addon.name)}`);
+        await this.heroku.delete(`/client/v11/databases/${addon.id}/transfer-schedules/${schedule.uuid}`, { hostname: (0, host_1.default)() });
+        core_1.ux.action.stop();
+    }
+}
+exports.default = Unschedule;
+Unschedule.topic = 'pg';
+Unschedule.description = 'stop daily backups';
+Unschedule.flags = {
+    app: command_1.flags.app({ required: true }),
+    remote: command_1.flags.remote(),
+};
+Unschedule.args = {
+    database: core_1.Args.string(),
+};

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 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: {
+        backup_id: import("@oclif/core/lib/interfaces/parser").Arg<string | undefined, Record<string, unknown>>;
+    };
+    run(): Promise<void>;
+}

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

@@ -0,0 +1,41 @@
+"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 lodash_1 = require("lodash");
+class Url extends command_1.Command {
+    async run() {
+        const { flags, args } = await this.parse(Url);
+        const { backup_id } = args;
+        const { app } = flags;
+        let num;
+        if (backup_id) {
+            num = await (0, backups_1.default)(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: (0, host_1.default)() });
+            const lastBackup = (0, lodash_1.sortBy)(transfers.filter(t => t.succeeded && t.to_type === 'gof3r'), 'created_at')
+                .pop();
+            if (!lastBackup)
+                throw new Error(`No backups on ${color_1.default.app(app)}. Capture one with ${color_1.default.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: (0, host_1.default)() });
+        core_1.ux.log(info.url);
+    }
+}
+exports.default = Url;
+Url.topic = 'pg';
+Url.description = 'get secret but publicly accessible URL of a backup';
+Url.flags = {
+    app: command_1.flags.app({ required: true }),
+    remote: command_1.flags.remote(),
+};
+Url.args = {
+    backup_id: core_1.Args.string(),
+};

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

@@ -0,0 +1,13 @@
+import { Command } from '@heroku-cli/command';
+export default class Bloat 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>;
+}

package/lib/commands/pg/bloat.js

@@ -0,0 +1,87 @@
+"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 psql_1 = require("../../lib/pg/psql");
+const query = `
+WITH constants AS (
+  SELECT current_setting('block_size')::numeric AS bs, 23 AS hdr, 4 AS ma
+), bloat_info AS (
+  SELECT
+    ma,bs,schemaname,tablename,
+    (datawidth+(hdr+ma-(case when hdr%ma=0 THEN ma ELSE hdr%ma END)))::numeric AS datahdr,
+    (maxfracsum*(nullhdr+ma-(case when nullhdr%ma=0 THEN ma ELSE nullhdr%ma END))) AS nullhdr2
+  FROM (
+    SELECT
+      schemaname, tablename, hdr, ma, bs,
+      SUM((1-null_frac)*avg_width) AS datawidth,
+      MAX(null_frac) AS maxfracsum,
+      hdr+(
+        SELECT 1+count(*)/8
+        FROM pg_stats s2
+        WHERE null_frac<>0 AND s2.schemaname = s.schemaname AND s2.tablename = s.tablename
+      ) AS nullhdr
+    FROM pg_stats s, constants
+    GROUP BY 1,2,3,4,5
+  ) AS foo
+), table_bloat AS (
+  SELECT
+    schemaname, tablename, cc.relpages, bs,
+    CEIL((cc.reltuples*((datahdr+ma-
+      (CASE WHEN datahdr%ma=0 THEN ma ELSE datahdr%ma END))+nullhdr2+4))/(bs-20::float)) AS otta
+  FROM bloat_info
+  JOIN pg_class cc ON cc.relname = bloat_info.tablename
+  JOIN pg_namespace nn ON cc.relnamespace = nn.oid AND nn.nspname = bloat_info.schemaname AND nn.nspname <> 'information_schema'
+), index_bloat AS (
+  SELECT
+    schemaname, tablename, bs,
+    COALESCE(c2.relname,'?') AS iname, COALESCE(c2.reltuples,0) AS ituples, COALESCE(c2.relpages,0) AS ipages,
+    COALESCE(CEIL((c2.reltuples*(datahdr-12))/(bs-20::float)),0) AS iotta -- very rough approximation, assumes all cols
+  FROM bloat_info
+  JOIN pg_class cc ON cc.relname = bloat_info.tablename
+  JOIN pg_namespace nn ON cc.relnamespace = nn.oid AND nn.nspname = bloat_info.schemaname AND nn.nspname <> 'information_schema'
+  JOIN pg_index i ON indrelid = cc.oid
+  JOIN pg_class c2 ON c2.oid = i.indexrelid
+)
+SELECT
+  type, schemaname, object_name, bloat, pg_size_pretty(raw_waste) as waste
+FROM
+(SELECT
+  'table' as type,
+  schemaname,
+  tablename as object_name,
+  ROUND(CASE WHEN otta=0 THEN 0.0 ELSE table_bloat.relpages/otta::numeric END,1) AS bloat,
+  CASE WHEN relpages < otta THEN '0' ELSE (bs*(table_bloat.relpages-otta)::bigint)::bigint END AS raw_waste
+FROM
+  table_bloat
+    UNION
+SELECT
+  'index' as type,
+  schemaname,
+  tablename || '::' || iname as object_name,
+  ROUND(CASE WHEN iotta=0 OR ipages=0 THEN 0.0 ELSE ipages/iotta::numeric END,1) AS bloat,
+  CASE WHEN ipages < iotta THEN '0' ELSE (bs*(ipages-iotta))::bigint END AS raw_waste
+FROM
+  index_bloat) bloat_summary
+ORDER BY raw_waste DESC, bloat DESC
+`;
+class Bloat extends command_1.Command {
+    async run() {
+        const { flags, args } = await this.parse(Bloat);
+        const { app } = flags;
+        const db = await (0, fetcher_1.database)(this.heroku, app, args.database);
+        const output = await (0, psql_1.exec)(db, query);
+        process.stdout.write(output);
+    }
+}
+exports.default = Bloat;
+Bloat.topic = 'pg';
+Bloat.description = 'show table and index bloat in your database ordered by most wasteful';
+Bloat.flags = {
+    app: command_1.flags.app({ required: true }),
+    remote: command_1.flags.remote(),
+};
+Bloat.args = {
+    database: core_1.Args.string(),
+};

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

@@ -0,0 +1,13 @@
+import { Command } from '@heroku-cli/command';
+export default class Blocking 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>;
+}

package/lib/commands/pg/blocking.js

@@ -0,0 +1,42 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+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 psql_1 = require("../../lib/pg/psql");
+class Blocking extends command_1.Command {
+    async run() {
+        const { flags, args } = await this.parse(Blocking);
+        const { app } = flags;
+        const query = (0, tsheredoc_1.default) `
+        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 db = await (0, fetcher_1.database)(this.heroku, app, args.database);
+        const output = await (0, psql_1.exec)(db, query);
+        core_1.ux.log(output);
+    }
+}
+exports.default = Blocking;
+Blocking.topic = 'pg';
+Blocking.description = 'display queries holding locks other queries are waiting to be released';
+Blocking.flags = {
+    app: command_1.flags.app({ required: true }),
+    remote: command_1.flags.remote(),
+};
+Blocking.args = {
+    database: core_1.Args.string(),
+};

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 topic: string;
+    static description: string;
+    static examples: string[];
+    static flags: {
+        as: 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>;
+}