heroku 10.13.2 → 11.0.0-alpha.2

package/lib/lib/pg/bastion.d.ts

@@ -1,29 +1 @@
-/// <reference types="node" />
-/// <reference types="node" />
-import { APIClient } from '@heroku-cli/command';
-import * as createTunnel from 'tunnel-ssh';
-import { ConnectionDetails } from './util';
-export declare const getBastion: (config: Record<string, string>, baseName: string) => {
-    bastionHost: string;
-    bastionKey: string;
-} | {
-    bastionHost?: undefined;
-    bastionKey?: undefined;
-};
-export declare const env: (db: ConnectionDetails) => {
-    PGAPPNAME: string;
-    PGSSLMODE: string;
-} & NodeJS.ProcessEnv;
-export declare type TunnelConfig = createTunnel.Config;
-export declare function tunnelConfig(db: ConnectionDetails): TunnelConfig;
-export declare function getConfigs(db: ConnectionDetails): {
-    dbEnv: NodeJS.ProcessEnv;
-    dbTunnelConfig: createTunnel.Config;
-};
-export declare function sshTunnel(db: ConnectionDetails, dbTunnelConfig: TunnelConfig, timeout?: number): Promise<void | import("net").Server | null>;
-export declare function fetchConfig(heroku: APIClient, db: {
-    id: string;
-}): Promise<import("@heroku/http-call").HTTP<{
-    host: string;
-    private_key: string;
-}>>;
+export {};

package/lib/lib/pg/bastion.js

@@ -1,121 +1,137 @@
-"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,
-    };
+export {};
+/*
+const debug = require('debug')('pg')
+import {APIClient} from '@heroku-cli/command'
+import * as EventEmitter from 'node:events'
+import * as createTunnel from 'tunnel-ssh'
+import {promisify} from 'util'
+import host from './host'
+import {ConnectionDetails} from './util'
+import {ux} from '@oclif/core'
+
+export const getBastion = function (config:Record<string, string>, baseName: string) {
+  // 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.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,
-        });
+
+export const env = (db: ConnectionDetails) => {
+  const baseEnv = Object.assign({
+    PGAPPNAME: 'psql non-interactive',
+    PGSSLMODE: (!db.host || db.host === 'localhost') ? 'prefer' : 'require',
+  }, process.env)
+  const mapping: Record<string, keyof Omit<typeof db, 'url' | 'pathname' | 'bastionHost' | 'bastionKey' | '_tunnel'>> = {
+    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 as string
     }
-    return {
-        dbEnv,
-        dbTunnelConfig,
-    };
+  })
+  return baseEnv
 }
-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');
-    }
+
+export type TunnelConfig = createTunnel.Config
+
+export function tunnelConfig(db: ConnectionDetails): TunnelConfig {
+  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 as string, 10)) || undefined,
+    localHost,
+    localPort,
+  }
 }
-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);
+
+export function getConfigs(db: ConnectionDetails) {
+  const dbEnv: NodeJS.ProcessEnv = env(db)
+  const dbTunnelConfig = tunnelConfig(db)
+  if (db.bastionKey) {
+    Object.assign(dbEnv, {
+      PGPORT: dbTunnelConfig.localPort,
+      PGHOST: dbTunnelConfig.localHost,
+    })
+  }
+
+  return {
+    dbEnv,
+    dbTunnelConfig,
+  }
+}
+
+class Timeout {
+  private readonly timeout: number
+  private readonly message: string
+  private readonly events = new EventEmitter()
+  private timer: NodeJS.Timeout | undefined
+
+  constructor(timeout: number, message: string) {
+    this.timeout = timeout
+    this.message = message
+  }
+
+  async promise() {
+    this.timer = setTimeout(() => {
+      this.events.emit('error', new Error(this.message))
+    }, this.timeout)
+
     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();
+      await EventEmitter.once(this.events, 'cancelled')
+    } finally {
+      clearTimeout(this.timer)
     }
+  }
+
+  cancel() {
+    this.events.emit('cancelled')
+  }
+}
+
+export async function sshTunnel(db: ConnectionDetails, dbTunnelConfig: TunnelConfig, timeout = 10000) {
+  if (!db.bastionKey) {
+    return null
+  }
+
+  const timeoutInstance = new Timeout(timeout, 'Establishing a secure tunnel timed out')
+  const createSSHTunnel = promisify(createTunnel)
+  try {
+    return await Promise.race([
+      timeoutInstance.promise(),
+      createSSHTunnel(dbTunnelConfig),
+    ])
+  } catch (error) {
+    debug(error)
+    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)(),
-    });
+
+export async function fetchConfig(heroku:APIClient, db: {id: string}) {
+  return heroku.get<{host: string, private_key:string}>(
+    `/client/v11/databases/${encodeURIComponent(db.id)}/bastion`,
+    {
+      hostname: host(),
+    },
+  )
 }
-exports.fetchConfig = fetchConfig;
+*/

package/lib/lib/pg/config.js

@@ -1,13 +1,9 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.getConfig = void 0;
 const responseByAppId = new Map();
-async function getConfig(heroku, app) {
+export 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;
+    return result?.body;
 }
-exports.getConfig = getConfig;

package/lib/lib/pg/download.js

@@ -1,22 +1,23 @@
-"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) {
+import * as fs from 'fs-extra';
+import * as Path from 'path';
+import * as https from 'https';
+import cliProgress from 'cli-progress';
+export default 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),
+        const bar = new cliProgress.SingleBar({
+            format: `Downloading ${path}... |{bar}| {percentage}% | ETA: {eta}s | {value}/{total} bytes`,
+            barCompleteChar: '\u2588',
+            barIncompleteChar: '\u2591',
         });
+        bar.start(Number.parseInt(rsp.headers['content-length'], 10), 0);
         let total = 0;
         rsp.on('data', function (chunk) {
             total += chunk.length;
-            bar.tick(chunk.length, { data: bytes(total, { decimalPlaces: 2, fixedDecimals: 2 }) });
+            bar.update(total);
+        });
+        rsp.on('end', () => {
+            bar.stop();
         });
     }
     return new Promise(function (resolve, reject) {
@@ -31,4 +32,3 @@ function download(url, path, opts) {
         });
     });
 }
-exports.default = download;

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

@@ -1,39 +1 @@
-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>;
+export {};