heroku 11.0.0-alpha.11 → 11.0.0-alpha.12

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

@@ -1 +1,3 @@
-export {};
+import { APIClient } from '@heroku-cli/command';
+import * as Heroku from '@heroku-cli/schema';
+export declare function getRelease(heroku: APIClient, appName: string, id: string): Promise<Heroku.Release>;

package/lib/lib/pg/fetcher.js

@@ -1,163 +1,4 @@
-export {};
-/*
-import {APIClient} from '@heroku-cli/command'
-import type {AddOnAttachment} from '@heroku-cli/schema'
-import * as Heroku from '@heroku-cli/schema'
-import {HerokuAPIError} from '@heroku-cli/command/lib/api-client'
-import debug from 'debug'
-import {AmbiguousError, appAttachment} from '../addons/resolve'
-import {fetchConfig} from './bastion'
-import {getConfig} from './config'
-import color from '@heroku-cli/color'
-import type {AddOnAttachmentWithConfigVarsAndPlan, AddOnWithRelatedData} from './types'
-import {bastionKeyPlan, getConfigVarName, getConnectionDetails} from './util'
-
-const pgDebug = debug('pg')
-
-export async function arbitraryAppDB(heroku: APIClient, app: string) {
-  // 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<Heroku.AddOn[]>(`/apps/${app}/addons`)
-  const addon = addons.find(a => a?.app?.name === app && a?.plan?.name?.startsWith('heroku-postgresql'))
-  if (!addon) throw new Error(`No heroku-postgresql databases on ${app}`)
-  return addon
+export async function getRelease(heroku, appName, id) {
+    const { body: release } = await heroku.get(`/apps/${appName}/releases/${id}`);
+    return release;
 }
-
-function getAttachmentNamesByAddon(attachments: AddOnAttachmentWithConfigVarsAndPlan[]): AddOnAttachmentWithConfigVarsAndPlan {
-  return attachments.reduce((results: any, a) => {
-    results[a.addon.id] = (results[a.addon.id] || []).concat(a.name)
-    return results
-  }, {})
-}
-
-export async function all(heroku: APIClient, app_id: string): Promise<AddOnWithRelatedData[]> {
-  const {uniqBy} = require('lodash')
-
-  pgDebug(`fetching all DBs on ${app_id}`)
-
-  const attachments = await allAttachments(heroku, app_id)
-  let addons: AddOnWithRelatedData[] = 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
-}
-
-async function matchesHelper(heroku: APIClient, app: string, db: string, namespace?: string): Promise<{matches: AddOnAttachment[] | null, error?: AmbiguousError | HerokuAPIError}> {
-  debug(`fetching ${db} on ${app}`)
-
-  const addonService = process.env.HEROKU_POSTGRESQL_ADDON_NAME || 'heroku-postgresql'
-  debug(`addon service: ${addonService}`)
-  try {
-    const attached = await appAttachment(heroku, app, db, {addon_service: addonService, namespace})
-    return ({matches: [attached]})
-  } catch (error) {
-    if (error instanceof AmbiguousError && error.body?.id === 'multiple_matches' && error.matches) {
-      return {matches: error.matches, error}
-    }
-
-    if (error instanceof HerokuAPIError && error.http.statusCode === 404 && error.body && error.body.id === 'not_found') {
-      return {matches: null, error}
-    }
-
-    throw error
-  }
-}
-
-export async function getAttachment(heroku: APIClient, app: string, db = 'DATABASE_URL', namespace = ''): Promise<Required<AddOnAttachment & {addon: AddOnAttachmentWithConfigVarsAndPlan}>> {
-  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] as Required<AddOnAttachment & {addon: AddOnAttachmentWithConfigVarsAndPlan}>
-  }
-
-  // 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([
-      getConfig(heroku, app),
-      allAttachments(heroku, app),
-    ])
-
-    if (attachments.length === 0) {
-      throw new Error(`${color.app(app)} has no databases`)
-    }
-
-    matches = attachments.filter(attachment => config[db] && config[db] === config[getConfigVarName(attachment.config_vars as string[])])
-
-    if (matches.length === 0) {
-      const validOptions = attachments.map(attachment => getConfigVarName(attachment.config_vars as string[]))
-      throw new Error(`Unknown database: ${db}. Valid options are: ${validOptions.join(', ')}`)
-    }
-  }
-
-  // case for multiple attachments with passedDb
-  const first = matches[0] as Required<AddOnAttachment & {addon: AddOnAttachmentWithConfigVarsAndPlan}>
-
-  // case for 422 where there are ambiguous attachments that are equivalent
-  if (matches.every(match => first.addon?.id === match.addon?.id && first.app?.id === match.app?.id)) {
-    const config = await getConfig(heroku, first.app.name as string) ?? {}
-
-    if (matches.every(match => config[getConfigVarName(first.config_vars)] === config[getConfigVarName(match.config_vars)])) {
-      return first
-    }
-  }
-
-  throw error
-}
-
-async function allAttachments(heroku: APIClient, app_id: string): Promise<AddOnAttachmentWithConfigVarsAndPlan[]> {
-  const {body: attachments} = await heroku.get<AddOnAttachmentWithConfigVarsAndPlan[]>(`/apps/${app_id}/addon-attachments`, {
-    headers: {'Accept-Inclusion': 'addon:plan,config_vars'},
-  })
-  return attachments.filter((a: AddOnAttachmentWithConfigVarsAndPlan) => a.addon.plan?.name?.startsWith('heroku-postgresql'))
-}
-
-export async function getAddon(heroku: APIClient, app: string, db = 'DATABASE_URL') {
-  return (await getAttachment(heroku, app, db)).addon
-}
-
-export async function database(heroku: APIClient, app: string, db?: string, namespace?: string) {
-  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 getConfig(heroku, attached.app.name as string)
-
-  const database = getConnectionDetails(attached, config)
-  if (bastionKeyPlan(attached.addon) && !database.bastionKey) {
-    const {body: bastionConfig} = await fetchConfig(heroku, attached.addon)
-    const bastionHost = bastionConfig.host
-    const bastionKey = bastionConfig.private_key
-
-    Object.assign(database, {bastionHost, bastionKey})
-  }
-
-  return database
-}
-
-export async function getRelease(heroku: APIClient, appName: string, id: string) {
-  const {body: release} = await heroku.get<Heroku.Release>(`/apps/${appName}/releases/${id}`)
-  return release
-}
-*/

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

@@ -1 +1,17 @@
-export {};
+/// <reference types="node" resolution-mode="require"/>
+/// <reference types="node" resolution-mode="require"/>
+import { SpawnOptions } from 'child_process';
+import { pg } from '@heroku/heroku-cli-util';
+export declare function fetchVersion(db: pg.ConnectionDetails): Promise<string | undefined>;
+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 execFile(db: pg.ConnectionDetails, file: string): Promise<string>;
+export declare function interactive(db: pg.ConnectionDetails): Promise<string>;

package/lib/lib/pg/psql.js

@@ -1,275 +1,65 @@
-export {};
-/*
-import {ux} from '@oclif/core'
-import {spawn, SpawnOptions, type SpawnOptionsWithStdioTuple} from 'child_process'
-import debug from 'debug'
-import * as fs from 'fs'
-import type {ChildProcess} from 'node:child_process'
-import {EventEmitter, once} from 'node:events'
-import type {Server} from 'node:net'
-import * as path from 'node:path'
-import {Stream} from 'node:stream'
-import {finished} from 'node:stream/promises'
-import {getConfigs, sshTunnel, TunnelConfig} from './bastion'
-import {ConnectionDetails, getConnectionDetails} from './util'
-
-const pgDebug = debug('pg')
-export function psqlQueryOptions(query:string, dbEnv: NodeJS.ProcessEnv, cmdArgs: string[] = []) {
-  pgDebug('Running query: %s', query.trim())
-
-  const psqlArgs = ['-c', query, '--set', 'sslmode=require', ...cmdArgs]
-
-  const childProcessOptions: SpawnOptionsWithStdioTuple<'ignore', 'pipe', 'inherit'> = {
-    stdio: ['ignore', 'pipe', 'inherit'],
-  }
-
-  return {
-    dbEnv,
-    psqlArgs,
-    childProcessOptions,
-  }
+import { ux } from '@oclif/core';
+import debug from 'debug';
+import * as fs from 'fs';
+import * as path from 'node:path';
+import { utils } from '@heroku/heroku-cli-util';
+export async function fetchVersion(db) {
+    const psqlService = new utils.pg.PsqlService(db);
+    const output = await psqlService.execQuery('SHOW server_version', ['-X', '-q']);
+    return output.match(/[0-9]{1,}\.[0-9]{1,}/)?.[0];
 }
-
-export function psqlFileOptions(file: string, dbEnv: NodeJS.ProcessEnv) {
-  pgDebug('Running sql file: %s', file.trim())
-
-  const childProcessOptions:SpawnOptions = {
-    stdio: ['ignore', 'pipe', 'inherit'],
-  }
-
-  const psqlArgs = ['-f', file, '--set', 'sslmode=require']
-
-  return {
-    dbEnv,
-    psqlArgs,
-    childProcessOptions,
-  }
+const pgDebug = debug('pg');
+export 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,
+    };
 }
-
-export function psqlInteractiveOptions(prompt: string, dbEnv: NodeJS.ProcessEnv) {
-  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 {
-      ux.warn(`HEROKU_PSQL_HISTORY is set but is not a valid path (${psqlHistoryPath})`)
+export 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 {
+            ux.warn(`HEROKU_PSQL_HISTORY is set but is not a valid path (${psqlHistoryPath})`);
+        }
     }
-  }
-
-  psqlArgs = psqlArgs.concat(['--set', 'sslmode=require'])
-
-  const childProcessOptions: SpawnOptions = {
-    stdio: 'inherit',
-  }
-
-  return {
-    dbEnv,
-    psqlArgs,
-    childProcessOptions,
-  }
+    psqlArgs = psqlArgs.concat(['--set', 'sslmode=require']);
+    const childProcessOptions = {
+        stdio: 'inherit',
+    };
+    return {
+        dbEnv,
+        psqlArgs,
+        childProcessOptions,
+    };
 }
-
-export function execPSQL({dbEnv, psqlArgs, childProcessOptions}: {dbEnv: NodeJS.ProcessEnv, psqlArgs: string[], childProcessOptions: SpawnOptions}) {
-  const options = {
-    env: dbEnv,
-    ...childProcessOptions,
-  }
-
-  pgDebug('opening psql process')
-  const psql = spawn('psql', psqlArgs, options)
-  psql.once('spawn', () => pgDebug('psql process spawned'))
-
-  return psql
+export async function execFile(db, file) {
+    const psqlService = new utils.pg.PsqlService(db);
+    const configs = utils.pg.psql.getPsqlConfigs(db);
+    const options = psqlFileOptions(file, configs.dbEnv);
+    return psqlService.runWithTunnel(configs.dbTunnelConfig, options);
 }
-
-export async function waitForPSQLExit(psql: EventEmitter) {
-  let errorToThrow: Error | null = null
-  try {
-    const [exitCode] = await 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 as {code: string}
-    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
-  }
-}
-
-// 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: ChildProcess, signal: number | NodeJS.Signals | undefined) {
-  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.
-export const trapAndForwardSignalsToChildProcess = (childProcess: ChildProcess) => {
-  const signalsToTrap: NodeJS.Signals[] = ['SIGINT']
-  const signalTraps = signalsToTrap.map(signal => {
-    process.removeAllListeners(signal)
-    const listener = () => kill(childProcess, signal)
-    process.on(signal, listener)
-    return [signal, listener]
-  }) as ([NodeJS.Signals, () => void])[]
-
-  // restores the built-in node ctrl+c and other handlers
-  return () => {
-    signalTraps.forEach(([signal, listener]) => {
-      process.removeListener(signal as string, listener)
-    })
-  }
-}
-
-export function consumeStream(inputStream: Stream) {
-  let result = ''
-  const throughStream = new Stream.PassThrough()
-
-  // eslint-disable-next-line no-async-promise-executor
-  const promise = new Promise(async (resolve, reject) => {
-    try {
-      await 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
-}
-
-export async function runWithTunnel(db: ConnectionDetails, tunnelConfig: TunnelConfig, options: Parameters<typeof execPSQL>[0]): Promise<string> {
-  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 = 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 as Promise<string>
-}
-
-// a small wrapper around tunnel-ssh
-// so that other code doesn't have to worry about
-// whether there is or is not a tunnel
-export class Tunnel {
-  private readonly bastionTunnel: Server
-  private readonly events: EventEmitter
-  constructor(bastionTunnel: Server) {
-    this.bastionTunnel = bastionTunnel
-    this.events = new EventEmitter()
-  }
-
-  async waitForClose() {
-    if (this.bastionTunnel) {
-      try {
-        pgDebug('wait for tunnel close')
-        await 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 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: ConnectionDetails, tunnelConfig: TunnelConfig) {
-    const tunnel = await sshTunnel(db, tunnelConfig)
-    return new Tunnel(tunnel as Server)
-  }
-}
-
-export async function fetchVersion(db: Parameters<typeof exec>[0]) {
-  const output = await exec(db, 'SHOW server_version', ['-X', '-q'])
-  return output.match(/[0-9]{1,}\.[0-9]{1,}/)?.[0]
-}
-
-export async function exec(db: ConnectionDetails, query: string, cmdArgs: string[] = []) {
-  const configs = getConfigs(db)
-  const options = psqlQueryOptions(query, configs.dbEnv, cmdArgs)
-  return runWithTunnel(db, configs.dbTunnelConfig, options)
-}
-
-export async function execFile(db:Parameters<typeof getConfigs>[0], file: string) {
-  const configs = getConfigs(db)
-  const options = psqlFileOptions(file, configs.dbEnv)
-
-  return runWithTunnel(db, configs.dbTunnelConfig, options)
-}
-
-export async function interactive(db: ReturnType<typeof getConnectionDetails>) {
-  const name = db.attachment.name
-  const prompt = `${db.attachment.app.name}::${name}%R%# `
-  const configs = getConfigs(db)
-  configs.dbEnv.PGAPPNAME = 'psql interactive' // default was 'psql non-interactive`
-  const options = psqlInteractiveOptions(prompt, configs.dbEnv)
-
-  return runWithTunnel(db, configs.dbTunnelConfig, options)
+export async function interactive(db) {
+    const psqlService = new utils.pg.PsqlService(db);
+    const attachmentName = db.attachment.name;
+    const prompt = `${db.attachment.app.name}::${attachmentName}%R%# `;
+    const configs = utils.pg.psql.getPsqlConfigs(db);
+    configs.dbEnv.PGAPPNAME = 'psql interactive'; // default was 'psql non-interactive`
+    const options = psqlInteractiveOptions(prompt, configs.dbEnv);
+    return psqlService.runWithTunnel(configs.dbTunnelConfig, options);
 }
-*/

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

@@ -1 +1,13 @@
+/// <reference types="node" resolution-mode="require"/>
+/// <reference types="node" resolution-mode="require"/>
+import type { pg } from '@heroku/heroku-cli-util';
+import { ChildProcess } from 'node:child_process';
+export declare const parseExclusions: (rawExcludeList: string | undefined) => Array<string>;
+declare type ExecFn = typeof exec;
+export declare const prepare: (target: pg.ConnectionDetails, execFn?: ExecFn) => Promise<void>;
+export declare const maybeTunnel: (herokuDb: pg.ConnectionDetails) => Promise<pg.ConnectionDetails>;
+export declare const connArgs: (uri: pg.ConnectionDetails, skipDFlag?: boolean) => string[];
+declare const exec: (cmd: string, opts?: {}) => Buffer;
+export declare const spawnPipe: (pgDump: ChildProcess, pgRestore: ChildProcess) => Promise<void>;
+export declare const verifyExtensionsMatch: (source: pg.ConnectionDetails, target: pg.ConnectionDetails) => Promise<void>;
 export {};