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

package/lib/commands/pg/diagnose.js

@@ -0,0 +1,106 @@
+import { Command, flags } from '@heroku-cli/command';
+import { Args, ux } from '@oclif/core';
+import { color, hux, utils } from '@heroku/heroku-cli-util';
+const capitalize = (str) => str.charAt(0).toUpperCase() + str.slice(1);
+import tsheredoc from 'tsheredoc';
+import { essentialPlan } from '../../lib/pg/util.js';
+import { uuidValidate } from '../../lib/utils/uuid-validate.js';
+const heredoc = tsheredoc.default;
+const PGDIAGNOSE_HOST = process.env.PGDIAGNOSE_URL || 'pgdiagnose.herokai.com';
+export default class Diagnose extends Command {
+    static topic = 'pg';
+    static description = heredoc(`
+    run or view diagnostics report
+    defaults to DATABASE_URL database if no DATABASE is specified
+    if REPORT_ID is specified instead, a previous report is displayed
+
+    `);
+    static flags = {
+        json: flags.boolean({ description: 'format output as JSON' }),
+        app: flags.app({ required: true }),
+        remote: flags.remote(),
+    };
+    static args = {
+        'DATABASE|REPORT_ID': Args.string({ description: 'config var exposed to the owning app containing the database URL or the report ID' }),
+    };
+    async run() {
+        const { flags, args } = await this.parse(Diagnose);
+        const id = args['DATABASE|REPORT_ID'];
+        let report;
+        if (id && uuidValidate(id)) {
+            ({ body: report } = await this.heroku.get(`/reports/${encodeURIComponent(id)}`, { hostname: PGDIAGNOSE_HOST }));
+        }
+        else {
+            report = await this.generateReport(id, flags.app);
+        }
+        this.displayReport(report, flags.json);
+    }
+    displayReport(report, json) {
+        if (json) {
+            hux.styledJSON(report);
+            return;
+        }
+        ux.stdout(`Report ${report.id} for ${report.app}::${report.database}\navailable for one month after creation on ${report.created_at}\n`);
+        this.display(report.checks.filter((c) => c.status === 'red'));
+        this.display(report.checks.filter((c) => c.status === 'yellow'));
+        this.display(report.checks.filter((c) => c.status === 'green'));
+        this.display(report.checks.filter((c) => !['green', 'red', 'yellow'].includes(c.status)));
+    }
+    display(checks) {
+        checks.forEach((check) => {
+            const colorFn = color[check.status] || ((txt) => txt);
+            ux.stdout(colorFn(`${check.status.toUpperCase()}: ${check.name}`));
+            const isNonEmptyArray = Array.isArray(check.results) && check.results.length > 0;
+            const resultsKeys = Object.keys(check.results ?? {});
+            if (check.status === 'green' || (!isNonEmptyArray && resultsKeys.length === 0)) {
+                return;
+            }
+            if (isNonEmptyArray) {
+                const keys = Object.keys(check.results[0]);
+                const cols = {};
+                keys.forEach((key) => {
+                    const keyStr = String(key);
+                    cols[capitalize(keyStr)] = {
+                        get: (row) => String(row[key]),
+                    };
+                });
+                hux.table(check.results, cols);
+            }
+            else {
+                const [key] = resultsKeys;
+                ux.stdout(`${key.split('_')
+                    .map(s => capitalize(s))
+                    .join(' ')} ${check.results[key]}`);
+            }
+        });
+    }
+    async generateParams(url, db, dbName) {
+        const base_params = {
+            url,
+            plan: db.plan.name.split(':')[1],
+            app: db.app.name,
+            database: dbName,
+        };
+        if (!essentialPlan(db)) {
+            const { body: metrics } = await this.heroku.get(`/client/v11/databases/${db.id}/metrics`, { hostname: utils.pg.host() });
+            base_params.metrics = metrics;
+            const { body: burstData } = await this.heroku.get(`/client/v11/databases/${db.id}/burst_status`, { hostname: utils.pg.host() });
+            if (burstData && Object.keys(burstData).length > 0) {
+                base_params.burst_data_present = true;
+                base_params.burst_status = burstData.burst_status;
+            }
+        }
+        return base_params;
+    }
+    async generateReport(database, app) {
+        const dbResolver = new utils.pg.DatabaseResolver(this.heroku);
+        const attachment = await dbResolver.getAttachment(app, database);
+        const { addon: db } = attachment;
+        const { body: config } = await this.heroku.get(`/apps/${app}/config-vars`);
+        const { url } = dbResolver.getConnectionDetails(attachment, config);
+        const dbName = utils.pg.psql.getConfigVarNameFromAttachment(attachment, config);
+        const body = await this.generateParams(url, db, dbName);
+        const { body: report } = await this.heroku.post('/reports', { hostname: PGDIAGNOSE_HOST, body });
+        return report;
+    }
+}

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

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

package/lib/commands/pg/info.js

@@ -0,0 +1,91 @@
+import { color, hux, utils } from '@heroku/heroku-cli-util';
+import { Command, flags } from '@heroku-cli/command';
+import { Args, ux } from '@oclif/core';
+import { configVarNamesFromValue, databaseNameFromUrl } from '../../lib/pg/util.js';
+import { nls } from '../../nls.js';
+function displayDB(db, app) {
+    if (db.addon.attachment_names) {
+        hux.styledHeader(db.addon.attachment_names.map((c) => color.attachment(c + '_URL'))
+            .join(', '));
+    }
+    else {
+        hux.styledHeader(db.configVars?.map(c => color.name(c))
+            .join(', ') || '');
+    }
+    if (db.addon.app.name && db.addon.app.name !== app) {
+        db.dbInfo?.info.push({ name: 'Billing App', values: [color.app(db.addon.app.name)] });
+    }
+    db.dbInfo?.info.push({ name: 'Add-on', values: [color.addon(db.addon.name)] });
+    const info = {};
+    db.dbInfo?.info.forEach(infoObject => {
+        if (infoObject.values.length > 0) {
+            let valuesArray;
+            if (infoObject.resolve_db_name) {
+                valuesArray = infoObject.values.map(v => databaseNameFromUrl(v, db.config));
+            }
+            else {
+                valuesArray = infoObject.values;
+            }
+            info[infoObject.name] = valuesArray.join(', ');
+        }
+    });
+    const keys = db.dbInfo?.info.map(i => i.name);
+    hux.styledObject(info, keys);
+    ux.stdout('');
+}
+export default class Info extends Command {
+    static topic = 'pg';
+    static description = 'show database information';
+    static flags = {
+        app: flags.app({ required: true }),
+        remote: flags.remote(),
+    };
+    static args = {
+        database: Args.string({ description: `${nls('pg:database:arg:description')} ${nls('pg:database:arg:description:all-dbs:suffix')}` }),
+    };
+    static aliases = ['pg'];
+    async run() {
+        const { flags, args } = await this.parse(Info);
+        const { app } = flags;
+        const lodash = await import('lodash');
+        const { sortBy } = lodash.default;
+        const { database: db } = args;
+        let addons;
+        const { body: config } = await this.heroku.get(`/apps/${app}/config-vars`);
+        if (db) {
+            const dbResolver = new utils.pg.DatabaseResolver(this.heroku);
+            const { addon } = await dbResolver.getAttachment(app, db);
+            addons = [addon];
+        }
+        else {
+            const dbResolver = new utils.pg.DatabaseResolver(this.heroku);
+            addons = await dbResolver.getAllLegacyDatabases(app);
+            if (addons.length === 0) {
+                ux.stdout(`${color.app(app)} has no heroku-postgresql databases.`);
+                return;
+            }
+        }
+        let dbs = await Promise.all(addons.map(async (addon) => {
+            const pgResponse = await this.heroku.get(`/client/v11/databases/${addon.id}`, {
+                hostname: utils.pg.host(),
+            })
+                .catch(error => {
+                if (error.statusCode !== 404)
+                    throw error;
+                ux.warn(`${color.datastore(addon.name)} is not yet provisioned.\nRun ${color.code('heroku addons:wait')} to wait until the db is provisioned.`);
+            });
+            const { body: dbInfo } = pgResponse || { body: null };
+            return {
+                addon,
+                config,
+                dbInfo,
+            };
+        }));
+        dbs = dbs.filter(db => db.dbInfo);
+        dbs.forEach(db => {
+            db.configVars = configVarNamesFromValue(db.config, db.dbInfo?.resource_url || '');
+        });
+        dbs = sortBy(dbs, (db) => db.configVars && db.configVars[0] !== 'DATABASE_URL', 'configVars[0]');
+        dbs.forEach(db => displayDB(db, app));
+    }
+}

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

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

package/lib/commands/pg/kill.js

@@ -0,0 +1,32 @@
+import { Command, flags } from '@heroku-cli/command';
+import { Args, ux } from '@oclif/core';
+import { utils } from '@heroku/heroku-cli-util';
+import tsheredoc from 'tsheredoc';
+import { nls } from '../../nls.js';
+const heredoc = tsheredoc.default;
+export default class Kill extends Command {
+    static topic = 'pg';
+    static description = 'kill a query';
+    static flags = {
+        force: flags.boolean({ char: 'f' }),
+        app: flags.app({ required: true }),
+        remote: flags.remote(),
+    };
+    static args = {
+        pid: Args.string({ required: true, description: 'ID of the process' }),
+        database: Args.string({ description: `${nls('pg:database:arg:description')} ${nls('pg:database:arg:description:default:suffix')}` }),
+    };
+    async run() {
+        const { flags, args } = await this.parse(Kill);
+        const { app, force } = flags;
+        const { pid, database } = args;
+        const dbResolver = new utils.pg.DatabaseResolver(this.heroku);
+        const db = await dbResolver.getDatabase(app, database);
+        const psqlService = new utils.pg.PsqlService(db);
+        const query = heredoc `
+      SELECT ${force ? 'pg_terminate_backend' : 'pg_cancel_backend'}(${Number.parseInt(pid, 10)});
+    `;
+        const output = await psqlService.execQuery(query);
+        ux.stdout(output);
+    }
+}

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

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

package/lib/commands/pg/killall.js

@@ -0,0 +1,24 @@
+import { Command, flags } from '@heroku-cli/command';
+import { Args, ux } from '@oclif/core';
+import { utils } from '@heroku/heroku-cli-util';
+import { nls } from '../../nls.js';
+export default class Killall extends Command {
+    static topic = 'pg';
+    static description = 'terminates all connections for all credentials';
+    static flags = {
+        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')}` }),
+    };
+    async run() {
+        const { flags, args } = await this.parse(Killall);
+        const { app } = flags;
+        ux.action.start('Terminating connections for all credentials');
+        const dbResolver = new utils.pg.DatabaseResolver(this.heroku);
+        const { addon } = await dbResolver.getAttachment(app, args.database);
+        await this.heroku.post(`/client/v11/databases/${addon.id}/connection_reset`, { hostname: utils.pg.host() });
+        ux.action.stop();
+    }
+}

package/lib/commands/pg/links/create.d.ts

@@ -0,0 +1,16 @@
+import { Command } from '@heroku-cli/command';
+export default class Create extends Command {
+    static args: {
+        remote: import("@oclif/core/interfaces").Arg<string, Record<string, unknown>>;
+        database: import("@oclif/core/interfaces").Arg<string, Record<string, unknown>>;
+    };
+    static description: string;
+    static example: string;
+    static flags: {
+        app: import("@oclif/core/interfaces").OptionFlag<string, import("@oclif/core/interfaces").CustomOptions>;
+        as: 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;
+    run(): Promise<void>;
+}

package/lib/commands/pg/links/create.js

@@ -0,0 +1,57 @@
+import { color, utils } from '@heroku/heroku-cli-util';
+import { Command, flags } from '@heroku-cli/command';
+import { Args, ux } from '@oclif/core';
+import { addonResolver } from '../../../lib/addons/resolve.js';
+import { essentialPlan } from '../../../lib/pg/util.js';
+import { nls } from '../../../nls.js';
+export default class Create extends Command {
+    /* eslint-disable perfectionist/sort-objects */
+    // the order of args is important for the command to work
+    // TODO: change database to be a flag
+    static args = {
+        remote: Args.string({ description: nls('pg:database:arg:description'), required: true }),
+        database: Args.string({ description: nls('pg:database:arg:description'), required: true }),
+    };
+    /* eslint-enable perfectionist/sort-objects */
+    static description = 'create a link between data stores';
+    static example = `${color.command('heroku pg:links:create HEROKU_REDIS_RED HEROKU_POSTGRESQL_CERULEAN')}`;
+    static flags = {
+        app: flags.app({ required: true }),
+        as: flags.string({ description: 'name of link to create' }),
+        remote: flags.remote(),
+    };
+    static topic = 'pg';
+    async run() {
+        const { args, flags } = await this.parse(Create);
+        const { app } = flags;
+        const service = async (remoteId) => {
+            const addon = await addonResolver(this.heroku, app, remoteId);
+            if (!addon.plan.name.match(/^heroku-(redis|postgresql)/))
+                throw new Error('Remote database must be heroku-redis or heroku-postgresql');
+            return addon;
+        };
+        const dbResolver = new utils.pg.DatabaseResolver(this.heroku);
+        const [{ addon: db }, target] = await Promise.all([
+            dbResolver.getAttachment(app, args.database),
+            service(args.remote),
+        ]);
+        if (essentialPlan(db))
+            throw new Error("pg:links isn't available for Essential-tier databases.");
+        if (essentialPlan(target))
+            throw new Error("pg:links isn't available for Essential-tier databases.");
+        ux.action.start(`Adding link from ${color.datastore(target.name)} to ${color.datastore(db.name)}`);
+        const { body: link } = await this.heroku.post(`/client/v11/databases/${db.id}/links`, {
+            body: {
+                as: flags.as,
+                target: target.name,
+            },
+            hostname: utils.pg.host(),
+        });
+        // This doesn't exist according to Shogun's link serializer. May it be that the original idea was to use to catch
+        // a Data API error and then show an re-throw the error here?
+        // if (link.message) {
+        //   throw new Error(link.message)
+        // }
+        ux.action.stop(`done, ${color.name(link.name)}`);
+    }
+}

package/lib/commands/pg/links/destroy.d.ts

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

package/lib/commands/pg/links/destroy.js

@@ -0,0 +1,40 @@
+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 ConfirmCommand from '../../../lib/confirmCommand.js';
+import { essentialPlan } from '../../../lib/pg/util.js';
+const heredoc = tsheredoc.default;
+import { nls } from '../../../nls.js';
+export default class Destroy extends Command {
+    static args = {
+        database: Args.string({ description: nls('pg:database:arg:description'), required: true }),
+        link: Args.string({ description: 'name of the linked data store', required: true }),
+    };
+    static description = 'destroys a link between data stores';
+    static example = `${color.command('heroku pg:links:destroy HEROKU_POSTGRESQL_CERULEAN redis-symmetrical-100')}`;
+    static flags = {
+        app: flags.app({ required: true }),
+        confirm: flags.string({ char: 'c' }),
+        remote: flags.remote(),
+    };
+    static topic = 'pg';
+    async run() {
+        const { args, flags } = await this.parse(Destroy);
+        const { app, confirm } = flags;
+        const { database, link } = args;
+        const dbResolver = new utils.pg.DatabaseResolver(this.heroku);
+        const { addon: db } = await dbResolver.getAttachment(app, database);
+        if (essentialPlan(db))
+            throw new Error("pg:links isn't available for Essential-tier databases.");
+        await new ConfirmCommand().confirm(app, confirm, heredoc(`
+      Destructive action
+      This command will affect the database ${color.yellow(db.name)}
+      This will delete ${color.cyan(link)} along with the tables and views created within it.
+      This may have adverse effects for software written against the ${color.cyan(link)} schema.
+    `));
+        ux.action.start(`Destroying link ${color.cyan(link)} from ${color.yellow(db.name)}`);
+        await this.heroku.delete(`/client/v11/databases/${db.id}/links/${encodeURIComponent(link)}`, { hostname: utils.pg.host() });
+        ux.action.stop();
+    }
+}

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

@@ -0,0 +1,13 @@
+import { Command } from '@heroku-cli/command';
+export default class Index extends Command {
+    static args: {
+        database: import("@oclif/core/interfaces").Arg<string | undefined, Record<string, unknown>>;
+    };
+    static description: 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/links/index.js

@@ -0,0 +1,62 @@
+import { color, hux, 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 Index extends Command {
+    static args = {
+        database: Args.string({ description: `${nls('pg:database:arg:description')} ${nls('pg:database:arg:description:default:suffix')}` }),
+    };
+    static description = 'lists all databases and information on link';
+    static flags = {
+        app: flags.app({ required: true }),
+        remote: flags.remote(),
+    };
+    static topic = 'pg';
+    async run() {
+        const { args, flags } = await this.parse(Index);
+        const { app } = flags;
+        const { database } = args;
+        let dbs;
+        if (database) {
+            const dbResolver = new utils.pg.DatabaseResolver(this.heroku);
+            const { addon } = await dbResolver.getAttachment(app, database);
+            dbs = [addon];
+        }
+        else {
+            const dbResolver = new utils.pg.DatabaseResolver(this.heroku);
+            dbs = await dbResolver.getAllLegacyDatabases(app);
+        }
+        if (dbs.length === 0)
+            throw new Error(`No databases on ${color.app(app)}`);
+        dbs = await Promise.all(dbs.map(async (db) => {
+            const { body: links } = await this.heroku.get(`/client/v11/databases/${db.id}/links`, { hostname: utils.pg.host() });
+            db.links = links;
+            return db;
+        }));
+        let once;
+        dbs.forEach(db => {
+            if (once)
+                this.log();
+            else
+                once = true;
+            hux.styledHeader(color.datastore(db.name));
+            // This doesn't exist according to Shogun's link serializer. May it be that the original idea was to use Promise.allSettled
+            // and capture here and show only the error message if an error was returned for some database? Currently a CLI error is
+            // thrown instead, because Promise.all will reject if any of the promises reject and there's no catch block for that.
+            // if (db.links?.message)
+            //   return this.log(db.links.message)
+            if (db.links?.length === 0)
+                return this.log('No data sources are linked into this database');
+            db.links?.forEach((link) => {
+                this.log(` * ${color.name(link.name)}`);
+                const remoteAttachmentName = link.remote?.attachment_name || '';
+                const remoteName = link.remote?.name || '';
+                const remoteLinkText = `${color.name(remoteAttachmentName)} (${color.datastore(remoteName)})`;
+                hux.styledObject({
+                    created_at: link.created_at,
+                    remote: remoteLinkText,
+                });
+            });
+        });
+    }
+}

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

@@ -0,0 +1,15 @@
+import { Command } from '@heroku-cli/command';
+export default class Locks extends Command {
+    static topic: string;
+    static description: string;
+    static flags: {
+        truncate: 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 | undefined, Record<string, unknown>>;
+    };
+    run(): Promise<void>;
+    protected truncatedQueryString(truncate: boolean): string;
+}

package/lib/commands/pg/locks.js

@@ -0,0 +1,53 @@
+import { Command, flags } from '@heroku-cli/command';
+import { Args, ux } from '@oclif/core';
+import { utils } from '@heroku/heroku-cli-util';
+import tsheredoc from 'tsheredoc';
+import { nls } from '../../nls.js';
+const heredoc = tsheredoc.default;
+export default class Locks extends Command {
+    static topic = 'pg';
+    static description = 'display queries with active locks';
+    static flags = {
+        truncate: flags.boolean({ char: 't', description: 'truncates queries to 40 characters' }),
+        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')}` }),
+    };
+    async run() {
+        const { flags, args } = await this.parse(Locks);
+        const { app, truncate } = flags;
+        const dbResolver = new utils.pg.DatabaseResolver(this.heroku);
+        const db = await dbResolver.getDatabase(app, args.database);
+        const psqlService = new utils.pg.PsqlService(db);
+        const query = heredoc `
+      SELECT
+        pg_stat_activity.pid,
+        pg_class.relname,
+        pg_locks.transactionid,
+        pg_locks.granted,
+        ${this.truncatedQueryString(truncate)} AS query_snippet,
+        age(now(), pg_stat_activity.query_start) AS "age"
+      FROM
+        pg_stat_activity,
+        pg_locks
+          LEFT OUTER JOIN pg_class
+          ON pg_locks.relation = pg_class.oid
+      WHERE
+        pg_stat_activity.query <> '<insufficient privilege>'
+        AND pg_locks.pid = pg_stat_activity.pid
+        AND pg_locks.mode = 'ExclusiveLock'
+        AND pg_stat_activity.pid <> pg_backend_pid() order by query_start;
+    `;
+        const output = await psqlService.execQuery(query);
+        ux.stdout(output);
+    }
+    truncatedQueryString(truncate) {
+        const column = 'pg_stat_activity.query';
+        if (truncate) {
+            return `CASE WHEN length(${column}) <= 40 THEN ${column} ELSE substr(${column}, 0, 39) || '…' END`;
+        }
+        return column;
+    }
+}

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

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

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

@@ -0,0 +1,27 @@
+import { Command, flags } from '@heroku-cli/command';
+import { Args, ux } from '@oclif/core';
+import { utils } from '@heroku/heroku-cli-util';
+import { essentialPlan } from '../../../lib/pg/util.js';
+import { nls } from '../../../nls.js';
+export default class Index extends Command {
+    static topic = 'pg';
+    static description = 'show current maintenance information';
+    static flags = {
+        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')}` }),
+    };
+    async run() {
+        const { flags, args } = await this.parse(Index);
+        const { app } = 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.');
+        const { body: info } = await this.heroku.get(`/client/v11/databases/${db.id}/maintenance`, { hostname: utils.pg.host() });
+        this.log(info.message);
+    }
+}

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

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