heroku 9.0.0-alpha.1 → 9.0.0-alpha.2

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

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

package/lib/commands/pg/push.js

@@ -0,0 +1,84 @@
+"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 fetcher_1 = require("../../lib/pg/fetcher");
+const util_1 = require("../../lib/pg/util");
+const push_pull_1 = require("../../lib/pg/push_pull");
+const node_child_process_1 = require("node:child_process");
+const env = process.env;
+class Push extends command_1.Command {
+    async run() {
+        const { flags, args } = await this.parse(Push);
+        const { app, 'exclude-table-data': excludeTableData } = flags;
+        const exclusions = (0, push_pull_1.parseExclusions)(excludeTableData);
+        const source = (0, util_1.parsePostgresConnectionString)(args.source);
+        const target = await (0, fetcher_1.database)(this.heroku, app, args.target);
+        core_1.ux.log(`Pushing ${color_1.default.cyan(args.source)} to ${color_1.default.addon(target.attachment.addon.name)}`);
+        await this.push(source, target, exclusions);
+        core_1.ux.log('Pushing complete.');
+    }
+    async push(sourceIn, targetIn, exclusions) {
+        await (0, push_pull_1.prepare)(targetIn);
+        const source = await (0, push_pull_1.maybeTunnel)(sourceIn);
+        const target = await (0, push_pull_1.maybeTunnel)(targetIn);
+        const exclude = exclusions.map(function (e) {
+            return '--exclude-table-data=' + e;
+        }).join(' ');
+        const dumpFlags = ['--verbose', '-F', 'c', '-Z', '0', '-N', '_heroku', ...(0, push_pull_1.connArgs)(source, true)];
+        if (exclude !== '')
+            dumpFlags.push(exclude);
+        const dumpOptions = {
+            env: Object.assign({ PGSSLMODE: 'prefer' }, env),
+            stdio: ['pipe', 'pipe', 2],
+            shell: true,
+        };
+        if (source.password)
+            dumpOptions.env.PGPASSWORD = source.password;
+        const restoreFlags = ['--verbose', '-F', 'c', '--no-acl', '--no-owner', ...(0, push_pull_1.connArgs)(target)];
+        const restoreOptions = {
+            env: Object.assign({}, env),
+            stdio: ['pipe', 'pipe', 2],
+            shell: true,
+        };
+        if (target.password)
+            restoreOptions.env.PGPASSWORD = target.password;
+        const pgDump = (0, node_child_process_1.spawn)('pg_dump', dumpFlags, dumpOptions);
+        const pgRestore = (0, node_child_process_1.spawn)('pg_restore', restoreFlags, restoreOptions);
+        await (0, push_pull_1.spawnPipe)(pgDump, pgRestore);
+        if (source._tunnel)
+            source._tunnel.close();
+        if (target._tunnel)
+            target._tunnel.close();
+        await (0, push_pull_1.verifyExtensionsMatch)(sourceIn, targetIn);
+    }
+}
+exports.default = Push;
+Push.topic = 'pg';
+Push.description = (0, tsheredoc_1.default) `
+    push local or remote into Heroku database
+    Push from SOURCE into TARGET. TARGET must be empty.
+
+    To empty a Heroku database for push run ${color_1.default.cmd('heroku pg:reset')}
+    
+    SOURCE must be either the name of a database existing on your localhost or the
+    fully qualified URL of a remote database.
+  `;
+Push.examples = [(0, tsheredoc_1.default) `
+      # push mylocaldb into a Heroku DB named postgresql-swimmingly-100
+      $ heroku pg:push mylocaldb postgresql-swimmingly-100 --app sushi
+    `, (0, tsheredoc_1.default) `
+      # push remote DB at postgres://myhost/mydb into a Heroku DB named postgresql-swimmingly-100
+      $ heroku pg:push postgres://myhost/mydb postgresql-swimmingly-100 --app sushi
+  `];
+Push.flags = {
+    'exclude-table-data': command_1.flags.string({ description: 'tables for which data should be excluded (use \';\' to split multiple names)', hasValue: true }),
+    app: command_1.flags.app({ required: true }),
+    remote: command_1.flags.remote(),
+};
+Push.args = {
+    source: core_1.Args.string({ required: true }),
+    target: core_1.Args.string({ required: true }),
+};

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

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

package/lib/commands/pg/reset.js

@@ -0,0 +1,44 @@
+"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 fetcher_1 = require("../../lib/pg/fetcher");
+const tsheredoc_1 = require("tsheredoc");
+class Reset extends command_1.Command {
+    async run() {
+        const { flags, args } = await this.parse(Reset);
+        const { app, confirm, extensions } = flags;
+        const db = await (0, fetcher_1.getAddon)(this.heroku, app, args.database);
+        let extensionsArray;
+        if (extensions) {
+            extensionsArray = extensions.split(',')
+                .map(ext => ext.trim()
+                .toLowerCase())
+                .sort();
+        }
+        await (0, confirmCommand_1.default)(app, confirm, (0, tsheredoc_1.default)(`
+      Destructive action
+      ${color_1.default.addon(db.name)} will lose all of its data
+    `));
+        core_1.ux.action.start(`Resetting ${color_1.default.addon(db.name)}`);
+        await this.heroku.put(`/client/v11/databases/${db.id}/reset`, {
+            body: { extensions: extensionsArray }, hostname: (0, host_1.default)(),
+        });
+        core_1.ux.action.stop();
+    }
+}
+exports.default = Reset;
+Reset.topic = 'pg';
+Reset.description = 'delete all data in DATABASE';
+Reset.flags = {
+    extensions: command_1.flags.string({ char: 'e', description: 'comma-separated list of extensions to pre-install in the public schema' }),
+    confirm: command_1.flags.string({ char: 'c' }),
+    app: command_1.flags.app({ required: true }),
+    remote: command_1.flags.remote(),
+};
+Reset.args = {
+    database: core_1.Args.string(),
+};

package/lib/commands/pg/settings/auto-explain/log-analyze.d.ts

@@ -0,0 +1,13 @@
+import { PGSettingsCommand, BooleanAsString } from '../../../../lib/pg/setter';
+import { SettingKey, Setting } from '../../../../lib/pg/types';
+export default class LogAnalyze extends PGSettingsCommand {
+    static topic: string;
+    static description: string;
+    static args: {
+        database: import("@oclif/core/lib/interfaces/parser").Arg<string | undefined, Record<string, unknown>>;
+        value: import("@oclif/core/lib/interfaces/parser").Arg<string | undefined, Record<string, unknown>>;
+    };
+    protected settingKey: SettingKey;
+    protected convertValue(val: BooleanAsString): boolean;
+    protected explain(setting: Setting<boolean>): "EXPLAIN ANALYZE execution plans will be logged." | "EXPLAIN ANALYZE execution plans will not be logged.";
+}

package/lib/commands/pg/settings/auto-explain/log-analyze.js

@@ -0,0 +1,32 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const core_1 = require("@oclif/core");
+const tsheredoc_1 = require("tsheredoc");
+const setter_1 = require("../../../../lib/pg/setter");
+class LogAnalyze extends setter_1.PGSettingsCommand {
+    constructor() {
+        super(...arguments);
+        this.settingKey = 'auto_explain.log_analyze';
+    }
+    convertValue(val) {
+        return (0, setter_1.booleanConverter)(val);
+    }
+    explain(setting) {
+        if (setting.value) {
+            return 'EXPLAIN ANALYZE execution plans will be logged.';
+        }
+        return 'EXPLAIN ANALYZE execution plans will not be logged.';
+    }
+}
+exports.default = LogAnalyze;
+LogAnalyze.topic = 'pg';
+LogAnalyze.description = (0, tsheredoc_1.default)(`
+    Shows actual run times on the execution plan.
+    This is equivalent to calling EXPLAIN ANALYZE.
+
+    WARNING: EXPLAIN ANALYZE will be run on ALL queries, not just logged queries. This can cause significant performance impacts to your database and should be used with caution.
+  `);
+LogAnalyze.args = {
+    database: core_1.Args.string(),
+    value: core_1.Args.string(),
+};

package/lib/commands/pg/settings/auto-explain/log-buffers.d.ts

@@ -0,0 +1,13 @@
+import { BooleanAsString, PGSettingsCommand } from '../../../../lib/pg/setter';
+import { Setting, SettingKey } from '../../../../lib/pg/types';
+export default class LogBuffersWaits extends PGSettingsCommand {
+    static topic: string;
+    static description: string;
+    static args: {
+        database: import("@oclif/core/lib/interfaces/parser").Arg<string | undefined, Record<string, unknown>>;
+        value: import("@oclif/core/lib/interfaces/parser").Arg<string | undefined, Record<string, unknown>>;
+    };
+    protected settingKey: SettingKey;
+    protected convertValue(val: BooleanAsString): boolean;
+    protected explain(setting: Setting<boolean>): "Buffer statistics have been enabled for auto_explain." | "Buffer statistics have been disabled for auto_explain.";
+}

package/lib/commands/pg/settings/auto-explain/log-buffers.js

@@ -0,0 +1,30 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const core_1 = require("@oclif/core");
+const tsheredoc_1 = require("tsheredoc");
+const setter_1 = require("../../../../lib/pg/setter");
+class LogBuffersWaits extends setter_1.PGSettingsCommand {
+    constructor() {
+        super(...arguments);
+        this.settingKey = 'auto_explain.log_buffers';
+    }
+    convertValue(val) {
+        return (0, setter_1.booleanConverter)(val);
+    }
+    explain(setting) {
+        if (setting.value) {
+            return 'Buffer statistics have been enabled for auto_explain.';
+        }
+        return 'Buffer statistics have been disabled for auto_explain.';
+    }
+}
+exports.default = LogBuffersWaits;
+LogBuffersWaits.topic = 'pg';
+LogBuffersWaits.description = (0, tsheredoc_1.default)(`
+    Includes buffer usage statistics when execution plans are logged.
+    This is equivalent to calling EXPLAIN BUFFERS and can only be used in conjunction with pg:settings:auto-explain:log-analyze turned on.
+  `);
+LogBuffersWaits.args = {
+    database: core_1.Args.string(),
+    value: core_1.Args.string(),
+};

package/lib/commands/pg/settings/auto-explain/log-min-duration.d.ts

@@ -0,0 +1,16 @@
+import { PGSettingsCommand } from '../../../../lib/pg/setter';
+import { Setting, SettingKey } from '../../../../lib/pg/types';
+export default class LogMinDuration extends PGSettingsCommand {
+    static topic: string;
+    static description: string;
+    static args: {
+        database: import("@oclif/core/lib/interfaces/parser").Arg<string | undefined, Record<string, unknown>>;
+        value: import("@oclif/core/lib/interfaces/parser").Arg<number | undefined, {
+            min?: number | undefined;
+            max?: number | undefined;
+        }>;
+    };
+    protected settingKey: SettingKey;
+    protected convertValue(val: string): number;
+    protected explain(setting: Setting<number>): string;
+}

package/lib/commands/pg/settings/auto-explain/log-min-duration.js

@@ -0,0 +1,33 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const core_1 = require("@oclif/core");
+const tsheredoc_1 = require("tsheredoc");
+const setter_1 = require("../../../../lib/pg/setter");
+class LogMinDuration extends setter_1.PGSettingsCommand {
+    constructor() {
+        super(...arguments);
+        this.settingKey = 'auto_explain.log_min_duration';
+    }
+    convertValue(val) {
+        return (0, setter_1.numericConverter)(val);
+    }
+    explain(setting) {
+        if (setting.value === -1) {
+            return 'Execution plan logging has been disabled.';
+        }
+        if (setting.value === 0) {
+            return 'All queries will have their execution plans logged.';
+        }
+        return `All execution plans will be logged for queries taking up to ${setting.value} milliseconds or more.`;
+    }
+}
+exports.default = LogMinDuration;
+LogMinDuration.topic = 'pg';
+LogMinDuration.description = (0, tsheredoc_1.default)(`
+    Sets the minimum execution time in milliseconds for a statement's plan to be logged.
+    Setting this value to 0 will log all queries. Setting this value to -1 will disable logging entirely.
+  `);
+LogMinDuration.args = {
+    database: core_1.Args.string(),
+    value: core_1.Args.integer(),
+};

package/lib/commands/pg/settings/auto-explain/log-nested-statements.d.ts

@@ -0,0 +1,12 @@
+import { PGSettingsCommand } from '../../../../lib/pg/setter';
+import type { Setting, SettingKey } from '../../../../lib/pg/types';
+export default class LogNestedStatements extends PGSettingsCommand {
+    static description: string;
+    static args: {
+        database: import("@oclif/core/lib/interfaces/parser").Arg<string | undefined, Record<string, unknown>>;
+        value: import("@oclif/core/lib/interfaces/parser").Arg<string | undefined, Record<string, unknown>>;
+    };
+    protected settingKey: SettingKey;
+    protected convertValue(val: unknown): boolean;
+    protected explain(setting: Setting<unknown>): "Nested statements will be included in execution plan logs." | "Only top-level execution plans will be included in logs.";
+}

package/lib/commands/pg/settings/auto-explain/log-nested-statements.js

@@ -0,0 +1,25 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const core_1 = require("@oclif/core");
+const setter_1 = require("../../../../lib/pg/setter");
+class LogNestedStatements extends setter_1.PGSettingsCommand {
+    constructor() {
+        super(...arguments);
+        this.settingKey = 'auto_explain.log_nested_statements';
+    }
+    convertValue(val) {
+        return (0, setter_1.booleanConverter)(val);
+    }
+    explain(setting) {
+        if (setting.value) {
+            return 'Nested statements will be included in execution plan logs.';
+        }
+        return 'Only top-level execution plans will be included in logs.';
+    }
+}
+exports.default = LogNestedStatements;
+LogNestedStatements.description = "Nested statements are included in the execution plan's log.";
+LogNestedStatements.args = {
+    database: core_1.Args.string(),
+    value: core_1.Args.string(),
+};

package/lib/commands/pg/settings/auto-explain/log-triggers.d.ts

@@ -0,0 +1,13 @@
+import { PGSettingsCommand, BooleanAsString } from '../../../../lib/pg/setter';
+import { SettingKey, Setting } from '../../../../lib/pg/types';
+export default class LogTriggers extends PGSettingsCommand {
+    static topic: string;
+    static description: string;
+    static args: {
+        database: import("@oclif/core/lib/interfaces/parser").Arg<string | undefined, Record<string, unknown>>;
+        value: import("@oclif/core/lib/interfaces/parser").Arg<string | undefined, Record<string, unknown>>;
+    };
+    protected settingKey: SettingKey;
+    protected convertValue(val: BooleanAsString): boolean;
+    protected explain(setting: Setting<boolean>): "Trigger execution statistics have been enabled for auto-explain." | "Trigger execution statistics have been disabled for auto-explain.";
+}

package/lib/commands/pg/settings/auto-explain/log-triggers.js

@@ -0,0 +1,30 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const core_1 = require("@oclif/core");
+const tsheredoc_1 = require("tsheredoc");
+const setter_1 = require("../../../../lib/pg/setter");
+class LogTriggers extends setter_1.PGSettingsCommand {
+    constructor() {
+        super(...arguments);
+        this.settingKey = 'auto_explain.log_triggers';
+    }
+    convertValue(val) {
+        return (0, setter_1.booleanConverter)(val);
+    }
+    explain(setting) {
+        if (setting.value) {
+            return 'Trigger execution statistics have been enabled for auto-explain.';
+        }
+        return 'Trigger execution statistics have been disabled for auto-explain.';
+    }
+}
+exports.default = LogTriggers;
+LogTriggers.topic = 'pg';
+LogTriggers.description = (0, tsheredoc_1.default)(`
+    Includes trigger execution statistics in execution plan logs.
+    This parameter can only be used in conjunction with pg:settings:auto-explain:log-analyze turned on.
+  `);
+LogTriggers.args = {
+    database: core_1.Args.string(),
+    value: core_1.Args.string(),
+};

package/lib/commands/pg/settings/auto-explain/log-verbose.d.ts

@@ -0,0 +1,17 @@
+import { PGSettingsCommand } from '../../../../lib/pg/setter';
+import type { Setting, SettingKey } from '../../../../lib/pg/types';
+export default class AutoExplainLogVerbose extends PGSettingsCommand {
+    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: {
+        database: import("@oclif/core/lib/interfaces/parser").Arg<string | undefined, Record<string, unknown>>;
+        value: import("@oclif/core/lib/interfaces/parser").Arg<string | undefined, Record<string, unknown>>;
+    };
+    protected settingKey: SettingKey;
+    protected explain(setting: Setting<unknown>): "Verbose execution plan logging has been enabled for auto_explain." | "Verbose execution plan logging has been disabled for auto_explain.";
+    protected convertValue(val: unknown): boolean;
+}

package/lib/commands/pg/settings/auto-explain/log-verbose.js

@@ -0,0 +1,33 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const command_1 = require("@heroku-cli/command");
+const core_1 = require("@oclif/core");
+const tsheredoc_1 = require("tsheredoc");
+const setter_1 = require("../../../../lib/pg/setter");
+class AutoExplainLogVerbose extends setter_1.PGSettingsCommand {
+    constructor() {
+        super(...arguments);
+        this.settingKey = 'auto_explain.log_verbose';
+    }
+    explain(setting) {
+        if (setting.value) {
+            return 'Verbose execution plan logging has been enabled for auto_explain.';
+        }
+        return 'Verbose execution plan logging has been disabled for auto_explain.';
+    }
+    convertValue(val) {
+        return (0, setter_1.booleanConverter)(val);
+    }
+}
+exports.default = AutoExplainLogVerbose;
+AutoExplainLogVerbose.topic = 'pg';
+AutoExplainLogVerbose.description = (0, tsheredoc_1.default)(`Include verbose details in execution plans.
+    This is equivalent to calling EXPLAIN VERBOSE.`);
+AutoExplainLogVerbose.flags = {
+    app: command_1.flags.app({ required: true }),
+    remote: command_1.flags.remote(),
+};
+AutoExplainLogVerbose.args = {
+    database: core_1.Args.string(),
+    value: core_1.Args.string(),
+};

package/lib/commands/pg/settings/auto-explain.d.ts

@@ -0,0 +1,18 @@
+import { BooleanAsString, PGSettingsCommand } from '../../../lib/pg/setter';
+import { Setting, SettingKey } from '../../../lib/pg/types';
+export default class AutoExplain extends PGSettingsCommand {
+    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: {
+        database: import("@oclif/core/lib/interfaces/parser").Arg<string | undefined, Record<string, unknown>>;
+        value: import("@oclif/core/lib/interfaces/parser").Arg<string | undefined, Record<string, unknown>>;
+    };
+    static strict: boolean;
+    protected settingKey: SettingKey;
+    protected convertValue(val: BooleanAsString): boolean;
+    protected explain(setting: Setting<boolean>): string;
+}

package/lib/commands/pg/settings/auto-explain.js

@@ -0,0 +1,38 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const command_1 = require("@heroku-cli/command");
+const core_1 = require("@oclif/core");
+const tsheredoc_1 = require("tsheredoc");
+const setter_1 = require("../../../lib/pg/setter");
+// ref: https://www.postgresql.org/docs/current/auto-explain.html
+class AutoExplain extends setter_1.PGSettingsCommand {
+    constructor() {
+        super(...arguments);
+        this.settingKey = 'auto_explain';
+    }
+    convertValue(val) {
+        return (0, setter_1.booleanConverter)(val);
+    }
+    explain(setting) {
+        if (setting.value) {
+            return 'Execution plans of queries will be logged for future connections.';
+        }
+        return 'Execution plans of queries will not be logged for future connections.';
+    }
+}
+exports.default = AutoExplain;
+AutoExplain.topic = 'pg';
+AutoExplain.description = (0, tsheredoc_1.default)(`
+  Automatically log execution plans of queries without running EXPLAIN by hand.
+  The auto_explain module is loaded at session-time so existing connections will not be logged.
+  Restart your Heroku app and/or restart existing connections for logging to start taking place.
+  `);
+AutoExplain.flags = {
+    app: command_1.flags.app({ required: true }),
+    remote: command_1.flags.remote(),
+};
+AutoExplain.args = {
+    database: core_1.Args.string(),
+    value: core_1.Args.string(),
+};
+AutoExplain.strict = false;

package/lib/commands/pg/settings/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/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>>;
+    };
+    run(): Promise<void>;
+}

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

@@ -0,0 +1,34 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const command_1 = require("@heroku-cli/command");
+const core_1 = require("@oclif/core");
+const resolve_1 = require("../../../lib/addons/resolve");
+const util_1 = require("../../../lib/pg/util");
+const host_1 = require("../../../lib/pg/host");
+class Index extends command_1.Command {
+    async run() {
+        const { flags, args } = await this.parse(Index);
+        const { app } = flags;
+        const { database } = args;
+        const db = await (0, resolve_1.addonResolver)(this.heroku, app, database || 'DATABASE_URL');
+        if ((0, util_1.essentialPlan)(db))
+            core_1.ux.error('You can’t perform this operation on Essential-tier databases.');
+        const { body: settings } = await this.heroku.get(`/postgres/v0/databases/${db.id}/config`, { hostname: (0, host_1.default)() });
+        core_1.ux.styledHeader(db.name);
+        const remapped = {};
+        Object.keys(settings).forEach(k => {
+            remapped[k.replace(/_/g, '-')] = settings[k].value;
+        });
+        core_1.ux.styledObject(remapped);
+    }
+}
+exports.default = Index;
+Index.topic = 'pg';
+Index.description = 'show your current database settings';
+Index.flags = {
+    app: command_1.flags.app({ required: true }),
+    remote: command_1.flags.remote(),
+};
+Index.args = {
+    database: core_1.Args.string(),
+};

package/lib/commands/pg/settings/log-connections.d.ts

@@ -0,0 +1,17 @@
+import { PGSettingsCommand } from '../../../lib/pg/setter';
+import type { Setting, SettingKey } from '../../../lib/pg/types';
+export default class LogConnections extends PGSettingsCommand {
+    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: {
+        database: import("@oclif/core/lib/interfaces/parser").Arg<string | undefined, Record<string, unknown>>;
+        value: import("@oclif/core/lib/interfaces/parser").Arg<string | undefined, Record<string, unknown>>;
+    };
+    protected settingKey: SettingKey;
+    protected convertValue(val: unknown): unknown;
+    protected explain(setting: Setting<unknown>): string;
+}

package/lib/commands/pg/settings/log-connections.js

@@ -0,0 +1,34 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const command_1 = require("@heroku-cli/command");
+const core_1 = require("@oclif/core");
+const tsheredoc_1 = require("tsheredoc");
+const setter_1 = require("../../../lib/pg/setter");
+class LogConnections extends setter_1.PGSettingsCommand {
+    constructor() {
+        super(...arguments);
+        this.settingKey = 'log_connections';
+    }
+    convertValue(val) {
+        return (0, setter_1.booleanConverter)(val);
+    }
+    explain(setting) {
+        if (setting.value) {
+            return 'When login attempts are made, a log message will be emitted in your application\'s logs.';
+        }
+        return 'When login attempts are made, no log message will be emitted in your application\'s logs.';
+    }
+}
+exports.default = LogConnections;
+LogConnections.topic = 'pg';
+LogConnections.description = (0, tsheredoc_1.default)(`
+  Controls whether a log message is produced when a login attempt is made. Default is true.
+  Setting log_connections to false stops emitting log messages for all attempts to login to the database.`);
+LogConnections.flags = {
+    app: command_1.flags.app({ required: true }),
+    remote: command_1.flags.remote(),
+};
+LogConnections.args = {
+    database: core_1.Args.string(),
+    value: core_1.Args.string(),
+};

package/lib/commands/pg/settings/log-lock-waits.d.ts

@@ -0,0 +1,13 @@
+import { PGSettingsCommand } from '../../../lib/pg/setter';
+import type { Setting, SettingKey } from '../../../lib/pg/types';
+export default class LogLockWaits extends PGSettingsCommand {
+    static topic: string;
+    static description: string;
+    static args: {
+        database: import("@oclif/core/lib/interfaces/parser").Arg<string | undefined, Record<string, unknown>>;
+        value: import("@oclif/core/lib/interfaces/parser").Arg<string | undefined, Record<string, unknown>>;
+    };
+    protected settingKey: SettingKey;
+    protected convertValue(val: unknown): boolean;
+    protected explain(setting: Setting<unknown>): "When a deadlock is detected, a log message will be emitted in your application's logs." | "When a deadlock is detected, no log message will be emitted in your application's logs.";
+}