heroku 11.6.0 → 11.7.0

package/dist/commands/pg/seq-scans.js

@@ -0,0 +1,36 @@
+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 generateSeqScansQuery = () => `
+SELECT relname AS name,
+       seq_scan as count
+FROM
+  pg_stat_user_tables
+ORDER BY seq_scan DESC;
+`.trim();
+export default class PgSeqScans 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 count of sequential scans by table descending by order';
+    static examples = [heredoc `
+    ${color.command('heroku pg:seq-scans --app example-app')}
+  `];
+    static flags = {
+        app: flags.app({ required: true }),
+        remote: flags.remote(),
+    };
+    static hiddenAliases = ['pg:seq_scans'];
+    static topic = 'pg';
+    async run() {
+        const { args, flags } = await this.parse(PgSeqScans);
+        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(generateSeqScansQuery());
+        ux.stdout(output);
+    }
+}

package/dist/commands/pg/stats-reset.d.ts

@@ -0,0 +1,15 @@
+import { Command } from '@heroku-cli/command';
+export default class PgStatsReset 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/stats-reset.js

@@ -0,0 +1,34 @@
+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 default class PgStatsReset extends Command {
+    static args = {
+        database: Args.string({ description: `${nls('pg:database:arg:description')} ${nls('pg:database:arg:description:default:suffix')}`, required: false }),
+    };
+    static description = 'calls the Postgres functions pg_stat_reset()';
+    static examples = [heredoc `
+    ${color.command('heroku pg:stats-reset --app example-app')}
+  `];
+    static flags = {
+        app: flags.app({ required: true }),
+        remote: flags.remote(),
+    };
+    static hiddenAliases = ['pg:stats_reset'];
+    static topic = 'pg';
+    async run() {
+        const { args, flags } = await this.parse(PgStatsReset);
+        const { app } = flags;
+        const dbResolver = new utils.pg.DatabaseResolver(this.heroku);
+        const db = await dbResolver.getDatabase(app, args.database);
+        await ensureEssentialTierPlan(db);
+        const { addon } = await dbResolver.getAttachment(app, args.database);
+        const { body } = await this.heroku.put(`/client/v11/databases/${addon.id}/stats_reset`, {
+            hostname: utils.pg.host(),
+        });
+        ux.stdout(body.message);
+    }
+}

package/dist/commands/pg/table-indexes-size.d.ts

@@ -0,0 +1,16 @@
+import { Command } from '@heroku-cli/command';
+export declare const generateTableIndexesSizeQuery: () => string;
+export default class PgTableIndexesSize 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/table-indexes-size.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 { nls } from '../../nls.js';
+const heredoc = tsheredoc.default;
+export const generateTableIndexesSizeQuery = () => `
+SELECT c.relname AS table,
+  pg_size_pretty(pg_indexes_size(c.oid)) AS index_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='r'
+ORDER BY pg_indexes_size(c.oid) DESC;
+`.trim();
+export default class PgTableIndexesSize 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 total size of all the indexes on each table, descending by size';
+    static examples = [heredoc `
+    ${color.command('heroku pg:table-indexes-size --app example-app')}
+  `];
+    static flags = {
+        app: flags.app({ required: true }),
+        remote: flags.remote(),
+    };
+    static hiddenAliases = ['pg:table_indexes_size'];
+    static topic = 'pg';
+    async run() {
+        const { args, flags } = await this.parse(PgTableIndexesSize);
+        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(generateTableIndexesSizeQuery());
+        ux.stdout(output);
+    }
+}

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

@@ -0,0 +1,16 @@
+import { Command } from '@heroku-cli/command';
+export declare const generateTableSizeQuery: () => string;
+export default class PgTableSize extends Command {
+    static aliases: string[];
+    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/table-size.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 { nls } from '../../nls.js';
+const heredoc = tsheredoc.default;
+export const generateTableSizeQuery = () => `
+SELECT c.relname AS name,
+  pg_size_pretty(pg_table_size(c.oid)) 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='r'
+ORDER BY pg_table_size(c.oid) DESC;
+`.trim();
+export default class PgTableSize extends Command {
+    static aliases = ['pg:table_size'];
+    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 the tables (excluding indexes), descending by size';
+    static examples = [heredoc `
+    ${color.command('heroku pg:table-size --app example-app')}
+  `];
+    static flags = {
+        app: flags.app({ required: true }),
+        remote: flags.remote(),
+    };
+    static topic = 'pg';
+    async run() {
+        const { args, flags } = await this.parse(PgTableSize);
+        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(generateTableSizeQuery());
+        ux.stdout(output);
+    }
+}

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

@@ -0,0 +1,16 @@
+import { Command } from '@heroku-cli/command';
+export declare const generateTotalIndexSizeQuery: () => string;
+export default class PgTotalIndexSize 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/total-index-size.js

@@ -0,0 +1,37 @@
+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 generateTotalIndexSizeQuery = () => `
+SELECT 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';
+`.trim();
+export default class PgTotalIndexSize 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 total size of all indexes in MB';
+    static examples = [heredoc `
+    ${color.command('heroku pg:total-index-size --app example-app')}
+  `];
+    static flags = {
+        app: flags.app({ required: true }),
+        remote: flags.remote(),
+    };
+    static hiddenAliases = ['pg:total_index_size'];
+    static topic = 'pg';
+    async run() {
+        const { args, flags } = await this.parse(PgTotalIndexSize);
+        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(generateTotalIndexSizeQuery());
+        ux.stdout(output);
+    }
+}

package/dist/commands/pg/total-table-size.d.ts

@@ -0,0 +1,16 @@
+import { Command } from '@heroku-cli/command';
+export declare const generateTotalTableSizeQuery: () => string;
+export default class PgTotalTableSize extends Command {
+    static aliases: string[];
+    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/total-table-size.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 { nls } from '../../nls.js';
+const heredoc = tsheredoc.default;
+export const generateTotalTableSizeQuery = () => `
+SELECT c.relname AS name,
+  pg_size_pretty(pg_total_relation_size(c.oid)) 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='r'
+ORDER BY pg_total_relation_size(c.oid) DESC;
+`.trim();
+export default class PgTotalTableSize extends Command {
+    static aliases = ['pg:total_table_size'];
+    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 the tables (including indexes), descending by size';
+    static examples = [heredoc `
+    ${color.command('heroku pg:total-table-size --app example-app')}
+  `];
+    static flags = {
+        app: flags.app({ required: true }),
+        remote: flags.remote(),
+    };
+    static topic = 'pg';
+    async run() {
+        const { args, flags } = await this.parse(PgTotalTableSize);
+        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(generateTotalTableSizeQuery());
+        ux.stdout(output);
+    }
+}

package/dist/commands/pg/unused-indexes.d.ts

@@ -0,0 +1,16 @@
+import { Command } from '@heroku-cli/command';
+export declare const generateUnusedIndexesQuery: () => string;
+export default class PgUnusedIndexes extends Command {
+    static aliases: string[];
+    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/unused-indexes.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 generateUnusedIndexesQuery = () => `
+SELECT
+  schemaname || '.' || relname AS table,
+  indexrelname AS index,
+  pg_size_pretty(pg_relation_size(i.indexrelid)) AS index_size,
+  idx_scan as index_scans
+FROM pg_stat_user_indexes ui
+JOIN pg_index i ON ui.indexrelid = i.indexrelid
+WHERE NOT indisunique AND idx_scan < 50 AND pg_relation_size(relid) > 5 * 8192
+ORDER BY pg_relation_size(i.indexrelid) / nullif(idx_scan, 0) DESC NULLS FIRST,
+pg_relation_size(i.indexrelid) DESC;
+`.trim();
+export default class PgUnusedIndexes extends Command {
+    static aliases = ['pg:unused_indexes'];
+    static args = {
+        database: Args.string({ description: `${nls('pg:database:arg:description')} ${nls('pg:database:arg:description:default:suffix')}`, required: false }),
+    };
+    static description = 'show unused and almost unused indexes';
+    static examples = [heredoc `
+    ${color.command('heroku pg:unused-indexes --app example-app')}
+  `];
+    static flags = {
+        app: flags.app({ required: true }),
+        remote: flags.remote(),
+    };
+    static topic = 'pg';
+    async run() {
+        const { args, flags } = await this.parse(PgUnusedIndexes);
+        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(generateUnusedIndexesQuery());
+        ux.stdout(output);
+    }
+}

package/dist/commands/pg/user-connections.d.ts

@@ -0,0 +1,16 @@
+import { Command } from '@heroku-cli/command';
+export declare const generateUserConnectionsQuery: () => string;
+export default class PgUserConnections 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/user-connections.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 generateUserConnectionsQuery = () => `
+SELECT
+  usename AS credential,
+  count(*) AS connections
+FROM pg_stat_activity
+WHERE state = 'active'
+GROUP BY usename
+ORDER BY connections DESC;
+`.trim();
+export default class PgUserConnections extends Command {
+    static args = {
+        database: Args.string({ description: `${nls('pg:database:arg:description')} ${nls('pg:database:arg:description:default:suffix')}`, required: false }),
+    };
+    static description = 'returns the number of connections per credential';
+    static examples = [heredoc `
+    ${color.command('heroku pg:user-connections --app example-app')}
+  `];
+    static flags = {
+        app: flags.app({ required: true }),
+        remote: flags.remote(),
+    };
+    static hiddenAliases = ['pg:user_connections'];
+    static topic = 'pg';
+    async run() {
+        const { args, flags } = await this.parse(PgUserConnections);
+        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(generateUserConnectionsQuery());
+        ux.stdout(output);
+    }
+}

package/dist/lib/pg/extras.d.ts

@@ -0,0 +1,11 @@
+import * as Heroku from '@heroku-cli/schema';
+import { pg } from '@heroku/heroku-cli-util';
+interface Plan {
+    plan: Heroku.AddOn['plan'];
+}
+export declare function ensurePGStatStatement(db: pg.ConnectionDetails): Promise<void>;
+export declare function ensureEssentialTierPlan(db: pg.ConnectionDetails): Promise<void>;
+export declare function essentialNumPlan(a: Plan): boolean;
+export declare function newTotalExecTimeField(db: pg.ConnectionDetails): Promise<boolean>;
+export declare function newBlkTimeFields(db: pg.ConnectionDetails): Promise<boolean>;
+export {};

package/dist/lib/pg/extras.js

@@ -0,0 +1,57 @@
+import { utils } from '@heroku/heroku-cli-util';
+import { ux } from '@oclif/core/ux';
+export async function ensurePGStatStatement(db) {
+    const query = `
+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 psqlService = new utils.pg.PsqlService(db);
+    const output = await psqlService.execQuery(query);
+    if (!output.includes('t')) {
+        ux.error(`pg_stat_statements extension need to be installed in the public schema first.
+You can install it by running:
+
+    CREATE EXTENSION pg_stat_statements;`, { exit: 1 });
+    }
+}
+export async function ensureEssentialTierPlan(db) {
+    const planName = db.attachment?.addon?.plan?.name;
+    if (!planName) {
+        ux.error('Unable to determine database plan type', { exit: 1 });
+        return;
+    }
+    if (/(dev|basic|essential-\d+)$/.test(planName)) {
+        ux.error('This operation is not supported by Essential-tier databases.', { exit: 1 });
+    }
+}
+export function essentialNumPlan(a) {
+    if (!a.plan?.name)
+        return false;
+    const parts = a.plan.name.split(':');
+    if (parts.length < 2)
+        return false;
+    return Boolean(parts[1].startsWith('essential'));
+}
+export async function newTotalExecTimeField(db) {
+    const newTotalExecTimeFieldQuery = 'SELECT current_setting(\'server_version_num\')::numeric >= 130000';
+    const psqlService = new utils.pg.PsqlService(db);
+    const newTotalExecTimeFieldRaw = await psqlService.execQuery(newTotalExecTimeFieldQuery, ['-t', '-q']);
+    // error checks
+    const newTotalExecTimeField = newTotalExecTimeFieldRaw.split('\n')[0].trim();
+    if (newTotalExecTimeField !== 't' && newTotalExecTimeField !== 'f') {
+        ux.error(`Unable to determine database version, expected "t" or "f", got: "${newTotalExecTimeField}"`, { exit: 1 });
+    }
+    return newTotalExecTimeField === 't';
+}
+export async function newBlkTimeFields(db) {
+    const newBlkTimeFieldsQuery = 'SELECT current_setting(\'server_version_num\')::numeric >= 170000';
+    const psqlService = new utils.pg.PsqlService(db);
+    const newBlkTimeFieldsRaw = await psqlService.execQuery(newBlkTimeFieldsQuery, ['-t', '-q']);
+    // error checks
+    const newBlkTimeField = newBlkTimeFieldsRaw.split('\n')[0].trim();
+    if (newBlkTimeField !== 't' && newBlkTimeField !== 'f') {
+        ux.error(`Unable to determine database version, expected "t" or "f", got: "${newBlkTimeField}"`, { exit: 1 });
+    }
+    return newBlkTimeField === 't';
+}

package/npm-shrinkwrap.json

@@ -1,12 +1,12 @@
 {
   "name": "heroku",
-  "version": "11.6.0",
+  "version": "11.7.0",
   "lockfileVersion": 3,
   "requires": true,
   "packages": {
     "": {
       "name": "heroku",
-      "version": "11.6.0",
+      "version": "11.7.0",
       "license": "ISC",
       "dependencies": {
         "@heroku-cli/command": "12.4.2",