heroku 9.0.0-dev.0 → 9.0.0

package/lib/commands/pg/credentials/rotate.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 confirmCommand_1 = require("../../../lib/confirmCommand");
+const fetcher_1 = require("../../../lib/pg/fetcher");
+const host_1 = require("../../../lib/pg/host");
+const util_1 = require("../../../lib/pg/util");
+class Rotate extends command_1.Command {
+    async run() {
+        const { flags, args } = await this.parse(Rotate);
+        const { app, all, confirm, name, force } = flags;
+        const { addon: db } = await (0, fetcher_1.getAttachment)(this.heroku, app, args.database);
+        const warnings = [];
+        const cred = name || 'default';
+        if (all && name !== undefined) {
+            throw new Error('cannot pass both --all and --name');
+        }
+        if ((0, util_1.legacyEssentialPlan)(db) && cred !== 'default') {
+            throw new Error('Legacy Essential-tier databases do not support named credentials.');
+        }
+        if (all && force) {
+            warnings.push('This forces rotation on all credentials including the default credential.');
+        }
+        let { body: attachments } = await this.heroku.get(`/addons/${db.name}/addon-attachments`);
+        if (name) {
+            attachments = attachments.filter(a => a.namespace === `credential:${cred}`);
+        }
+        if (!all) {
+            warnings.push(`The password for the ${cred} credential will rotate.`);
+        }
+        if (all || force || cred === 'default') {
+            warnings.push('Connections will be reset and applications will be restarted.');
+        }
+        else {
+            warnings.push('Connections older than 30 minutes will be reset, and a temporary rotation username will be used during the process.');
+        }
+        if (force) {
+            warnings.push(`Any followers lagging in replication (see ${color_1.default.cyan.bold('heroku pg:info')}) will be inaccessible until caught up.`);
+        }
+        if (attachments.length > 0) {
+            const uniqueAttachments = [...new Set(attachments.map(attachment => color_1.default.app(attachment.app.name || '')))]
+                .sort()
+                .join(', ');
+            warnings.push(`This command will affect the app${(attachments.length > 1) ? 's' : ''} ${uniqueAttachments}.`);
+        }
+        await (0, confirmCommand_1.default)(app, confirm, `Destructive Action\n${warnings.join('\n')}`);
+        const options = {
+            hostname: (0, host_1.default)(),
+            body: { forced: force !== null && force !== void 0 ? force : undefined },
+            headers: {
+                Authorization: `Basic ${Buffer.from(`:${this.heroku.auth}`).toString('base64')}`,
+            },
+        };
+        if (all) {
+            core_1.ux.action.start(`Rotating all credentials on ${color_1.default.yellow(db.name)}`);
+            await this.heroku.post(`/postgres/v0/databases/${db.name}/credentials_rotation`, options);
+        }
+        else {
+            core_1.ux.action.start(`Rotating ${cred} on ${color_1.default.yellow(db.name)}`);
+            await this.heroku.post(`/postgres/v0/databases/${db.name}/credentials/${encodeURIComponent(cred)}/credentials_rotation`, options);
+        }
+        core_1.ux.action.stop();
+    }
+}
+exports.default = Rotate;
+Rotate.topic = 'pg';
+Rotate.description = 'rotate the database credentials';
+Rotate.flags = {
+    name: command_1.flags.string({
+        char: 'n',
+        description: 'which credential to rotate (default credentials if not specified and --all is not used)',
+    }),
+    all: command_1.flags.boolean({ description: 'rotate all credentials', exclusive: ['name'] }),
+    confirm: command_1.flags.string({ char: 'c' }),
+    force: command_1.flags.boolean({ description: 'forces rotating the targeted credentials' }),
+    app: command_1.flags.app({ required: true }),
+};
+Rotate.args = {
+    database: core_1.Args.string(),
+};

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

@@ -0,0 +1,14 @@
+import { Command } from '@heroku-cli/command';
+export default class Url extends Command {
+    static 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/url.js

@@ -0,0 +1,64 @@
+"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 util_1 = require("../../../lib/pg/util");
+const fetcher_1 = require("../../../lib/pg/fetcher");
+const host_1 = require("../../../lib/pg/host");
+const url_1 = require("url");
+const tsheredoc_1 = require("tsheredoc");
+class Url extends command_1.Command {
+    async run() {
+        const { flags, args } = await this.parse(Url);
+        const { app, name } = flags;
+        const { database } = args;
+        const db = await (0, fetcher_1.getAddon)(this.heroku, app, database);
+        if ((0, util_1.legacyEssentialPlan)(db) && name !== 'default') {
+            core_1.ux.error('Legacy Essential-tier databases do not support named credentials.');
+        }
+        const { body: credInfo } = await this.heroku.get(`/postgres/v0/databases/${db.name}/credentials/${encodeURIComponent(name)}`, {
+            hostname: (0, host_1.default)(),
+            headers: {
+                Authorization: `Basic ${Buffer.from(`:${this.heroku.auth}`).toString('base64')}`,
+            },
+        });
+        const activeCreds = credInfo.credentials.find(c => c.state === 'active');
+        if (!activeCreds) {
+            core_1.ux.error(`Could not find any active credentials for ${name}`, { exit: 1 });
+        }
+        const creds = Object.assign({}, db, {
+            database: credInfo.database, host: credInfo.host, port: credInfo.port,
+        }, {
+            user: activeCreds === null || activeCreds === void 0 ? void 0 : activeCreds.user, password: activeCreds === null || activeCreds === void 0 ? void 0 : activeCreds.password,
+        });
+        const connUrl = new url_1.URL(`postgres://${creds.host}/${creds.database}`);
+        connUrl.port = creds.port.toString();
+        if (creds.user && creds.password) {
+            connUrl.username = creds.user;
+            connUrl.password = creds.password;
+        }
+        core_1.ux.log((0, tsheredoc_1.default)(`
+      Connection information for ${color_1.default.yellow(name)} credential.
+      Connection info string:
+        "dbname=${creds.database} host=${creds.host} port=${creds.port} user=${creds.user} password=${creds.password} sslmode=require"
+      Connection URL:
+        ${connUrl}
+    `));
+    }
+}
+exports.default = Url;
+Url.topic = 'pg';
+Url.description = 'show information on a database credential';
+Url.flags = {
+    name: command_1.flags.string({
+        char: 'n',
+        description: 'which credential to show (default credentials if not specified)',
+        default: 'default',
+    }),
+    app: command_1.flags.app({ required: true }),
+    remote: command_1.flags.remote(),
+};
+Url.args = {
+    database: core_1.Args.string(),
+};

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

@@ -0,0 +1,16 @@
+import { Command } from '@heroku-cli/command';
+import { CredentialInfo, CredentialsInfo } from '../../lib/pg/types';
+export default class Credentials 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>;
+    protected sortByDefaultAndName(credentials: CredentialsInfo): CredentialsInfo;
+    protected isDefaultCredential(cred: CredentialInfo): boolean;
+}

package/lib/commands/pg/credentials.js

@@ -0,0 +1,61 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+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 util_1 = require("../../lib/pg/util");
+class Credentials extends command_1.Command {
+    async run() {
+        const { flags, args } = await this.parse(Credentials);
+        const { app } = flags;
+        const { database } = args;
+        const addon = await (0, fetcher_1.getAddon)(this.heroku, app, database);
+        const { body: credentials } = await this.heroku.get(`/postgres/v0/databases/${addon.id}/credentials`, {
+            hostname: (0, host_1.default)(),
+            headers: {
+                Authorization: `Basic ${Buffer.from(`:${this.heroku.auth}`).toString('base64')}`,
+            },
+        });
+        const sortedCredentials = this.sortByDefaultAndName(credentials);
+        const { body: attachments } = await this.heroku.get(`/addons/${addon.id}/addon-attachments`);
+        const presentCredential = (cred) => {
+            let credAttachments = [];
+            if (cred.name === 'default') {
+                credAttachments = attachments.filter(a => a.namespace === null);
+            }
+            else {
+                credAttachments = attachments.filter(a => a.namespace === `credential:${cred.name}`);
+            }
+            return (0, util_1.presentCredentialAttachments)(app, credAttachments, sortedCredentials, cred.name);
+        };
+        core_1.ux.table(credentials, {
+            Credential: {
+                get: presentCredential,
+            },
+            State: {
+                get: cred => cred.state,
+            },
+        });
+    }
+    sortByDefaultAndName(credentials) {
+        return credentials.sort((a, b) => {
+            const isDefaultA = this.isDefaultCredential(a);
+            const isDefaultB = this.isDefaultCredential(b);
+            return isDefaultB < isDefaultA ? -1 : (isDefaultA < isDefaultB ? 1 : a.name.localeCompare(b.name));
+        });
+    }
+    isDefaultCredential(cred) {
+        return cred.name === 'default';
+    }
+}
+exports.default = Credentials;
+Credentials.topic = 'pg';
+Credentials.description = 'show information on credentials in the database';
+Credentials.flags = {
+    app: command_1.flags.app({ required: true }),
+    remote: command_1.flags.remote(),
+};
+Credentials.args = {
+    database: core_1.Args.string(),
+};

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

@@ -0,0 +1,18 @@
+import { Command } from '@heroku-cli/command';
+export default class Diagnose extends Command {
+    static topic: string;
+    static description: string;
+    static flags: {
+        json: import("@oclif/core/lib/interfaces").BooleanFlag<boolean>;
+        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|REPORT_ID': import("@oclif/core/lib/interfaces/parser").Arg<string | undefined, Record<string, unknown>>;
+    };
+    run(): Promise<void>;
+    private displayReport;
+    private display;
+    private generateParams;
+    private generateReport;
+}

package/lib/commands/pg/diagnose.js

@@ -0,0 +1,109 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const command_1 = require("@heroku-cli/command");
+const core_1 = require("@oclif/core");
+const util_1 = require("@oclif/core/lib/util");
+const tsheredoc_1 = require("tsheredoc");
+const fetcher_1 = require("../../lib/pg/fetcher");
+const host_1 = require("../../lib/pg/host");
+const util_2 = require("../../lib/pg/util");
+const color_1 = require("@heroku-cli/color");
+const uuid_validate_1 = require("../../lib/utils/uuid-validate");
+const PGDIAGNOSE_HOST = process.env.PGDIAGNOSE_URL || 'pgdiagnose.herokai.com';
+class Diagnose extends command_1.Command {
+    async run() {
+        const { flags, args } = await this.parse(Diagnose);
+        const id = args['DATABASE|REPORT_ID'];
+        let report;
+        if (id && (0, uuid_validate_1.uuidValidate)(id)) {
+            ({ body: report } = await this.heroku.get(`/reports/${encodeURIComponent(id)}`, { hostname: PGDIAGNOSE_HOST }));
+        }
+        else {
+            report = await this.generateReport(id, flags.app);
+        }
+        this.displayReport(report, flags.json);
+    }
+    displayReport(report, json) {
+        if (json) {
+            core_1.ux.styledJSON(report);
+            return;
+        }
+        core_1.ux.log(`Report ${report.id} for ${report.app}::${report.database}\navailable for one month after creation on ${report.created_at}\n`);
+        this.display(report.checks.filter(c => c.status === 'red'));
+        this.display(report.checks.filter(c => c.status === 'yellow'));
+        this.display(report.checks.filter(c => c.status === 'green'));
+        this.display(report.checks.filter(c => !['red', 'yellow', 'green'].includes(c.status)));
+    }
+    display(checks) {
+        checks.forEach(check => {
+            var _a;
+            const colorFn = color_1.default[check.status] || ((txt) => txt);
+            core_1.ux.log(colorFn(`${check.status.toUpperCase()}: ${check.name}`));
+            const isNonEmptyArray = Array.isArray(check.results) && check.results.length > 0;
+            const resultsKeys = Object.keys((_a = check.results) !== null && _a !== void 0 ? _a : {});
+            if (check.status === 'green' || (!isNonEmptyArray && resultsKeys.length === 0)) {
+                return;
+            }
+            if (isNonEmptyArray) {
+                const keys = Object.keys(check.results[0]);
+                const cols = {};
+                keys.forEach(key => {
+                    cols[(0, util_1.capitalize)(key)] = {
+                        get: (row) => row[key],
+                    };
+                });
+                core_1.ux.table(check.results, cols);
+            }
+            else {
+                const [key] = resultsKeys;
+                core_1.ux.log(`${key.split('_')
+                    .map(s => (0, util_1.capitalize)(s))
+                    .join(' ')} ${check.results[key]}`);
+            }
+        });
+    }
+    async generateParams(url, db, dbName) {
+        const base_params = {
+            url,
+            plan: db.plan.name.split(':')[1],
+            app: db.app.name,
+            database: dbName,
+        };
+        if (!(0, util_2.essentialPlan)(db)) {
+            const { body: metrics } = await this.heroku.get(`/client/v11/databases/${db.id}/metrics`, { hostname: (0, host_1.default)() });
+            base_params.metrics = metrics;
+            const { body: burstData } = await this.heroku.get(`/client/v11/databases/${db.id}/burst_status`, { hostname: (0, host_1.default)() });
+            if (burstData && Object.keys(burstData).length > 0) {
+                base_params.burst_data_present = true;
+                base_params.burst_status = burstData.burst_status;
+            }
+        }
+        return base_params;
+    }
+    async generateReport(database, app) {
+        const attachment = await (0, fetcher_1.getAttachment)(this.heroku, app, database);
+        const { addon: db } = attachment;
+        const { body: config } = await this.heroku.get(`/apps/${app}/config-vars`);
+        const { url } = (0, util_2.getConnectionDetails)(attachment, config);
+        const dbName = (0, util_2.getConfigVarNameFromAttachment)(attachment, config);
+        const body = await this.generateParams(url, db, dbName);
+        const { body: report } = await this.heroku.post('/reports', { hostname: PGDIAGNOSE_HOST, body });
+        return report;
+    }
+}
+exports.default = Diagnose;
+Diagnose.topic = 'pg';
+Diagnose.description = (0, tsheredoc_1.default)(`
+    run or view diagnostics report
+    defaults to DATABASE_URL database if no DATABASE is specified
+    if REPORT_ID is specified instead, a previous report is displayed
+
+    `);
+Diagnose.flags = {
+    json: command_1.flags.boolean({ description: 'format output as JSON' }),
+    app: command_1.flags.app({ required: true }),
+    remote: command_1.flags.remote(),
+};
+Diagnose.args = {
+    'DATABASE|REPORT_ID': core_1.Args.string(),
+};

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

@@ -0,0 +1,14 @@
+import { Command } from '@heroku-cli/command';
+export default class Info 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>>;
+    };
+    static aliases: string[];
+    run(): Promise<void>;
+}

package/lib/commands/pg/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 fetcher_1 = require("../../lib/pg/fetcher");
+const util_1 = require("../../lib/pg/util");
+function displayDB(db, app) {
+    var _a, _b, _c, _d, _e;
+    if (db.addon.attachment_names) {
+        core_1.ux.styledHeader(db.addon.attachment_names.map((c) => color_1.default.green(c + '_URL'))
+            .join(', '));
+    }
+    else {
+        core_1.ux.styledHeader(((_a = db.configVars) === null || _a === void 0 ? void 0 : _a.map(c => color_1.default.green(c)).join(', ')) || '');
+    }
+    if (db.addon.app.name && db.addon.app.name !== app) {
+        (_b = db.dbInfo) === null || _b === void 0 ? void 0 : _b.info.push({ name: 'Billing App', values: [color_1.default.cyan(db.addon.app.name)] });
+    }
+    (_c = db.dbInfo) === null || _c === void 0 ? void 0 : _c.info.push({ name: 'Add-on', values: [color_1.default.yellow(db.addon.name)] });
+    const info = {};
+    (_d = db.dbInfo) === null || _d === void 0 ? void 0 : _d.info.forEach(infoObject => {
+        if (infoObject.values.length > 0) {
+            let valuesArray;
+            if (infoObject.resolve_db_name) {
+                valuesArray = infoObject.values.map(v => (0, util_1.databaseNameFromUrl)(v, db.config));
+            }
+            else {
+                valuesArray = infoObject.values;
+            }
+            info[infoObject.name] = valuesArray.join(', ');
+        }
+    });
+    const keys = (_e = db.dbInfo) === null || _e === void 0 ? void 0 : _e.info.map(i => i.name);
+    core_1.ux.styledObject(info, keys);
+    core_1.ux.log();
+}
+class Info extends command_1.Command {
+    async run() {
+        const { flags, args } = await this.parse(Info);
+        const { app } = flags;
+        const { sortBy } = require('lodash');
+        const { database: db } = args;
+        let addons;
+        const { body: config } = await this.heroku.get(`/apps/${app}/config-vars`);
+        if (db) {
+            addons = await Promise.all([(0, fetcher_1.getAddon)(this.heroku, app, db)]);
+        }
+        else {
+            addons = await (0, fetcher_1.all)(this.heroku, app);
+            if (addons.length === 0) {
+                core_1.ux.log(`${color_1.default.magenta(app)} has no heroku-postgresql databases.`);
+                return;
+            }
+        }
+        let dbs = await Promise.all(addons.map(async (addon) => {
+            const pgResponse = await this.heroku.get(`/client/v11/databases/${addon.id}`, {
+                hostname: (0, host_1.default)(),
+            })
+                .catch(error => {
+                if (error.statusCode !== 404)
+                    throw error;
+                core_1.ux.warn(`${color_1.default.yellow(addon.name)} is not yet provisioned.\nRun ${color_1.default.cyan.bold('heroku addons:wait')} to wait until the db is provisioned.`);
+            });
+            const { body: dbInfo } = pgResponse || { body: null };
+            return {
+                addon,
+                config,
+                dbInfo,
+            };
+        }));
+        dbs = dbs.filter(db => db.dbInfo);
+        dbs.forEach(db => {
+            var _a;
+            db.configVars = (0, util_1.configVarNamesFromValue)(db.config, ((_a = db.dbInfo) === null || _a === void 0 ? void 0 : _a.resource_url) || '');
+        });
+        dbs = sortBy(dbs, (db) => db.configVars && db.configVars[0] !== 'DATABASE_URL', 'configVars[0]');
+        dbs.forEach(db => displayDB(db, app));
+    }
+}
+exports.default = Info;
+Info.topic = 'pg';
+Info.description = 'show database information';
+Info.flags = {
+    app: command_1.flags.app({ required: true }),
+    remote: command_1.flags.remote(),
+};
+Info.args = {
+    database: core_1.Args.string(),
+};
+Info.aliases = ['pg'];

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

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

package/lib/commands/pg/kill.js

@@ -0,0 +1,32 @@
+"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 tsheredoc_1 = require("tsheredoc");
+class Kill extends command_1.Command {
+    async run() {
+        const { flags, args } = await this.parse(Kill);
+        const { app, force } = flags;
+        const { pid } = args;
+        const db = await (0, fetcher_1.database)(this.heroku, app, args.database);
+        const query = (0, tsheredoc_1.default) `
+      SELECT ${force ? 'pg_terminate_backend' : 'pg_cancel_backend'}(${Number.parseInt(pid, 10)});
+    `;
+        const output = await (0, psql_1.exec)(db, query);
+        core_1.ux.log(output);
+    }
+}
+exports.default = Kill;
+Kill.topic = 'pg';
+Kill.description = 'kill a query';
+Kill.flags = {
+    force: command_1.flags.boolean({ char: 'f' }),
+    app: command_1.flags.app({ required: true }),
+    remote: command_1.flags.remote(),
+};
+Kill.args = {
+    pid: core_1.Args.string({ required: true }),
+    database: core_1.Args.string(),
+};

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

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

@@ -0,0 +1,26 @@
+"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 host_1 = require("../../lib/pg/host");
+class Killall extends command_1.Command {
+    async run() {
+        const { flags, args } = await this.parse(Killall);
+        const { app } = flags;
+        core_1.ux.action.start('Terminating connections for all credentials');
+        const database = await (0, fetcher_1.getAddon)(this.heroku, app, args.database);
+        await this.heroku.post(`/client/v11/databases/${database.id}/connection_reset`, { hostname: (0, host_1.default)() });
+        core_1.ux.action.stop();
+    }
+}
+exports.default = Killall;
+Killall.topic = 'pg';
+Killall.description = 'terminates all connections for all credentials';
+Killall.flags = {
+    app: command_1.flags.app({ required: true }),
+    remote: command_1.flags.remote(),
+};
+Killall.args = {
+    database: core_1.Args.string(),
+};

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

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

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

@@ -0,0 +1,58 @@
+"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 resolve_1 = require("../../../lib/addons/resolve");
+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 } = flags;
+        const service = async (remoteId) => {
+            const addon = await (0, resolve_1.addonResolver)(this.heroku, app, remoteId);
+            if (!addon.plan.name.match(/^heroku-(redis|postgresql)/))
+                throw new Error('Remote database must be heroku-redis or heroku-postgresql');
+            return addon;
+        };
+        const [db, target] = await Promise.all([
+            (0, fetcher_1.getAddon)(this.heroku, app, args.database),
+            service(args.remote),
+        ]);
+        if ((0, util_1.essentialPlan)(db))
+            throw new Error('pg:links isn’t available for Essential-tier databases.');
+        if ((0, util_1.essentialPlan)(target))
+            throw new Error('pg:links isn’t available for Essential-tier databases.');
+        core_1.ux.action.start(`Adding link from ${color_1.default.yellow(target.name)} to ${color_1.default.yellow(db.name)}`);
+        const { body: link } = await this.heroku.post(`/client/v11/databases/${db.id}/links`, {
+            body: {
+                target: target.name,
+                as: flags.as,
+            },
+            hostname: (0, host_1.default)(),
+        });
+        if (link.message) {
+            throw new Error(link.message);
+        }
+        core_1.ux.action.stop(`done, ${color_1.default.cyan(link.name)}`);
+    }
+}
+exports.default = Create;
+Create.topic = 'pg';
+Create.description = (0, tsheredoc_1.default)(`
+  create a link between data stores
+  Example:
+  heroku pg:links:create HEROKU_REDIS_RED HEROKU_POSTGRESQL_CERULEAN
+  `);
+Create.flags = {
+    as: command_1.flags.string({ description: 'name of link to create' }),
+    app: command_1.flags.app({ required: true }),
+    remote: command_1.flags.remote(),
+};
+Create.args = {
+    remote: core_1.Args.string({ required: true }),
+    database: core_1.Args.string({ required: true }),
+};