heroku 9.0.0-dev.0 → 9.1.0-beta.0

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

package/lib/commands/pg/copy.js

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

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

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

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

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

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

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