heroku 9.0.0-dev.0 → 9.1.0-beta.0

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.";
+}

package/lib/commands/pg/settings/log-lock-waits.js

@@ -0,0 +1,31 @@
+"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 LogLockWaits extends setter_1.PGSettingsCommand {
+    constructor() {
+        super(...arguments);
+        this.settingKey = 'log_lock_waits';
+    }
+    convertValue(val) {
+        return (0, setter_1.booleanConverter)(val);
+    }
+    explain(setting) {
+        if (setting.value) {
+            return "When a deadlock is detected, a log message will be emitted in your application's logs.";
+        }
+        return "When a deadlock is detected, no log message will be emitted in your application's logs.";
+    }
+}
+exports.default = LogLockWaits;
+LogLockWaits.topic = 'pg';
+LogLockWaits.description = (0, tsheredoc_1.default)(`
+    Controls whether a log message is produced when a session waits longer than the deadlock_timeout to acquire a lock. deadlock_timeout is set to 1 second
+    Delays due to lock contention occur when multiple transactions are trying to access the same resource at the same time.
+    Applications and their query patterns should try to avoid changes to many different tables within the same transaction.
+  `);
+LogLockWaits.args = {
+    database: core_1.Args.string(),
+    value: core_1.Args.string(),
+};

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

@@ -0,0 +1,15 @@
+import { PGSettingsCommand } from '../../../lib/pg/setter';
+import type { Setting, SettingKey } from '../../../lib/pg/types';
+export default class LogMinDurationStatement 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<number | undefined, {
+            min?: number | undefined;
+            max?: number | undefined;
+        }>;
+    };
+    protected settingKey: SettingKey;
+    protected convertValue(val: unknown): number;
+    protected explain(setting: Setting<unknown>): string;
+}

package/lib/commands/pg/settings/log-min-duration-statement.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 LogMinDurationStatement extends setter_1.PGSettingsCommand {
+    constructor() {
+        super(...arguments);
+        this.settingKey = 'log_min_duration_statement';
+    }
+    convertValue(val) {
+        return val;
+    }
+    explain(setting) {
+        if (setting.value === -1) {
+            return 'The duration of each completed statement will not be logged.';
+        }
+        if (setting.value === 0) {
+            return 'The duration of each completed statement will be logged.';
+        }
+        return `The duration of each completed statement will be logged if the statement ran for at least ${setting.value} milliseconds.`;
+    }
+}
+exports.default = LogMinDurationStatement;
+LogMinDurationStatement.description = (0, tsheredoc_1.default)(`
+    The duration of each completed statement will be logged if the statement completes after the time specified by VALUE.
+    VALUE needs to specified as a whole number, in milliseconds.
+    Setting log_min_duration_statement to zero prints all statement durations and -1 will disable logging statement durations.
+  `);
+LogMinDurationStatement.args = {
+    database: core_1.Args.string(),
+    value: core_1.Args.integer(),
+};

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

@@ -0,0 +1,12 @@
+import { type Setting, type SettingKey } from '../../../lib/pg/types';
+import { PGSettingsCommand } from '../../../lib/pg/setter';
+export default class LogStatement 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: string): string;
+    protected explain(setting: Setting<string>): string;
+}

package/lib/commands/pg/settings/log-statement.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 LogStatement extends setter_1.PGSettingsCommand {
+    constructor() {
+        super(...arguments);
+        this.settingKey = 'log_statement';
+    }
+    convertValue(val) {
+        return val;
+    }
+    explain(setting) {
+        return setting.values[setting.value];
+    }
+}
+exports.default = LogStatement;
+LogStatement.description = (0, tsheredoc_1.default)(`
+    log_statement controls which SQL statements are logged.
+    Valid values for VALUE:
+    none - No statements are logged
+    ddl  - All data definition statements, such as CREATE, ALTER and DROP will be logged
+    mod  - Includes all statements from ddl as well as data-modifying statements such as INSERT, UPDATE, DELETE, TRUNCATE, COPY
+    all  - All statements are logged
+  `);
+LogStatement.args = {
+    database: core_1.Args.string(),
+    value: core_1.Args.string({ options: ['none', 'ddl', 'mod', 'all'] }),
+};

package/lib/commands/pg/settings/track-functions.d.ts

@@ -0,0 +1,12 @@
+import { PGSettingsCommand } from '../../../lib/pg/setter';
+import type { Setting, SettingKey } from '../../../lib/pg/types';
+export default class TrackFunctions 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): unknown;
+    protected explain(setting: Setting<keyof Setting<unknown>['value']>): string;
+}

package/lib/commands/pg/settings/track-functions.js

@@ -0,0 +1,29 @@
+"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");
+// ref: https://www.postgresql.org/docs/current/runtime-config-statistics.html#GUC-TRACK-FUNCTIONS
+class TrackFunctions extends setter_1.PGSettingsCommand {
+    constructor() {
+        super(...arguments);
+        this.settingKey = 'track_functions';
+    }
+    convertValue(val) {
+        return val;
+    }
+    explain(setting) {
+        return setting.values[setting.value];
+    }
+}
+exports.default = TrackFunctions;
+TrackFunctions.description = (0, tsheredoc_1.default)(`
+    track_functions controls tracking of function call counts and time used. Default is none.
+    Valid values for VALUE:
+    none - No functions are tracked (default)
+    pl   - Only procedural language functions are tracked
+    all  - All functions, including SQL and C language functions, are tracked. Simple SQL-language that are inlined are not tracked`);
+TrackFunctions.args = {
+    database: core_1.Args.string(),
+    value: core_1.Args.string({ options: ['none', 'pl', 'all'] }),
+};

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

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

package/lib/commands/pg/unfollow.js

@@ -0,0 +1,40 @@
+"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 fetcher_1 = require("../../lib/pg/fetcher");
+const host_1 = require("../../lib/pg/host");
+const util_1 = require("../../lib/pg/util");
+const confirmCommand_1 = require("../../lib/confirmCommand");
+const tsheredoc_1 = require("tsheredoc");
+class Unfollow extends command_1.Command {
+    async run() {
+        const { flags, args } = await this.parse(Unfollow);
+        const { app, confirm } = flags;
+        const db = await (0, fetcher_1.getAddon)(this.heroku, app, args.database);
+        const { body: replica } = await this.heroku.get(`/client/v11/databases/${db.id}`, { hostname: (0, host_1.default)() });
+        if (!replica.following)
+            core_1.ux.error(`${color_1.default.addon(db.name)} is not a follower`);
+        const { body: configVars } = await this.heroku.get(`/apps/${app}/config-vars`);
+        const origin = (0, util_1.databaseNameFromUrl)(replica.following, configVars);
+        await (0, confirmCommand_1.default)(app, confirm, (0, tsheredoc_1.default)(`
+      Destructive action
+      ${color_1.default.addon(db.name)} will become writeable and no longer follow ${origin}. This cannot be undone.
+    `));
+        core_1.ux.action.start(`${color_1.default.addon(db.name)} unfollowing`);
+        await this.heroku.put(`/client/v11/databases/${db.id}/unfollow`, { hostname: (0, host_1.default)() });
+        core_1.ux.action.stop();
+    }
+}
+exports.default = Unfollow;
+Unfollow.topic = 'pg';
+Unfollow.description = 'stop a replica from following and make it a writeable database';
+Unfollow.flags = {
+    confirm: command_1.flags.string({ char: 'c' }),
+    app: command_1.flags.app({ required: true }),
+    remote: command_1.flags.remote(),
+};
+Unfollow.args = {
+    database: core_1.Args.string({ required: true }),
+};

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

@@ -0,0 +1,15 @@
+import { Command } from '@heroku-cli/command';
+export default class Upgrade extends Command {
+    static topic: string;
+    static description: string;
+    static flags: {
+        confirm: import("@oclif/core/lib/interfaces").OptionFlag<string | undefined, import("@oclif/core/lib/interfaces/parser").CustomOptions>;
+        version: 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>;
+}