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

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

package/lib/commands/pg/connection-pooling/attach.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 tsheredoc_1 = require("tsheredoc");
+const util_1 = require("../../../lib/pg/util");
+const fetcher_1 = require("../../../lib/pg/fetcher");
+class Attach extends command_1.Command {
+    async run() {
+        const { flags, args } = await this.parse(Attach);
+        const { app } = flags;
+        const db = await (0, fetcher_1.getAddon)(this.heroku, app, args.database);
+        const { body: addon } = await this.heroku.get(`/addons/${encodeURIComponent(db.name)}`);
+        if ((0, util_1.essentialPlan)(db))
+            core_1.ux.error('You can’t perform this operation on Essential-tier databases.');
+        core_1.ux.action.start(`Enabling Connection Pooling on ${color_1.default.yellow(addon.name)} to ${color_1.default.magenta(app)}`);
+        const { body: attachment } = await this.heroku.post(`/client/v11/databases/${encodeURIComponent(db.name)}/connection-pooling`, {
+            body: { name: flags.as, credential: 'default', app: app }, hostname: (0, host_1.default)(),
+        });
+        core_1.ux.action.stop();
+        core_1.ux.action.start(`Setting ${color_1.default.cyan(attachment.name)} config vars and restarting ${color_1.default.magenta(app)}`);
+        const { body: releases } = await this.heroku.get(`/apps/${app}/releases`, { partial: true, headers: { Range: 'version ..; max=1, order=desc' } });
+        core_1.ux.action.stop(`done, v${releases[0].version}`);
+    }
+}
+exports.default = Attach;
+Attach.topic = 'pg';
+Attach.description = 'add an attachment to a database using connection pooling';
+Attach.examples = [(0, tsheredoc_1.default) `
+      $ heroku pg:connection-pooling:attach postgresql-something-12345
+    `];
+Attach.flags = {
+    as: command_1.flags.string({ description: 'name for add-on attachment' }),
+    app: command_1.flags.app({ required: true }),
+    remote: command_1.flags.remote(),
+};
+Attach.args = {
+    database: core_1.Args.string(),
+};

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

@@ -0,0 +1,18 @@
+import { Command } from '@heroku-cli/command';
+export default class Copy extends Command {
+    static topic: string;
+    static description: string;
+    static help: string;
+    static flags: {
+        'wait-interval': 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: {
+        source: import("@oclif/core/lib/interfaces/parser").Arg<string, Record<string, unknown>>;
+        target: import("@oclif/core/lib/interfaces/parser").Arg<string, Record<string, unknown>>;
+    };
+    run(): Promise<void>;
+}