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

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

package/lib/commands/pg/upgrade.js

@@ -0,0 +1,58 @@
+"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 host_1 = require("../../lib/pg/host");
+const util_1 = require("../../lib/pg/util");
+const confirmCommand_1 = require("../../lib/confirmCommand");
+class Upgrade extends command_1.Command {
+    async run() {
+        const { flags, args } = await this.parse(Upgrade);
+        const { app, version, confirm } = flags;
+        const { database } = args;
+        const db = await (0, fetcher_1.getAddon)(this.heroku, app, database);
+        if ((0, util_1.legacyEssentialPlan)(db))
+            core_1.ux.error('pg:upgrade is only available for Essential-* databases and follower databases on Standard-tier and higher plans.');
+        const { body: replica } = await this.heroku.get(`/client/v11/databases/${db.id}`, { hostname: (0, host_1.default)() });
+        if (replica.following) {
+            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 be upgraded to a newer PostgreSQL version, stop following ${origin}, and become writable.
+
+        This cannot be undone.
+      `));
+        }
+        else {
+            await (0, confirmCommand_1.default)(app, confirm, (0, tsheredoc_1.default)(`
+        Destructive action
+        ${color_1.default.addon(db.name)} will be upgraded to a newer PostgreSQL version.
+
+        This cannot be undone.
+      `));
+        }
+        const data = { version };
+        core_1.ux.action.start(`Starting upgrade of ${color_1.default.addon(db.name)}`);
+        await this.heroku.post(`/client/v11/databases/${db.id}/upgrade`, { hostname: (0, host_1.default)(), body: data });
+        core_1.ux.action.stop(`Use ${color_1.default.cmd('heroku pg:wait')} to track status`);
+    }
+}
+exports.default = Upgrade;
+Upgrade.topic = 'pg';
+Upgrade.description = (0, tsheredoc_1.default)(`
+    For an Essential-* plan, this command upgrades the database's PostgreSQL version. For a Standard-tier and higher plan, this command unfollows the leader database before upgrading the PostgreSQL version.
+    To upgrade to another PostgreSQL version, use pg:copy instead
+  `);
+Upgrade.flags = {
+    confirm: command_1.flags.string({ char: 'c' }),
+    version: command_1.flags.string({ char: 'v', description: 'PostgreSQL version to upgrade to' }),
+    app: command_1.flags.app({ required: true }),
+    remote: command_1.flags.remote(),
+};
+Upgrade.args = {
+    database: core_1.Args.string(),
+};

package/lib/commands/pg/vacuum-stats.d.ts

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

@@ -0,0 +1,65 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const command_1 = require("@heroku-cli/command");
+const core_1 = require("@oclif/core");
+const fetcher_1 = require("../../lib/pg/fetcher");
+const psql_1 = require("../../lib/pg/psql");
+const tsheredoc_1 = require("tsheredoc");
+class VacuumStats extends command_1.Command {
+    async run() {
+        const { flags, args } = await this.parse(VacuumStats);
+        const db = await (0, fetcher_1.database)(this.heroku, flags.app, args.database);
+        const query = (0, tsheredoc_1.default)(`
+      WITH table_opts AS (
+        SELECT
+          pg_class.oid, relname, nspname, array_to_string(reloptions, '') AS relopts
+        FROM
+          pg_class INNER JOIN pg_namespace ns ON relnamespace = ns.oid
+      ), vacuum_settings AS (
+        SELECT
+          oid, relname, nspname,
+          CASE
+            WHEN relopts LIKE '%autovacuum_vacuum_threshold%'
+              THEN substring(relopts, '.*autovacuum_vacuum_threshold=([0-9.]+).*')::integer
+              ELSE current_setting('autovacuum_vacuum_threshold')::integer
+            END AS autovacuum_vacuum_threshold,
+          CASE
+            WHEN relopts LIKE '%autovacuum_vacuum_scale_factor%'
+              THEN substring(relopts, '.*autovacuum_vacuum_scale_factor=([0-9.]+).*')::real
+              ELSE current_setting('autovacuum_vacuum_scale_factor')::real
+            END AS autovacuum_vacuum_scale_factor
+        FROM
+          table_opts
+      )
+      SELECT
+        vacuum_settings.nspname AS schema,
+        vacuum_settings.relname AS table,
+        to_char(psut.last_vacuum, 'YYYY-MM-DD HH24:MI') AS last_vacuum,
+        to_char(psut.last_autovacuum, 'YYYY-MM-DD HH24:MI') AS last_autovacuum,
+        to_char(pg_class.reltuples, '9G999G999G999') AS rowcount,
+        to_char(psut.n_dead_tup, '9G999G999G999') AS dead_rowcount,
+        to_char(autovacuum_vacuum_threshold
+              + (autovacuum_vacuum_scale_factor::numeric * pg_class.reltuples), '9G999G999G999') AS autovacuum_threshold,
+        CASE
+          WHEN autovacuum_vacuum_threshold + (autovacuum_vacuum_scale_factor::numeric * pg_class.reltuples) < psut.n_dead_tup
+          THEN 'yes'
+        END AS expect_autovacuum
+      FROM
+        pg_stat_user_tables psut INNER JOIN pg_class ON psut.relid = pg_class.oid
+          INNER JOIN vacuum_settings ON pg_class.oid = vacuum_settings.oid
+      ORDER BY 1
+    `);
+        const output = await (0, psql_1.exec)(db, query);
+        core_1.ux.log(output);
+    }
+}
+exports.default = VacuumStats;
+VacuumStats.topic = 'pg';
+VacuumStats.description = 'show dead rows and whether an automatic vacuum is expected to be triggered';
+VacuumStats.flags = {
+    app: command_1.flags.app({ required: true }),
+    remote: command_1.flags.remote(),
+};
+VacuumStats.args = {
+    database: core_1.Args.string(),
+};

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

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

@@ -0,0 +1,79 @@
+"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 debug_1 = require("debug");
+const fetcher_1 = require("../../lib/pg/fetcher");
+const host_1 = require("../../lib/pg/host");
+const notify_1 = require("../../lib/notify");
+const wait = (ms) => new Promise(resolve => {
+    setTimeout(resolve, ms);
+});
+class Wait extends command_1.Command {
+    async run() {
+        const { flags, args } = await this.parse(Wait);
+        const { app, 'wait-interval': waitInterval } = flags;
+        const dbName = args.database;
+        const pgDebug = (0, debug_1.default)('pg');
+        const waitFor = async (db) => {
+            let interval = waitInterval && Number.parseInt(waitInterval, 10);
+            if (!interval || interval < 0)
+                interval = 5;
+            let status;
+            let waiting = false;
+            let retries = 20;
+            while (true) {
+                try {
+                    ({ body: status } = await this.heroku.get(`/client/v11/databases/${db.id}/wait_status`, { hostname: (0, host_1.default)() }));
+                }
+                catch (error) {
+                    const httpError = error;
+                    pgDebug(httpError);
+                    if (!retries || httpError.statusCode !== 404)
+                        throw httpError;
+                    retries--;
+                    status = { 'waiting?': true };
+                }
+                if (status['error?']) {
+                    (0, notify_1.default)('error', `${db.name} ${status.message}`, false);
+                    core_1.ux.error(status.message || '', { exit: 1 });
+                }
+                if (!status['waiting?']) {
+                    if (waiting) {
+                        core_1.ux.action.stop(status.message);
+                    }
+                    return;
+                }
+                if (!waiting) {
+                    waiting = true;
+                    core_1.ux.action.start(`Waiting for database ${color_1.default.yellow(db.name)}`, status.message);
+                }
+                core_1.ux.action.status = status.message;
+                await wait(interval * 1000);
+            }
+        };
+        let dbs = [];
+        if (dbName) {
+            dbs = [await (0, fetcher_1.getAddon)(this.heroku, app, dbName)];
+        }
+        else {
+            dbs = await (0, fetcher_1.all)(this.heroku, app);
+        }
+        for (const db of dbs) {
+            await waitFor(db);
+        }
+    }
+}
+exports.default = Wait;
+Wait.topic = 'pg';
+Wait.description = 'blocks until database is available';
+Wait.flags = {
+    'wait-interval': command_1.flags.string({ description: 'how frequently to poll in seconds (to avoid rate limiting)' }),
+    'no-notify': command_1.flags.boolean({ description: 'do not show OS notification' }),
+    app: command_1.flags.app({ required: true }),
+    remote: command_1.flags.remote(),
+};
+Wait.args = {
+    database: core_1.Args.string(),
+};

package/lib/commands/pipelines/connect.js

@@ -32,7 +32,7 @@ class Connect extends command_1.Command {
     }
 }
 exports.default = Connect;
-Connect.description = 'connect a github repo to an existing pipeline';
+Connect.description = 'connect a GitHub repo to an existing pipeline';
 Connect.examples = [
     '$ heroku pipelines:connect my-pipeline -r githuborg/reponame',
 ];

package/lib/commands/pipelines/diff.js

@@ -20,7 +20,7 @@ async function diff(targetApp, downstreamApp, githubToken, herokuUserAgent) {
     if (downstreamApp.hash === targetApp.hash) {
         return core_1.ux.log(`\n${color_1.default.app(targetApp.name)} is up to date with ${color_1.default.app(downstreamApp.name)}`);
     }
-    // Do the actual Github diff
+    // Do the actual GitHub diff
     try {
         const path = `${targetApp.repo}/compare/${downstreamApp.hash}...${targetApp.hash}`;
         const headers = { authorization: 'token ' + githubToken };

package/lib/commands/ps/index.d.ts

@@ -0,0 +1,15 @@
+import { Command } from '@heroku-cli/command';
+export default class Index extends Command {
+    static topic: string;
+    static description: string;
+    static strict: boolean;
+    static usage: string;
+    static examples: 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>;
+        json: import("@oclif/core/lib/interfaces").BooleanFlag<boolean>;
+        extended: import("@oclif/core/lib/interfaces").BooleanFlag<boolean>;
+    };
+    run(): Promise<void>;
+}