heroku 11.6.0 → 11.7.0

package/CHANGELOG.md

@@ -4,6 +4,18 @@ All notable changes to this project will be documented in this file.
 See [Conventional Commits](https://conventionalcommits.org) for commit guidelines.
 
 
+## [11.7.0](https://github.com/heroku/cli/compare/v11.6.0...v11.7.0) (2026-06-23)
+
+
+### Features
+
+* migrate extra pg commands from pg-extras plugin to cli ([#3782](https://github.com/heroku/cli/issues/3782)) ([38a4604](https://github.com/heroku/cli/commit/38a4604e46a3385578a223cd88c6d7c784119e53))
+
+
+### Bug Fixes
+
+* revert whoami status code fix ([#3785](https://github.com/heroku/cli/issues/3785)) ([1706012](https://github.com/heroku/cli/commit/1706012f6e37253677efffff35d866c8097648c2))
+
 ## [11.6.0](https://github.com/heroku/cli/compare/v11.5.0...v11.6.0) (2026-06-17)
 
 

package/dist/commands/auth/whoami.js

@@ -17,7 +17,7 @@ export default class AuthWhoami extends Command {
             this.log(account.email);
         }
         catch (error) {
-            if (error.http.statusCode === 401)
+            if (error.statusCode === 401)
                 this.notloggedin();
             throw error;
         }

package/dist/commands/pg/cache-hit.d.ts

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

package/dist/commands/pg/cache-hit.js

@@ -0,0 +1,40 @@
+import { Command, flags } from '@heroku-cli/command';
+import { color, utils } from '@heroku/heroku-cli-util';
+import { Args, ux } from '@oclif/core';
+import tsheredoc from 'tsheredoc';
+import { nls } from '../../nls.js';
+const heredoc = tsheredoc.default;
+export const generateCacheHitQuery = () => `
+SELECT
+  'index hit rate' AS name,
+  (sum(idx_blks_hit)) / nullif(sum(idx_blks_hit + idx_blks_read),0) AS ratio
+FROM pg_statio_user_indexes
+UNION ALL
+SELECT
+ 'table hit rate' AS name,
+  sum(heap_blks_hit) / nullif(sum(heap_blks_hit) + sum(heap_blks_read),0) AS ratio
+FROM pg_statio_user_tables;
+`.trim();
+export default class PgCacheHit extends Command {
+    static args = {
+        database: Args.string({ description: `${nls('pg:database:arg:description')} ${nls('pg:database:arg:description:default:suffix')}`, required: false }),
+    };
+    static description = 'show index and table hit rate';
+    static examples = [heredoc `
+    ${color.command('heroku pg:cache-hit --app example-app')}
+  `];
+    static flags = {
+        app: flags.app({ required: true }),
+        remote: flags.remote(),
+    };
+    static hiddenAliases = ['pg:cache_hit'];
+    static topic = 'pg';
+    async run() {
+        const { args, flags } = await this.parse(PgCacheHit);
+        const dbResolver = new utils.pg.DatabaseResolver(this.heroku);
+        const db = await dbResolver.getDatabase(flags.app, args.database);
+        const psqlService = new utils.pg.PsqlService(db);
+        const output = await psqlService.execQuery(generateCacheHitQuery());
+        ux.stdout(output);
+    }
+}

package/dist/commands/pg/calls.d.ts

@@ -0,0 +1,19 @@
+import { Command } from '@heroku-cli/command';
+import { pg } from '@heroku/heroku-cli-util';
+export declare function generateCallsQuery(db: pg.ConnectionDetails, flags: {
+    truncate?: boolean;
+}): Promise<string>;
+export default class PgCalls extends Command {
+    static args: {
+        database: import("@oclif/core/interfaces").Arg<string | undefined, Record<string, unknown>>;
+    };
+    static description: string;
+    static examples: 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>;
+        truncate: import("@oclif/core/interfaces").BooleanFlag<boolean>;
+    };
+    static topic: string;
+    run(): Promise<void>;
+}

package/dist/commands/pg/calls.js

@@ -0,0 +1,55 @@
+import { Command, flags } from '@heroku-cli/command';
+import { color, utils } from '@heroku/heroku-cli-util';
+import { Args, ux } from '@oclif/core';
+import tsheredoc from 'tsheredoc';
+import { ensurePGStatStatement, newBlkTimeFields, newTotalExecTimeField } from '../../lib/pg/extras.js';
+import { nls } from '../../nls.js';
+const heredoc = tsheredoc.default;
+export async function generateCallsQuery(db, flags) {
+    await ensurePGStatStatement(db);
+    const truncatedQueryString = flags.truncate
+        ? 'CASE WHEN length(query) <= 40 THEN query ELSE substr(query, 0, 39) || \'…\' END'
+        : 'query';
+    const newTotalExecTime = await newTotalExecTimeField(db);
+    const totalExecTimeField = newTotalExecTime ? 'total_exec_time' : 'total_time';
+    const newBlkTime = await newBlkTimeFields(db);
+    const blkReadField = newBlkTime ? 'shared_blk_read_time' : 'blk_read_time';
+    const blkWriteField = newBlkTime ? 'shared_blk_write_time' : 'blk_write_time';
+    return `
+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' * (${blkReadField} + ${blkWriteField}) 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 calls DESC
+LIMIT 10
+`.trim();
+}
+export default class PgCalls extends Command {
+    static args = {
+        database: Args.string({ description: `${nls('pg:database:arg:description')} ${nls('pg:database:arg:description:default:suffix')}`, required: false }),
+    };
+    static description = 'show 10 queries that have highest frequency of execution';
+    static examples = [heredoc `
+    ${color.command('heroku pg:calls --app example-app')}
+  `, heredoc `
+    # truncate queries to 40 characters
+    ${color.command('heroku pg:calls --truncate --app example-app')}
+  `];
+    static flags = {
+        app: flags.app({ required: true }),
+        remote: flags.remote(),
+        truncate: flags.boolean({ char: 't', description: 'truncate queries to 40 characters' }),
+    };
+    static topic = 'pg';
+    async run() {
+        const { args, flags } = await this.parse(PgCalls);
+        const dbResolver = new utils.pg.DatabaseResolver(this.heroku);
+        const db = await dbResolver.getDatabase(flags.app, args.database);
+        const psqlService = new utils.pg.PsqlService(db);
+        const query = await generateCallsQuery(db, flags);
+        const output = await psqlService.execQuery(query);
+        ux.stdout(output);
+    }
+}

package/dist/commands/pg/extensions.d.ts

@@ -0,0 +1,16 @@
+import { Command } from '@heroku-cli/command';
+import { pg } from '@heroku/heroku-cli-util';
+export declare function generateExtensionsQuery(db: pg.ConnectionDetails): string;
+export default class PgExtensions extends Command {
+    static args: {
+        database: import("@oclif/core/interfaces").Arg<string | undefined, Record<string, unknown>>;
+    };
+    static description: string;
+    static examples: 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/dist/commands/pg/extensions.js

@@ -0,0 +1,39 @@
+import { Command, flags } from '@heroku-cli/command';
+import { color, utils } from '@heroku/heroku-cli-util';
+import { Args, ux } from '@oclif/core';
+import tsheredoc from 'tsheredoc';
+import { essentialNumPlan } from '../../lib/pg/extras.js';
+import { nls } from '../../nls.js';
+const heredoc = tsheredoc.default;
+export function generateExtensionsQuery(db) {
+    return essentialNumPlan(db.attachment.addon)
+        ? `SELECT *
+                     FROM pg_available_extensions
+                     WHERE name IN (SELECT unnest(string_to_array(current_setting('rds.allowed_extensions'), ',')))`
+        : `SELECT *
+                     FROM pg_available_extensions
+                     WHERE name IN (SELECT unnest(string_to_array(current_setting('extwlist.extensions'), ',')))`;
+}
+export default class PgExtensions extends Command {
+    static args = {
+        database: Args.string({ description: `${nls('pg:database:arg:description')} ${nls('pg:database:arg:description:default:suffix')}`, required: false }),
+    };
+    static description = 'list available and installed extensions';
+    static examples = [heredoc `
+    ${color.command('heroku pg:extensions --app example-app')}
+  `];
+    static flags = {
+        app: flags.app({ required: true }),
+        remote: flags.remote(),
+    };
+    static topic = 'pg';
+    async run() {
+        const { args, flags } = await this.parse(PgExtensions);
+        const dbResolver = new utils.pg.DatabaseResolver(this.heroku);
+        const db = await dbResolver.getDatabase(flags.app, args.database);
+        const psqlService = new utils.pg.PsqlService(db);
+        const query = generateExtensionsQuery(db);
+        const output = await psqlService.execQuery(query);
+        ux.stdout(output);
+    }
+}

package/dist/commands/pg/fdwsql.d.ts

@@ -0,0 +1,16 @@
+import { Command } from '@heroku-cli/command';
+export declare const generateFdwsqlQuery: (prefix: string) => string;
+export default class PgFdwsql extends Command {
+    static args: {
+        prefix: import("@oclif/core/interfaces").Arg<string, Record<string, unknown>>;
+        database: import("@oclif/core/interfaces").Arg<string | undefined, Record<string, unknown>>;
+    };
+    static description: string;
+    static examples: 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/dist/commands/pg/fdwsql.js

@@ -0,0 +1,70 @@
+import { Command, flags } from '@heroku-cli/command';
+import { color, utils } from '@heroku/heroku-cli-util';
+import { Args, ux } from '@oclif/core';
+import tsheredoc from 'tsheredoc';
+import { ensureEssentialTierPlan } from '../../lib/pg/extras.js';
+import { nls } from '../../nls.js';
+const heredoc = tsheredoc.default;
+export const generateFdwsqlQuery = (prefix) => `
+SELECT
+  'CREATE FOREIGN TABLE '
+  || quote_ident('${prefix}_' || c.relname)
+  || '(' || array_to_string(array_agg(quote_ident(a.attname) || ' ' || t.typname), ', ') || ') '
+  || ' SERVER ${prefix}_db OPTIONS'
+  || ' (schema_name ''' || quote_ident(n.nspname) || ''', table_name ''' || quote_ident(c.relname) || ''');'
+FROM
+  pg_class     c,
+  pg_attribute a,
+  pg_type      t,
+  pg_namespace n
+WHERE
+  a.attnum > 0
+  AND a.attrelid = c.oid
+  AND a.atttypid = t.oid
+  AND n.oid = c.relnamespace
+  AND c.relkind in ('r', 'v')
+  AND n.nspname <> 'pg_catalog'
+  AND n.nspname <> 'information_schema'
+  AND n.nspname !~ '^pg_toast'
+  AND pg_catalog.pg_table_is_visible(c.oid)
+GROUP BY c.relname, n.nspname
+ORDER BY c.relname;
+`.trim();
+export default class PgFdwsql extends Command {
+    /* eslint-disable perfectionist/sort-objects */
+    static args = {
+        prefix: Args.string({ description: 'prefix for foreign data wrapper', required: true }),
+        database: Args.string({ description: `${nls('pg:database:arg:description')} ${nls('pg:database:arg:description:default:suffix')}`, required: false }),
+    };
+    /* eslint-enable perfectionist/sort-objects */
+    static description = 'generate fdw install sql for database';
+    static examples = [heredoc `
+    ${color.command('heroku pg:fdwsql example_prefix --app example-app')}
+  `];
+    static flags = {
+        app: flags.app({ required: true }),
+        remote: flags.remote(),
+    };
+    static topic = 'pg';
+    async run() {
+        const { args, flags } = await this.parse(PgFdwsql);
+        if (!/^[A-Za-z_][A-Za-z0-9_]*$/.test(args.prefix)) {
+            ux.error('prefix must start with a letter or underscore and contain only letters, numbers, and underscores', { exit: 1 });
+        }
+        const dbResolver = new utils.pg.DatabaseResolver(this.heroku);
+        const db = await dbResolver.getDatabase(flags.app, args.database);
+        await ensureEssentialTierPlan(db);
+        const psqlService = new utils.pg.PsqlService(db);
+        ux.stdout('CREATE EXTENSION IF NOT EXISTS postgres_fdw;');
+        ux.stdout(`DROP SERVER IF EXISTS ${args.prefix}_db;`);
+        ux.stdout(`CREATE SERVER ${args.prefix}_db
+  FOREIGN DATA WRAPPER postgres_fdw
+  OPTIONS (dbname '${db.database}', host '${db.host}');`);
+        ux.stdout(`CREATE USER MAPPING FOR CURRENT_USER
+  SERVER ${args.prefix}_db
+  OPTIONS (user '${db.user}', password '${db.password}');`);
+        let output = await psqlService.execQuery(generateFdwsqlQuery(args.prefix));
+        output = output.split('\n').filter((l) => /CREATE/.test(l)).join('\n');
+        ux.stdout(output);
+    }
+}

package/dist/commands/pg/index-size.d.ts

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

package/dist/commands/pg/index-size.js

@@ -0,0 +1,40 @@
+import { Command, flags } from '@heroku-cli/command';
+import { color, utils } from '@heroku/heroku-cli-util';
+import { Args, ux } from '@oclif/core';
+import tsheredoc from 'tsheredoc';
+import { nls } from '../../nls.js';
+const heredoc = tsheredoc.default;
+export const generateIndexSizeQuery = () => `
+SELECT c.relname AS name,
+  pg_size_pretty(sum(c.relpages::bigint*8192)::bigint) AS size
+FROM pg_class c
+LEFT JOIN pg_namespace n ON (n.oid = c.relnamespace)
+WHERE n.nspname NOT IN ('pg_catalog', 'information_schema')
+AND n.nspname !~ '^pg_toast'
+AND c.relkind='i'
+GROUP BY c.relname
+ORDER BY sum(c.relpages) DESC;
+`.trim();
+export default class PgIndexSize extends Command {
+    static args = {
+        database: Args.string({ description: `${nls('pg:database:arg:description')} ${nls('pg:database:arg:description:default:suffix')}`, required: false }),
+    };
+    static description = 'show the size of indexes, descending by size';
+    static examples = [heredoc `
+    ${color.command('heroku pg:index-size --app example-app')}
+  `];
+    static flags = {
+        app: flags.app({ required: true }),
+        remote: flags.remote(),
+    };
+    static hiddenAliases = ['pg:index_size'];
+    static topic = 'pg';
+    async run() {
+        const { args, flags } = await this.parse(PgIndexSize);
+        const dbResolver = new utils.pg.DatabaseResolver(this.heroku);
+        const db = await dbResolver.getDatabase(flags.app, args.database);
+        const psqlService = new utils.pg.PsqlService(db);
+        const output = await psqlService.execQuery(generateIndexSizeQuery());
+        ux.stdout(output);
+    }
+}

package/dist/commands/pg/index-usage.d.ts

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

package/dist/commands/pg/index-usage.js

@@ -0,0 +1,41 @@
+import { Command, flags } from '@heroku-cli/command';
+import { color, utils } from '@heroku/heroku-cli-util';
+import { Args, ux } from '@oclif/core';
+import tsheredoc from 'tsheredoc';
+import { nls } from '../../nls.js';
+const heredoc = tsheredoc.default;
+export const generateIndexUsageQuery = () => `
+SELECT relname,
+   CASE idx_scan
+     WHEN 0 THEN 'Insufficient data'
+     ELSE (100 * idx_scan / (seq_scan + idx_scan))::text
+   END percent_of_times_index_used,
+   n_live_tup rows_in_table
+ FROM
+   pg_stat_user_tables
+ ORDER BY
+   n_live_tup DESC;
+`.trim();
+export default class PgIndexUsage extends Command {
+    static args = {
+        database: Args.string({ description: `${nls('pg:database:arg:description')} ${nls('pg:database:arg:description:default:suffix')}`, required: false }),
+    };
+    static description = 'calculates your index hit rate (effective databases are at 99% and up)';
+    static examples = [heredoc `
+    ${color.command('heroku pg:index-usage --app example-app')}
+  `];
+    static flags = {
+        app: flags.app({ required: true }),
+        remote: flags.remote(),
+    };
+    static hiddenAliases = ['pg:index_usage'];
+    static topic = 'pg';
+    async run() {
+        const { args, flags } = await this.parse(PgIndexUsage);
+        const dbResolver = new utils.pg.DatabaseResolver(this.heroku);
+        const db = await dbResolver.getDatabase(flags.app, args.database);
+        const psqlService = new utils.pg.PsqlService(db);
+        const output = await psqlService.execQuery(generateIndexUsageQuery());
+        ux.stdout(output);
+    }
+}

package/dist/commands/pg/long-running-queries.d.ts

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

package/dist/commands/pg/long-running-queries.js

@@ -0,0 +1,43 @@
+import { Command, flags } from '@heroku-cli/command';
+import { color, utils } from '@heroku/heroku-cli-util';
+import { Args, ux } from '@oclif/core';
+import tsheredoc from 'tsheredoc';
+import { nls } from '../../nls.js';
+const heredoc = tsheredoc.default;
+export const generateLongRunningQueriesQuery = () => `
+SELECT
+  pid,
+  now() - pg_stat_activity.query_start AS duration,
+  query AS query
+FROM
+  pg_stat_activity
+WHERE
+  pg_stat_activity.query <> ''::text
+  AND state <> 'idle'
+  AND now() - pg_stat_activity.query_start > interval '5 minutes'
+ORDER BY
+  now() - pg_stat_activity.query_start DESC;
+`.trim();
+export default class PgLongRunningQueries extends Command {
+    static args = {
+        database: Args.string({ description: `${nls('pg:database:arg:description')} ${nls('pg:database:arg:description:default:suffix')}`, required: false }),
+    };
+    static description = 'show all queries longer than five minutes by descending duration';
+    static examples = [heredoc `
+    ${color.command('heroku pg:long-running-queries --app example-app')}
+  `];
+    static flags = {
+        app: flags.app({ required: true }),
+        remote: flags.remote(),
+    };
+    static hiddenAliases = ['pg:long_running_queries'];
+    static topic = 'pg';
+    async run() {
+        const { args, flags } = await this.parse(PgLongRunningQueries);
+        const dbResolver = new utils.pg.DatabaseResolver(this.heroku);
+        const db = await dbResolver.getDatabase(flags.app, args.database);
+        const psqlService = new utils.pg.PsqlService(db);
+        const output = await psqlService.execQuery(generateLongRunningQueriesQuery());
+        ux.stdout(output);
+    }
+}

package/dist/commands/pg/mandelbrot.d.ts

@@ -0,0 +1,15 @@
+import { Command } from '@heroku-cli/command';
+export declare const generateMandelbrotQuery: () => string;
+export default class PgMandelbrot extends Command {
+    static args: {
+        database: import("@oclif/core/interfaces").Arg<string | undefined, Record<string, unknown>>;
+    };
+    static description: string;
+    static examples: 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/dist/commands/pg/mandelbrot.js

@@ -0,0 +1,49 @@
+import { Command, flags } from '@heroku-cli/command';
+import { color, utils } from '@heroku/heroku-cli-util';
+import { Args, ux } from '@oclif/core';
+import tsheredoc from 'tsheredoc';
+import { nls } from '../../nls.js';
+const heredoc = tsheredoc.default;
+export const generateMandelbrotQuery = () => `
+  WITH RECURSIVE Z(IX, IY, CX, CY, X, Y, I) AS (
+            SELECT IX, IY, X::float, Y::float, X::float, Y::float, 0
+            FROM (select -2.2 + 0.031 * i, i from generate_series(0,101) as i) as xgen(x,ix),
+                 (select -1.5 + 0.031 * i, i from generate_series(0,101) as i) as ygen(y,iy)
+            UNION ALL
+            SELECT IX, IY, CX, CY, X * X - Y * Y + CX AS X, Y * X * 2 + CY, I + 1
+            FROM Z
+            WHERE X * X + Y * Y < 16::float
+            AND I < 100
+      )
+SELECT array_to_string(array_agg(SUBSTRING(' .,,,-----++++%%%%@@@@#### ', LEAST(GREATEST(I,1),27), 1)),'')
+FROM (
+      SELECT IX, IY, MAX(I) AS I
+      FROM Z
+      GROUP BY IY, IX
+      ORDER BY IY, IX
+     ) AS ZT
+GROUP BY IY
+ORDER BY IY
+  `.trim();
+export default class PgMandelbrot extends Command {
+    static args = {
+        database: Args.string({ description: `${nls('pg:database:arg:description')} ${nls('pg:database:arg:description:default:suffix')}`, required: false }),
+    };
+    static description = 'show the mandelbrot set';
+    static examples = [heredoc `
+    ${color.command('heroku pg:mandelbrot --app example-app')}
+  `];
+    static flags = {
+        app: flags.app({ required: true }),
+        remote: flags.remote(),
+    };
+    static topic = 'pg';
+    async run() {
+        const { args, flags } = await this.parse(PgMandelbrot);
+        const dbResolver = new utils.pg.DatabaseResolver(this.heroku);
+        const db = await dbResolver.getDatabase(flags.app, args.database);
+        const psqlService = new utils.pg.PsqlService(db);
+        const output = await psqlService.execQuery(generateMandelbrotQuery());
+        ux.stdout(output);
+    }
+}

package/dist/commands/pg/records-rank.d.ts

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

package/dist/commands/pg/records-rank.js

@@ -0,0 +1,38 @@
+import { Command, flags } from '@heroku-cli/command';
+import { color, utils } from '@heroku/heroku-cli-util';
+import { Args, ux } from '@oclif/core';
+import tsheredoc from 'tsheredoc';
+import { nls } from '../../nls.js';
+const heredoc = tsheredoc.default;
+export const generateRecordsRankQuery = () => `
+SELECT
+  relname AS name,
+  n_live_tup AS estimated_count
+FROM
+  pg_stat_user_tables
+ORDER BY
+  n_live_tup DESC;
+`.trim();
+export default class PgRecordsRank extends Command {
+    static args = {
+        database: Args.string({ description: `${nls('pg:database:arg:description')} ${nls('pg:database:arg:description:default:suffix')}`, required: false }),
+    };
+    static description = 'show all tables and the number of rows in each ordered by number of rows descending';
+    static examples = [heredoc `
+    ${color.command('heroku pg:records-rank --app example-app')}
+  `];
+    static flags = {
+        app: flags.app({ required: true }),
+        remote: flags.remote(),
+    };
+    static hiddenAliases = ['pg:records_rank'];
+    static topic = 'pg';
+    async run() {
+        const { args, flags } = await this.parse(PgRecordsRank);
+        const dbResolver = new utils.pg.DatabaseResolver(this.heroku);
+        const db = await dbResolver.getDatabase(flags.app, args.database);
+        const psqlService = new utils.pg.PsqlService(db);
+        const output = await psqlService.execQuery(generateRecordsRankQuery());
+        ux.stdout(output);
+    }
+}

package/dist/commands/pg/seq-scans.d.ts

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