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

package/lib/lib/pg/push_pull.d.ts

@@ -0,0 +1,13 @@
+/// <reference types="node" />
+import { ConnectionDetails } from './util';
+import { Server } from 'net';
+import { ChildProcess } from 'node:child_process';
+export declare const parseExclusions: (rawExcludeList: string | undefined) => string[];
+export declare const prepare: (target: ConnectionDetails) => Promise<void>;
+export declare type ConnectionDetailsWithOptionalTunnel = ConnectionDetails & {
+    _tunnel?: Server;
+};
+export declare const maybeTunnel: (herokuDb: ConnectionDetails) => Promise<ConnectionDetailsWithOptionalTunnel>;
+export declare const connArgs: (uri: ConnectionDetails, skipDFlag?: boolean) => string[];
+export declare const spawnPipe: (pgDump: ChildProcess, pgRestore: ChildProcess) => Promise<void>;
+export declare const verifyExtensionsMatch: (source: ConnectionDetails, target: ConnectionDetails) => Promise<void>;

package/lib/lib/pg/push_pull.js

@@ -0,0 +1,118 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.verifyExtensionsMatch = exports.spawnPipe = exports.connArgs = exports.maybeTunnel = exports.prepare = exports.parseExclusions = void 0;
+const psql_1 = require("./psql");
+const core_1 = require("@oclif/core");
+const color_1 = require("@heroku-cli/color");
+const bastion_1 = require("./bastion");
+const node_child_process_1 = require("node:child_process");
+const tsheredoc_1 = require("tsheredoc");
+const debug_1 = require("debug");
+const debug = (0, debug_1.default)('pg:push-pull');
+const parseExclusions = (rawExcludeList) => {
+    return (rawExcludeList || '')
+        .split(';').map(excl => excl.trim())
+        .filter(texcl => texcl !== '');
+};
+exports.parseExclusions = parseExclusions;
+const prepare = async (target) => {
+    if (target.host === 'localhost' || !target.host) {
+        exec(`createdb ${(0, exports.connArgs)(target, true).join(' ')}`);
+    }
+    else {
+        // N.B.: we don't have a proper postgres driver and we don't want to rely on overriding
+        // possible .psqlrc output configurations, so we generate a random marker that is returned
+        // from the query. We avoid including it verbatim in the query text in case the equivalent
+        // of --echo-all is set.
+        const num = Math.random();
+        const emptyMarker = `${num}${num}`;
+        const result = await (0, psql_1.exec)(target, `SELECT CASE count(*) WHEN 0 THEN '${num}' || '${num}' END FROM pg_stat_user_tables`);
+        if (!result.includes(emptyMarker))
+            core_1.ux.error(`Remote database is not empty. Please create a new database or use ${color_1.color.cmd('heroku pg:reset')}`);
+    }
+};
+exports.prepare = prepare;
+const maybeTunnel = async (herokuDb) => {
+    var _a;
+    let withTunnel = Object.assign({}, herokuDb);
+    const configs = (0, bastion_1.getConfigs)(herokuDb);
+    const tunnel = await (0, bastion_1.sshTunnel)(herokuDb, configs.dbTunnelConfig);
+    if (tunnel) {
+        const tunnelHost = {
+            host: configs.dbTunnelConfig.localHost,
+            port: (_a = configs.dbTunnelConfig.localPort) === null || _a === void 0 ? void 0 : _a.toString(),
+            _tunnel: tunnel,
+        };
+        withTunnel = Object.assign(withTunnel, tunnelHost);
+    }
+    return withTunnel;
+};
+exports.maybeTunnel = maybeTunnel;
+const connArgs = (uri, skipDFlag = false) => {
+    const args = [];
+    if (uri.user)
+        args.push('-U', uri.user);
+    if (uri.host)
+        args.push('-h', uri.host);
+    if (uri.port)
+        args.push('-p', uri.port);
+    if (!skipDFlag)
+        args.push('-d');
+    args.push(uri.database);
+    return args;
+};
+exports.connArgs = connArgs;
+const exec = (cmd, opts = {}) => {
+    debug(cmd);
+    opts = Object.assign({}, opts, { stdio: 'inherit' });
+    try {
+        return (0, node_child_process_1.execSync)(cmd, opts);
+    }
+    catch (error) {
+        const { status } = error;
+        if (status)
+            process.exit(status);
+        throw error;
+    }
+};
+const spawnPipe = async (pgDump, pgRestore) => {
+    return new Promise((resolve, reject) => {
+        const dumpStdout = pgDump.stdout;
+        const restoreStdin = pgRestore.stdin;
+        dumpStdout.pipe(restoreStdin);
+        pgDump.on('close', code => code ? reject(new Error(`pg_dump errored with ${code}`)) : restoreStdin.end());
+        pgRestore.on('close', code => code ? reject(new Error(`pg_restore errored with ${code}`)) : resolve());
+    });
+};
+exports.spawnPipe = spawnPipe;
+const verifyExtensionsMatch = async function (source, target) {
+    // It's pretty common for local DBs to not have extensions available that
+    // are used by the remote app, so take the final precaution of warning if
+    // the extensions available in the local database don't match. We don't
+    // report it if the difference is solely in the version of an extension
+    // used, though.
+    const sql = 'SELECT extname FROM pg_extension ORDER BY extname;';
+    const [extensionTarget, extensionSource] = await Promise.all([
+        (0, psql_1.exec)(target, sql),
+        (0, psql_1.exec)(source, sql),
+    ]);
+    const extensions = {
+        target: extensionTarget,
+        source: extensionSource,
+    };
+    // TODO: it shouldn't matter if the target has *more* extensions than the source
+    if (extensions.target !== extensions.source) {
+        core_1.ux.warn((0, tsheredoc_1.default) `
+      Extensions in newly created target database differ from existing source database.
+      Target extensions:
+    ` + extensions.target + (0, tsheredoc_1.default) `
+      Source extensions:
+    ` + extensions.source + (0, tsheredoc_1.default) `
+      HINT: You should review output to ensure that any errors
+      ignored are acceptable - entire tables may have been missed, where a dependency
+      could not be resolved. You may need to install a postgresql-contrib package
+      and retry.
+    `);
+    }
+};
+exports.verifyExtensionsMatch = verifyExtensionsMatch;

package/lib/lib/pg/setter.d.ts

@@ -0,0 +1,16 @@
+import { Command } from '@heroku-cli/command';
+import { SettingKey, Setting } from './types';
+export declare abstract class PGSettingsCommand extends Command {
+    protected abstract settingKey: SettingKey;
+    protected abstract convertValue(val: string): unknown;
+    protected abstract explain(setting: Setting<unknown>): string;
+    static topic: 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>;
+}
+export declare type BooleanAsString = 'on' | 'ON' | 'true' | 'TRUE' | 'off' | 'OFF' | 'false' | 'FALSE';
+export declare const booleanConverter: (value: BooleanAsString) => boolean;
+export declare const numericConverter: (value: string) => number;

package/lib/lib/pg/setter.js

@@ -0,0 +1,65 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.numericConverter = exports.booleanConverter = exports.PGSettingsCommand = void 0;
+const command_1 = require("@heroku-cli/command");
+const core_1 = require("@oclif/core");
+const resolve_1 = require("../addons/resolve");
+const host_1 = require("./host");
+const util_1 = require("./util");
+class PGSettingsCommand extends command_1.Command {
+    async run() {
+        const { flags, args } = await this.parse();
+        const { app } = flags;
+        const { value, database } = args;
+        const db = await (0, resolve_1.addonResolver)(this.heroku, app, database || 'DATABASE_URL');
+        if ((0, util_1.essentialPlan)(db))
+            core_1.ux.error('You can’t perform this operation on Essential-tier databases.');
+        if (value) {
+            const { body: settings } = await this.heroku.patch(`/postgres/v0/databases/${db.id}/config`, {
+                hostname: (0, host_1.default)(),
+                body: { [this.settingKey]: this.convertValue(value) },
+            });
+            const setting = settings[this.settingKey];
+            core_1.ux.log(`${this.settingKey.replace(/_/g, '-')} has been set to ${setting.value} for ${db.name}.`);
+            core_1.ux.log(this.explain(setting));
+        }
+        else {
+            const { body: settings } = await this.heroku.get(`/postgres/v0/databases/${db.id}/config`, { hostname: (0, host_1.default)() });
+            const setting = settings[this.settingKey];
+            core_1.ux.log(`${this.settingKey.replace(/_/g, '-')} is set to ${setting.value} for ${db.name}.`);
+            core_1.ux.log(this.explain(setting));
+        }
+    }
+}
+exports.PGSettingsCommand = PGSettingsCommand;
+PGSettingsCommand.topic = 'pg';
+PGSettingsCommand.flags = {
+    app: command_1.flags.app({ required: true }),
+    remote: command_1.flags.remote(),
+};
+const booleanConverter = (value) => {
+    switch (value) {
+        case 'true':
+        case 'TRUE':
+        case 'ON':
+        case 'on':
+            return true;
+        case 'false':
+        case 'FALSE':
+        case 'OFF':
+        case 'off':
+        case null:
+            return false;
+        default:
+            throw new TypeError('Invalid value. Valid options are: a boolean value');
+    }
+};
+exports.booleanConverter = booleanConverter;
+const numericConverter = (value) => {
+    const n = Number(value);
+    if (!Number.isFinite(n)) {
+        throw new TypeError('Invalid value. Valid options are: a numeric value');
+    }
+    return n;
+};
+exports.numericConverter = numericConverter;

package/lib/lib/pg/types.d.ts

@@ -0,0 +1,230 @@
+import * as Heroku from '@heroku-cli/schema';
+export declare type TransferSchedule = {
+    hour: number;
+    name: string;
+    timezone: string;
+    uuid: string;
+};
+export declare type PublicUrlResponse = {
+    url: string;
+};
+declare type TransferTargetType = 'pg_dump' | 'pg_restore' | 'gof3r' | 'htcat';
+export declare type BackupTransfer = {
+    uuid: string;
+    num: number;
+    from_name: string;
+    from_type: TransferTargetType;
+    from_url: string;
+    to_name: string;
+    to_type: TransferTargetType;
+    to_url: string;
+    options: {
+        [k: string]: unknown;
+    };
+    source_bytes: number;
+    processed_bytes: number;
+    succeeded: boolean;
+    warnings: number;
+    created_at: string;
+    started_at: string;
+    canceled_at: string;
+    updated_at: string;
+    finished_at: string;
+    deleted_at: string;
+    purged_at: string;
+    num_keep: number;
+    schedule?: {
+        uuid: string;
+    };
+    logs: Array<{
+        created_at: string;
+        level: string;
+        message: string;
+    }>;
+};
+export declare type AddOnWithRelatedData = Required<Heroku.AddOnAttachment['addon']> & {
+    attachment_names?: string[];
+    links?: Link[];
+    plan: Required<Heroku.AddOn['plan']>;
+};
+declare type ServiceInfo = 'Status' | 'Fork/Follow' | 'Rollback' | 'Created' | 'Region' | 'Data Encryption' | 'Continuous Protection' | 'Enhanced Certificates' | 'Upgradable Extensions' | 'Plan' | 'HA Status' | 'Behind By' | 'Data Size' | 'Tables' | 'PG Version' | 'Connections' | 'Connection Pooling' | 'Credentials' | 'Restricted Credentials' | 'Mutual TLS' | 'Customer Encryption Key' | 'Following' | 'Forked From' | 'Followers' | 'Forks' | 'Maintenance' | 'Maintenance window' | 'Infrastructure' | 'Warning';
+export declare type PgDatabaseService = {
+    addon_id: string;
+    name: string;
+    heroku_resource_id: string;
+    formation?: {
+        id: string;
+        primary: string;
+    };
+    metaas_source: string;
+    num_tables: number;
+    num_connections: number;
+    num_connections_waiting: number;
+    num_bytes: number;
+    postgres_version: string;
+    current_transaction: number;
+    is_in_recovery?: boolean;
+    plan: {
+        id: number;
+        name: string;
+    };
+    created_at: string;
+    'standalone?'?: boolean;
+    port: number;
+    database_name: string;
+    database_user: string;
+    'hot_standby?'?: boolean;
+    status_updated_at?: string;
+    following?: string;
+    forked_from: string;
+    target_transaction: string | null;
+    available_for_ingress: boolean;
+    resource_url: string;
+    database_password: string;
+    'waiting?': boolean;
+    credentials: number;
+    leader: string | null;
+    info: Array<{
+        name: ServiceInfo;
+        values: string[];
+    }>;
+};
+export declare type PgStatus = {
+    'waiting?': boolean;
+    'error?': boolean;
+    message: string;
+};
+declare type TenantInfoNames = 'Plan' | 'Status' | 'Connections' | 'PG Version' | 'Created' | 'Data Size' | 'Tables' | 'Fork/Follow' | 'Rollback' | 'Continuous Protection' | 'Billing App' | 'Add-on';
+export declare type TenantInfo = {
+    name: TenantInfoNames;
+    values: string[];
+    resolve_db_name?: boolean;
+};
+export declare type PgDatabaseTenant = {
+    addon_id: string;
+    name: string;
+    plan: string;
+    created_at: string;
+    database_user: string;
+    database_name: string;
+    following?: string;
+    resource_url: string;
+    'waiting?': boolean;
+    num_bytes: number;
+    info: Array<TenantInfo>;
+};
+export declare type PgDatabase = PgDatabaseService & PgDatabaseTenant;
+export declare type AddOnWithPlan = Required<Heroku.AddOnAttachment['addon']> & {
+    plan: Required<Heroku.AddOn['plan']>;
+};
+export declare type AddOnAttachmentWithConfigVarsAndPlan = Required<Heroku.AddOnAttachment> & {
+    config_vars: Heroku.AddOn['config_vars'];
+    addon: AddOnWithRelatedData;
+};
+export declare type Link = {
+    attachment_name?: string;
+    created_at: string;
+    message: string;
+    name: string;
+    remote?: Link;
+};
+declare type CredentialState = 'enabling' | 'active' | 'revoking' | 'revoked' | 'archived';
+export declare type Credential = {
+    user: string;
+    password: string;
+    state: CredentialState;
+    connections?: number | null;
+};
+declare type CredentialStoreState = 'provisioning' | 'wait_for_provisioning' | 'active' | 'rotating' | 'rotation_completed' | 'revoking' | 'archived';
+export declare type CredentialInfo = {
+    uuid: string;
+    name: string;
+    state: CredentialStoreState;
+    database: string;
+    host: string;
+    port: number;
+    credentials: Array<Credential>;
+};
+export declare type CredentialsInfo = Array<CredentialInfo>;
+export declare type MaintenanceApiResponse = {
+    message: string;
+};
+export declare type PgDatabaseConfig = {
+    [key: string]: any;
+    'log_lock_waits': {
+        value: boolean;
+    };
+};
+export declare type SettingKey = 'log_lock_waits' | 'log_connections' | 'log_min_duration_statement' | 'log_statement' | 'track_functions' | 'pgbouncer_max_client_conn' | 'pg_bouncer_max_db_conns' | 'pg_bouncer_default_pool_size' | 'auto_explain' | 'auto_explain.log_min_duration' | 'auto_explain.log_analyze' | 'auto_explain.log_triggers' | 'auto_explain.log_buffers' | 'auto_explain.log_verbose' | 'auto_explain.log_nested_statements';
+export declare type Setting<T> = {
+    value: T;
+    values: Record<string, string>;
+    desc: string;
+    default: T;
+};
+export declare type SettingsResponse = Record<SettingKey, Setting<unknown>>;
+export declare type PGDiagnoseResponse = {
+    id: string;
+    app: string;
+    database: string;
+    created_at: string;
+    checks: [
+        PGDiagnoseCheck<ConnCountResult>,
+        PGDiagnoseCheck<QueriesResult>,
+        PGDiagnoseCheck<QueriesResult>,
+        PGDiagnoseCheck<UnusedIndexesResult>,
+        PGDiagnoseCheck<BloatResult>,
+        PGDiagnoseCheck<HitRateResult>,
+        PGDiagnoseCheck<BlockingResult>
+    ];
+};
+export declare type PGDiagnoseCheck<T extends PGDiagnoseResult = PGDiagnoseResult> = {
+    name: string;
+    status: 'red' | 'yellow' | 'green';
+    results: T[];
+};
+export declare type PGDiagnoseResult = ConnCountResult | QueriesResult | UnusedIndexesResult | BloatResult | HitRateResult | BlockingResult;
+export declare type ConnCountResult = {
+    count: number;
+};
+export declare type QueriesResult = {
+    pid: number;
+    duration: string;
+    query: string;
+};
+export declare type UnusedIndexesResult = {
+    reason: string;
+    index: string;
+    index_scan_pct: string;
+    scans_per_write: string;
+    index_size: string;
+    table_size: string;
+};
+export declare type BloatResult = {
+    type: string;
+    object: string;
+    bloat: number;
+    waste: string;
+};
+export declare type HitRateResult = {
+    name: string;
+    ratio: number;
+};
+export declare type BlockingResult = {
+    blocked_pid: number;
+    blocking_statement: string;
+    blocking_duration: string;
+    blocking_pid: number;
+    blocked_statement: string;
+    blocked_duration: string;
+};
+export declare type PGDiagnoseRequest = {
+    url: string;
+    plan: string;
+    app: string;
+    database: string;
+    metrics?: unknown[];
+    burst_data_present?: boolean;
+    burst_status?: string;
+};
+export {};

package/lib/lib/pg/types.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/lib/lib/pg/util.d.ts

@@ -0,0 +1,36 @@
+/// <reference types="node" />
+import type { AddOnAttachment } from '@heroku-cli/schema';
+import type { AddOnAttachmentWithConfigVarsAndPlan, CredentialsInfo } from './types';
+import { Server } from 'net';
+export declare function getConfigVarName(configVars: string[]): string;
+export declare const essentialNumPlan: (addon: AddOnAttachmentWithConfigVarsAndPlan) => boolean;
+export declare const legacyEssentialPlan: (addon: AddOnAttachmentWithConfigVarsAndPlan) => boolean;
+export declare function essentialPlan(addon: AddOnAttachmentWithConfigVarsAndPlan): boolean;
+export declare function getConfigVarNameFromAttachment(attachment: Required<AddOnAttachment & {
+    addon: AddOnAttachmentWithConfigVarsAndPlan;
+}>, config?: Record<string, string>): string;
+export declare function presentCredentialAttachments(app: string, credAttachments: Required<AddOnAttachment>[], credentials: CredentialsInfo, cred: string): string;
+export declare type ConnectionDetails = {
+    user: string;
+    password: string;
+    database: string;
+    host: string;
+    port: string;
+    pathname: string;
+    url: string;
+    bastionKey?: string;
+    bastionHost?: string;
+    _tunnel?: Server;
+};
+export declare type ConnectionDetailsWithAttachment = ConnectionDetails & {
+    attachment: Required<AddOnAttachment & {
+        addon: AddOnAttachmentWithConfigVarsAndPlan;
+    }>;
+};
+export declare const getConnectionDetails: (attachment: Required<AddOnAttachment & {
+    addon: AddOnAttachmentWithConfigVarsAndPlan;
+}>, configVars?: Record<string, string>) => ConnectionDetailsWithAttachment;
+export declare const bastionKeyPlan: (a: AddOnAttachmentWithConfigVarsAndPlan) => boolean;
+export declare const configVarNamesFromValue: (config: Record<string, string>, value: string) => string[];
+export declare const databaseNameFromUrl: (uri: string, config: Record<string, string>) => any;
+export declare const parsePostgresConnectionString: (db: string) => ConnectionDetails;

package/lib/lib/pg/util.js

@@ -0,0 +1,183 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parsePostgresConnectionString = exports.databaseNameFromUrl = exports.configVarNamesFromValue = exports.bastionKeyPlan = exports.getConnectionDetails = exports.presentCredentialAttachments = exports.getConfigVarNameFromAttachment = exports.essentialPlan = exports.legacyEssentialPlan = exports.essentialNumPlan = exports.getConfigVarName = void 0;
+const color_1 = require("@heroku-cli/color");
+const core_1 = require("@oclif/core");
+const debug_1 = require("debug");
+const addons_1 = require("../../commands/addons");
+const multisort_1 = require("../utils/multisort");
+const bastion_1 = require("./bastion");
+const process_1 = require("process");
+function getConfigVarName(configVars) {
+    const connStringVars = configVars.filter(cv => (cv.endsWith('_URL')));
+    if (connStringVars.length === 0)
+        throw new Error('Database URL not found for this addon');
+    return connStringVars[0];
+}
+exports.getConfigVarName = getConfigVarName;
+const essentialNumPlan = (addon) => { var _a, _b; return Boolean((_b = (_a = addon === null || addon === void 0 ? void 0 : addon.plan) === null || _a === void 0 ? void 0 : _a.name) === null || _b === void 0 ? void 0 : _b.split(':')[1].match(/^essential/)); };
+exports.essentialNumPlan = essentialNumPlan;
+const legacyEssentialPlan = (addon) => { var _a, _b; return Boolean((_b = (_a = addon === null || addon === void 0 ? void 0 : addon.plan) === null || _a === void 0 ? void 0 : _a.name) === null || _b === void 0 ? void 0 : _b.split(':')[1].match(/(dev|basic|mini)$/)); };
+exports.legacyEssentialPlan = legacyEssentialPlan;
+function essentialPlan(addon) {
+    return (0, exports.essentialNumPlan)(addon) || (0, exports.legacyEssentialPlan)(addon);
+}
+exports.essentialPlan = essentialPlan;
+function getConfigVarNameFromAttachment(attachment, config = {}) {
+    var _a, _b;
+    const configVars = (_b = (_a = attachment.config_vars) === null || _a === void 0 ? void 0 : _a.filter((cv) => {
+        var _a;
+        return (_a = config[cv]) === null || _a === void 0 ? void 0 : _a.startsWith('postgres://');
+    })) !== null && _b !== void 0 ? _b : [];
+    if (configVars.length === 0) {
+        core_1.ux.error(`No config vars found for ${attachment.name}; perhaps they were removed as a side effect of ${color_1.default.cmd('heroku rollback')}? Use ${color_1.default.cmd('heroku addons:attach')} to create a new attachment and then ${color_1.default.cmd('heroku addons:detach')} to remove the current attachment.`);
+    }
+    const configVarName = `${attachment.name}_URL`;
+    if (configVars.includes(configVarName) && configVarName in config) {
+        return configVarName;
+    }
+    return getConfigVarName(configVars);
+}
+exports.getConfigVarNameFromAttachment = getConfigVarNameFromAttachment;
+function presentCredentialAttachments(app, credAttachments, credentials, cred) {
+    const isForeignApp = (attOrAddon) => attOrAddon.app.name === app ? 0 : 1;
+    const comparators = [
+        (a, b) => {
+            const fa = isForeignApp(a);
+            const fb = isForeignApp(b);
+            return fa < fb ? -1 : (fb < fa ? 1 : 0);
+        },
+        (a, b) => a.name.localeCompare(b.name),
+        (a, b) => { var _a, _b, _c, _d, _e; return (_e = (_b = (_a = a.app) === null || _a === void 0 ? void 0 : _a.name) === null || _b === void 0 ? void 0 : _b.localeCompare((_d = (_c = b.app) === null || _c === void 0 ? void 0 : _c.name) !== null && _d !== void 0 ? _d : '')) !== null && _e !== void 0 ? _e : 0; },
+    ];
+    credAttachments.sort((0, multisort_1.multiSortCompareFn)(comparators));
+    // render each attachment under the credential
+    const attLines = credAttachments.map(function (attachment, idx) {
+        const isLast = (idx === credAttachments.length - 1);
+        return (0, addons_1.renderAttachment)(attachment, app, isLast);
+    });
+    const rotationLines = [];
+    const credentialStore = credentials.find(a => a.name === cred);
+    if ((credentialStore === null || credentialStore === void 0 ? void 0 : credentialStore.state) === 'rotating') {
+        const formatted = credentialStore === null || credentialStore === void 0 ? void 0 : credentialStore.credentials.map(credential => {
+            return {
+                user: credential.user,
+                state: credential.state,
+                connections: credential.connections,
+            };
+        });
+        // eslint-disable-next-line no-eq-null, eqeqeq
+        const connectionInformationAvailable = formatted.some(c => c.connections != null);
+        if (connectionInformationAvailable) {
+            const prefix = '       ';
+            rotationLines.push(`${prefix}Usernames currently active for this credential:`);
+            core_1.ux.table(formatted, {
+                user: {
+                    get(row) {
+                        return `${prefix}${row.user}`;
+                    },
+                },
+                state: {
+                    get(row) {
+                        return row.state === 'revoking' ? 'waiting for no connections to be revoked' : row.state;
+                    },
+                },
+                connections: {
+                    get(row) {
+                        return `${row.connections} connections`;
+                    },
+                },
+            }, {
+                'no-header': true,
+                printLine(line) {
+                    rotationLines.push(line);
+                },
+            });
+        }
+    }
+    return [cred, ...attLines, ...rotationLines].join('\n');
+}
+exports.presentCredentialAttachments = presentCredentialAttachments;
+const getConnectionDetails = (attachment, configVars = {}) => {
+    const connStringVar = getConfigVarNameFromAttachment(attachment, configVars);
+    // remove _URL from the end of the config var name
+    const baseName = connStringVar.slice(0, -4);
+    // build the default payload for non-bastion dbs
+    (0, debug_1.default)(`Using "${connStringVar}" to connect to your database…`);
+    const conn = (0, exports.parsePostgresConnectionString)(configVars[connStringVar]);
+    const payload = {
+        user: conn.user,
+        password: conn.password,
+        database: conn.database,
+        host: conn.host,
+        port: conn.port,
+        pathname: conn.pathname,
+        url: conn.url,
+        attachment,
+    };
+    // If bastion creds exist, graft it into the payload
+    const bastion = (0, bastion_1.getBastion)(configVars, baseName);
+    if (bastion) {
+        Object.assign(payload, bastion);
+    }
+    return payload;
+};
+exports.getConnectionDetails = getConnectionDetails;
+const bastionKeyPlan = (a) => Boolean(a.plan.name.match(/private/));
+exports.bastionKeyPlan = bastionKeyPlan;
+const configVarNamesFromValue = (config, value) => {
+    const keys = [];
+    for (const key of Object.keys(config)) {
+        const configVal = config[key];
+        if (configVal === value) {
+            keys.push(key);
+        }
+        else if (configVal.startsWith('postgres://')) {
+            try {
+                const configURL = new URL(configVal);
+                const ourURL = new URL(value);
+                const components = ['protocol', 'hostname', 'port', 'pathname'];
+                if (components.every(component => ourURL[component] === configURL[component])) {
+                    keys.push(key);
+                }
+            }
+            catch (_a) {
+                // ignore -- this is not a valid URL so not a matching URL
+            }
+        }
+    }
+    const comparator = (a, b) => {
+        const isDatabaseUrlA = Number(a === 'DATABASE_URL');
+        const isDatabaseUrlB = Number(b === 'DATABASE_URL');
+        return isDatabaseUrlA < isDatabaseUrlB ? -1 : (isDatabaseUrlB < isDatabaseUrlA ? 1 : 0);
+    };
+    return keys.sort(comparator);
+};
+exports.configVarNamesFromValue = configVarNamesFromValue;
+const databaseNameFromUrl = (uri, config) => {
+    const names = (0, exports.configVarNamesFromValue)(config, uri);
+    let name = names.pop();
+    while (names.length > 0 && name === 'DATABASE_URL')
+        name = names.pop();
+    if (name) {
+        return color_1.default.configVar(name.replace(/_URL$/, ''));
+    }
+    const conn = (0, exports.parsePostgresConnectionString)(uri);
+    return `${conn.host}:${conn.port}${conn.pathname}`;
+};
+exports.databaseNameFromUrl = databaseNameFromUrl;
+const parsePostgresConnectionString = (db) => {
+    const dbPath = db.match(/:\/\//) ? db : `postgres:///${db}`;
+    const url = new URL(dbPath);
+    const { username, password, hostname, pathname, port } = url;
+    return {
+        user: username,
+        password,
+        database: pathname.charAt(0) === '/' ? pathname.slice(1) : pathname,
+        host: hostname,
+        port: port || process_1.env.PGPORT || (hostname && '5432'),
+        pathname,
+        url: dbPath,
+    };
+};
+exports.parsePostgresConnectionString = parsePostgresConnectionString;