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

package/lib/commands/pg/maintenance/run.js

@@ -0,0 +1,34 @@
+import { color, utils } from '@heroku/heroku-cli-util';
+import { Command, flags } from '@heroku-cli/command';
+import { Args, ux } from '@oclif/core';
+import { essentialPlan } from '../../../lib/pg/util.js';
+import { nls } from '../../../nls.js';
+export default class Run extends Command {
+    static args = {
+        database: Args.string({ description: `${nls('pg:database:arg:description')} ${nls('pg:database:arg:description:default:suffix')}` }),
+    };
+    static description = 'start maintenance';
+    static flags = {
+        app: flags.app({ required: true }),
+        force: flags.boolean({ char: 'f' }),
+        remote: flags.remote(),
+    };
+    static topic = 'pg';
+    async run() {
+        const { args, flags } = await this.parse(Run);
+        const { app, force } = flags;
+        const { database } = args;
+        const dbResolver = new utils.pg.DatabaseResolver(this.heroku);
+        const { addon: db } = await dbResolver.getAttachment(app, database);
+        if (essentialPlan(db))
+            ux.error("pg:maintenance isn't available for Essential-tier databases.");
+        ux.action.start(`Starting maintenance for ${color.datastore(db.name)}`);
+        if (!force) {
+            const { body: appInfo } = await this.heroku.get(`/apps/${app}`);
+            if (!appInfo.maintenance)
+                ux.error('Application must be in maintenance mode or run with --force');
+        }
+        const { body: response } = await this.heroku.post(`/client/v11/databases/${db.id}/maintenance`, { hostname: utils.pg.host() });
+        ux.action.stop(response.message || 'done');
+    }
+}

package/lib/commands/pg/maintenance/window.d.ts

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

package/lib/commands/pg/maintenance/window.js

@@ -0,0 +1,41 @@
+import { color, utils } from '@heroku/heroku-cli-util';
+import { Command, flags } from '@heroku-cli/command';
+import { Args, ux } from '@oclif/core';
+import tsheredoc from 'tsheredoc';
+import { essentialPlan } from '../../../lib/pg/util.js';
+const heredoc = tsheredoc.default;
+import { nls } from '../../../nls.js';
+export default class Window extends Command {
+    /* eslint-disable perfectionist/sort-objects */
+    static args = {
+        window: Args.string({ description: 'timestamp of the maintenance window', required: true }),
+        database: Args.string({ description: `${nls('pg:database:arg:description')} ${nls('pg:database:arg:description:default:suffix')}` }),
+    };
+    /* eslint-enable perfectionist/sort-objects */
+    static description = heredoc(`
+    Set weekly maintenance window.
+    All times are in UTC.
+  `);
+    static example = `${color.command('heroku pg:maintenance:window "Sunday 06:00" postgres-slippery-100')}`;
+    static flags = {
+        app: flags.app({ required: true }),
+        remote: flags.remote(),
+    };
+    static topic = 'pg';
+    async run() {
+        const { args, flags } = await this.parse(Window);
+        const { database, window } = args;
+        const { app } = flags;
+        const dbResolver = new utils.pg.DatabaseResolver(this.heroku);
+        const { addon: db } = await dbResolver.getAttachment(app, database);
+        if (essentialPlan(db))
+            ux.error("pg:maintenance isn't available for Essential-tier databases.");
+        if (!window.match(/^[A-Za-z]{2,10} \d\d?:[03]0$/))
+            ux.error('Window must be "Day HH:MM" where MM is 00 or 30');
+        ux.action.start(`Setting maintenance window for ${color.datastore(db.name)} to ${color.info(window)}`);
+        const { body: response } = await this.heroku.put(`/client/v11/databases/${db.id}/maintenance_window`, {
+            body: { description: window }, hostname: utils.pg.host(),
+        });
+        ux.action.stop(response.message || 'done');
+    }
+}

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

@@ -0,0 +1,19 @@
+import { Command } from '@heroku-cli/command';
+export default class Outliers extends Command {
+    static topic: string;
+    static description: string;
+    static flags: {
+        reset: import("@oclif/core/interfaces").BooleanFlag<boolean>;
+        truncate: import("@oclif/core/interfaces").BooleanFlag<boolean>;
+        num: import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
+        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>;
+    };
+    static args: {
+        database: import("@oclif/core/interfaces").Arg<string | undefined, Record<string, unknown>>;
+    };
+    private psqlService;
+    run(): Promise<void>;
+    protected ensurePGStatStatement(): Promise<void>;
+    protected outliersQuery(version: string | undefined, limit: number, truncate: boolean): string;
+}

package/lib/commands/pg/outliers.js

@@ -0,0 +1,100 @@
+import { Command, flags } from '@heroku-cli/command';
+import { Args, ux } from '@oclif/core';
+import { utils } from '@heroku/heroku-cli-util';
+import { fetchVersion } from '../../lib/pg/psql.js';
+import tsheredoc from 'tsheredoc';
+import { nls } from '../../nls.js';
+const heredoc = tsheredoc.default;
+export default class Outliers extends Command {
+    static topic = 'pg';
+    static description = 'show 10 queries that have longest execution time in aggregate';
+    static flags = {
+        reset: flags.boolean({ description: 'resets statistics gathered by pg_stat_statements' }),
+        truncate: flags.boolean({ char: 't', description: 'truncate queries to 40 characters' }),
+        num: flags.string({ char: 'n', description: 'the number of queries to display (default: 10)' }),
+        app: flags.app({ required: true }),
+        remote: flags.remote(),
+    };
+    static args = {
+        database: Args.string({ description: `${nls('pg:database:arg:description')} ${nls('pg:database:arg:description:default:suffix')}` }),
+    };
+    psqlService;
+    async run() {
+        const { flags, args } = await this.parse(Outliers);
+        const { app, reset, truncate, num } = flags;
+        const dbResolver = new utils.pg.DatabaseResolver(this.heroku);
+        const db = await dbResolver.getDatabase(app, args.database);
+        this.psqlService = new utils.pg.PsqlService(db);
+        const version = await fetchVersion(db);
+        await this.ensurePGStatStatement();
+        if (reset) {
+            await this.psqlService.execQuery('SELECT pg_stat_statements_reset();');
+            return;
+        }
+        let limit = 10;
+        if (num) {
+            if (/^(\d+)$/.exec(num)) {
+                limit = Number.parseInt(num, 10);
+            }
+            else {
+                ux.error(`Cannot parse num param value "${num}" to a number`);
+            }
+        }
+        const query = this.outliersQuery(version, limit, truncate);
+        const output = await this.psqlService.execQuery(query);
+        ux.stdout(output);
+    }
+    async ensurePGStatStatement() {
+        const query = heredoc `
+      SELECT exists(
+        SELECT 1
+        FROM pg_extension e
+          LEFT JOIN pg_namespace n ON n.oid = e.extnamespace
+        WHERE e.extname = 'pg_stat_statements' AND n.nspname IN ('public', 'heroku_ext')
+      ) AS available;
+    `;
+        const output = await this.psqlService.execQuery(query);
+        if (!output.includes('t')) {
+            ux.error(heredoc `
+        pg_stat_statements extension need to be installed first.
+        You can install it by running: CREATE EXTENSION pg_stat_statements WITH SCHEMA heroku_ext;
+      `);
+        }
+    }
+    outliersQuery(version, limit, truncate) {
+        const truncatedQueryString = truncate ? heredoc `
+      CASE WHEN length(query) <= 40 THEN query ELSE substr(query, 0, 39) || '…' END
+    ` : 'query';
+        let totalExecTimeField = '';
+        if (version && Number.parseInt(version, 10) >= 13) {
+            totalExecTimeField = 'total_exec_time';
+        }
+        else {
+            totalExecTimeField = 'total_time';
+        }
+        let blkReadTimeField = '';
+        let blkWriteTimeField = '';
+        if (version && Number.parseInt(version, 10) >= 17) {
+            blkReadTimeField = 'shared_blk_read_time';
+            blkWriteTimeField = 'shared_blk_write_time';
+        }
+        else {
+            blkReadTimeField = 'blk_read_time';
+            blkWriteTimeField = 'blk_write_time';
+        }
+        return heredoc `
+        SELECT
+          interval '1 millisecond' * ${totalExecTimeField} AS total_exec_time,
+          to_char((${totalExecTimeField}/sum(${totalExecTimeField}) OVER()) * 100, 'FM90D0') || '%'  AS prop_exec_time,
+          to_char(calls, 'FM999G999G999G990') AS ncalls,
+          interval '1 millisecond' * (${blkReadTimeField} + ${blkWriteTimeField}) AS sync_io_time,
+          ${truncatedQueryString} AS query
+        FROM pg_stat_statements
+        WHERE userid = (
+          SELECT usesysid FROM pg_user WHERE usename = current_user LIMIT 1
+        )
+        ORDER BY ${totalExecTimeField} DESC
+        LIMIT ${limit};
+      `;
+    }
+}

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

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

package/lib/commands/pg/promote.js

@@ -0,0 +1,167 @@
+/* eslint-disable complexity */
+import { color, utils } from '@heroku/heroku-cli-util';
+import { Command, flags } from '@heroku-cli/command';
+import { Args, ux } from '@oclif/core';
+import tsheredoc from 'tsheredoc';
+import { getRelease } from '../../lib/pg/fetcher.js';
+import { nls } from '../../nls.js';
+const heredoc = tsheredoc.default;
+export default class Promote extends Command {
+    static topic = 'pg';
+    static description = 'sets DATABASE as your DATABASE_URL';
+    static flags = {
+        force: flags.boolean({ char: 'f' }),
+        app: flags.app({ required: true }),
+        remote: flags.remote(),
+    };
+    static args = {
+        database: Args.string({ required: true, description: nls('pg:database:arg:description') }),
+    };
+    async run() {
+        const { flags, args } = await this.parse(Promote);
+        const { force, app } = flags;
+        const { database } = args;
+        const dbResolver = new utils.pg.DatabaseResolver(this.heroku);
+        const attachment = await dbResolver.getAttachment(app, database);
+        ux.action.start(`Ensuring an alternate alias for existing ${color.datastore('DATABASE_URL')}`);
+        const { body: attachments } = await this.heroku.get(`/apps/${app}/addon-attachments`);
+        const current = attachments.find(a => a.name === 'DATABASE');
+        if (current) {
+            // eslint-disable-next-line eqeqeq
+            if (current.addon?.name === attachment.addon.name && current.namespace == attachment.namespace) {
+                if (attachment.namespace) {
+                    ux.error(`${color.attachment(attachment.name)} is already promoted on ${color.app(app)}`);
+                }
+                else {
+                    ux.error(`${color.addon(attachment.addon.name)} is already promoted on ${color.app(app)}`);
+                }
+            }
+            const existing = attachments.filter(a => a.addon?.id === current.addon?.id && a.namespace === current.namespace)
+                .find(a => a.name !== 'DATABASE');
+            if (existing) {
+                ux.action.stop(color.attachment(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: current.addon?.name },
+                        namespace: current.namespace,
+                        confirm: app,
+                    },
+                });
+                ux.action.stop(color.attachment(backup.name + '_URL'));
+            }
+        }
+        if (!force) {
+            const { body: status } = await this.heroku.get(`/client/v11/databases/${attachment.addon.id}/wait_status`, {
+                hostname: utils.pg.host(),
+            });
+            if (status['waiting?']) {
+                ux.error(heredoc(`
+          Database cannot be promoted while in state: ${status.message}
+
+          Promoting this database can lead to application errors and outage. Please run ${color.code('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.attachment(attachment.name)} to ${color.datastore('DATABASE_URL')} on ${color.app(app)}`;
+        }
+        else {
+            promotionMessage = `Promoting ${color.datastore(attachment.addon.name)} to ${color.datastore('DATABASE_URL')} on ${color.app(app)}`;
+        }
+        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,
+            },
+        });
+        ux.action.stop();
+        const currentPooler = attachments.find(a => a.namespace === 'connection-pooling:default' && a.addon?.id === current?.addon?.id && a.name === 'DATABASE_CONNECTION_POOL');
+        if (currentPooler) {
+            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,
+                },
+            });
+            ux.action.stop();
+        }
+        const { body: promotedDatabaseDetails } = await this.heroku.get(`/client/v11/databases/${attachment.addon.id}`, {
+            hostname: utils.pg.host(),
+        });
+        if (promotedDatabaseDetails.following) {
+            const unfollowLeaderCmd = `heroku pg:unfollow ${attachment.addon.name}`;
+            ux.warn(heredoc(`
+        Your database has been promoted but it is currently a follower database in read-only mode.
+
+        Promoting a database with ${color.code('heroku pg:promote')} doesn't automatically unfollow its leader.
+
+        Use ${color.code(unfollowLeaderCmd)} to stop this follower from replicating from its leader (${color.datastore(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) {
+            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 => release.description?.includes('Attach DATABASE'));
+            const detach = releases.find(release => release.description?.includes('Detach DATABASE'));
+            if (!attach || !detach) {
+                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?.id, detach?.id];
+            while (true) {
+                const attach = await getRelease(this.heroku, app, attachId);
+                if (attach && attach.status === 'succeeded') {
+                    let msg = 'pg:promote succeeded.';
+                    const detach = await getRelease(this.heroku, app, detachId);
+                    if (detach && detach.status === 'failed') {
+                        msg += ` It is safe to ignore the failed ${detach.description} release.`;
+                    }
+                    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 getRelease(this.heroku, app, detachId);
+                    if (detach && detach.status === 'succeeded') {
+                        msg += 'without an attached DATABASE_URL.';
+                    }
+                    else {
+                        msg += `with ${current?.addon?.name} attached as DATABASE_URL.`;
+                    }
+                    msg += ' Check your release phase logs for failure causes.';
+                    ux.action.stop(msg);
+                    return;
+                }
+                if (Date.now() > endTime) {
+                    ux.action.stop('timeout. Check your Attach DATABASE release for failures.');
+                    return;
+                }
+                await new Promise(resolve => setTimeout(resolve, 5000));
+            }
+        }
+    }
+}

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

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

package/lib/commands/pg/ps.js

@@ -0,0 +1,52 @@
+import { Command, flags } from '@heroku-cli/command';
+import { Args } from '@oclif/core';
+import tsheredoc from 'tsheredoc';
+import { utils } from '@heroku/heroku-cli-util';
+import { nls } from '../../nls.js';
+const heredoc = tsheredoc.default;
+export default class Ps extends Command {
+    static description = 'view active queries with execution time';
+    static flags = {
+        verbose: flags.boolean({ char: 'v' }),
+        app: flags.app({ required: true }),
+        remote: flags.remote(),
+    };
+    static topic = 'pg';
+    static args = {
+        database: Args.string({ description: `${nls('pg:database:arg:description')} ${nls('pg:database:arg:description:default:suffix')}` }),
+    };
+    async run() {
+        const { flags, args } = await this.parse(Ps);
+        const { database: databaseName } = args;
+        const { verbose, app } = flags;
+        const dbResolver = new utils.pg.DatabaseResolver(this.heroku);
+        const db = await dbResolver.getDatabase(app, databaseName);
+        const psqlService = new utils.pg.PsqlService(db);
+        const num = Math.random();
+        const waitingMarker = `${num}${num}`;
+        const waitingQuery = heredoc(`
+    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 psqlService.execQuery(waitingQuery);
+        const waiting = waitingOutput.includes(waitingMarker) ? 'waiting' : 'wait_event IS NOT NULL AS waiting';
+        const query = heredoc(`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 psqlService.execQuery(query);
+        process.stdout.write(output);
+    }
+}

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/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
+        file: import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
+        credential: import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
+        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>;
+    };
+    static args: {
+        database: import("@oclif/core/interfaces").Arg<string | undefined, Record<string, unknown>>;
+    };
+    static aliases: string[];
+    run(): Promise<void>;
+}

package/lib/commands/pg/psql.js

@@ -0,0 +1,47 @@
+import { color, utils } from '@heroku/heroku-cli-util';
+import { Command, flags } from '@heroku-cli/command';
+import { Args } from '@oclif/core';
+import { nls } from '../../nls.js';
+export default class Psql extends Command {
+    static description = 'open a psql shell to the database';
+    static flags = {
+        command: flags.string({ char: 'c', description: 'SQL command to run' }),
+        file: flags.string({ char: 'f', description: 'SQL file to run' }),
+        credential: flags.string({ description: 'credential to use' }),
+        app: flags.app({ required: true }),
+        remote: flags.remote(),
+    };
+    static args = {
+        database: Args.string({ description: `${nls('pg:database:arg:description')} ${nls('pg:database:arg:description:default:suffix')}` }),
+    };
+    static aliases = ['psql'];
+    async run() {
+        const { flags, args } = await this.parse(Psql);
+        const { app, command, credential, file } = flags;
+        const namespace = credential ? `credential:${credential}` : undefined;
+        let db;
+        const dbResolver = new utils.pg.DatabaseResolver(this.heroku);
+        try {
+            db = await dbResolver.getDatabase(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;
+        }
+        const psqlService = new utils.pg.PsqlService(db);
+        console.error(`--> Connecting to ${color.datastore(db.attachment.addon.name)}`);
+        if (command) {
+            const output = await psqlService.execQuery(command);
+            process.stdout.write(output);
+        }
+        else if (file) {
+            const output = await psqlService.execFile(file);
+            process.stdout.write(output);
+        }
+        else {
+            await psqlService.interactiveSession();
+        }
+    }
+}

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

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

package/lib/commands/pg/pull.js

@@ -0,0 +1,87 @@
+import { Command, flags } from '@heroku-cli/command';
+import { Args, ux } from '@oclif/core';
+import tsheredoc from 'tsheredoc';
+import { color, utils } from '@heroku/heroku-cli-util';
+// import {SpawnOptions, spawn} from 'node:child_process'
+import childProcess from 'node:child_process';
+import { nls } from '../../nls.js';
+import { connArgs, maybeTunnel, parseExclusions, prepare, spawnPipe, verifyExtensionsMatch, } from '../../lib/pg/push_pull.js';
+const { env } = process;
+const heredoc = tsheredoc.default;
+export default class Pull extends Command {
+    static args = {
+        source: Args.string({ required: true, description: `${nls('pg:database:arg:description')} ${nls('pg:database:arg:description:default:suffix')}` }),
+        target: Args.string({ required: true, description: 'PostgreSQL connection string for the target database' }),
+    };
+    static description = heredoc `
+    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.code('dropdb TARGET')}.
+    To create an empty remote database, run ${color.code('createdb')} with connection command-line options (run ${color.code('createdb --help')} for details).
+  `;
+    static examples = [heredoc `
+    # pull Heroku DB named postgresql-swimmingly-100 into local DB mylocaldb that must not exist
+    ${color.command('heroku pg:pull postgresql-swimmingly-100 mylocaldb --app sushi')}
+  `, heredoc `
+    # pull Heroku DB named postgresql-swimmingly-100 into empty remote DB at postgres://myhost/mydb
+    ${color.command('heroku pg:pull postgresql-swimmingly-100 postgres://myhost/mydb --app sushi')}
+  `];
+    static flags = {
+        app: flags.app({ required: true }),
+        'exclude-table-data': flags.string({ description: 'tables for which data should be excluded (use \';\' to split multiple names)', hasValue: true }),
+        remote: flags.remote(),
+    };
+    static topic = 'pg';
+    async pull(sourceIn, targetIn, exclusions) {
+        await prepare(targetIn);
+        const source = await maybeTunnel(sourceIn);
+        const target = await maybeTunnel(targetIn);
+        const exclude = exclusions.map(e => ('--exclude-table-data=' + e)).join(' ');
+        const dumpFlags = ['--verbose', '-F', 'c', '-Z', '0', '-N', '_heroku', ...connArgs(source, true)];
+        if (exclude !== '')
+            dumpFlags.push(exclude);
+        const dumpOptions = {
+            env: {
+                PGSSLMODE: 'prefer',
+                ...env,
+            },
+            shell: true,
+            stdio: ['pipe', 'pipe', 2],
+        };
+        if (source.password)
+            dumpOptions.env.PGPASSWORD = source.password;
+        const restoreFlags = ['--verbose', '-F', 'c', '--no-acl', '--no-owner', ...connArgs(target)];
+        const restoreOptions = {
+            env: { ...env },
+            shell: true,
+            stdio: ['pipe', 'pipe', 2],
+        };
+        if (target.password)
+            restoreOptions.env.PGPASSWORD = target.password;
+        const pgDump = childProcess.spawn('pg_dump', dumpFlags, dumpOptions);
+        const pgRestore = childProcess.spawn('pg_restore', restoreFlags, restoreOptions);
+        await spawnPipe(pgDump, pgRestore);
+        if (source._tunnel)
+            source._tunnel.close();
+        if (target._tunnel)
+            target._tunnel.close();
+        await verifyExtensionsMatch(sourceIn, targetIn);
+    }
+    async run() {
+        const { args, flags } = await this.parse(Pull);
+        const { app, 'exclude-table-data': excludeTableData } = flags;
+        const exclusions = parseExclusions(excludeTableData);
+        const dbResolver = new utils.pg.DatabaseResolver(this.heroku);
+        const source = await dbResolver.getDatabase(app, args.source);
+        const target = utils.pg.DatabaseResolver.parsePostgresConnectionString(args.target);
+        ux.stdout(`Pulling ${color.cyan(source.attachment.addon.name)} to ${color.addon(args.target)}`);
+        await this.pull(source, target, exclusions);
+        ux.stdout('Pulling complete.');
+    }
+}

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

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