heroku 10.13.2-beta.0 → 11.0.0-alpha.1

package/lib/lib/pg/push_pull.js

@@ -1,118 +1,128 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.verifyExtensionsMatch = exports.spawnPipe = exports.connArgs = exports.maybeTunnel = exports.prepare = exports.parseExclusions = void 0;
-const psql_1 = require("./psql");
-const core_1 = require("@oclif/core");
-const color_1 = require("@heroku-cli/color");
-const bastion_1 = require("./bastion");
-const node_child_process_1 = require("node:child_process");
-const tsheredoc_1 = require("tsheredoc");
-const debug_1 = require("debug");
-const debug = (0, debug_1.default)('pg:push-pull');
-const parseExclusions = (rawExcludeList) => {
-    return (rawExcludeList || '')
-        .split(';').map(excl => excl.trim())
-        .filter(texcl => texcl !== '');
-};
-exports.parseExclusions = parseExclusions;
-const prepare = async (target) => {
-    if (target.host === 'localhost' || !target.host) {
-        exec(`createdb ${(0, exports.connArgs)(target, true).join(' ')}`);
+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 || '')
+    .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,
     }
-    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 (0, psql_1.exec)(target, `SELECT CASE count(*) WHEN 0 THEN '${num}' || '${num}' END FROM pg_stat_user_tables`);
-        if (!result.includes(emptyMarker))
-            core_1.ux.error(`Remote database is not empty. Please create a new database or use ${color_1.color.cmd('heroku pg:reset')}`);
-    }
-};
-exports.prepare = prepare;
-const maybeTunnel = async (herokuDb) => {
-    var _a;
-    let withTunnel = Object.assign({}, herokuDb);
-    const configs = (0, bastion_1.getConfigs)(herokuDb);
-    const tunnel = await (0, bastion_1.sshTunnel)(herokuDb, configs.dbTunnelConfig);
-    if (tunnel) {
-        const tunnelHost = {
-            host: configs.dbTunnelConfig.localHost,
-            port: (_a = configs.dbTunnelConfig.localPort) === null || _a === void 0 ? void 0 : _a.toString(),
-            _tunnel: tunnel,
-        };
-        withTunnel = Object.assign(withTunnel, tunnelHost);
-    }
-    return withTunnel;
-};
-exports.maybeTunnel = maybeTunnel;
-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;
-};
-exports.connArgs = connArgs;
-const exec = (cmd, opts = {}) => {
-    debug(cmd);
-    opts = Object.assign({}, opts, { stdio: 'inherit' });
-    try {
-        return (0, node_child_process_1.execSync)(cmd, opts);
-    }
-    catch (error) {
-        const { status } = error;
-        if (status)
-            process.exit(status);
-        throw error;
-    }
-};
-const spawnPipe = async (pgDump, pgRestore) => {
-    return 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());
-    });
-};
-exports.spawnPipe = spawnPipe;
-const verifyExtensionsMatch = async function (source, 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([
-        (0, psql_1.exec)(target, sql),
-        (0, psql_1.exec)(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) {
-        core_1.ux.warn((0, tsheredoc_1.default) `
+
+    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`
       Extensions in newly created target database differ from existing source database.
       Target extensions:
-    ` + extensions.target + (0, tsheredoc_1.default) `
+    ` + extensions.target + heredoc`
       Source extensions:
-    ` + extensions.source + (0, tsheredoc_1.default) `
+    ` + 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.
-    `);
-    }
-};
-exports.verifyExtensionsMatch = verifyExtensionsMatch;
+    `)
+  }
+}
+*/

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

@@ -1,16 +1 @@
-import { Command } from '@heroku-cli/command';
-import { SettingKey, Setting } from './types';
-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/lib/interfaces").OptionFlag<string, import("@oclif/core/lib/interfaces/parser").CustomOptions>;
-        remote: import("@oclif/core/lib/interfaces").OptionFlag<string | undefined, import("@oclif/core/lib/interfaces/parser").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;
+export {};

package/lib/lib/pg/setter.js

@@ -1,65 +1,75 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.numericConverter = exports.booleanConverter = exports.PGSettingsCommand = void 0;
-const command_1 = require("@heroku-cli/command");
-const core_1 = require("@oclif/core");
-const resolve_1 = require("../addons/resolve");
-const host_1 = require("./host");
-const util_1 = require("./util");
-class PGSettingsCommand extends command_1.Command {
-    async run() {
-        const { flags, args } = await this.parse();
-        const { app } = flags;
-        const { value, database } = args;
-        const db = await (0, resolve_1.addonResolver)(this.heroku, app, database || 'DATABASE_URL');
-        if ((0, util_1.essentialPlan)(db))
-            core_1.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: (0, host_1.default)(),
-                body: { [this.settingKey]: this.convertValue(value) },
-            });
-            const setting = settings[this.settingKey];
-            core_1.ux.log(`${this.settingKey.replace(/_/g, '-')} has been set to ${setting.value} for ${db.name}.`);
-            core_1.ux.log(this.explain(setting));
-        }
-        else {
-            const { body: settings } = await this.heroku.get(`/postgres/v0/databases/${db.id}/config`, { hostname: (0, host_1.default)() });
-            const setting = settings[this.settingKey];
-            core_1.ux.log(`${this.settingKey.replace(/_/g, '-')} is set to ${setting.value} for ${db.name}.`);
-            core_1.ux.log(this.explain(setting));
-        }
+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))
     }
+  }
 }
-exports.PGSettingsCommand = PGSettingsCommand;
-PGSettingsCommand.topic = 'pg';
-PGSettingsCommand.flags = {
-    app: command_1.flags.app({ required: true }),
-    remote: command_1.flags.remote(),
-};
-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');
-    }
-};
-exports.booleanConverter = booleanConverter;
-const numericConverter = (value) => {
-    const n = Number(value);
-    if (!Number.isFinite(n)) {
-        throw new TypeError('Invalid value. Valid options are: a numeric value');
-    }
-    return n;
-};
-exports.numericConverter = numericConverter;
+
+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
+}
+*/

package/lib/lib/pg/types.js

@@ -1,2 +1 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
+export {};

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

@@ -1,37 +1 @@
-/// <reference types="node" />
-import type { AddOnAttachment } from '@heroku-cli/schema';
-import type { AddOnAttachmentWithConfigVarsAndPlan, CredentialsInfo } from './types';
-import { Server } from 'net';
-export declare function getConfigVarName(configVars: string[]): string;
-export declare const essentialNumPlan: (addon: AddOnAttachmentWithConfigVarsAndPlan) => boolean;
-export declare const legacyEssentialPlan: (addon: AddOnAttachmentWithConfigVarsAndPlan) => boolean;
-export declare function essentialPlan(addon: AddOnAttachmentWithConfigVarsAndPlan): boolean;
-export declare function getConfigVarNameFromAttachment(attachment: Required<AddOnAttachment & {
-    addon: AddOnAttachmentWithConfigVarsAndPlan;
-}>, config?: Record<string, string>): string;
-export declare function formatResponseWithCommands(response: string): string;
-export declare function presentCredentialAttachments(app: string, credAttachments: Required<AddOnAttachment>[], credentials: CredentialsInfo, cred: string): string;
-export declare type ConnectionDetails = {
-    user: string;
-    password: string;
-    database: string;
-    host: string;
-    port: string;
-    pathname: string;
-    url: string;
-    bastionKey?: string;
-    bastionHost?: string;
-    _tunnel?: Server;
-};
-export declare type ConnectionDetailsWithAttachment = ConnectionDetails & {
-    attachment: Required<AddOnAttachment & {
-        addon: AddOnAttachmentWithConfigVarsAndPlan;
-    }>;
-};
-export declare const getConnectionDetails: (attachment: Required<AddOnAttachment & {
-    addon: AddOnAttachmentWithConfigVarsAndPlan;
-}>, configVars?: Record<string, string>) => ConnectionDetailsWithAttachment;
-export declare const bastionKeyPlan: (a: AddOnAttachmentWithConfigVarsAndPlan) => boolean;
-export declare const configVarNamesFromValue: (config: Record<string, string>, value: string) => string[];
-export declare const databaseNameFromUrl: (uri: string, config: Record<string, string>) => any;
-export declare const parsePostgresConnectionString: (db: string) => ConnectionDetails;
+export {};