heroku 10.13.2 → 11.0.0-alpha.10

package/lib/lib/pg/backups.js

@@ -1,164 +1,175 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-const tslib_1 = require("tslib");
-const color_1 = require("@heroku-cli/color");
-const core_1 = require("@oclif/core");
-const tsheredoc_1 = require("tsheredoc");
-const host_1 = require("./host");
-const bytes = require("bytes");
-function prefix(transfer) {
-    if (transfer.from_type === 'pg_dump') {
-        if (transfer.to_type === 'pg_restore') {
-            return 'c';
-        }
-        return transfer.schedule ? 'a' : 'b';
-        // eslint-disable-next-line no-else-return
+export {};
+/*
+import color from '@heroku-cli/color'
+import {APIClient} from '@heroku-cli/command'
+import {ux} from '@oclif/core'
+import heredoc from 'tsheredoc'
+import host from './host'
+import type {BackupTransfer} from './types'
+import bytes = require('bytes')
+
+function prefix(transfer: BackupTransfer) {
+  if (transfer.from_type === 'pg_dump') {
+    if (transfer.to_type === 'pg_restore') {
+      return 'c'
     }
-    else {
-        if (transfer.to_type === 'pg_restore') {
-            return 'r';
-        }
-        return 'b';
+
+    return transfer.schedule ? 'a' : 'b'
+
+    // eslint-disable-next-line no-else-return
+  } else {
+    if (transfer.to_type === 'pg_restore') {
+      return 'r'
     }
+
+    return 'b'
+  }
 }
+
 class Backups {
-    constructor(app, heroku) {
-        this.logsAlreadyShown = new Set();
-        this.status = (transfer) => {
-            if (transfer.finished_at && transfer.succeeded) {
-                const warnings = transfer.warnings;
-                if (warnings > 0) {
-                    return `Finished with ${warnings} warnings`;
-                }
-                return `Completed ${transfer.finished_at}`;
-            }
-            if (transfer.finished_at) {
-                return `Failed ${transfer.finished_at}`;
-            }
-            if (transfer.started_at) {
-                return `Running (processed ${this.filesize(transfer.processed_bytes)})`;
-            }
-            return 'Pending';
-        };
-        this.num = async (name) => {
-            let m = name.match(/^[abcr](\d+)$/);
-            if (m)
-                return Number.parseInt(m[1], 10);
-            m = name.match(/^o[ab]\d+$/);
-            if (m) {
-                const { body: transfers } = await this.heroku.get(`/client/v11/apps/${this.app}/transfers`, { hostname: (0, host_1.default)() });
-                const transfer = transfers.find(t => this.name(t) === name);
-                if (transfer)
-                    return transfer.num;
-            }
-        };
-        this.name = (transfer) => {
-            const oldPGBName = transfer.options && transfer.options.pgbackups_name;
-            if (oldPGBName)
-                return `o${oldPGBName}`;
-            return `${prefix(transfer)}${(transfer.num || '').toString().padStart(3, '0')}`;
-        };
-        this.wait = async (action, transferID, interval, verbose, app) => {
-            var e_1, _a;
-            if (verbose) {
-                core_1.ux.log(`${action}...`);
-            }
-            core_1.ux.action.start(action);
-            try {
-                try {
-                    for (var _b = tslib_1.__asyncValues(this.poll(transferID, interval, verbose, app || this.app)), _c; _c = await _b.next(), !_c.done;) {
-                        const backupSucceeded = _c.value;
-                        if (backupSucceeded) {
-                            core_1.ux.action.stop();
-                            break;
-                        }
-                    }
-                }
-                catch (e_1_1) { e_1 = { error: e_1_1 }; }
-                finally {
-                    try {
-                        if (_c && !_c.done && (_a = _b.return)) await _a.call(_b);
-                    }
-                    finally { if (e_1) throw e_1.error; }
-                }
-            }
-            catch (error) {
-                core_1.ux.action.stop('!');
-                core_1.ux.error(error);
-            }
-        };
-        this.app = app;
-        this.heroku = heroku;
+  protected app: string
+  protected heroku: APIClient
+  protected logsAlreadyShown = new Set<string>()
+
+  constructor(app: string, heroku: APIClient) {
+    this.app = app
+    this.heroku = heroku
+  }
+
+  public filesize(size: number, opts = {}): string {
+    Object.assign(opts, {
+      decimalPlaces: 2,
+      fixedDecimals: true,
+    })
+    return bytes(size, opts)
+  }
+
+  public status = (transfer: BackupTransfer): string => {
+    if (transfer.finished_at && transfer.succeeded) {
+      const warnings = transfer.warnings
+      if (warnings > 0) {
+        return `Finished with ${warnings} warnings`
+      }
+
+      return `Completed ${transfer.finished_at}`
+    }
+
+    if (transfer.finished_at) {
+      return `Failed ${transfer.finished_at}`
+    }
+
+    if (transfer.started_at) {
+      return `Running (processed ${this.filesize(transfer.processed_bytes)})`
     }
-    filesize(size, opts = {}) {
-        Object.assign(opts, {
-            decimalPlaces: 2,
-            fixedDecimals: true,
-        });
-        return bytes(size, opts);
+
+    return 'Pending'
+  }
+
+  public num = async (name: string) => {
+    let m = name.match(/^[abcr](\d+)$/)
+    if (m) return Number.parseInt(m[1], 10)
+    m = name.match(/^o[ab]\d+$/)
+    if (m) {
+      const {body: transfers} = await this.heroku.get<BackupTransfer[]>(`/client/v11/apps/${this.app}/transfers`, {hostname: host()})
+      const transfer = transfers.find(t => this.name(t) === name)
+      if (transfer) return transfer.num
+    }
+  }
+
+  public name = (transfer: BackupTransfer) => {
+    const oldPGBName = transfer.options && transfer.options.pgbackups_name
+    if (oldPGBName) return `o${oldPGBName}`
+    return `${prefix(transfer)}${(transfer.num || '').toString().padStart(3, '0')}`
+  }
+
+  public wait = async (action: string, transferID: string, interval: number, verbose: boolean, app: string) => {
+    if (verbose) {
+      ux.log(`${action}...`)
     }
-    displayLogs(logs) {
-        for (const log of logs) {
-            if (this.logsAlreadyShown.has(log.created_at + log.message)) {
-                continue;
-            }
-            this.logsAlreadyShown.add(log.created_at + log.message);
-            core_1.ux.log(`${log.created_at} ${log.message}`);
+
+    ux.action.start(action)
+    try {
+      for await (const backupSucceeded of this.poll(transferID, interval, verbose, app || this.app)) {
+        if (backupSucceeded) {
+          ux.action.stop()
+          break
         }
+      }
+    } catch (error) {
+      ux.action.stop('!')
+      ux.error(error as Error)
+    }
+  }
+
+  protected displayLogs(logs: BackupTransfer['logs']) {
+    for (const log of logs) {
+      if (this.logsAlreadyShown.has(log.created_at + log.message)) {
+        continue
+      }
+
+      this.logsAlreadyShown.add(log.created_at + log.message)
+      ux.log(`${log.created_at} ${log.message}`)
     }
-    poll(transferID, interval, verbose, appId) {
-        var _a;
-        return tslib_1.__asyncGenerator(this, arguments, function* poll_1() {
-            const tty = process.env.TERM !== 'dumb' && process.stderr.isTTY;
-            let backup = {};
-            let failures = 0;
-            const quietUrl = `/client/v11/apps/${appId !== null && appId !== void 0 ? appId : this.app}/transfers/${transferID}`;
-            const verboseUrl = quietUrl + '?verbose=true';
-            const url = verbose ? verboseUrl : quietUrl;
-            while (failures < 21) {
-                try {
-                    ({ body: backup } = yield tslib_1.__await(this.heroku.get(url, { hostname: (0, host_1.default)() })));
-                }
-                catch (error) {
-                    if (failures++ > 20) {
-                        throw error;
-                    }
-                }
-                if (verbose) {
-                    this.displayLogs(backup.logs);
-                }
-                else if (tty) {
-                    const msg = backup.started_at ? this.filesize(backup.processed_bytes) : 'pending';
-                    const log = (_a = backup.logs) === null || _a === void 0 ? void 0 : _a.pop();
-                    if (log) {
-                        core_1.ux.action.status = `${msg}\n${log.created_at + ' ' + log.message}`;
-                    }
-                    else {
-                        core_1.ux.action.status = msg;
-                    }
-                }
-                if (backup === null || backup === void 0 ? void 0 : backup.finished_at) {
-                    if (backup.succeeded) {
-                        yield yield tslib_1.__await(true);
-                        break;
-                    }
-                    // logs is undefined unless verbose=true is passed
-                    ({ body: backup } = yield tslib_1.__await(this.heroku.get(verboseUrl, { hostname: (0, host_1.default)() })));
-                    throw new Error((0, tsheredoc_1.default)(`
+  }
+
+  protected async * poll(transferID: string, interval: number, verbose: boolean, appId: string) {
+    const tty = process.env.TERM !== 'dumb' && process.stderr.isTTY
+    let backup: BackupTransfer = {} as BackupTransfer
+    let failures = 0
+
+    const quietUrl = `/client/v11/apps/${appId ?? this.app}/transfers/${transferID}`
+    const verboseUrl = quietUrl + '?verbose=true'
+
+    const url = verbose ? verboseUrl : quietUrl
+
+    while (failures < 21) {
+      try {
+        ({body: backup} = await this.heroku.get<BackupTransfer>(url, {hostname: host()}))
+      } catch (error) {
+        if (failures++ > 20) {
+          throw error
+        }
+      }
+
+      if (verbose) {
+        this.displayLogs(backup.logs)
+      } else if (tty) {
+        const msg = backup.started_at ? this.filesize(backup.processed_bytes) : 'pending'
+        const log = backup.logs?.pop()
+        if (log) {
+          ux.action.status = `${msg}\n${log.created_at + ' ' + log.message}`
+        } else {
+          ux.action.status = msg
+        }
+      }
+
+      if (backup?.finished_at) {
+        if (backup.succeeded) {
+          yield true
+          break
+        }
+
+        // logs is undefined unless verbose=true is passed
+        ({body: backup} = await this.heroku.get<BackupTransfer>(verboseUrl, {hostname: host()}))
+
+        throw new Error(heredoc(`
           An error occurred and the backup did not finish.
 
           ${backup.logs.slice(-5).map(l => l.message).join('\n')}
 
-          Run ${color_1.default.cmd('heroku pg:backups:info ' + this.name(backup))} for more details.`));
-                }
-                yield yield tslib_1.__await(new Promise(resolve => {
-                    setTimeout(resolve, interval * 1000);
-                }));
-            }
-        });
+          Run ${color.cmd('heroku pg:backups:info ' + this.name(backup))} for more details.`))
+      }
+
+      yield new Promise(resolve => {
+        setTimeout(resolve, interval * 1000)
+      })
     }
+  }
 }
-function factory(app, heroku) {
-    return new Backups(app, heroku);
+
+function factory(app: string, heroku: APIClient) {
+  return new Backups(app, heroku)
 }
-exports.default = factory;
+
+export default factory
+*/

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;