heroku 10.13.2 → 10.13.3-beta.0

package/lib/lib/pg/fetcher.js

@@ -1,13 +1,8 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.getRelease = exports.database = exports.getAddon = exports.getAttachment = exports.all = exports.arbitraryAppDB = void 0;
-const api_client_1 = require("@heroku-cli/command/lib/api-client");
+exports.getRelease = exports.all = exports.arbitraryAppDB = void 0;
 const debug_1 = require("debug");
-const resolve_1 = require("../addons/resolve");
-const bastion_1 = require("./bastion");
-const config_1 = require("./config");
-const color_1 = require("@heroku-cli/color");
-const util_1 = require("./util");
+const lodash_1 = require("lodash");
 const pgDebug = (0, debug_1.default)('pg');
 async function arbitraryAppDB(heroku, app) {
     // Since Postgres backups are tied to the app and not the add-on, but
@@ -28,108 +23,24 @@ function getAttachmentNamesByAddon(attachments) {
     }, {});
 }
 async function all(heroku, app_id) {
-    const { uniqBy } = require('lodash');
     pgDebug(`fetching all DBs on ${app_id}`);
     const attachments = await allAttachments(heroku, app_id);
     let addons = attachments.map(a => a.addon);
     // Get the list of attachment names per addon here and add to each addon obj
     const attachmentNamesByAddon = getAttachmentNamesByAddon(attachments);
-    addons = uniqBy(addons, 'id');
+    addons = (0, lodash_1.uniqBy)(addons, 'id');
     addons.forEach(addon => {
         addon.attachment_names = attachmentNamesByAddon[addon.id];
     });
     return addons;
 }
 exports.all = all;
-async function matchesHelper(heroku, app, db, namespace) {
-    var _a;
-    (0, debug_1.default)(`fetching ${db} on ${app}`);
-    const addonService = process.env.HEROKU_POSTGRESQL_ADDON_NAME || 'heroku-postgresql';
-    (0, debug_1.default)(`addon service: ${addonService}`);
-    try {
-        const attached = await (0, resolve_1.appAttachment)(heroku, app, db, { addon_service: addonService, namespace });
-        return ({ matches: [attached] });
-    }
-    catch (error) {
-        if (error instanceof resolve_1.AmbiguousError && ((_a = error.body) === null || _a === void 0 ? void 0 : _a.id) === 'multiple_matches' && error.matches) {
-            return { matches: error.matches, error };
-        }
-        if (error instanceof api_client_1.HerokuAPIError && error.http.statusCode === 404 && error.body && error.body.id === 'not_found') {
-            return { matches: null, error };
-        }
-        throw error;
-    }
-}
-async function getAttachment(heroku, app, db = 'DATABASE_URL', namespace = '') {
-    var _a;
-    const matchesOrError = await matchesHelper(heroku, app, db, namespace);
-    let { matches } = matchesOrError;
-    const { error } = matchesOrError;
-    // happy path where the resolver matches just one
-    if (matches && matches.length === 1) {
-        return matches[0];
-    }
-    // case for 404 where there are implicit attachments
-    if (!matches) {
-        const appConfigMatch = /^(.+?)::(.+)/.exec(db);
-        if (appConfigMatch) {
-            app = appConfigMatch[1];
-            db = appConfigMatch[2];
-        }
-        if (!db.endsWith('_URL')) {
-            db += '_URL';
-        }
-        const [config = {}, attachments] = await Promise.all([
-            (0, config_1.getConfig)(heroku, app),
-            allAttachments(heroku, app),
-        ]);
-        if (attachments.length === 0) {
-            throw new Error(`${color_1.default.app(app)} has no databases`);
-        }
-        matches = attachments.filter(attachment => config[db] && config[db] === config[(0, util_1.getConfigVarName)(attachment.config_vars)]);
-        if (matches.length === 0) {
-            const validOptions = attachments.map(attachment => (0, util_1.getConfigVarName)(attachment.config_vars));
-            throw new Error(`Unknown database: ${db}. Valid options are: ${validOptions.join(', ')}`);
-        }
-    }
-    // case for multiple attachments with passedDb
-    const first = matches[0];
-    // case for 422 where there are ambiguous attachments that are equivalent
-    if (matches.every(match => { var _a, _b, _c, _d; return ((_a = first.addon) === null || _a === void 0 ? void 0 : _a.id) === ((_b = match.addon) === null || _b === void 0 ? void 0 : _b.id) && ((_c = first.app) === null || _c === void 0 ? void 0 : _c.id) === ((_d = match.app) === null || _d === void 0 ? void 0 : _d.id); })) {
-        const config = (_a = await (0, config_1.getConfig)(heroku, first.app.name)) !== null && _a !== void 0 ? _a : {};
-        if (matches.every(match => config[(0, util_1.getConfigVarName)(first.config_vars)] === config[(0, util_1.getConfigVarName)(match.config_vars)])) {
-            return first;
-        }
-    }
-    throw error;
-}
-exports.getAttachment = getAttachment;
 async function allAttachments(heroku, app_id) {
     const { body: attachments } = await heroku.get(`/apps/${app_id}/addon-attachments`, {
         headers: { 'Accept-Inclusion': 'addon:plan,config_vars' },
     });
     return attachments.filter((a) => { var _a, _b; return (_b = (_a = a.addon.plan) === null || _a === void 0 ? void 0 : _a.name) === null || _b === void 0 ? void 0 : _b.startsWith('heroku-postgresql'); });
 }
-async function getAddon(heroku, app, db = 'DATABASE_URL') {
-    return (await getAttachment(heroku, app, db)).addon;
-}
-exports.getAddon = getAddon;
-async function database(heroku, app, db, namespace) {
-    const attached = await getAttachment(heroku, app, db, namespace);
-    // would inline this as well but in some cases attachment pulls down config
-    // as well, and we would request twice at the same time but I did not want
-    // to push this down into attachment because we do not always need config
-    const config = await (0, config_1.getConfig)(heroku, attached.app.name);
-    const database = (0, util_1.getConnectionDetails)(attached, config);
-    if ((0, util_1.bastionKeyPlan)(attached.addon) && !database.bastionKey) {
-        const { body: bastionConfig } = await (0, bastion_1.fetchConfig)(heroku, attached.addon);
-        const bastionHost = bastionConfig.host;
-        const bastionKey = bastionConfig.private_key;
-        Object.assign(database, { bastionHost, bastionKey });
-    }
-    return database;
-}
-exports.database = database;
 async function getRelease(heroku, appName, id) {
     const { body: release } = await heroku.get(`/apps/${appName}/releases/${id}`);
     return release;

package/lib/lib/pg/psql.d.ts

@@ -1,20 +1,8 @@
 /// <reference types="node" />
 /// <reference types="node" />
-/// <reference types="node" />
-/// <reference types="node" />
-/// <reference types="node" />
-import { SpawnOptions, type SpawnOptionsWithStdioTuple } from 'child_process';
-import type { ChildProcess } from 'node:child_process';
-import { EventEmitter } from 'node:events';
-import type { Server } from 'node:net';
-import { Stream } from 'node:stream';
-import { getConfigs, TunnelConfig } from './bastion';
-import { ConnectionDetails, getConnectionDetails } from './util';
-export declare function psqlQueryOptions(query: string, dbEnv: NodeJS.ProcessEnv, cmdArgs?: string[]): {
-    dbEnv: NodeJS.ProcessEnv;
-    psqlArgs: string[];
-    childProcessOptions: SpawnOptionsWithStdioTuple<"ignore", "pipe", "inherit">;
-};
+import { SpawnOptions } from 'child_process';
+import { ConnectionDetailsWithAttachment } from '@heroku/heroku-cli-util';
+export declare function fetchVersion(db: ConnectionDetailsWithAttachment): Promise<string | undefined>;
 export declare function psqlFileOptions(file: string, dbEnv: NodeJS.ProcessEnv): {
     dbEnv: NodeJS.ProcessEnv;
     psqlArgs: string[];
@@ -25,24 +13,5 @@ export declare function psqlInteractiveOptions(prompt: string, dbEnv: NodeJS.Pro
     psqlArgs: string[];
     childProcessOptions: SpawnOptions;
 };
-export declare function execPSQL({ dbEnv, psqlArgs, childProcessOptions }: {
-    dbEnv: NodeJS.ProcessEnv;
-    psqlArgs: string[];
-    childProcessOptions: SpawnOptions;
-}): ChildProcess;
-export declare function waitForPSQLExit(psql: EventEmitter): Promise<void>;
-export declare const trapAndForwardSignalsToChildProcess: (childProcess: ChildProcess) => () => void;
-export declare function consumeStream(inputStream: Stream): Promise<unknown>;
-export declare function runWithTunnel(db: ConnectionDetails, tunnelConfig: TunnelConfig, options: Parameters<typeof execPSQL>[0]): Promise<string>;
-export declare class Tunnel {
-    private readonly bastionTunnel;
-    private readonly events;
-    constructor(bastionTunnel: Server);
-    waitForClose(): Promise<void>;
-    close(): void;
-    static connect(db: ConnectionDetails, tunnelConfig: TunnelConfig): Promise<Tunnel>;
-}
-export declare function fetchVersion(db: Parameters<typeof exec>[0]): Promise<string | undefined>;
-export declare function exec(db: ConnectionDetails, query: string, cmdArgs?: string[]): Promise<string>;
-export declare function execFile(db: Parameters<typeof getConfigs>[0], file: string): Promise<string>;
-export declare function interactive(db: ReturnType<typeof getConnectionDetails>): Promise<string>;
+export declare function execFile(db: ConnectionDetailsWithAttachment, file: string): Promise<string>;
+export declare function interactive(db: ConnectionDetailsWithAttachment): Promise<string>;

package/lib/lib/pg/psql.js

@@ -1,29 +1,19 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.interactive = exports.execFile = exports.exec = exports.fetchVersion = exports.Tunnel = exports.runWithTunnel = exports.consumeStream = exports.trapAndForwardSignalsToChildProcess = exports.waitForPSQLExit = exports.execPSQL = exports.psqlInteractiveOptions = exports.psqlFileOptions = exports.psqlQueryOptions = void 0;
+exports.interactive = exports.execFile = exports.psqlInteractiveOptions = exports.psqlFileOptions = exports.fetchVersion = void 0;
 const core_1 = require("@oclif/core");
-const child_process_1 = require("child_process");
 const debug_1 = require("debug");
 const fs = require("fs");
-const node_events_1 = require("node:events");
 const path = require("node:path");
-const node_stream_1 = require("node:stream");
-const promises_1 = require("node:stream/promises");
-const bastion_1 = require("./bastion");
-const pgDebug = (0, debug_1.default)('pg');
-function psqlQueryOptions(query, dbEnv, cmdArgs = []) {
-    pgDebug('Running query: %s', query.trim());
-    const psqlArgs = ['-c', query, '--set', 'sslmode=require', ...cmdArgs];
-    const childProcessOptions = {
-        stdio: ['ignore', 'pipe', 'inherit'],
-    };
-    return {
-        dbEnv,
-        psqlArgs,
-        childProcessOptions,
-    };
+const heroku_cli_util_1 = require("@heroku/heroku-cli-util");
+async function fetchVersion(db) {
+    var _a;
+    const psqlService = new heroku_cli_util_1.utils.pg.PsqlService(db);
+    const output = await psqlService.execQuery('SHOW server_version', ['-X', '-q']);
+    return (_a = output.match(/[0-9]{1,}\.[0-9]{1,}/)) === null || _a === void 0 ? void 0 : _a[0];
 }
-exports.psqlQueryOptions = psqlQueryOptions;
+exports.fetchVersion = fetchVersion;
+const pgDebug = (0, debug_1.default)('pg');
 function psqlFileOptions(file, dbEnv) {
     pgDebug('Running sql file: %s', file.trim());
     const childProcessOptions = {
@@ -65,188 +55,20 @@ function psqlInteractiveOptions(prompt, dbEnv) {
     };
 }
 exports.psqlInteractiveOptions = psqlInteractiveOptions;
-function execPSQL({ dbEnv, psqlArgs, childProcessOptions }) {
-    const options = Object.assign({ env: dbEnv }, childProcessOptions);
-    pgDebug('opening psql process');
-    const psql = (0, child_process_1.spawn)('psql', psqlArgs, options);
-    psql.once('spawn', () => pgDebug('psql process spawned'));
-    return psql;
-}
-exports.execPSQL = execPSQL;
-async function waitForPSQLExit(psql) {
-    let errorToThrow = null;
-    try {
-        const [exitCode] = await (0, node_events_1.once)(psql, 'close');
-        pgDebug(`psql exited with code ${exitCode}`);
-        if (exitCode > 0) {
-            errorToThrow = new Error(`psql exited with code ${exitCode}`);
-        }
-    }
-    catch (error) {
-        pgDebug('psql process error', error);
-        const { code } = error;
-        if (code === 'ENOENT') {
-            errorToThrow = new Error('The local psql command could not be located. For help installing psql, see https://devcenter.heroku.com/articles/heroku-postgresql#local-setup');
-        }
-    }
-    if (errorToThrow) {
-        throw errorToThrow;
-    }
-}
-exports.waitForPSQLExit = waitForPSQLExit;
-// According to node.js docs, sending a kill to a process won't cause an error
-// but could have unintended consequences if the PID gets reassigned:
-// https://nodejs.org/docs/latest-v14.x/api/child_process.html#child_process_subprocess_kill_signal
-// To be on the safe side, check if the process was already killed before sending the signal
-function kill(childProcess, signal) {
-    if (!childProcess.killed) {
-        pgDebug('killing psql child process');
-        childProcess.kill(signal);
-    }
-}
-// trap SIGINT so that ctrl+c can be used by psql without killing the
-// parent node process.
-// you can use ctrl+c in psql to kill running queries
-// while keeping the psql process open.
-// This code is to stop the parent node process (heroku CLI)
-// from exiting. If the parent Heroku CLI node process exits, then psql will exit as it
-// is a child process of the Heroku CLI node process.
-const trapAndForwardSignalsToChildProcess = (childProcess) => {
-    const signalsToTrap = ['SIGINT'];
-    const signalTraps = signalsToTrap.map(signal => {
-        process.removeAllListeners(signal);
-        const listener = () => kill(childProcess, signal);
-        process.on(signal, listener);
-        return [signal, listener];
-    });
-    // restores the built-in node ctrl+c and other handlers
-    return () => {
-        signalTraps.forEach(([signal, listener]) => {
-            process.removeListener(signal, listener);
-        });
-    };
-};
-exports.trapAndForwardSignalsToChildProcess = trapAndForwardSignalsToChildProcess;
-function consumeStream(inputStream) {
-    let result = '';
-    const throughStream = new node_stream_1.Stream.PassThrough();
-    // eslint-disable-next-line no-async-promise-executor
-    const promise = new Promise(async (resolve, reject) => {
-        try {
-            await (0, promises_1.finished)(throughStream);
-            resolve(result);
-        }
-        catch (error) {
-            reject(error);
-        }
-    });
-    // eslint-disable-next-line no-return-assign
-    throughStream.on('data', chunk => result += chunk.toString());
-    inputStream.pipe(throughStream);
-    return promise;
-}
-exports.consumeStream = consumeStream;
-async function runWithTunnel(db, tunnelConfig, options) {
-    const tunnel = await Tunnel.connect(db, tunnelConfig);
-    pgDebug('after create tunnel');
-    const psql = execPSQL(options);
-    // interactive opens with stdio: 'inherit'
-    // which gives the child process the same stdin,stdout,stderr of the node process (global `process`)
-    // https://nodejs.org/api/child_process.html#child_process_options_stdio
-    // psql.stdout will be null in this case
-    // return a string for consistency but ideally we should return the child process from this function
-    // and let the caller decide what to do with stdin/stdout/stderr
-    const stdoutPromise = psql.stdout ? consumeStream(psql.stdout) : Promise.resolve('');
-    const cleanupSignalTraps = (0, exports.trapAndForwardSignalsToChildProcess)(psql);
-    try {
-        pgDebug('waiting for psql or tunnel to exit');
-        // wait for either psql or tunnel to exit;
-        // the important bit is that we ensure both processes are
-        // always cleaned up in the `finally` block below
-        await Promise.race([
-            waitForPSQLExit(psql),
-            tunnel.waitForClose(),
-        ]);
-    }
-    catch (error) {
-        pgDebug('wait for psql or tunnel error', error);
-        throw error;
-    }
-    finally {
-        pgDebug('begin tunnel cleanup');
-        cleanupSignalTraps();
-        tunnel.close();
-        kill(psql, 'SIGKILL');
-        pgDebug('end tunnel cleanup');
-    }
-    return stdoutPromise;
-}
-exports.runWithTunnel = runWithTunnel;
-// a small wrapper around tunnel-ssh
-// so that other code doesn't have to worry about
-// whether there is or is not a tunnel
-class Tunnel {
-    constructor(bastionTunnel) {
-        this.bastionTunnel = bastionTunnel;
-        this.events = new node_events_1.EventEmitter();
-    }
-    async waitForClose() {
-        if (this.bastionTunnel) {
-            try {
-                pgDebug('wait for tunnel close');
-                await (0, node_events_1.once)(this.bastionTunnel, 'close');
-                pgDebug('tunnel closed');
-            }
-            catch (error) {
-                pgDebug('tunnel close error', error);
-                throw new Error('Secure tunnel to your database failed');
-            }
-        }
-        else {
-            pgDebug('no bastion required; waiting for fake close event');
-            await (0, node_events_1.once)(this.events, 'close');
-        }
-    }
-    close() {
-        if (this.bastionTunnel) {
-            pgDebug('close tunnel');
-            this.bastionTunnel.close();
-        }
-        else {
-            pgDebug('no tunnel necessary; sending fake close event');
-            this.events.emit('close', 0);
-        }
-    }
-    static async connect(db, tunnelConfig) {
-        const tunnel = await (0, bastion_1.sshTunnel)(db, tunnelConfig);
-        return new Tunnel(tunnel);
-    }
-}
-exports.Tunnel = Tunnel;
-async function fetchVersion(db) {
-    var _a;
-    const output = await exec(db, 'SHOW server_version', ['-X', '-q']);
-    return (_a = output.match(/[0-9]{1,}\.[0-9]{1,}/)) === null || _a === void 0 ? void 0 : _a[0];
-}
-exports.fetchVersion = fetchVersion;
-async function exec(db, query, cmdArgs = []) {
-    const configs = (0, bastion_1.getConfigs)(db);
-    const options = psqlQueryOptions(query, configs.dbEnv, cmdArgs);
-    return runWithTunnel(db, configs.dbTunnelConfig, options);
-}
-exports.exec = exec;
 async function execFile(db, file) {
-    const configs = (0, bastion_1.getConfigs)(db);
+    const psqlService = new heroku_cli_util_1.utils.pg.PsqlService(db);
+    const configs = heroku_cli_util_1.utils.pg.psql.getPsqlConfigs(db);
     const options = psqlFileOptions(file, configs.dbEnv);
-    return runWithTunnel(db, configs.dbTunnelConfig, options);
+    return psqlService.runWithTunnel(configs.dbTunnelConfig, options);
 }
 exports.execFile = execFile;
 async function interactive(db) {
-    const name = db.attachment.name;
-    const prompt = `${db.attachment.app.name}::${name}%R%# `;
-    const configs = (0, bastion_1.getConfigs)(db);
+    const psqlService = new heroku_cli_util_1.utils.pg.PsqlService(db);
+    const attachmentName = db.attachment.name;
+    const prompt = `${db.attachment.app.name}::${attachmentName}%R%# `;
+    const configs = heroku_cli_util_1.utils.pg.psql.getPsqlConfigs(db);
     configs.dbEnv.PGAPPNAME = 'psql interactive'; // default was 'psql non-interactive`
     const options = psqlInteractiveOptions(prompt, configs.dbEnv);
-    return runWithTunnel(db, configs.dbTunnelConfig, options);
+    return psqlService.runWithTunnel(configs.dbTunnelConfig, options);
 }
 exports.interactive = interactive;

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

@@ -1,13 +1,8 @@
-/// <reference types="node" />
-import { ConnectionDetails } from './util';
-import { Server } from 'net';
+import { ConnectionDetails } from '@heroku/heroku-cli-util';
 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 maybeTunnel: (herokuDb: ConnectionDetails) => Promise<ConnectionDetails>;
 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

@@ -1,10 +1,9 @@
 "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 heroku_cli_util_1 = require("@heroku/heroku-cli-util");
 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");
@@ -16,6 +15,7 @@ const parseExclusions = (rawExcludeList) => {
 };
 exports.parseExclusions = parseExclusions;
 const prepare = async (target) => {
+    const psqlService = new heroku_cli_util_1.utils.pg.PsqlService(target);
     if (target.host === 'localhost' || !target.host) {
         exec(`createdb ${(0, exports.connArgs)(target, true).join(' ')}`);
     }
@@ -26,7 +26,7 @@ const prepare = async (target) => {
         // 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`);
+        const result = await psqlService.execQuery(`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')}`);
     }
@@ -35,8 +35,8 @@ 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);
+    const configs = heroku_cli_util_1.utils.pg.psql.getPsqlConfigs(herokuDb);
+    const tunnel = await heroku_cli_util_1.utils.pg.psql.sshTunnel(herokuDb, configs.dbTunnelConfig);
     if (tunnel) {
         const tunnelHost = {
             host: configs.dbTunnelConfig.localHost,
@@ -86,6 +86,8 @@ const spawnPipe = async (pgDump, pgRestore) => {
 };
 exports.spawnPipe = spawnPipe;
 const verifyExtensionsMatch = async function (source, target) {
+    const psqlSource = new heroku_cli_util_1.utils.pg.PsqlService(source);
+    const psqlTarget = new heroku_cli_util_1.utils.pg.PsqlService(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
@@ -93,8 +95,8 @@ const verifyExtensionsMatch = async function (source, target) {
     // 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),
+        psqlTarget.execQuery(sql),
+        psqlSource.execQuery(sql),
     ]);
     const extensions = {
         target: extensionTarget,

package/lib/lib/pg/setter.js

@@ -4,7 +4,7 @@ exports.numericConverter = exports.booleanConverter = exports.PGSettingsCommand
 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 heroku_cli_util_1 = require("@heroku/heroku-cli-util");
 const util_1 = require("./util");
 class PGSettingsCommand extends command_1.Command {
     async run() {
@@ -16,7 +16,7 @@ class PGSettingsCommand extends command_1.Command {
             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)(),
+                hostname: heroku_cli_util_1.utils.pg.host(),
                 body: { [this.settingKey]: this.convertValue(value) },
             });
             const setting = settings[this.settingKey];
@@ -24,7 +24,7 @@ class PGSettingsCommand extends command_1.Command {
             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 { body: settings } = await this.heroku.get(`/postgres/v0/databases/${db.id}/config`, { hostname: heroku_cli_util_1.utils.pg.host() });
             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));

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

@@ -42,11 +42,10 @@ export declare type BackupTransfer = {
         message: string;
     }>;
 };
-export declare type AddOnWithRelatedData = Required<Heroku.AddOnAttachment['addon']> & {
-    attachment_names?: string[];
-    links?: Link[];
-    plan: Required<Heroku.AddOn['plan']>;
-};
+export declare type ExtendedAddon = {
+    addon_service: Required<Heroku.AddOnService>;
+    plan: Required<Heroku.Plan>;
+} & Required<Heroku.AddOn>;
 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;
@@ -129,19 +128,15 @@ export declare type PgUpgradeError = {
         message: string;
     };
 };
-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;
+    id: string;
     created_at: string;
-    message: string;
     name: string;
-    remote?: Link;
+    remote_name: string;
+    remote: {
+        name: string;
+        attachment_name: string;
+    };
 };
 declare type CredentialState = 'enabling' | 'active' | 'revoking' | 'revoked' | 'archived';
 export declare type Credential = {

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

@@ -1,37 +1,11 @@
-/// <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;
+import type { ExtendedAddonAttachment } from '@heroku/heroku-cli-util';
+import type { CredentialsInfo } from './types';
+import type { ExtendedAddon } from './types';
+export declare const essentialNumPlan: (addon: ExtendedAddonAttachment['addon'] | ExtendedAddon) => boolean;
+export declare const legacyEssentialPlan: (addon: ExtendedAddonAttachment['addon'] | ExtendedAddon) => boolean;
+export declare function essentialPlan(addon: ExtendedAddonAttachment['addon'] | ExtendedAddon): boolean;
 export declare function formatResponseWithCommands(response: 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;