heroku 11.0.0-alpha.11 → 11.0.0-alpha.13

package/lib/lib/pg/push_pull.js

@@ -1,128 +1,106 @@
-export {};
-/*
-import {ConnectionDetails} from './util'
-import {exec as psqlExec} from './psql'
-import {ux} from '@oclif/core'
-import {color} from '@heroku-cli/color'
-import {Server} from 'net'
-import {getConfigs, sshTunnel} from './bastion'
-import {ChildProcess, SpawnSyncReturns, execSync} from 'node:child_process'
-import {Readable, Writable} from 'node:stream'
-import heredoc from 'tsheredoc'
-import debugFactory from 'debug'
-const debug = debugFactory('pg:push-pull')
-
-export const parseExclusions = (rawExcludeList: string | undefined) => {
-  return (rawExcludeList || '')
+import { color, utils } from '@heroku/heroku-cli-util';
+import { ux } from '@oclif/core';
+import debugFactory from 'debug';
+import childProcess from 'node:child_process';
+import tsheredoc from 'tsheredoc';
+const heredoc = tsheredoc.default;
+const debug = debugFactory('pg:push-pull');
+export const parseExclusions = (rawExcludeList) => ((rawExcludeList || '')
     .split(';').map(excl => excl.trim())
-    .filter(texcl => texcl !== '')
-}
-
-export const prepare = async (target: ConnectionDetails) => {
-  if (target.host === 'localhost' || !target.host) {
-    exec(`createdb ${connArgs(target, true).join(' ')}`)
-  } else {
-    // N.B.: we don't have a proper postgres driver and we don't want to rely on overriding
-    // possible .psqlrc output configurations, so we generate a random marker that is returned
-    // from the query. We avoid including it verbatim in the query text in case the equivalent
-    // of --echo-all is set.
-    const num = Math.random()
-    const emptyMarker = `${num}${num}`
-    const result = await psqlExec(target, `SELECT CASE count(*) WHEN 0 THEN '${num}' || '${num}' END FROM pg_stat_user_tables`)
-    if (!result.includes(emptyMarker)) ux.error(`Remote database is not empty. Please create a new database or use ${color.cmd('heroku pg:reset')}`)
-  }
-}
-
-export type ConnectionDetailsWithOptionalTunnel = ConnectionDetails & {
-  _tunnel?: Server
-}
-
-export const maybeTunnel = async (
-  herokuDb: ConnectionDetails,
-): Promise<ConnectionDetailsWithOptionalTunnel> => {
-  let withTunnel: ConnectionDetailsWithOptionalTunnel = Object.assign({}, herokuDb)
-  const configs = getConfigs(herokuDb)
-  const tunnel = await sshTunnel(herokuDb, configs.dbTunnelConfig)
-
-  if (tunnel) {
-    const tunnelHost = {
-      host: configs.dbTunnelConfig.localHost,
-      port: configs.dbTunnelConfig.localPort?.toString(),
-      _tunnel: tunnel,
+    .filter(texcl => texcl !== ''));
+export const prepare = async (target, execFn = exec) => {
+    const psqlService = new utils.pg.PsqlService(target);
+    if (target.host === 'localhost' || !target.host) {
+        execFn(`createdb ${connArgs(target, true).join(' ')}`);
     }
-
-    withTunnel = Object.assign(withTunnel, tunnelHost)
-  }
-
-  return withTunnel
-}
-
-export const connArgs = (uri: ConnectionDetails, skipDFlag = false) => {
-  const args: string[] = []
-
-  if (uri.user) args.push('-U', uri.user)
-  if (uri.host) args.push('-h', uri.host)
-  if (uri.port) args.push('-p', uri.port)
-  if (!skipDFlag) args.push('-d')
-  args.push(uri.database)
-
-  return args
-}
-
-const exec = (cmd: string, opts = {}) => {
-  debug(cmd)
-  opts = Object.assign({}, opts, {stdio: 'inherit'})
-
-  try {
-    return execSync(cmd, opts)
-  } catch (error) {
-    const {status} = error as SpawnSyncReturns<string | Buffer>
-    if (status) process.exit(status)
-    throw error
-  }
-}
-
-export const spawnPipe = async (pgDump: ChildProcess, pgRestore: ChildProcess) => {
-  return new Promise<void>((resolve, reject) => {
-    const dumpStdout = pgDump.stdout as Readable
-    const restoreStdin = pgRestore.stdin as Writable
-
-    dumpStdout.pipe(restoreStdin)
-
-    pgDump.on('close', code => code ? reject(new Error(`pg_dump errored with ${code}`)) : restoreStdin.end())
-    pgRestore.on('close', code => code ? reject(new Error(`pg_restore errored with ${code}`)) : resolve())
-  })
-}
-
-export const verifyExtensionsMatch = async function (source: ConnectionDetails, target: ConnectionDetails) {
-  // 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
-  // report it if the difference is solely in the version of an extension
-  // used, though.
-  const sql = 'SELECT extname FROM pg_extension ORDER BY extname;'
-  const [extensionTarget, extensionSource] = await Promise.all([
-    psqlExec(target, sql),
-    psqlExec(source, sql),
-  ])
-  const extensions = {
-    target: extensionTarget,
-    source: extensionSource,
-  }
-
-  // TODO: it shouldn't matter if the target has *more* extensions than the source
-  if (extensions.target !== extensions.source) {
-    ux.warn(heredoc`
+    else {
+        // N.B.: we don't have a proper postgres driver and we don't want to rely on overriding
+        // possible .psqlrc output configurations, so we generate a random marker that is returned
+        // from the query. We avoid including it verbatim in the query text in case the equivalent
+        // of --echo-all is set.
+        const num = Math.random();
+        const emptyMarker = `${num}${num}`;
+        const result = await psqlService.execQuery(`SELECT CASE count(*) WHEN 0 THEN '${num}' || '${num}' END FROM pg_stat_user_tables`);
+        if (!result.includes(emptyMarker))
+            ux.error(`Remote database is not empty. Please create a new database or use ${color.code('heroku pg:reset')}`);
+    }
+};
+export const maybeTunnel = async (herokuDb) => {
+    let withTunnel = { ...herokuDb };
+    const configs = utils.pg.psql.getPsqlConfigs(herokuDb);
+    const tunnel = await utils.pg.psql.sshTunnel(herokuDb, configs.dbTunnelConfig);
+    if (tunnel) {
+        const tunnelHost = {
+            _tunnel: tunnel,
+            host: configs.dbTunnelConfig.localHost,
+            port: configs.dbTunnelConfig.localPort?.toString(),
+        };
+        withTunnel = Object.assign(withTunnel, tunnelHost);
+    }
+    return withTunnel;
+};
+export const connArgs = (uri, skipDFlag = false) => {
+    const args = [];
+    if (uri.user)
+        args.push('-U', uri.user);
+    if (uri.host)
+        args.push('-h', uri.host);
+    if (uri.port)
+        args.push('-p', uri.port);
+    if (!skipDFlag)
+        args.push('-d');
+    args.push(uri.database);
+    return args;
+};
+const exec = (cmd, opts = {}) => {
+    debug(cmd);
+    opts = { ...opts, stdio: 'inherit' };
+    try {
+        return childProcess.execSync(cmd, opts);
+    }
+    catch (error) {
+        const { status } = error;
+        if (status)
+            ux.exit(status);
+        throw error;
+    }
+};
+export const spawnPipe = async (pgDump, pgRestore) => (new Promise((resolve, reject) => {
+    const dumpStdout = pgDump.stdout;
+    const restoreStdin = pgRestore.stdin;
+    dumpStdout.pipe(restoreStdin);
+    pgDump.on('close', code => code ? reject(new Error(`pg_dump errored with ${code}`)) : restoreStdin.end());
+    pgRestore.on('close', code => code ? reject(new Error(`pg_restore errored with ${code}`)) : resolve());
+}));
+export const verifyExtensionsMatch = async function (source, target) {
+    const psqlSource = new utils.pg.PsqlService(source);
+    const psqlTarget = new 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
+    // report it if the difference is solely in the version of an extension
+    // used, though.
+    const sql = 'SELECT extname FROM pg_extension ORDER BY extname;';
+    const [extensionTarget, extensionSource] = await Promise.all([
+        psqlTarget.execQuery(sql),
+        psqlSource.execQuery(sql),
+    ]);
+    const extensions = {
+        source: extensionSource,
+        target: extensionTarget,
+    };
+    // TODO: it shouldn't matter if the target has *more* extensions than the source
+    if (extensions.target !== extensions.source) {
+        ux.warn(heredoc `
       Extensions in newly created target database differ from existing source database.
       Target extensions:
-    ` + extensions.target + heredoc`
+    ` + extensions.target + heredoc `
       Source extensions:
-    ` + extensions.source + heredoc`
+    ` + extensions.source + heredoc `
       HINT: You should review output to ensure that any errors
       ignored are acceptable - entire tables may have been missed, where a dependency
       could not be resolved. You may need to install a postgresql-contrib package
       and retry.
-    `)
-  }
-}
-*/
+    `);
+    }
+};

package/lib/lib/pg/setter.d.ts

@@ -1 +1,16 @@
-export {};
+import { Command } from '@heroku-cli/command';
+import type { SettingKey, Setting } from './types.js';
+export declare abstract class PGSettingsCommand extends Command {
+    protected abstract settingKey: SettingKey;
+    protected abstract convertValue(val: string): unknown;
+    protected abstract explain(setting: Setting<unknown>): string;
+    static topic: string;
+    static flags: {
+        app: import("@oclif/core/interfaces").OptionFlag<string, import("@oclif/core/interfaces").CustomOptions>;
+        remote: import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
+    };
+    run(): Promise<void>;
+}
+export declare type BooleanAsString = 'on' | 'ON' | 'true' | 'TRUE' | 'off' | 'OFF' | 'false' | 'FALSE';
+export declare const booleanConverter: (value: BooleanAsString) => boolean;
+export declare const numericConverter: (value: string) => number;

package/lib/lib/pg/setter.js

@@ -1,75 +1,63 @@
-export {};
-/*
-import {Command, flags} from '@heroku-cli/command'
-import {ux} from '@oclif/core'
-import {addonResolver} from '../addons/resolve'
-import host from './host'
-import {essentialPlan} from './util'
-import {SettingKey, Setting, SettingsResponse} from './types'
-
-export abstract class PGSettingsCommand extends Command {
-  protected abstract settingKey: SettingKey
-  protected abstract convertValue(val: string): unknown
-  protected abstract explain(setting: Setting<unknown>): string
-
-  static topic = 'pg'
-
-  static flags = {
-    app: flags.app({required: true}),
-    remote: flags.remote(),
-  }
-
-  public async run(): Promise<void> {
-    const {flags, args} = await this.parse()
-    const {app} = flags
-    const {value, database} = args as {value: string | undefined, database: string | undefined}
-
-    const db = await addonResolver(this.heroku, app, database || 'DATABASE_URL')
-
-    if (essentialPlan(db)) ux.error('You can’t perform this operation on Essential-tier databases.')
-
-    if (value) {
-      const {body: settings} = await this.heroku.patch<SettingsResponse>(`/postgres/v0/databases/${db.id}/config`, {
-        hostname: host(),
-        body: {[this.settingKey]: this.convertValue(value)},
-      })
-      const setting = settings[this.settingKey]
-      ux.log(`${this.settingKey.replace(/_/g, '-')} has been set to ${setting.value} for ${db.name}.`)
-      ux.log(this.explain(setting))
-    } else {
-      const {body: settings} = await this.heroku.get<SettingsResponse>(`/postgres/v0/databases/${db.id}/config`, {hostname: host()})
-      const setting = settings[this.settingKey]
-      ux.log(`${this.settingKey.replace(/_/g, '-')} is set to ${setting.value} for ${db.name}.`)
-      ux.log(this.explain(setting))
+import { Command, flags } from '@heroku-cli/command';
+import { ux } from '@oclif/core';
+import { utils } from '@heroku/heroku-cli-util';
+import { essentialPlan } from './util.js';
+export class PGSettingsCommand extends Command {
+    static topic = 'pg';
+    static flags = {
+        app: flags.app({ required: true }),
+        remote: flags.remote(),
+    };
+    async run() {
+        const { flags, args } = await this.parse();
+        const { app } = flags;
+        const { value, database } = args;
+        const dbResolver = new utils.pg.DatabaseResolver(this.heroku);
+        const { addon: db } = await dbResolver.getAttachment(app, database);
+        if (essentialPlan(db)) {
+            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: utils.pg.host(),
+                body: { [this.settingKey]: this.convertValue(value) },
+            });
+            const setting = settings[this.settingKey];
+            ux.stdout(`${this.settingKey.replace(/_/g, '-')} has been set to ${setting.value} for ${db.name}.`);
+            ux.stdout(this.explain(setting));
+        }
+        else {
+            const { body: settings } = await this.heroku.get(`/postgres/v0/databases/${db.id}/config`, { hostname: utils.pg.host() });
+            const setting = settings[this.settingKey];
+            ux.stdout(`${this.settingKey.replace(/_/g, '-')} is set to ${setting.value} for ${db.name}.`);
+            ux.stdout(this.explain(setting));
+        }
     }
-  }
 }
-
-export type BooleanAsString = 'on' | 'ON' | 'true' | 'TRUE' | 'off' | 'OFF' | 'false' | 'FALSE'
-export const booleanConverter = (value: BooleanAsString) => {
-  switch (value) {
-  case 'true':
-  case 'TRUE':
-  case 'ON':
-  case 'on':
-    return true
-  case 'false':
-  case 'FALSE':
-  case 'OFF':
-  case 'off':
-  case null:
-    return false
-  default:
-    throw new TypeError('Invalid value. Valid options are: a boolean value')
-  }
-}
-
-export const numericConverter = (value: string) => {
-  const n = Number(value)
-  if (!Number.isFinite(n)) {
-    throw new TypeError('Invalid value. Valid options are: a numeric value')
-  }
-
-  return n
-}
-*/
+export const booleanConverter = (value) => {
+    switch (value) {
+        case 'true':
+        case 'TRUE':
+        case 'ON':
+        case 'on': {
+            return true;
+        }
+        case 'false':
+        case 'FALSE':
+        case 'OFF':
+        case 'off':
+        case null: {
+            return false;
+        }
+        default: {
+            throw new TypeError('Invalid value. Valid options are: a boolean value');
+        }
+    }
+};
+export const numericConverter = (value) => {
+    const n = Number(value);
+    if (!Number.isFinite(n)) {
+        throw new TypeError('Invalid value. Valid options are: a numeric value');
+    }
+    return n;
+};

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,38 +128,16 @@ 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;
-};
-declare type CredentialState = 'enabling' | 'active' | 'revoking' | 'revoked' | 'archived';
-export declare type Credential = {
-    user: string;
-    password: string;
-    state: CredentialState;
-    connections?: number | null;
-};
-declare type CredentialStoreState = 'provisioning' | 'wait_for_provisioning' | 'active' | 'rotating' | 'rotation_completed' | 'revoking' | 'archived';
-export declare type CredentialInfo = {
-    uuid: string;
-    name: string;
-    state: CredentialStoreState;
-    database: string;
-    host: string;
-    port: number;
-    credentials: Array<Credential>;
+    remote_name: string;
+    remote: {
+        name: string;
+        attachment_name: string;
+    };
 };
-export declare type CredentialsInfo = Array<CredentialInfo>;
 export declare type MaintenanceApiResponse = {
     message: string;
 };

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

@@ -1 +1,8 @@
-export {};
+import type { AddOnAttachment } from '@heroku-cli/schema';
+import { pg } from '@heroku/heroku-cli-util';
+import { type CredentialInfo } from '../../lib/data/types.js';
+export declare function essentialPlan(addon: pg.ExtendedAddon | pg.ExtendedAddonAttachment['addon']): boolean;
+export declare function formatResponseWithCommands(response: string): string;
+export declare function presentCredentialAttachments(app: string, credAttachments: Required<AddOnAttachment>[], credentials: CredentialInfo[], cred: string): string;
+export declare const configVarNamesFromValue: (config: Record<string, string>, value: string) => string[];
+export declare const databaseNameFromUrl: (uri: string, config: Record<string, string>) => string;