heroku 11.0.0-alpha.11 → 11.0.0-alpha.12

package/lib/commands/pg/push.js

@@ -0,0 +1,83 @@
+import { Command, flags } from '@heroku-cli/command';
+import { Args, ux } from '@oclif/core';
+import tsheredoc from 'tsheredoc';
+import { color, utils } from '@heroku/heroku-cli-util';
+import { connArgs, maybeTunnel, parseExclusions, prepare, spawnPipe, verifyExtensionsMatch, } from '../../lib/pg/push_pull.js';
+import childProcess from 'node:child_process';
+import { nls } from '../../nls.js';
+const heredoc = tsheredoc.default;
+const { env } = process;
+export default class Push extends Command {
+    static args = {
+        source: Args.string({ description: 'PostgreSQL connection string for the source database', required: true }),
+        target: Args.string({ description: `${nls('pg:database:arg:description')} ${nls('pg:database:arg:description:default:suffix')}`, required: true }),
+    };
+    static description = heredoc `
+    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.code('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.
+  `;
+    static examples = [heredoc `
+      # push mylocaldb into a Heroku DB named postgresql-swimmingly-100
+      $ heroku pg:push mylocaldb postgresql-swimmingly-100 --app sushi
+    `, heredoc `
+      # 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
+  `];
+    static flags = {
+        app: flags.app({ required: true }),
+        'exclude-table-data': flags.string({ description: 'tables for which data should be excluded (use \';\' to split multiple names)', hasValue: true }),
+        remote: flags.remote(),
+    };
+    static topic = 'pg';
+    async push(sourceIn, targetIn, exclusions) {
+        await prepare(targetIn);
+        const source = await maybeTunnel(sourceIn);
+        const target = await maybeTunnel(targetIn);
+        const exclude = exclusions.map(e => ('--exclude-table-data=' + e)).join(' ');
+        const dumpFlags = ['--verbose', '-F', 'c', '-Z', '0', '-N', '_heroku', ...connArgs(source, true)];
+        if (exclude !== '')
+            dumpFlags.push(exclude);
+        const dumpOptions = {
+            env: {
+                PGSSLMODE: 'prefer',
+                ...env,
+            },
+            shell: true,
+            stdio: ['pipe', 'pipe', 2],
+        };
+        if (source.password)
+            dumpOptions.env.PGPASSWORD = source.password;
+        const restoreFlags = ['--verbose', '-F', 'c', '--no-acl', '--no-owner', ...connArgs(target)];
+        const restoreOptions = {
+            env: { ...env },
+            shell: true,
+            stdio: ['pipe', 'pipe', 2],
+        };
+        if (target.password)
+            restoreOptions.env.PGPASSWORD = target.password;
+        const pgDump = childProcess.spawn('pg_dump', dumpFlags, dumpOptions);
+        const pgRestore = childProcess.spawn('pg_restore', restoreFlags, restoreOptions);
+        await spawnPipe(pgDump, pgRestore);
+        if (source._tunnel)
+            source._tunnel.close();
+        if (target._tunnel)
+            target._tunnel.close();
+        await verifyExtensionsMatch(sourceIn, targetIn);
+    }
+    async run() {
+        const { args, flags } = await this.parse(Push);
+        const { app, 'exclude-table-data': excludeTableData } = flags;
+        const exclusions = parseExclusions(excludeTableData);
+        const source = utils.pg.DatabaseResolver.parsePostgresConnectionString(args.source);
+        const dbResolver = new utils.pg.DatabaseResolver(this.heroku);
+        const target = await dbResolver.getDatabase(app, args.target);
+        ux.stdout(`Pushing ${color.cyan(args.source)} to ${color.addon(target.attachment.addon.name)}`);
+        await this.push(source, target, exclusions);
+        ux.stdout('Pushing complete.');
+    }
+}

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

@@ -0,0 +1,15 @@
+import { Command } from '@heroku-cli/command';
+export default class Reset 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>;
+        confirm: import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
+        extensions: 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/reset.js

@@ -0,0 +1,43 @@
+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 { nls } from '../../nls.js';
+const heredoc = tsheredoc.default;
+export default class Reset extends Command {
+    static args = {
+        database: Args.string({ description: `${nls('pg:database:arg:description')} ${nls('pg:database:arg:description:default:suffix')}` }),
+    };
+    static description = 'delete all data in DATABASE';
+    static flags = {
+        app: flags.app({ required: true }),
+        confirm: flags.string({ char: 'c' }),
+        extensions: flags.string({ char: 'e', description: 'comma-separated list of extensions to pre-install in the public schema' }),
+        remote: flags.remote(),
+    };
+    static topic = 'pg';
+    async run() {
+        const { args, flags } = await this.parse(Reset);
+        const { app, confirm, extensions } = flags;
+        const dbResolver = new utils.pg.DatabaseResolver(this.heroku);
+        const { addon: db } = await dbResolver.getAttachment(app, args.database);
+        let extensionsArray;
+        if (extensions) {
+            extensionsArray = extensions.split(',')
+                .map((ext) => ext.trim()
+                .toLowerCase())
+                .sort();
+        }
+        const confirmCommand = new ConfirmCommand();
+        await confirmCommand.confirm(app, confirm, heredoc(`
+      Destructive action
+      ${color.addon(db.name)} will lose all of its data
+    `));
+        ux.action.start(`Resetting ${color.addon(db.name)}`);
+        await this.heroku.put(`/client/v11/databases/${db.id}/reset`, {
+            body: { extensions: extensionsArray }, hostname: utils.pg.host(),
+        });
+        ux.action.stop();
+    }
+}

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

@@ -0,0 +1,13 @@
+import { PGSettingsCommand, BooleanAsString } from '../../../../lib/pg/setter.js';
+import { SettingKey, Setting } from '../../../../lib/pg/types.js';
+export default class LogAnalyze extends PGSettingsCommand {
+    static topic: string;
+    static description: string;
+    static args: {
+        database: import("@oclif/core/interfaces").Arg<string | undefined, Record<string, unknown>>;
+        value: import("@oclif/core/interfaces").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,28 @@
+import { Args } from '@oclif/core';
+import tsheredoc from 'tsheredoc';
+import { PGSettingsCommand, booleanConverter } from '../../../../lib/pg/setter.js';
+import { nls } from '../../../../nls.js';
+const heredoc = tsheredoc.default;
+export default class LogAnalyze extends PGSettingsCommand {
+    static topic = 'pg';
+    static description = heredoc(`
+    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.
+  `);
+    static args = {
+        database: Args.string({ description: `${nls('pg:database:arg:description')} ${nls('pg:database:arg:description:default:suffix')}` }),
+        value: Args.string({ description: 'boolean indicating if execution plans get logged' }),
+    };
+    settingKey = 'auto_explain.log_analyze';
+    convertValue(val) {
+        return booleanConverter(val);
+    }
+    explain(setting) {
+        if (setting.value) {
+            return 'EXPLAIN ANALYZE execution plans will be logged.';
+        }
+        return 'EXPLAIN ANALYZE execution plans will not be logged.';
+    }
+}

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

@@ -0,0 +1,13 @@
+import { BooleanAsString, PGSettingsCommand } from '../../../../lib/pg/setter.js';
+import { Setting, SettingKey } from '../../../../lib/pg/types.js';
+export default class LogBuffersWaits extends PGSettingsCommand {
+    static topic: string;
+    static description: string;
+    static args: {
+        database: import("@oclif/core/interfaces").Arg<string | undefined, Record<string, unknown>>;
+        value: import("@oclif/core/interfaces").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,26 @@
+import { Args } from '@oclif/core';
+import tsheredoc from 'tsheredoc';
+import { PGSettingsCommand, booleanConverter } from '../../../../lib/pg/setter.js';
+import { nls } from '../../../../nls.js';
+const heredoc = tsheredoc.default;
+export default class LogBuffersWaits extends PGSettingsCommand {
+    static topic = 'pg';
+    static description = heredoc(`
+    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.
+  `);
+    static args = {
+        database: Args.string({ description: `${nls('pg:database:arg:description')} ${nls('pg:database:arg:description:default:suffix')}` }),
+        value: Args.string({ description: 'boolean indicating if the database has buffer statistics enabled' }),
+    };
+    settingKey = 'auto_explain.log_buffers';
+    convertValue(val) {
+        return 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.';
+    }
+}

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

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

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

@@ -0,0 +1,22 @@
+import { Args } from '@oclif/core';
+import { PGSettingsCommand } from '../../../../lib/pg/setter.js';
+import tsheredoc from 'tsheredoc';
+import { nls } from '../../../../nls.js';
+const heredoc = tsheredoc.default;
+export default class LogFormat extends PGSettingsCommand {
+    static description = heredoc(`
+    selects the EXPLAIN output format to be used
+    The allowed values are text, xml, json, and yaml. The default is text.
+  `);
+    static args = {
+        database: Args.string({ description: `${nls('pg:database:arg:description')} ${nls('pg:database:arg:description:default:suffix')}` }),
+        value: Args.string({ options: ['text', 'json', 'yaml', 'xml'], description: 'format of the log output\n<options: text|json|yaml|xml>' }),
+    };
+    settingKey = 'auto_explain.log_format';
+    explain(setting) {
+        return `Auto explain log output will log in ${setting.value} format.`;
+    }
+    convertValue(val) {
+        return val;
+    }
+}

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

@@ -0,0 +1,13 @@
+import { PGSettingsCommand } from '../../../../lib/pg/setter.js';
+import { Setting, SettingKey } from '../../../../lib/pg/types.js';
+export default class LogMinDuration extends PGSettingsCommand {
+    static topic: string;
+    static description: string;
+    static args: {
+        database: import("@oclif/core/interfaces").Arg<string | undefined, Record<string, unknown>>;
+        value: import("@oclif/core/interfaces").Arg<string | undefined, Record<string, unknown>>;
+    };
+    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,29 @@
+import { Args } from '@oclif/core';
+import tsheredoc from 'tsheredoc';
+import { PGSettingsCommand, numericConverter } from '../../../../lib/pg/setter.js';
+import { nls } from '../../../../nls.js';
+const heredoc = tsheredoc.default;
+export default class LogMinDuration extends PGSettingsCommand {
+    static topic = 'pg';
+    static description = heredoc(`
+    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.
+  `);
+    static args = {
+        database: Args.string({ description: `${nls('pg:database:arg:description')} ${nls('pg:database:arg:description:default:suffix')}` }),
+        value: Args.string({ description: 'minimum duration in milliseconds for queries before logging execution plans. A value of -1 disables it. A value of 0 logs all query execution plans.' }),
+    };
+    settingKey = 'auto_explain.log_min_duration';
+    convertValue(val) {
+        return 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.`;
+    }
+}

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

@@ -0,0 +1,12 @@
+import { PGSettingsCommand } from '../../../../lib/pg/setter.js';
+import type { Setting, SettingKey } from '../../../../lib/pg/types.js';
+export default class LogNestedStatements extends PGSettingsCommand {
+    static description: string;
+    static args: {
+        database: import("@oclif/core/interfaces").Arg<string | undefined, Record<string, unknown>>;
+        value: import("@oclif/core/interfaces").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,20 @@
+import { Args } from '@oclif/core';
+import { booleanConverter, PGSettingsCommand } from '../../../../lib/pg/setter.js';
+import { nls } from '../../../../nls.js';
+export default class LogNestedStatements extends PGSettingsCommand {
+    static description = "Nested statements are included in the execution plan's log.";
+    static args = {
+        database: Args.string({ description: `${nls('pg:database:arg:description')} ${nls('pg:database:arg:description:default:suffix')}` }),
+        value: Args.string({ description: 'boolean indicating if execution plan logs include nested statements' }),
+    };
+    settingKey = 'auto_explain.log_nested_statements';
+    convertValue(val) {
+        return 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.';
+    }
+}

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

@@ -0,0 +1,13 @@
+import { PGSettingsCommand, BooleanAsString } from '../../../../lib/pg/setter.js';
+import { SettingKey, Setting } from '../../../../lib/pg/types.js';
+export default class LogTriggers extends PGSettingsCommand {
+    static topic: string;
+    static description: string;
+    static args: {
+        database: import("@oclif/core/interfaces").Arg<string | undefined, Record<string, unknown>>;
+        value: import("@oclif/core/interfaces").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,26 @@
+import { Args } from '@oclif/core';
+import tsheredoc from 'tsheredoc';
+import { PGSettingsCommand, booleanConverter } from '../../../../lib/pg/setter.js';
+import { nls } from '../../../../nls.js';
+const heredoc = tsheredoc.default;
+export default class LogTriggers extends PGSettingsCommand {
+    static topic = 'pg';
+    static description = heredoc(`
+    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.
+  `);
+    static args = {
+        database: Args.string({ description: `${nls('pg:database:arg:description')} ${nls('pg:database:arg:description:default:suffix')}` }),
+        value: Args.string({ description: 'boolean indicating if the database has trigger execution statistics enabled' }),
+    };
+    settingKey = 'auto_explain.log_triggers';
+    convertValue(val) {
+        return 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.';
+    }
+}

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

@@ -0,0 +1,17 @@
+import { PGSettingsCommand } from '../../../../lib/pg/setter.js';
+import type { Setting, SettingKey } from '../../../../lib/pg/types.js';
+export default class AutoExplainLogVerbose extends PGSettingsCommand {
+    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>>;
+        value: import("@oclif/core/interfaces").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,29 @@
+import { flags } from '@heroku-cli/command';
+import { Args } from '@oclif/core';
+import tsheredoc from 'tsheredoc';
+import { booleanConverter, PGSettingsCommand } from '../../../../lib/pg/setter.js';
+import { nls } from '../../../../nls.js';
+const heredoc = tsheredoc.default;
+export default class AutoExplainLogVerbose extends PGSettingsCommand {
+    static topic = 'pg';
+    static description = heredoc(`Include verbose details in execution plans.
+    This is equivalent to calling EXPLAIN VERBOSE.`);
+    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')}` }),
+        value: Args.string({ description: 'boolean indicating if the database has verbose execution plan logging enabled' }),
+    };
+    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 booleanConverter(val);
+    }
+}

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

@@ -0,0 +1,18 @@
+import { BooleanAsString, PGSettingsCommand } from '../../../lib/pg/setter.js';
+import type { Setting, SettingKey } from '../../../lib/pg/types.js';
+export default class AutoExplain extends PGSettingsCommand {
+    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>>;
+        value: import("@oclif/core/interfaces").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,34 @@
+import { flags } from '@heroku-cli/command';
+import { Args } from '@oclif/core';
+import tsheredoc from 'tsheredoc';
+import { booleanConverter, PGSettingsCommand } from '../../../lib/pg/setter.js';
+import { nls } from '../../../nls.js';
+const heredoc = tsheredoc.default;
+// ref: https://www.postgresql.org/docs/current/auto-explain.html
+export default class AutoExplain extends PGSettingsCommand {
+    static topic = 'pg';
+    static description = heredoc(`
+  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.
+  `);
+    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')}` }),
+        value: Args.string({ description: 'boolean indicating if execution plans of queries will be logged for future connections' }),
+    };
+    static strict = false;
+    settingKey = 'auto_explain';
+    convertValue(val) {
+        return 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.';
+    }
+}

package/lib/commands/pg/settings/data-connector-details-logs.d.ts

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

package/lib/commands/pg/settings/data-connector-details-logs.js

@@ -0,0 +1,30 @@
+import { flags } from '@heroku-cli/command';
+import { Args } from '@oclif/core';
+import tsheredoc from 'tsheredoc';
+import { booleanConverter, PGSettingsCommand } from '../../../lib/pg/setter.js';
+import { nls } from '../../../nls.js';
+const heredoc = tsheredoc.default;
+export default class DataConnectorDetailsLogs extends PGSettingsCommand {
+    static aliases = ['pg:settings:explain-data-connector-details'];
+    static description = heredoc(`
+  displays stats on replication slots on your database, the default value is "off"
+  `);
+    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')}` }),
+        value: Args.string({ description: 'boolean indicating if data replication slot details get logged' }),
+    };
+    settingKey = 'data_connector_details_logs';
+    convertValue(val) {
+        return booleanConverter(val);
+    }
+    explain(setting) {
+        if (setting?.value) {
+            return 'Data replication slot details will be logged.';
+        }
+        return 'Data replication slot details will no longer be logged.';
+    }
+}

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/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/settings/index.js

@@ -0,0 +1,33 @@
+import { Command, flags } from '@heroku-cli/command';
+import { Args, ux } from '@oclif/core';
+import { hux, 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 your current database settings';
+    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('You can\'t perform this operation on Essential-tier databases.');
+        }
+        const { body: settings } = await this.heroku.get(`/postgres/v0/databases/${db.id}/config`, { hostname: utils.pg.host() });
+        hux.styledHeader(db.name);
+        const remapped = {};
+        Object.keys(settings).forEach(k => {
+            remapped[k.replace(/_/g, '-')] = settings[k].value;
+        });
+        hux.styledObject(remapped);
+    }
+}

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

@@ -0,0 +1,17 @@
+import { PGSettingsCommand } from '../../../lib/pg/setter.js';
+import type { Setting, SettingKey } from '../../../lib/pg/types.js';
+export default class LogConnections extends PGSettingsCommand {
+    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>>;
+        value: import("@oclif/core/interfaces").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,30 @@
+import { flags } from '@heroku-cli/command';
+import { Args } from '@oclif/core';
+import tsheredoc from 'tsheredoc';
+import { booleanConverter, PGSettingsCommand } from '../../../lib/pg/setter.js';
+import { nls } from '../../../nls.js';
+const heredoc = tsheredoc.default;
+export default class LogConnections extends PGSettingsCommand {
+    static topic = 'pg';
+    static description = heredoc(`
+  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.`);
+    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')}` }),
+        value: Args.string({ description: 'boolean indicating if database login attempts get logged' }),
+    };
+    settingKey = 'log_connections';
+    convertValue(val) {
+        return 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.';
+    }
+}