heroku 9.0.0-dev.0 → 9.0.0

package/lib/commands/pg/promote.js

@@ -0,0 +1,169 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+/* eslint-disable complexity */
+const color_1 = require("@heroku-cli/color");
+const command_1 = require("@heroku-cli/command");
+const core_1 = require("@oclif/core");
+const tsheredoc_1 = require("tsheredoc");
+const fetcher_1 = require("../../lib/pg/fetcher");
+const host_1 = require("../../lib/pg/host");
+class Promote extends command_1.Command {
+    async run() {
+        var _a, _b, _c;
+        const { flags, args } = await this.parse(Promote);
+        const { force, app } = flags;
+        const { database } = args;
+        const attachment = await (0, fetcher_1.getAttachment)(this.heroku, app, database);
+        core_1.ux.action.start(`Ensuring an alternate alias for existing ${color_1.default.green('DATABASE_URL')}`);
+        const { body: attachments } = await this.heroku.get(`/apps/${app}/addon-attachments`);
+        const current = attachments.find(a => a.name === 'DATABASE');
+        if (!current)
+            return;
+        // eslint-disable-next-line eqeqeq
+        if (((_a = current.addon) === null || _a === void 0 ? void 0 : _a.name) === attachment.addon.name && current.namespace == attachment.namespace) {
+            if (attachment.namespace) {
+                core_1.ux.error(`${color_1.default.cyan(attachment.name)} is already promoted on ${color_1.default.app(app)}`);
+            }
+            else {
+                core_1.ux.error(`${color_1.default.addon(attachment.addon.name)} is already promoted on ${color_1.default.app(app)}`);
+            }
+        }
+        const existing = attachments.filter(a => { var _a, _b; return ((_a = a.addon) === null || _a === void 0 ? void 0 : _a.id) === ((_b = current.addon) === null || _b === void 0 ? void 0 : _b.id) && a.namespace === current.namespace; })
+            .find(a => a.name !== 'DATABASE');
+        if (existing) {
+            core_1.ux.action.stop(color_1.default.green(existing.name + '_URL'));
+        }
+        else {
+            // The current add-on occupying the DATABASE attachment has no
+            // other attachments. In order to promote this database without
+            // error, we can create a secondary attachment, just-in-time.
+            const { body: backup } = await this.heroku.post('/addon-attachments', {
+                body: {
+                    app: { name: app },
+                    addon: { name: (_b = current.addon) === null || _b === void 0 ? void 0 : _b.name },
+                    namespace: current.namespace,
+                    confirm: app,
+                },
+            });
+            core_1.ux.action.stop(color_1.default.green(backup.name + '_URL'));
+        }
+        if (!force) {
+            const { body: status } = await this.heroku.get(`/client/v11/databases/${attachment.addon.id}/wait_status`, {
+                hostname: (0, host_1.default)(),
+            });
+            if (status['waiting?']) {
+                core_1.ux.error((0, tsheredoc_1.default)(`
+          Database cannot be promoted while in state: ${status.message}
+          
+          Promoting this database can lead to application errors and outage. Please run ${color_1.default.cmd('heroku pg:wait')} to wait for database to become available.
+          
+          To ignore this error, you can pass the --force flag to promote the database and risk application issues.
+        `));
+            }
+        }
+        let promotionMessage;
+        if (attachment.namespace) {
+            promotionMessage = `Promoting ${color_1.default.cyan(attachment.name)} to ${color_1.default.green('DATABASE_URL')} on ${color_1.default.app(app)}`;
+        }
+        else {
+            promotionMessage = `Promoting ${color_1.default.addon(attachment.addon.name)} to ${color_1.default.green('DATABASE_URL')} on ${color_1.default.app(app)}`;
+        }
+        core_1.ux.action.start(promotionMessage);
+        await this.heroku.post('/addon-attachments', {
+            body: {
+                name: 'DATABASE',
+                app: { name: app },
+                addon: { name: attachment.addon.name },
+                namespace: attachment.namespace || null,
+                confirm: app,
+            },
+        });
+        core_1.ux.action.stop();
+        const currentPooler = attachments.find(a => { var _a, _b; return a.namespace === 'connection-pooling:default' && ((_a = a.addon) === null || _a === void 0 ? void 0 : _a.id) === ((_b = current.addon) === null || _b === void 0 ? void 0 : _b.id) && a.name === 'DATABASE_CONNECTION_POOL'; });
+        if (currentPooler) {
+            core_1.ux.action.start('Reattaching pooler to new leader');
+            await this.heroku.post('/addon-attachments', {
+                body: {
+                    name: currentPooler.name,
+                    app: { name: app },
+                    addon: { name: attachment.addon.name },
+                    namespace: 'connection-pooling:default',
+                    confirm: app,
+                },
+            });
+            core_1.ux.action.stop();
+        }
+        const { body: promotedDatabaseDetails } = await this.heroku.get(`/client/v11/databases/${attachment.addon.id}`, {
+            hostname: (0, host_1.default)(),
+        });
+        if (promotedDatabaseDetails.following) {
+            const unfollowLeaderCmd = `heroku pg:unfollow ${attachment.addon.name}`;
+            core_1.ux.warn((0, tsheredoc_1.default)(`
+        Your database has been promoted but it is currently a follower database in read-only mode.
+        
+        Promoting a database with ${color_1.default.cmd('heroku pg:promote')} doesn't automatically unfollow its leader.
+        
+        Use ${color_1.default.cmd(unfollowLeaderCmd)} to stop this follower from replicating from its leader (${color_1.default.yellow(promotedDatabaseDetails.leader)}) and convert it into a writable database.
+      `));
+        }
+        const { body: formation } = await this.heroku.get(`/apps/${app}/formation`);
+        const releasePhase = formation.find(process => process.type === 'release');
+        if (releasePhase) {
+            core_1.ux.action.start('Checking release phase');
+            const { body: releases } = await this.heroku.get(`/apps/${app}/releases`, {
+                partial: true,
+                headers: {
+                    Range: 'version ..; max=5, order=desc',
+                },
+            });
+            const attach = releases.find(release => { var _a; return (_a = release.description) === null || _a === void 0 ? void 0 : _a.includes('Attach DATABASE'); });
+            const detach = releases.find(release => { var _a; return (_a = release.description) === null || _a === void 0 ? void 0 : _a.includes('Detach DATABASE'); });
+            if (!attach || !detach) {
+                core_1.ux.error('Unable to check release phase. Check your Attach DATABASE release for failures.');
+            }
+            const endTime = Date.now() + 900000; // 15 minutes from now
+            const [attachId, detachId] = [attach === null || attach === void 0 ? void 0 : attach.id, detach === null || detach === void 0 ? void 0 : detach.id];
+            while (true) {
+                const attach = await (0, fetcher_1.getRelease)(this.heroku, app, attachId);
+                if (attach && attach.status === 'succeeded') {
+                    let msg = 'pg:promote succeeded.';
+                    const detach = await (0, fetcher_1.getRelease)(this.heroku, app, detachId);
+                    if (detach && detach.status === 'failed') {
+                        msg += ` It is safe to ignore the failed ${detach.description} release.`;
+                    }
+                    core_1.ux.action.stop(msg);
+                    return;
+                }
+                if (attach && attach.status === 'failed') {
+                    let msg = `pg:promote failed because ${attach.description} release was unsuccessful. Your application is currently running `;
+                    const detach = await (0, fetcher_1.getRelease)(this.heroku, app, detachId);
+                    if (detach && detach.status === 'succeeded') {
+                        msg += 'without an attached DATABASE_URL.';
+                    }
+                    else {
+                        msg += `with ${(_c = current.addon) === null || _c === void 0 ? void 0 : _c.name} attached as DATABASE_URL.`;
+                    }
+                    msg += ' Check your release phase logs for failure causes.';
+                    core_1.ux.action.stop(msg);
+                    return;
+                }
+                if (Date.now() > endTime) {
+                    core_1.ux.action.stop('timeout. Check your Attach DATABASE release for failures.');
+                    return;
+                }
+                await new Promise(resolve => setTimeout(resolve, 5000));
+            }
+        }
+    }
+}
+exports.default = Promote;
+Promote.topic = 'pg';
+Promote.description = 'sets DATABASE as your DATABASE_URL';
+Promote.flags = {
+    force: command_1.flags.boolean({ char: 'f' }),
+    app: command_1.flags.app({ required: true }),
+    remote: command_1.flags.remote(),
+};
+Promote.args = {
+    database: core_1.Args.string({ required: true }),
+};

package/lib/commands/pg/ps.d.ts

@@ -0,0 +1,14 @@
+import { Command } from '@heroku-cli/command';
+export default class Ps extends Command {
+    static topic: string;
+    static description: string;
+    static flags: {
+        verbose: import("@oclif/core/lib/interfaces").BooleanFlag<boolean>;
+        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>;
+    };
+    static args: {
+        database: import("@oclif/core/lib/interfaces/parser").Arg<string | undefined, Record<string, unknown>>;
+    };
+    run(): Promise<void>;
+}

package/lib/commands/pg/ps.js

@@ -0,0 +1,52 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const command_1 = require("@heroku-cli/command");
+const core_1 = require("@oclif/core");
+const tsheredoc_1 = require("tsheredoc");
+const fetcher_1 = require("../../lib/pg/fetcher");
+const psql_1 = require("../../lib/pg/psql");
+class Ps extends command_1.Command {
+    async run() {
+        const { flags, args } = await this.parse(Ps);
+        const { database: databaseName } = args;
+        const { verbose, app } = flags;
+        const db = await (0, fetcher_1.database)(this.heroku, app, databaseName);
+        const num = Math.random();
+        const waitingMarker = `${num}${num}`;
+        const waitingQuery = (0, tsheredoc_1.default)(`
+    SELECT '${num}' || '${num}'
+    WHERE EXISTS
+        (SELECT 1
+         FROM information_schema.columns
+         WHERE table_schema = 'pg_catalog'
+           AND TABLE_NAME = 'pg_stat_activity'
+           AND COLUMN_NAME = 'waiting')
+    `);
+        const waitingOutput = await (0, psql_1.exec)(db, waitingQuery);
+        const waiting = waitingOutput.includes(waitingMarker) ? 'waiting' : 'wait_event IS NOT NULL AS waiting';
+        const query = (0, tsheredoc_1.default)(`SELECT pid,
+           state,
+           application_name AS SOURCE,
+           usename AS username,
+           age(now(), xact_start) AS running_for,
+           xact_start AS transaction_start, ${waiting}, query
+    FROM pg_stat_activity
+    WHERE query <> '<insufficient privilege>' ${verbose ? '' : "AND state <> 'idle'"}
+      AND pid <> pg_backend_pid()
+    ORDER BY query_start DESC
+    `);
+        const output = await (0, psql_1.exec)(db, query);
+        process.stdout.write(output);
+    }
+}
+exports.default = Ps;
+Ps.topic = 'pg';
+Ps.description = 'view active queries with execution time';
+Ps.flags = {
+    verbose: command_1.flags.boolean({ char: 'v' }),
+    app: command_1.flags.app({ required: true }),
+    remote: command_1.flags.remote(),
+};
+Ps.args = {
+    database: core_1.Args.string(),
+};

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

@@ -0,0 +1,16 @@
+import { Command } from '@heroku-cli/command';
+export default class Psql extends Command {
+    static description: string;
+    static flags: {
+        command: import("@oclif/core/lib/interfaces").OptionFlag<string | undefined, import("@oclif/core/lib/interfaces/parser").CustomOptions>;
+        file: import("@oclif/core/lib/interfaces").OptionFlag<string | undefined, import("@oclif/core/lib/interfaces/parser").CustomOptions>;
+        credential: import("@oclif/core/lib/interfaces").OptionFlag<string | undefined, import("@oclif/core/lib/interfaces/parser").CustomOptions>;
+        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>;
+    };
+    static args: {
+        database: import("@oclif/core/lib/interfaces/parser").Arg<string | undefined, Record<string, unknown>>;
+    };
+    static aliases: string[];
+    run(): Promise<void>;
+}

package/lib/commands/pg/psql.js

@@ -0,0 +1,49 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const color_1 = require("@heroku-cli/color");
+const command_1 = require("@heroku-cli/command");
+const core_1 = require("@oclif/core");
+const fetcher_1 = require("../../lib/pg/fetcher");
+const psql_1 = require("../../lib/pg/psql");
+class Psql extends command_1.Command {
+    async run() {
+        const { flags, args } = await this.parse(Psql);
+        const { app, command, credential, file } = flags;
+        const namespace = credential ? `credential:${credential}` : undefined;
+        let db;
+        try {
+            db = await (0, fetcher_1.database)(this.heroku, app, args.database, namespace);
+        }
+        catch (error) {
+            if (namespace && error instanceof Error && error.message === "Couldn't find that addon.") {
+                throw new Error("Credential doesn't match, make sure credential is attached");
+            }
+            throw error;
+        }
+        console.error(`--> Connecting to ${color_1.default.yellow(db.attachment.addon.name)}`);
+        if (command) {
+            const output = await (0, psql_1.exec)(db, command);
+            process.stdout.write(output);
+        }
+        else if (file) {
+            const output = await (0, psql_1.execFile)(db, file);
+            process.stdout.write(output);
+        }
+        else {
+            await (0, psql_1.interactive)(db);
+        }
+    }
+}
+exports.default = Psql;
+Psql.description = 'open a psql shell to the database';
+Psql.flags = {
+    command: command_1.flags.string({ char: 'c', description: 'SQL command to run' }),
+    file: command_1.flags.string({ char: 'f', description: 'SQL file to run' }),
+    credential: command_1.flags.string({ description: 'credential to use' }),
+    app: command_1.flags.app({ required: true }),
+    remote: command_1.flags.remote(),
+};
+Psql.args = {
+    database: core_1.Args.string(),
+};
+Psql.aliases = ['psql'];

package/lib/commands/pg/pull.d.ts

@@ -0,0 +1,18 @@
+import { Command } from '@heroku-cli/command';
+import { ConnectionDetails } from '../../lib/pg/util';
+export default class Pull extends Command {
+    static topic: string;
+    static description: string;
+    static examples: string[];
+    static flags: {
+        'exclude-table-data': import("@oclif/core/lib/interfaces").OptionFlag<string | undefined, import("@oclif/core/lib/interfaces/parser").CustomOptions>;
+        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>;
+    };
+    static args: {
+        source: import("@oclif/core/lib/interfaces/parser").Arg<string, Record<string, unknown>>;
+        target: import("@oclif/core/lib/interfaces/parser").Arg<string, Record<string, unknown>>;
+    };
+    run(): Promise<void>;
+    protected pull(sourceIn: ConnectionDetails, targetIn: ConnectionDetails, exclusions: string[]): Promise<void>;
+}

package/lib/commands/pg/pull.js

@@ -0,0 +1,87 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const color_1 = require("@heroku-cli/color");
+const command_1 = require("@heroku-cli/command");
+const core_1 = require("@oclif/core");
+const tsheredoc_1 = require("tsheredoc");
+const fetcher_1 = require("../../lib/pg/fetcher");
+const util_1 = require("../../lib/pg/util");
+const push_pull_1 = require("../../lib/pg/push_pull");
+const node_child_process_1 = require("node:child_process");
+const env = process.env;
+class Pull extends command_1.Command {
+    async run() {
+        const { flags, args } = await this.parse(Pull);
+        const { app, 'exclude-table-data': excludeTableData } = flags;
+        const exclusions = (0, push_pull_1.parseExclusions)(excludeTableData);
+        const source = await (0, fetcher_1.database)(this.heroku, app, args.source);
+        const target = (0, util_1.parsePostgresConnectionString)(args.target);
+        core_1.ux.log(`Pulling ${color_1.default.cyan(source.attachment.addon.name)} to ${color_1.default.addon(args.target)}`);
+        await this.pull(source, target, exclusions);
+        core_1.ux.log('Pulling complete.');
+    }
+    async pull(sourceIn, targetIn, exclusions) {
+        await (0, push_pull_1.prepare)(targetIn);
+        const source = await (0, push_pull_1.maybeTunnel)(sourceIn);
+        const target = await (0, push_pull_1.maybeTunnel)(targetIn);
+        const exclude = exclusions.map(function (e) {
+            return '--exclude-table-data=' + e;
+        }).join(' ');
+        const dumpFlags = ['--verbose', '-F', 'c', '-Z', '0', '-N', '_heroku', ...(0, push_pull_1.connArgs)(source, true)];
+        if (exclude !== '')
+            dumpFlags.push(exclude);
+        const dumpOptions = {
+            env: Object.assign({ PGSSLMODE: 'prefer' }, env),
+            stdio: ['pipe', 'pipe', 2],
+            shell: true,
+        };
+        if (source.password)
+            dumpOptions.env.PGPASSWORD = source.password;
+        const restoreFlags = ['--verbose', '-F', 'c', '--no-acl', '--no-owner', ...(0, push_pull_1.connArgs)(target)];
+        const restoreOptions = {
+            env: Object.assign({}, env),
+            stdio: ['pipe', 'pipe', 2],
+            shell: true,
+        };
+        if (target.password)
+            restoreOptions.env.PGPASSWORD = target.password;
+        const pgDump = (0, node_child_process_1.spawn)('pg_dump', dumpFlags, dumpOptions);
+        const pgRestore = (0, node_child_process_1.spawn)('pg_restore', restoreFlags, restoreOptions);
+        await (0, push_pull_1.spawnPipe)(pgDump, pgRestore);
+        if (source._tunnel)
+            source._tunnel.close();
+        if (target._tunnel)
+            target._tunnel.close();
+        await (0, push_pull_1.verifyExtensionsMatch)(sourceIn, targetIn);
+    }
+}
+exports.default = Pull;
+Pull.topic = 'pg';
+Pull.description = (0, tsheredoc_1.default) `
+    pull Heroku database into local or remote database
+    Pull from SOURCE into TARGET.
+
+    TARGET must be one of:
+    * a database name (i.e. on a local PostgreSQL server)  => TARGET must not exist and will be created
+    * a fully qualified URL to a local PostgreSQL server   => TARGET must not exist and will be created
+    * a fully qualified URL to a remote PostgreSQL server  => TARGET must exist and be empty
+
+    To delete a local database run ${color_1.default.cmd('dropdb TARGET')}.
+    To create an empty remote database, run ${color_1.default.cmd('createdb')} with connection command-line options (run ${color_1.default.cmd('createdb --help')} for details).
+  `;
+Pull.examples = [(0, tsheredoc_1.default) `
+    # pull Heroku DB named postgresql-swimmingly-100 into local DB mylocaldb that must not exist
+    $ heroku pg:pull postgresql-swimmingly-100 mylocaldb --app sushi
+  `, (0, tsheredoc_1.default) `
+    # pull Heroku DB named postgresql-swimmingly-100 into empty remote DB at postgres://myhost/mydb
+    $ heroku pg:pull postgresql-swimmingly-100 postgres://myhost/mydb --app sushi
+  `];
+Pull.flags = {
+    'exclude-table-data': command_1.flags.string({ description: 'tables for which data should be excluded (use \';\' to split multiple names)', hasValue: true }),
+    app: command_1.flags.app({ required: true }),
+    remote: command_1.flags.remote(),
+};
+Pull.args = {
+    source: core_1.Args.string({ required: true }),
+    target: core_1.Args.string({ required: true }),
+};

package/lib/commands/pg/push.d.ts

@@ -0,0 +1,18 @@
+import { Command } from '@heroku-cli/command';
+import { ConnectionDetails } from '../../lib/pg/util';
+export default class Push extends Command {
+    static topic: string;
+    static description: string;
+    static examples: string[];
+    static flags: {
+        'exclude-table-data': import("@oclif/core/lib/interfaces").OptionFlag<string | undefined, import("@oclif/core/lib/interfaces/parser").CustomOptions>;
+        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>;
+    };
+    static args: {
+        source: import("@oclif/core/lib/interfaces/parser").Arg<string, Record<string, unknown>>;
+        target: import("@oclif/core/lib/interfaces/parser").Arg<string, Record<string, unknown>>;
+    };
+    run(): Promise<void>;
+    protected push(sourceIn: ConnectionDetails, targetIn: ConnectionDetails, exclusions: string[]): Promise<void>;
+}

package/lib/commands/pg/push.js

@@ -0,0 +1,84 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const color_1 = require("@heroku-cli/color");
+const command_1 = require("@heroku-cli/command");
+const core_1 = require("@oclif/core");
+const tsheredoc_1 = require("tsheredoc");
+const fetcher_1 = require("../../lib/pg/fetcher");
+const util_1 = require("../../lib/pg/util");
+const push_pull_1 = require("../../lib/pg/push_pull");
+const node_child_process_1 = require("node:child_process");
+const env = process.env;
+class Push extends command_1.Command {
+    async run() {
+        const { flags, args } = await this.parse(Push);
+        const { app, 'exclude-table-data': excludeTableData } = flags;
+        const exclusions = (0, push_pull_1.parseExclusions)(excludeTableData);
+        const source = (0, util_1.parsePostgresConnectionString)(args.source);
+        const target = await (0, fetcher_1.database)(this.heroku, app, args.target);
+        core_1.ux.log(`Pushing ${color_1.default.cyan(args.source)} to ${color_1.default.addon(target.attachment.addon.name)}`);
+        await this.push(source, target, exclusions);
+        core_1.ux.log('Pushing complete.');
+    }
+    async push(sourceIn, targetIn, exclusions) {
+        await (0, push_pull_1.prepare)(targetIn);
+        const source = await (0, push_pull_1.maybeTunnel)(sourceIn);
+        const target = await (0, push_pull_1.maybeTunnel)(targetIn);
+        const exclude = exclusions.map(function (e) {
+            return '--exclude-table-data=' + e;
+        }).join(' ');
+        const dumpFlags = ['--verbose', '-F', 'c', '-Z', '0', '-N', '_heroku', ...(0, push_pull_1.connArgs)(source, true)];
+        if (exclude !== '')
+            dumpFlags.push(exclude);
+        const dumpOptions = {
+            env: Object.assign({ PGSSLMODE: 'prefer' }, env),
+            stdio: ['pipe', 'pipe', 2],
+            shell: true,
+        };
+        if (source.password)
+            dumpOptions.env.PGPASSWORD = source.password;
+        const restoreFlags = ['--verbose', '-F', 'c', '--no-acl', '--no-owner', ...(0, push_pull_1.connArgs)(target)];
+        const restoreOptions = {
+            env: Object.assign({}, env),
+            stdio: ['pipe', 'pipe', 2],
+            shell: true,
+        };
+        if (target.password)
+            restoreOptions.env.PGPASSWORD = target.password;
+        const pgDump = (0, node_child_process_1.spawn)('pg_dump', dumpFlags, dumpOptions);
+        const pgRestore = (0, node_child_process_1.spawn)('pg_restore', restoreFlags, restoreOptions);
+        await (0, push_pull_1.spawnPipe)(pgDump, pgRestore);
+        if (source._tunnel)
+            source._tunnel.close();
+        if (target._tunnel)
+            target._tunnel.close();
+        await (0, push_pull_1.verifyExtensionsMatch)(sourceIn, targetIn);
+    }
+}
+exports.default = Push;
+Push.topic = 'pg';
+Push.description = (0, tsheredoc_1.default) `
+    push local or remote into Heroku database
+    Push from SOURCE into TARGET. TARGET must be empty.
+
+    To empty a Heroku database for push run ${color_1.default.cmd('heroku pg:reset')}
+    
+    SOURCE must be either the name of a database existing on your localhost or the
+    fully qualified URL of a remote database.
+  `;
+Push.examples = [(0, tsheredoc_1.default) `
+      # push mylocaldb into a Heroku DB named postgresql-swimmingly-100
+      $ heroku pg:push mylocaldb postgresql-swimmingly-100 --app sushi
+    `, (0, tsheredoc_1.default) `
+      # push remote DB at postgres://myhost/mydb into a Heroku DB named postgresql-swimmingly-100
+      $ heroku pg:push postgres://myhost/mydb postgresql-swimmingly-100 --app sushi
+  `];
+Push.flags = {
+    'exclude-table-data': command_1.flags.string({ description: 'tables for which data should be excluded (use \';\' to split multiple names)', hasValue: true }),
+    app: command_1.flags.app({ required: true }),
+    remote: command_1.flags.remote(),
+};
+Push.args = {
+    source: core_1.Args.string({ required: true }),
+    target: core_1.Args.string({ required: true }),
+};

package/lib/commands/pg/reset.d.ts

@@ -0,0 +1,15 @@
+import { Command } from '@heroku-cli/command';
+export default class Reset extends Command {
+    static topic: string;
+    static description: string;
+    static flags: {
+        extensions: import("@oclif/core/lib/interfaces").OptionFlag<string | undefined, import("@oclif/core/lib/interfaces/parser").CustomOptions>;
+        confirm: import("@oclif/core/lib/interfaces").OptionFlag<string | undefined, import("@oclif/core/lib/interfaces/parser").CustomOptions>;
+        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>;
+    };
+    static args: {
+        database: import("@oclif/core/lib/interfaces/parser").Arg<string | undefined, Record<string, unknown>>;
+    };
+    run(): Promise<void>;
+}

package/lib/commands/pg/reset.js

@@ -0,0 +1,44 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const color_1 = require("@heroku-cli/color");
+const command_1 = require("@heroku-cli/command");
+const core_1 = require("@oclif/core");
+const confirmCommand_1 = require("../../lib/confirmCommand");
+const host_1 = require("../../lib/pg/host");
+const fetcher_1 = require("../../lib/pg/fetcher");
+const tsheredoc_1 = require("tsheredoc");
+class Reset extends command_1.Command {
+    async run() {
+        const { flags, args } = await this.parse(Reset);
+        const { app, confirm, extensions } = flags;
+        const db = await (0, fetcher_1.getAddon)(this.heroku, app, args.database);
+        let extensionsArray;
+        if (extensions) {
+            extensionsArray = extensions.split(',')
+                .map(ext => ext.trim()
+                .toLowerCase())
+                .sort();
+        }
+        await (0, confirmCommand_1.default)(app, confirm, (0, tsheredoc_1.default)(`
+      Destructive action
+      ${color_1.default.addon(db.name)} will lose all of its data
+    `));
+        core_1.ux.action.start(`Resetting ${color_1.default.addon(db.name)}`);
+        await this.heroku.put(`/client/v11/databases/${db.id}/reset`, {
+            body: { extensions: extensionsArray }, hostname: (0, host_1.default)(),
+        });
+        core_1.ux.action.stop();
+    }
+}
+exports.default = Reset;
+Reset.topic = 'pg';
+Reset.description = 'delete all data in DATABASE';
+Reset.flags = {
+    extensions: command_1.flags.string({ char: 'e', description: 'comma-separated list of extensions to pre-install in the public schema' }),
+    confirm: command_1.flags.string({ char: 'c' }),
+    app: command_1.flags.app({ required: true }),
+    remote: command_1.flags.remote(),
+};
+Reset.args = {
+    database: core_1.Args.string(),
+};

package/lib/commands/pg/settings/auto-explain/log-analyze.d.ts

@@ -0,0 +1,13 @@
+import { PGSettingsCommand, BooleanAsString } from '../../../../lib/pg/setter';
+import { SettingKey, Setting } from '../../../../lib/pg/types';
+export default class LogAnalyze extends PGSettingsCommand {
+    static topic: string;
+    static description: string;
+    static args: {
+        database: import("@oclif/core/lib/interfaces/parser").Arg<string | undefined, Record<string, unknown>>;
+        value: import("@oclif/core/lib/interfaces/parser").Arg<string | undefined, Record<string, unknown>>;
+    };
+    protected settingKey: SettingKey;
+    protected convertValue(val: BooleanAsString): boolean;
+    protected explain(setting: Setting<boolean>): "EXPLAIN ANALYZE execution plans will be logged." | "EXPLAIN ANALYZE execution plans will not be logged.";
+}

package/lib/commands/pg/settings/auto-explain/log-analyze.js

@@ -0,0 +1,32 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const core_1 = require("@oclif/core");
+const tsheredoc_1 = require("tsheredoc");
+const setter_1 = require("../../../../lib/pg/setter");
+class LogAnalyze extends setter_1.PGSettingsCommand {
+    constructor() {
+        super(...arguments);
+        this.settingKey = 'auto_explain.log_analyze';
+    }
+    convertValue(val) {
+        return (0, setter_1.booleanConverter)(val);
+    }
+    explain(setting) {
+        if (setting.value) {
+            return 'EXPLAIN ANALYZE execution plans will be logged.';
+        }
+        return 'EXPLAIN ANALYZE execution plans will not be logged.';
+    }
+}
+exports.default = LogAnalyze;
+LogAnalyze.topic = 'pg';
+LogAnalyze.description = (0, tsheredoc_1.default)(`
+    Shows actual run times on the execution plan.
+    This is equivalent to calling EXPLAIN ANALYZE.
+
+    WARNING: EXPLAIN ANALYZE will be run on ALL queries, not just logged queries. This can cause significant performance impacts to your database and should be used with caution.
+  `);
+LogAnalyze.args = {
+    database: core_1.Args.string(),
+    value: core_1.Args.string(),
+};

package/lib/commands/pg/settings/auto-explain/log-buffers.d.ts

@@ -0,0 +1,13 @@
+import { BooleanAsString, PGSettingsCommand } from '../../../../lib/pg/setter';
+import { Setting, SettingKey } from '../../../../lib/pg/types';
+export default class LogBuffersWaits extends PGSettingsCommand {
+    static topic: string;
+    static description: string;
+    static args: {
+        database: import("@oclif/core/lib/interfaces/parser").Arg<string | undefined, Record<string, unknown>>;
+        value: import("@oclif/core/lib/interfaces/parser").Arg<string | undefined, Record<string, unknown>>;
+    };
+    protected settingKey: SettingKey;
+    protected convertValue(val: BooleanAsString): boolean;
+    protected explain(setting: Setting<boolean>): "Buffer statistics have been enabled for auto_explain." | "Buffer statistics have been disabled for auto_explain.";
+}