heroku 9.0.0-dev.0 → 9.1.0-beta.0

package/lib/commands/pg/backups/capture.js

@@ -0,0 +1,65 @@
+"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 backups_1 = require("../../../lib/pg/backups");
+const fetcher_1 = require("../../../lib/pg/fetcher");
+const host_1 = require("../../../lib/pg/host");
+const tsheredoc_1 = require("tsheredoc");
+class Capture extends command_1.Command {
+    async run() {
+        var _a;
+        const { flags, args } = await this.parse(Capture);
+        const { app, 'wait-interval': waitInterval, verbose } = flags;
+        const { database } = args;
+        const interval = Math.max(3, Number.parseInt(waitInterval || '3', 10));
+        const db = await (0, fetcher_1.getAddon)(this.heroku, app, database);
+        const pgBackupsApi = (0, backups_1.default)(app, this.heroku);
+        try {
+            const { body: dbInfo } = await this.heroku.get(`/client/v11/databases/${db.id}`, { hostname: (0, host_1.default)() });
+            const dbProtected = /On/.test(((_a = dbInfo.info.find(attribute => attribute.name === 'Continuous Protection')) === null || _a === void 0 ? void 0 : _a.values[0]) || '');
+            if (dbProtected) {
+                core_1.ux.warn('Continuous protection is already enabled for this database. Logical backups of large databases are likely to fail.');
+                core_1.ux.warn('See https://devcenter.heroku.com/articles/heroku-postgres-data-safety-and-continuous-protection#physical-backups-on-heroku-postgres.');
+            }
+        }
+        catch (error) {
+            const httpError = error;
+            if (httpError.statusCode !== 404)
+                throw httpError;
+            core_1.ux.error((0, tsheredoc_1.default) `
+          ${color_1.default.yellow(db.name)} is not yet provisioned.
+          Run ${color_1.default.cmd('heroku addons:wait')} to wait until the db is provisioned.
+        `, { exit: 1 });
+        }
+        core_1.ux.action.start(`Starting backup of ${color_1.default.yellow(db.name)}`);
+        const { body: backup } = await this.heroku.post(`/client/v11/databases/${db.id}/backups`, { hostname: (0, host_1.default)() });
+        core_1.ux.action.stop();
+        core_1.ux.log((0, tsheredoc_1.default) `
+
+      Use Ctrl-C at any time to stop monitoring progress; the backup will continue running.
+      Use ${color_1.default.cmd('heroku pg:backups:info')} to check progress.
+      Stop a running backup with ${color_1.default.cmd('heroku pg:backups:cancel')}.
+    `);
+        if (app !== db.app.name) {
+            core_1.ux.log((0, tsheredoc_1.default) `
+        HINT: You are running this command with a non-billing application.
+        Use ${color_1.default.cmd('heroku pg:backups -a ' + db.app.name)} to check the list of backups.
+      `);
+        }
+        await pgBackupsApi.wait(`Backing up ${color_1.default.green(backup.from_name)} to ${color_1.default.cyan(pgBackupsApi.name(backup))}`, backup.uuid, interval, verbose, db.app.name || app);
+    }
+}
+exports.default = Capture;
+Capture.topic = 'pg';
+Capture.description = 'capture a new backup';
+Capture.flags = {
+    'wait-interval': command_1.flags.string(),
+    verbose: command_1.flags.boolean({ char: 'v' }),
+    app: command_1.flags.app({ required: true }),
+    remote: command_1.flags.remote(),
+};
+Capture.args = {
+    database: core_1.Args.string(),
+};

package/lib/commands/pg/backups/delete.d.ts

@@ -0,0 +1,15 @@
+import { Command } from '@heroku-cli/command';
+export default class Delete extends Command {
+    static topic: string;
+    static description: string;
+    static flags: {
+        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: {
+        backup_id: import("@oclif/core/lib/interfaces/parser").Arg<string, Record<string, unknown>>;
+    };
+    static examples: string[];
+    run(): Promise<void>;
+}

package/lib/commands/pg/backups/delete.js

@@ -0,0 +1,38 @@
+"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 backups_1 = require("../../../lib/pg/backups");
+class Delete extends command_1.Command {
+    async run() {
+        const { flags, args } = await this.parse(Delete);
+        const { app, confirm } = flags;
+        const { backup_id } = args;
+        const pgbackups = (0, backups_1.default)(app, this.heroku);
+        await (0, confirmCommand_1.default)(app, confirm);
+        core_1.ux.action.start(`Deleting backup ${color_1.default.cyan(backup_id)} on ${color_1.default.app(app)}`);
+        const num = await pgbackups.num(backup_id);
+        if (!num) {
+            throw new Error(`Invalid Backup: ${backup_id}`);
+        }
+        await this.heroku.delete(`/client/v11/apps/${app}/transfers/${num}`, { hostname: (0, host_1.default)() });
+        core_1.ux.action.stop();
+    }
+}
+exports.default = Delete;
+Delete.topic = 'pg';
+Delete.description = 'delete a backup';
+Delete.flags = {
+    confirm: command_1.flags.string({ char: 'c' }),
+    app: command_1.flags.app({ required: true }),
+    remote: command_1.flags.remote(),
+};
+Delete.args = {
+    backup_id: core_1.Args.string({ required: true }),
+};
+Delete.examples = [
+    '$ heroku pg:backup:delete --app APP_ID BACKUP_ID',
+];

package/lib/commands/pg/backups/download.d.ts

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

package/lib/commands/pg/backups/download.js

@@ -0,0 +1,58 @@
+"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 host_1 = require("../../../lib/pg/host");
+const backups_1 = require("../../../lib/pg/backups");
+const lodash_1 = require("lodash");
+const download_1 = require("../../../lib/pg/download");
+const fs = require("fs-extra");
+function defaultFilename() {
+    let f = 'latest.dump';
+    if (!fs.existsSync(f))
+        return f;
+    let i = 1;
+    do
+        f = `latest.dump.${i++}`;
+    while (fs.existsSync(f));
+    return f;
+}
+class Download extends command_1.Command {
+    async run() {
+        const { flags, args } = await this.parse(Download);
+        const { backup_id } = args;
+        const { app } = flags;
+        const output = flags.output || defaultFilename();
+        let num;
+        core_1.ux.action.start(`Getting backup from ${color_1.default.magenta(app)}`);
+        if (backup_id) {
+            num = await (0, backups_1.default)(app, this.heroku).num(backup_id);
+            if (!num)
+                throw new Error(`Invalid Backup: ${backup_id}`);
+        }
+        else {
+            const { body: transfers } = await this.heroku.get(`/client/v11/apps/${app}/transfers`, { hostname: (0, host_1.default)() });
+            const lastBackup = (0, lodash_1.sortBy)(transfers.filter(t => t.succeeded && t.to_type === 'gof3r'), 'created_at')
+                .pop();
+            if (!lastBackup)
+                throw new Error(`No backups on ${color_1.default.magenta(app)}. Capture one with ${color_1.default.cyan.bold('heroku pg:backups:capture')}`);
+            num = lastBackup.num;
+        }
+        core_1.ux.action.status = `fetching url of #${num}`;
+        const { body: info } = await this.heroku.post(`/client/v11/apps/${app}/transfers/${num}/actions/public-url`, { hostname: (0, host_1.default)() });
+        core_1.ux.action.stop(`done, #${num}`);
+        await (0, download_1.default)(info.url, output, { progress: true });
+    }
+}
+exports.default = Download;
+Download.topic = 'pg';
+Download.description = 'downloads database backup';
+Download.flags = {
+    output: command_1.flags.string({ char: 'o', description: 'location to download to. Defaults to latest.dump' }),
+    app: command_1.flags.app({ required: true }),
+    remote: command_1.flags.remote(),
+};
+Download.args = {
+    backup_id: core_1.Args.string(),
+};

package/lib/commands/pg/backups/index.d.ts

@@ -0,0 +1,20 @@
+import { Command } from '@heroku-cli/command';
+export default class Index extends Command {
+    static topic: string;
+    static description: string;
+    static strict: boolean;
+    static flags: {
+        verbose: import("@oclif/core/lib/interfaces").BooleanFlag<boolean>;
+        confirm: import("@oclif/core/lib/interfaces").OptionFlag<string | undefined, import("@oclif/core/lib/interfaces/parser").CustomOptions>;
+        output: import("@oclif/core/lib/interfaces").OptionFlag<string | undefined, import("@oclif/core/lib/interfaces/parser").CustomOptions>;
+        'wait-interval': import("@oclif/core/lib/interfaces").OptionFlag<string | undefined, import("@oclif/core/lib/interfaces/parser").CustomOptions>;
+        at: import("@oclif/core/lib/interfaces").OptionFlag<string | undefined, import("@oclif/core/lib/interfaces/parser").CustomOptions>;
+        quiet: 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>;
+    };
+    run(): Promise<void>;
+    private displayBackups;
+    private displayRestores;
+    private displayCopies;
+}

package/lib/commands/pg/backups/index.js

@@ -0,0 +1,129 @@
+"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 backups_1 = require("../../../lib/pg/backups");
+const host_1 = require("../../../lib/pg/host");
+class Index extends command_1.Command {
+    async run() {
+        const { flags: { app } } = await this.parse(Index);
+        const { body: transfers } = await this.heroku.get(`/client/v11/apps/${app}/transfers`, { hostname: (0, host_1.default)() });
+        // NOTE that the sort order is descending
+        transfers.sort((transferA, transferB) => {
+            if (transferA.created_at > transferB.created_at) {
+                return -1;
+            }
+            if (transferB.created_at > transferA.created_at) {
+                return 1;
+            }
+            return 0;
+        });
+        this.displayBackups(transfers, app);
+        this.displayRestores(transfers, app);
+        this.displayCopies(transfers, app);
+    }
+    displayBackups(transfers, app) {
+        const backups = transfers.filter(backupTransfer => backupTransfer.from_type === 'pg_dump' && backupTransfer.to_type === 'gof3r');
+        const { name, status, filesize } = (0, backups_1.default)(app, this.heroku);
+        core_1.ux.styledHeader('Backups');
+        if (backups.length === 0) {
+            core_1.ux.log(`No backups. Capture one with ${color_1.default.cyan.bold('heroku pg:backups:capture')}`);
+        }
+        else {
+            core_1.ux.table(backups, {
+                ID: {
+                    get: (transfer) => color_1.default.cyan(name(transfer)),
+                },
+                'Created at': {
+                    get: (transfer) => transfer.created_at,
+                },
+                Status: {
+                    get: (transfer) => status(transfer),
+                },
+                Size: {
+                    get: (transfer) => filesize(transfer.processed_bytes),
+                },
+                Database: {
+                    get: (transfer) => color_1.default.green(transfer.from_name) || 'UNKNOWN',
+                },
+            });
+        }
+        core_1.ux.log();
+    }
+    displayRestores(transfers, app) {
+        const restores = transfers
+            .filter(t => t.from_type !== 'pg_dump' && t.to_type === 'pg_restore')
+            .slice(0, 10); // first 10 only
+        const { name, status, filesize } = (0, backups_1.default)(app, this.heroku);
+        core_1.ux.styledHeader('Restores');
+        if (restores.length === 0) {
+            core_1.ux.log(`No restores found. Use ${color_1.default.cyan.bold('heroku pg:backups:restore')} to restore a backup`);
+        }
+        else {
+            core_1.ux.table(restores, {
+                ID: {
+                    get: (transfer) => color_1.default.cyan(name(transfer)),
+                },
+                'Started at': {
+                    get: (transfer) => transfer.created_at,
+                },
+                Status: {
+                    get: (transfer) => status(transfer),
+                },
+                Size: {
+                    get: (transfer) => filesize(transfer.processed_bytes),
+                },
+                Database: {
+                    get: (transfer) => color_1.default.green(transfer.to_name) || 'UNKNOWN',
+                },
+            });
+        }
+        core_1.ux.log();
+    }
+    displayCopies(transfers, app) {
+        const { name, status, filesize } = (0, backups_1.default)(app, this.heroku);
+        const copies = transfers.filter(t => t.from_type === 'pg_dump' && t.to_type === 'pg_restore').slice(0, 10);
+        core_1.ux.styledHeader('Copies');
+        if (copies.length === 0) {
+            core_1.ux.log(`No copies found. Use ${color_1.default.cyan.bold('heroku pg:copy')} to copy a database to another`);
+        }
+        else {
+            core_1.ux.table(copies, {
+                ID: {
+                    get: (transfer) => color_1.default.cyan(name(transfer)),
+                },
+                'Started at': {
+                    get: (transfer) => transfer.created_at,
+                },
+                Status: {
+                    get: (transfer) => status(transfer),
+                },
+                Size: {
+                    get: (transfer) => filesize(transfer.processed_bytes),
+                },
+                From: {
+                    get: (transfer) => color_1.default.green(transfer.from_name) || 'UNKNOWN',
+                },
+                To: {
+                    get: (transfer) => color_1.default.green(transfer.to_name) || 'UNKNOWN',
+                },
+            });
+        }
+        core_1.ux.log();
+    }
+}
+exports.default = Index;
+Index.topic = 'pg';
+Index.description = 'list database backups';
+Index.strict = false;
+Index.flags = {
+    verbose: command_1.flags.boolean({ char: 'v', hidden: true }),
+    confirm: command_1.flags.string({ char: 'c', hidden: true }),
+    output: command_1.flags.string({ char: 'o', hidden: true }),
+    'wait-interval': command_1.flags.string({ hidden: true }),
+    at: command_1.flags.string({ hidden: true }),
+    quiet: command_1.flags.boolean({ char: 'q', hidden: true }),
+    app: command_1.flags.app({ required: true }),
+    remote: command_1.flags.remote(),
+};

package/lib/commands/pg/backups/info.d.ts

@@ -0,0 +1,17 @@
+import { Command } from '@heroku-cli/command';
+import type { BackupTransfer } from '../../../lib/pg/types';
+export default class Info extends Command {
+    static topic: string;
+    static description: 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>;
+    };
+    static args: {
+        backup_id: import("@oclif/core/lib/interfaces/parser").Arg<string | undefined, Record<string, unknown>>;
+    };
+    getBackup: (id: string | undefined, app: string) => Promise<BackupTransfer>;
+    displayBackup: (backup: BackupTransfer, app: string) => void;
+    displayLogs: (backup: BackupTransfer) => void;
+    run(): Promise<void>;
+}

package/lib/commands/pg/backups/info.js

@@ -0,0 +1,92 @@
+"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 host_1 = require("../../../lib/pg/host");
+const backups_1 = require("../../../lib/pg/backups");
+const lodash_1 = require("lodash");
+function status(backup) {
+    if (backup.succeeded) {
+        if (backup.warnings > 0)
+            return `Finished with ${backup.warnings} warnings`;
+        return 'Completed';
+    }
+    if (backup.canceled_at)
+        return 'Canceled';
+    if (backup.finished_at)
+        return 'Failed';
+    if (backup.started_at)
+        return 'Running';
+    return 'Pending';
+}
+function compression(compressed, total) {
+    let pct = 0;
+    if (compressed > 0) {
+        pct = Math.round((total - compressed) / total * 100);
+        pct = Math.max(0, pct);
+    }
+    return ` (${pct}% compression)`;
+}
+class Info extends command_1.Command {
+    constructor() {
+        super(...arguments);
+        this.getBackup = async (id, app) => {
+            let backupID;
+            if (id) {
+                const { num } = (0, backups_1.default)(app, this.heroku);
+                backupID = await num(id);
+                if (!backupID)
+                    throw new Error(`Invalid ID: ${id}`);
+            }
+            else {
+                let { body: transfers } = await this.heroku.get(`/client/v11/apps/${app}/transfers`, { hostname: (0, host_1.default)() });
+                transfers = (0, lodash_1.sortBy)(transfers, 'created_at');
+                const backups = transfers.filter(t => t.from_type === 'pg_dump' && t.to_type === 'gof3r');
+                const lastBackup = backups.pop();
+                if (!lastBackup)
+                    throw new Error(`No backups. Capture one with ${color_1.default.cyan.bold('heroku pg:backups:capture')}`);
+                backupID = lastBackup.num;
+            }
+            const { body: backup } = await this.heroku.get(`/client/v11/apps/${app}/transfers/${backupID}?verbose=true`, { hostname: (0, host_1.default)() });
+            return backup;
+        };
+        this.displayBackup = (backup, app) => {
+            const { filesize, name } = (0, backups_1.default)(app, this.heroku);
+            core_1.ux.styledHeader(`Backup ${color_1.default.cyan(name(backup))}`);
+            core_1.ux.styledObject({
+                Database: color_1.default.green(backup.from_name),
+                'Started at': backup.started_at,
+                'Finished at': backup.finished_at,
+                Status: status(backup),
+                Type: backup.schedule ? 'Scheduled' : 'Manual', 'Original DB Size': filesize(backup.source_bytes),
+                'Backup Size': `${filesize(backup.processed_bytes)}${backup.finished_at ? compression(backup.processed_bytes, backup.source_bytes) : ''}`,
+            }, ['Database', 'Started at', 'Finished at', 'Status', 'Type', 'Original DB Size', 'Backup Size']);
+            core_1.ux.log();
+        };
+        this.displayLogs = (backup) => {
+            core_1.ux.styledHeader('Backup Logs');
+            for (const log of backup.logs)
+                core_1.ux.log(`${log.created_at} ${log.message}`);
+            core_1.ux.log();
+        };
+    }
+    async run() {
+        const { flags, args } = await this.parse(Info);
+        const { app } = flags;
+        const { backup_id } = args;
+        const backup = await this.getBackup(backup_id, app);
+        this.displayBackup(backup, app);
+        this.displayLogs(backup);
+    }
+}
+exports.default = Info;
+Info.topic = 'pg';
+Info.description = 'get information about a specific backup';
+Info.flags = {
+    app: command_1.flags.app({ required: true }),
+    remote: command_1.flags.remote(),
+};
+Info.args = {
+    backup_id: core_1.Args.string(),
+};

package/lib/commands/pg/backups/restore.d.ts

@@ -0,0 +1,19 @@
+import { Command } from '@heroku-cli/command';
+export default class Restore extends Command {
+    static topic: string;
+    static description: string;
+    static flags: {
+        'wait-interval': import("@oclif/core/lib/interfaces").OptionFlag<number, import("@oclif/core/lib/interfaces/parser").CustomOptions>;
+        extensions: import("@oclif/core/lib/interfaces").OptionFlag<string | undefined, import("@oclif/core/lib/interfaces/parser").CustomOptions>;
+        verbose: import("@oclif/core/lib/interfaces").BooleanFlag<boolean>;
+        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: {
+        backup: import("@oclif/core/lib/interfaces/parser").Arg<string | undefined, Record<string, unknown>>;
+        database: import("@oclif/core/lib/interfaces/parser").Arg<string | undefined, Record<string, unknown>>;
+    };
+    run(): Promise<void>;
+    protected getSortedExtensions(extensions: string | null | undefined): string[] | undefined;
+}

package/lib/commands/pg/backups/restore.js

@@ -0,0 +1,107 @@
+"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 confirmCommand_1 = require("../../../lib/confirmCommand");
+const backups_1 = require("../../../lib/pg/backups");
+const fetcher_1 = require("../../../lib/pg/fetcher");
+const host_1 = require("../../../lib/pg/host");
+function dropboxURL(url) {
+    if (url.match(/^https?:\/\/www\.dropbox\.com/) && !url.endsWith('dl=1')) {
+        if (url.endsWith('dl=0'))
+            url = url.replace('dl=0', 'dl=1');
+        else if (url.includes('?'))
+            url += '&dl=1';
+        else
+            url += '?dl=1';
+    }
+    return url;
+}
+class Restore extends command_1.Command {
+    async run() {
+        const { flags, args } = await this.parse(Restore);
+        const { app, 'wait-interval': waitInterval, extensions, confirm, verbose } = flags;
+        const interval = Math.max(3, waitInterval);
+        const { addon: db } = await (0, fetcher_1.getAttachment)(this.heroku, app, args.database);
+        const { name, wait } = (0, backups_1.default)(app, this.heroku);
+        let backupURL;
+        let backupName = args.backup;
+        if (backupName && backupName.match(/^https?:\/\//)) {
+            backupURL = dropboxURL(backupName);
+        }
+        else {
+            let backupApp;
+            if (backupName && backupName.match(/::/)) {
+                [backupApp, backupName] = backupName.split('::');
+            }
+            else {
+                backupApp = app;
+            }
+            const { body: transfers } = await this.heroku.get(`/client/v11/apps/${backupApp}/transfers`, { hostname: (0, host_1.default)() });
+            const backups = transfers.filter(t => t.from_type === 'pg_dump' && t.to_type === 'gof3r');
+            let backup;
+            if (backupName) {
+                backup = backups.find(b => name(b) === backupName);
+                if (!backup)
+                    throw new Error(`Backup ${color_1.default.cyan(backupName)} not found for ${color_1.default.app(backupApp)}`);
+                if (!backup.succeeded)
+                    throw new Error(`Backup ${color_1.default.cyan(backupName)} for ${color_1.default.app(backupApp)} did not complete successfully`);
+            }
+            else {
+                backup = backups.filter(b => b.succeeded).sort((a, b) => {
+                    if (a.finished_at < b.finished_at) {
+                        return -1;
+                    }
+                    if (a.finished_at > b.finished_at) {
+                        return 1;
+                    }
+                    return 0;
+                }).pop();
+                if (!backup) {
+                    throw new Error(`No backups for ${color_1.default.app(backupApp)}. Capture one with ${color_1.default.cyan.bold('heroku pg:backups:capture')}`);
+                }
+                backupName = name(backup);
+            }
+            backupURL = backup.to_url;
+        }
+        await (0, confirmCommand_1.default)(app, confirm);
+        core_1.ux.action.start(`Starting restore of ${color_1.default.cyan(backupName)} to ${color_1.default.yellow(db.name)}`);
+        core_1.ux.log((0, tsheredoc_1.default)(`
+
+    Use Ctrl-C at any time to stop monitoring progress; the backup will continue restoring.
+    Use ${color_1.default.cyan.bold('heroku pg:backups')} to check progress.
+    Stop a running restore with ${color_1.default.cyan.bold('heroku pg:backups:cancel')}.
+    `));
+        const { body: restore } = await this.heroku.post(`/client/v11/databases/${db.id}/restores`, {
+            body: { backup_url: backupURL, extensions: this.getSortedExtensions(extensions) }, hostname: (0, host_1.default)(),
+        });
+        core_1.ux.action.stop();
+        await wait('Restoring', restore.uuid, interval, verbose, db.app.id);
+    }
+    getSortedExtensions(extensions) {
+        return extensions === null || extensions === void 0 ? void 0 : extensions.split(',').map(ext => ext.trim().toLowerCase()).sort();
+    }
+}
+exports.default = Restore;
+Restore.topic = 'pg';
+Restore.description = 'restore a backup (default latest) to a database';
+Restore.flags = {
+    'wait-interval': command_1.flags.integer({ default: 3 }),
+    extensions: command_1.flags.string({
+        char: 'e',
+        description: (0, tsheredoc_1.default)(`
+      comma-separated list of extensions to pre-install in the public schema
+      defaults to saving the latest database to DATABASE_URL
+      `),
+    }),
+    verbose: command_1.flags.boolean({ char: 'v' }),
+    confirm: command_1.flags.string({ char: 'c' }),
+    app: command_1.flags.app({ required: true }),
+    remote: command_1.flags.remote(),
+};
+Restore.args = {
+    backup: core_1.Args.string(),
+    database: core_1.Args.string(),
+};

package/lib/commands/pg/backups/schedule.d.ts

@@ -0,0 +1,21 @@
+import { Command } from '@heroku-cli/command';
+declare type BackupSchedule = {
+    hour: string;
+    timezone: string;
+    schedule_name?: string;
+};
+export default class Schedule extends Command {
+    static topic: string;
+    static description: string;
+    static flags: {
+        at: import("@oclif/core/lib/interfaces").OptionFlag<string, 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>>;
+    };
+    parseDate: (at: string) => BackupSchedule;
+    run(): Promise<void>;
+}
+export {};