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

package/lib/lib/pg/bastion.js

@@ -0,0 +1,121 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.fetchConfig = exports.sshTunnel = exports.getConfigs = exports.tunnelConfig = exports.env = exports.getBastion = void 0;
+const debug = require('debug')('pg');
+const EventEmitter = require("node:events");
+const createTunnel = require("tunnel-ssh");
+const util_1 = require("util");
+const host_1 = require("./host");
+const core_1 = require("@oclif/core");
+const getBastion = function (config, baseName) {
+    // If there are bastions, extract a host and a key
+    // otherwise, return an empty Object
+    // If there are bastions:
+    // * there should be one *_BASTION_KEY
+    // * pick one host from the comma-separated list in *_BASTIONS
+    // We assert that _BASTIONS and _BASTION_KEY always exist together
+    // If either is falsy, pretend neither exist
+    const bastionKey = config[`${baseName}_BASTION_KEY`];
+    const bastions = (config[`${baseName}_BASTIONS`] || '').split(',');
+    const bastionHost = bastions[Math.floor(Math.random() * bastions.length)];
+    return (bastionKey && bastionHost) ? { bastionHost, bastionKey } : {};
+};
+exports.getBastion = getBastion;
+const env = (db) => {
+    const baseEnv = Object.assign({
+        PGAPPNAME: 'psql non-interactive',
+        PGSSLMODE: (!db.host || db.host === 'localhost') ? 'prefer' : 'require',
+    }, process.env);
+    const mapping = {
+        PGUSER: 'user',
+        PGPASSWORD: 'password',
+        PGDATABASE: 'database',
+        PGPORT: 'port',
+        PGHOST: 'host',
+    };
+    Object.keys(mapping).forEach(envVar => {
+        const val = db[mapping[envVar]];
+        if (val) {
+            baseEnv[envVar] = val;
+        }
+    });
+    return baseEnv;
+};
+exports.env = env;
+function tunnelConfig(db) {
+    const localHost = '127.0.0.1';
+    const localPort = Math.floor((Math.random() * (65535 - 49152)) + 49152);
+    return {
+        username: 'bastion',
+        host: db.bastionHost,
+        privateKey: db.bastionKey,
+        dstHost: db.host || undefined,
+        dstPort: (db.port && Number.parseInt(db.port, 10)) || undefined,
+        localHost,
+        localPort,
+    };
+}
+exports.tunnelConfig = tunnelConfig;
+function getConfigs(db) {
+    const dbEnv = (0, exports.env)(db);
+    const dbTunnelConfig = tunnelConfig(db);
+    if (db.bastionKey) {
+        Object.assign(dbEnv, {
+            PGPORT: dbTunnelConfig.localPort,
+            PGHOST: dbTunnelConfig.localHost,
+        });
+    }
+    return {
+        dbEnv,
+        dbTunnelConfig,
+    };
+}
+exports.getConfigs = getConfigs;
+class Timeout {
+    constructor(timeout, message) {
+        this.events = new EventEmitter();
+        this.timeout = timeout;
+        this.message = message;
+    }
+    async promise() {
+        this.timer = setTimeout(() => {
+            this.events.emit('error', new Error(this.message));
+        }, this.timeout);
+        try {
+            await EventEmitter.once(this.events, 'cancelled');
+        }
+        finally {
+            clearTimeout(this.timer);
+        }
+    }
+    cancel() {
+        this.events.emit('cancelled');
+    }
+}
+async function sshTunnel(db, dbTunnelConfig, timeout = 10000) {
+    if (!db.bastionKey) {
+        return null;
+    }
+    const timeoutInstance = new Timeout(timeout, 'Establishing a secure tunnel timed out');
+    const createSSHTunnel = (0, util_1.promisify)(createTunnel);
+    try {
+        return await Promise.race([
+            timeoutInstance.promise(),
+            createSSHTunnel(dbTunnelConfig),
+        ]);
+    }
+    catch (error) {
+        debug(error);
+        core_1.ux.error('Unable to establish a secure tunnel to your database.');
+    }
+    finally {
+        timeoutInstance.cancel();
+    }
+}
+exports.sshTunnel = sshTunnel;
+async function fetchConfig(heroku, db) {
+    return heroku.get(`/client/v11/databases/${encodeURIComponent(db.id)}/bastion`, {
+        hostname: (0, host_1.default)(),
+    });
+}
+exports.fetchConfig = fetchConfig;

package/lib/lib/pg/config.d.ts

@@ -0,0 +1,2 @@
+import type { APIClient } from '@heroku-cli/command';
+export declare function getConfig(heroku: APIClient, app: string): Promise<Record<string, string> | undefined>;

package/lib/lib/pg/config.js

@@ -0,0 +1,13 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getConfig = void 0;
+const responseByAppId = new Map();
+async function getConfig(heroku, app) {
+    if (!responseByAppId.has(app)) {
+        const promise = heroku.get(`/apps/${app}/config-vars`);
+        responseByAppId.set(app, promise);
+    }
+    const result = await responseByAppId.get(app);
+    return result === null || result === void 0 ? void 0 : result.body;
+}
+exports.getConfig = getConfig;

package/lib/lib/pg/download.d.ts

@@ -0,0 +1,5 @@
+declare type downloadOptions = {
+    progress: boolean;
+};
+export default function download(url: string, path: string, opts: downloadOptions): Promise<unknown>;
+export {};

package/lib/lib/pg/download.js

@@ -0,0 +1,34 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const fs = require("fs-extra");
+const Path = require("path");
+const https = require('https');
+const bytes = require('bytes');
+const progress = require('smooth-progress');
+function download(url, path, opts) {
+    const tty = process.stderr.isTTY && process.env.TERM !== 'dumb';
+    function showProgress(rsp) {
+        const bar = progress({
+            tmpl: `Downloading ${path}... :bar :percent :eta :data`,
+            width: 25,
+            total: Number.parseInt(rsp.headers['content-length'], 10),
+        });
+        let total = 0;
+        rsp.on('data', function (chunk) {
+            total += chunk.length;
+            bar.tick(chunk.length, { data: bytes(total, { decimalPlaces: 2, fixedDecimals: 2 }) });
+        });
+    }
+    return new Promise(function (resolve, reject) {
+        fs.mkdirSync(Path.dirname(path), { recursive: true });
+        const file = fs.createWriteStream(path);
+        https.get(url, function (rsp) {
+            if (tty && opts.progress)
+                showProgress(rsp);
+            rsp.pipe(file)
+                .on('error', reject)
+                .on('close', resolve);
+        });
+    });
+}
+exports.default = download;

package/lib/lib/pg/fetcher.d.ts

@@ -0,0 +1,39 @@
+import { APIClient } from '@heroku-cli/command';
+import type { AddOnAttachment } from '@heroku-cli/schema';
+import * as Heroku from '@heroku-cli/schema';
+import type { AddOnAttachmentWithConfigVarsAndPlan, AddOnWithRelatedData } from './types';
+export declare function arbitraryAppDB(heroku: APIClient, app: string): Promise<Heroku.AddOn>;
+export declare function all(heroku: APIClient, app_id: string): Promise<AddOnWithRelatedData[]>;
+export declare function getAttachment(heroku: APIClient, app: string, db?: string, namespace?: string): Promise<Required<AddOnAttachment & {
+    addon: AddOnAttachmentWithConfigVarsAndPlan;
+}>>;
+export declare function getAddon(heroku: APIClient, app: string, db?: string): Promise<{
+    id: string;
+    name: string;
+    app: {
+        [k: string]: any;
+        id?: string | undefined;
+        name?: string | undefined;
+    };
+} & Required<AddOnAttachment> & {
+    config_vars: string[] | undefined;
+    addon: Required<{
+        id: string;
+        name: string;
+        app: {
+            [k: string]: any;
+            id?: string | undefined;
+            name?: string | undefined;
+        };
+    }> & {
+        attachment_names?: string[] | undefined;
+        links?: import("./types").Link[] | undefined;
+        plan: Required<{
+            [k: string]: any;
+            id?: string | undefined;
+            name?: string | undefined;
+        } | undefined>;
+    };
+}>;
+export declare function database(heroku: APIClient, app: string, db?: string, namespace?: string): Promise<import("./util").ConnectionDetailsWithAttachment>;
+export declare function getRelease(heroku: APIClient, appName: string, id: string): Promise<Heroku.Release>;

package/lib/lib/pg/fetcher.js

@@ -0,0 +1,137 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getRelease = exports.database = exports.getAddon = exports.getAttachment = 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 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
+    // we require *an* add-on to interact with, make sure that add-on is
+    // attached to the right app.
+    pgDebug(`fetching arbitrary app db on ${app}`);
+    const { body: addons } = await heroku.get(`/apps/${app}/addons`);
+    const addon = addons.find(a => { var _a, _b, _c; return ((_a = a === null || a === void 0 ? void 0 : a.app) === null || _a === void 0 ? void 0 : _a.name) === app && ((_c = (_b = a === null || a === void 0 ? void 0 : a.plan) === null || _b === void 0 ? void 0 : _b.name) === null || _c === void 0 ? void 0 : _c.startsWith('heroku-postgresql')); });
+    if (!addon)
+        throw new Error(`No heroku-postgresql databases on ${app}`);
+    return addon;
+}
+exports.arbitraryAppDB = arbitraryAppDB;
+function getAttachmentNamesByAddon(attachments) {
+    return attachments.reduce((results, a) => {
+        results[a.addon.id] = (results[a.addon.id] || []).concat(a.name);
+        return results;
+    }, {});
+}
+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.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 resolve_1.NotFound) {
+            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`);
+        }
+        console.log('hi', JSON.stringify(attachments));
+        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;
+}
+exports.getRelease = getRelease;

package/lib/lib/pg/host.d.ts

@@ -0,0 +1 @@
+export default function (): string;

package/lib/lib/pg/host.js

@@ -0,0 +1,7 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+function default_1() {
+    const host = process.env.HEROKU_DATA_HOST || process.env.HEROKU_POSTGRESQL_HOST;
+    return host ? host : 'api.data.heroku.com';
+}
+exports.default = default_1;

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

@@ -0,0 +1,48 @@
+/// <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">;
+};
+export declare function psqlFileOptions(file: string, dbEnv: NodeJS.ProcessEnv): {
+    dbEnv: NodeJS.ProcessEnv;
+    psqlArgs: string[];
+    childProcessOptions: SpawnOptions;
+};
+export declare function psqlInteractiveOptions(prompt: string, dbEnv: NodeJS.ProcessEnv): {
+    dbEnv: NodeJS.ProcessEnv;
+    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>;

package/lib/lib/pg/psql.js

@@ -0,0 +1,252 @@
+"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;
+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,
+    };
+}
+exports.psqlQueryOptions = psqlQueryOptions;
+function psqlFileOptions(file, dbEnv) {
+    pgDebug('Running sql file: %s', file.trim());
+    const childProcessOptions = {
+        stdio: ['ignore', 'pipe', 'inherit'],
+    };
+    const psqlArgs = ['-f', file, '--set', 'sslmode=require'];
+    return {
+        dbEnv,
+        psqlArgs,
+        childProcessOptions,
+    };
+}
+exports.psqlFileOptions = psqlFileOptions;
+function psqlInteractiveOptions(prompt, dbEnv) {
+    let psqlArgs = ['--set', `PROMPT1=${prompt}`, '--set', `PROMPT2=${prompt}`];
+    const psqlHistoryPath = process.env.HEROKU_PSQL_HISTORY;
+    if (psqlHistoryPath) {
+        if (fs.existsSync(psqlHistoryPath) && fs.statSync(psqlHistoryPath).isDirectory()) {
+            const appLogFile = `${psqlHistoryPath}/${prompt.split(':')[0]}`;
+            pgDebug('Logging psql history to %s', appLogFile);
+            psqlArgs = psqlArgs.concat(['--set', `HISTFILE=${appLogFile}`]);
+        }
+        else if (fs.existsSync(path.dirname(psqlHistoryPath))) {
+            pgDebug('Logging psql history to %s', psqlHistoryPath);
+            psqlArgs = psqlArgs.concat(['--set', `HISTFILE=${psqlHistoryPath}`]);
+        }
+        else {
+            core_1.ux.warn(`HEROKU_PSQL_HISTORY is set but is not a valid path (${psqlHistoryPath})`);
+        }
+    }
+    psqlArgs = psqlArgs.concat(['--set', 'sslmode=require']);
+    const childProcessOptions = {
+        stdio: 'inherit',
+    };
+    return {
+        dbEnv,
+        psqlArgs,
+        childProcessOptions,
+    };
+}
+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 options = psqlFileOptions(file, configs.dbEnv);
+    return runWithTunnel(db, 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);
+    configs.dbEnv.PGAPPNAME = 'psql interactive'; // default was 'psql non-interactive`
+    const options = psqlInteractiveOptions(prompt, configs.dbEnv);
+    return runWithTunnel(db, configs.dbTunnelConfig, options);
+}
+exports.interactive = interactive;