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

package/lib/commands/redis/cli.js

@@ -0,0 +1,204 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const command_1 = require("@heroku-cli/command");
+const core_1 = require("@oclif/core");
+const readline = require("readline");
+const ssh2_1 = require("ssh2");
+const Parser = require("redis-parser");
+const portfinder = require("portfinder");
+const confirmCommand_1 = require("../../lib/confirmCommand");
+const tls = require("tls");
+const node_util_1 = require("node:util");
+const net = require("net");
+const api_1 = require("../../lib/redis/api");
+const REPLY_OK = 'OK';
+async function redisCLI(uri, client) {
+    const io = readline.createInterface(process.stdin, process.stdout);
+    const reply = new Parser({
+        returnReply(reply) {
+            switch (state) {
+                case 'monitoring':
+                    if (reply !== REPLY_OK) {
+                        console.log(reply);
+                    }
+                    break;
+                case 'subscriber':
+                    if (Array.isArray(reply)) {
+                        reply.forEach(function (value, i) {
+                            console.log(`${i + 1}) ${value}`);
+                        });
+                    }
+                    else {
+                        console.log(reply);
+                    }
+                    break;
+                case 'connect':
+                    if (reply !== REPLY_OK) {
+                        console.log(reply);
+                    }
+                    state = 'normal';
+                    io.prompt();
+                    break;
+                case 'closing':
+                    if (reply !== REPLY_OK) {
+                        console.log(reply);
+                    }
+                    break;
+                default:
+                    if (Array.isArray(reply)) {
+                        reply.forEach(function (value, i) {
+                            console.log(`${i + 1}) ${value}`);
+                        });
+                    }
+                    else {
+                        console.log(reply);
+                    }
+                    io.prompt();
+                    break;
+            }
+        }, returnError(err) {
+            console.log(err.message);
+            io.prompt();
+        }, returnFatalError(err) {
+            client.emit('error', err);
+            console.dir(err);
+        },
+    });
+    let state = 'connect';
+    client.write(`AUTH ${uri.password}\n`);
+    io.setPrompt(uri.host + '> ');
+    io.on('line', function (line) {
+        switch (line.split(' ')[0]) {
+            case 'MONITOR':
+                state = 'monitoring';
+                break;
+            case 'PSUBSCRIBE':
+            case 'SUBSCRIBE':
+                state = 'subscriber';
+                break;
+        }
+        client.write(`${line}\n`);
+    });
+    io.on('close', function () {
+        state = 'closing';
+        client.write('QUIT\n');
+    });
+    client.on('data', function (data) {
+        reply.execute(data);
+    });
+    return new Promise((resolve, reject) => {
+        client.on('error', reject);
+        client.on('end', function () {
+            console.log('\nDisconnected from instance.');
+            io.close();
+            resolve();
+        });
+    });
+}
+async function bastionConnect(uri, bastions, config, preferNativeTls) {
+    const tunnel = await new Promise(resolve => {
+        var _a;
+        const ssh2 = new ssh2_1.Client();
+        resolve(ssh2);
+        ssh2.once('ready', () => resolve(ssh2));
+        ssh2.connect({
+            host: bastions.split(',')[0],
+            username: 'bastion',
+            privateKey: (_a = match(config, /_BASTION_KEY/)) !== null && _a !== void 0 ? _a : '',
+        });
+    });
+    const localPort = await portfinder.getPortPromise({ startPort: 49152, stopPort: 65535 });
+    const stream = await (0, node_util_1.promisify)(tunnel.forwardOut)('localhost', localPort, uri.hostname, Number.parseInt(uri.port, 10));
+    let client = stream;
+    if (preferNativeTls) {
+        client = tls.connect({
+            socket: stream,
+            port: Number.parseInt(uri.port, 10),
+            host: uri.hostname,
+            rejectUnauthorized: false,
+        });
+    }
+    stream.on('close', () => tunnel.end());
+    stream.on('end', () => client.end());
+    return redisCLI(uri, client);
+}
+function match(config, lookup) {
+    for (const key in config) {
+        if (lookup.test(key)) {
+            return config[key];
+        }
+    }
+    return null;
+}
+async function maybeTunnel(redis, config) {
+    var _a;
+    const bastions = match(config, /_BASTIONS/);
+    const hobby = redis.plan.indexOf('hobby') === 0;
+    const preferNativeTls = redis.prefer_native_tls;
+    const uri = preferNativeTls && hobby ? new URL((_a = match(config, /_TLS_URL/)) !== null && _a !== void 0 ? _a : '') : new URL(redis.resource_url);
+    if (bastions !== null) {
+        return bastionConnect(uri, bastions, config, preferNativeTls);
+    }
+    let client;
+    if (preferNativeTls) {
+        client = tls.connect({
+            port: Number.parseInt(uri.port, 10), host: uri.hostname, rejectUnauthorized: false,
+        });
+    }
+    else if (hobby) {
+        client = net.connect({ port: Number.parseInt(uri.port, 10), host: uri.hostname });
+    }
+    else {
+        client = tls.connect({
+            port: Number.parseInt(uri.port, 10) + 1, host: uri.hostname, rejectUnauthorized: false,
+        });
+    }
+    return redisCLI(uri, client);
+}
+class Cli extends command_1.Command {
+    async run() {
+        const { flags, args } = await this.parse(Cli);
+        const api = (0, api_1.default)(flags.app, args.database, false, this.heroku);
+        const addon = await api.getRedisAddon();
+        const configVars = await getRedisConfigVars(addon, this.heroku);
+        const { body: redis } = await api.request(`/redis/v0/databases/${addon.id}`);
+        if (redis.plan.startsWith('shield-')) {
+            core_1.ux.error('\n      Using redis:cli on Heroku Redis shield plans is not supported.\n      Please see Heroku DevCenter for more details: https://devcenter.heroku.com/articles/shield-private-space#shield-features\n      ', { exit: 1 });
+        }
+        const hobby = redis.plan.indexOf('hobby') === 0;
+        const prefer_native_tls = redis.prefer_native_tls;
+        if (!prefer_native_tls && hobby) {
+            await (0, confirmCommand_1.default)(flags.app, flags.confirm, 'WARNING: Insecure action.\nAll data, including the Redis password, will not be encrypted.');
+        }
+        const nonBastionVars = Object.keys(configVars)
+            .filter(function (configVar) {
+            return !(/(?:BASTIONS|BASTION_KEY|BASTION_REKEYS_AFTER)$/.test(configVar));
+        })
+            .join(', ');
+        core_1.ux.log(`Connecting to ${addon.name} (${nonBastionVars}):`);
+        return maybeTunnel(redis, configVars);
+    }
+}
+exports.default = Cli;
+Cli.topic = 'redis';
+Cli.description = 'opens a redis prompt';
+Cli.flags = {
+    confirm: command_1.flags.string({ char: 'c' }),
+    app: command_1.flags.app({ required: true }),
+    remote: command_1.flags.remote(),
+};
+Cli.args = {
+    database: core_1.Args.string(),
+};
+Cli.examples = [
+    '$ heroku redis:cli --app=my-app my-database',
+    '$ heroku redis:cli --app=my-app --confirm my-database',
+];
+async function getRedisConfigVars(addon, heroku) {
+    const { body: config } = await heroku.get(`/apps/${addon.billing_entity.name}/config-vars`);
+    const redisConfigVars = {};
+    addon.config_vars.forEach(configVar => {
+        redisConfigVars[configVar] = config[configVar];
+    });
+    return redisConfigVars;
+}

package/lib/commands/redis/credentials.d.ts

@@ -0,0 +1,14 @@
+import { Command } from '@heroku-cli/command';
+export default class Credentials 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>;
+        reset: import("@oclif/core/lib/interfaces").BooleanFlag<boolean>;
+    };
+    static args: {
+        database: import("@oclif/core/lib/interfaces/parser").Arg<string | undefined, Record<string, unknown>>;
+    };
+    run(): Promise<void>;
+}

package/lib/commands/redis/credentials.js

@@ -0,0 +1,32 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const command_1 = require("@heroku-cli/command");
+const core_1 = require("@oclif/core");
+const api_1 = require("../../lib/redis/api");
+class Credentials extends command_1.Command {
+    async run() {
+        const { args, flags } = await this.parse(Credentials);
+        const { app, reset } = flags;
+        const { database } = args;
+        const addon = await (0, api_1.default)(app, database, false, this.heroku).getRedisAddon();
+        if (reset) {
+            core_1.ux.log(`Resetting credentials for ${addon.name}`);
+            await (0, api_1.default)(app, database, false, this.heroku).request(`/redis/v0/databases/${addon.name}/credentials_rotation`, 'POST');
+        }
+        else {
+            const { body: redis } = await (0, api_1.default)(app, database, false, this.heroku).request(`/redis/v0/databases/${addon.name}`);
+            core_1.ux.log(redis.resource_url);
+        }
+    }
+}
+exports.default = Credentials;
+Credentials.topic = 'redis';
+Credentials.description = 'display credentials information';
+Credentials.flags = {
+    app: command_1.flags.app({ required: true }),
+    remote: command_1.flags.remote(),
+    reset: command_1.flags.boolean({ description: 'reset credentials' }),
+};
+Credentials.args = {
+    database: core_1.Args.string({ required: false }),
+};

package/lib/commands/redis/info.d.ts

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

package/lib/commands/redis/info.js

@@ -0,0 +1,25 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const command_1 = require("@heroku-cli/command");
+const core_1 = require("@oclif/core");
+const api_1 = require("../../lib/redis/api");
+class Info extends command_1.Command {
+    async run() {
+        const { flags, args } = await this.parse(Info);
+        const { app, json } = flags;
+        const { database } = args;
+        return (0, api_1.default)(app, database, json, this.heroku).info();
+    }
+}
+exports.default = Info;
+Info.topic = 'redis';
+Info.description = 'gets information about redis';
+Info.aliases = ['redis'];
+Info.flags = {
+    app: command_1.flags.app({ required: true }),
+    remote: command_1.flags.remote(),
+    json: command_1.flags.boolean({ char: 'j', description: 'output in json format' }),
+};
+Info.args = {
+    database: core_1.Args.string(),
+};

package/lib/commands/redis/keyspace-notifications.d.ts

@@ -0,0 +1,14 @@
+import { Command } from '@heroku-cli/command';
+export default class KeyspaceNotifications 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>;
+        config: import("@oclif/core/lib/interfaces").OptionFlag<string, 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/redis/keyspace-notifications.js

@@ -0,0 +1,47 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const command_1 = require("@heroku-cli/command");
+const core_1 = require("@oclif/core");
+const api_1 = require("../../lib/redis/api");
+const tsheredoc_1 = require("tsheredoc");
+const core_2 = require("@oclif/core");
+class KeyspaceNotifications extends command_1.Command {
+    async run() {
+        const { flags, args } = await this.parse(KeyspaceNotifications);
+        const { app, config } = flags;
+        const { database } = args;
+        const api = (0, api_1.default)(app, database, false, this.heroku);
+        const addon = await api.getRedisAddon();
+        const { body: updated_config } = await api.request(`/redis/v0/databases/${addon.name}/config`, 'PATCH', { notify_keyspace_events: config });
+        core_2.ux.log(`Keyspace notifications for ${addon.name} (${addon.config_vars.join(', ')}) set to '${updated_config.notify_keyspace_events.value}'.`);
+    }
+}
+exports.default = KeyspaceNotifications;
+KeyspaceNotifications.topic = 'redis';
+KeyspaceNotifications.description = (0, tsheredoc_1.default) `
+    set the keyspace notifications configuration
+    Set the configuration to enable keyspace notification events:
+    K     Keyspace events, published with __keyspace@<db>__ prefix.
+    E     Keyevent events, published with __keyevent@<db>__ prefix.
+    g     Generic commands (non-type specific) like DEL, EXPIRE, RENAME, ...
+    $     String commands
+    l     List commands
+    s     Set commands
+    h     Hash commands
+    z     Sorted set commands
+    t     Stream commands
+    x     Expired events (events generated every time a key expires)
+    e     Evicted events (events generated when a key is evicted for maxmemory)
+    m     Key miss events (events generated when a key that doesn't exist is accessed)
+    A     Alias for "g$lshztxe", so that the "AKE" string means all the events except "m".
+
+    pass an empty string ('') to disable keyspace notifications
+  `;
+KeyspaceNotifications.flags = {
+    app: command_1.flags.app({ required: true }),
+    remote: command_1.flags.remote(),
+    config: command_1.flags.string({ char: 'c', description: 'set keyspace notifications configuration', hasValue: true, required: true }),
+};
+KeyspaceNotifications.args = {
+    database: core_1.Args.string(),
+};

package/lib/commands/redis/maintenance.d.ts

@@ -0,0 +1,16 @@
+import { Command } from '@heroku-cli/command';
+export default class Maintenance 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>;
+        window: import("@oclif/core/lib/interfaces").OptionFlag<string | undefined, import("@oclif/core/lib/interfaces/parser").CustomOptions>;
+        run: import("@oclif/core/lib/interfaces").BooleanFlag<boolean>;
+        force: import("@oclif/core/lib/interfaces").BooleanFlag<boolean>;
+    };
+    static args: {
+        database: import("@oclif/core/lib/interfaces/parser").Arg<string | undefined, Record<string, unknown>>;
+    };
+    run(): Promise<void>;
+}

package/lib/commands/redis/maintenance.js

@@ -0,0 +1,63 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const command_1 = require("@heroku-cli/command");
+const core_1 = require("@oclif/core");
+const api_1 = require("../../lib/redis/api");
+const tsheredoc_1 = require("tsheredoc");
+class Maintenance extends command_1.Command {
+    async run() {
+        var _a;
+        const { args, flags } = await this.parse(Maintenance);
+        const { app: appName, window, run, force } = flags;
+        const { database } = args;
+        const api = (0, api_1.default)(appName, database, false, this.heroku);
+        const addon = await api.getRedisAddon();
+        if ((_a = addon.plan.name) === null || _a === void 0 ? void 0 : _a.match(/hobby/)) {
+            core_1.ux.error('redis:maintenance is not available for hobby-dev instances', { exit: 1 });
+        }
+        if (window) {
+            if (!window.match(/[A-Za-z]{3,10} \d\d?:[03]0/)) {
+                core_1.ux.error('Maintenance windows must be "Day HH:MM", where MM is 00 or 30.', { exit: 1 });
+            }
+            const { body: maintenance } = await api.request(`/redis/v0/databases/${addon.name}/maintenance_window`, 'PUT', { description: window });
+            core_1.ux.log(`Maintenance window for ${addon.name} (${addon.config_vars.join(', ')}) set to ${maintenance.window}.`);
+            return;
+        }
+        if (run) {
+            const { body: app } = await this.heroku.get(`/apps/${appName}`);
+            if (!app.maintenance && !force) {
+                core_1.ux.error('Application must be in maintenance mode or --force flag must be used', { exit: 1 });
+            }
+            const { body: maintenance } = await api.request(`/redis/v0/databases/${addon.name}/maintenance`, 'POST');
+            core_1.ux.log(maintenance.message);
+            return;
+        }
+        const { body: maintenance } = await api.request(`/redis/v0/databases/${addon.name}/maintenance`, 'GET');
+        core_1.ux.log(maintenance.message);
+    }
+}
+exports.default = Maintenance;
+Maintenance.topic = 'redis';
+Maintenance.description = (0, tsheredoc_1.default) `
+    manage maintenance windows
+    Set or change the maintenance window for your Redis instance
+  `;
+Maintenance.flags = {
+    app: command_1.flags.app({ required: true }),
+    remote: command_1.flags.remote(),
+    window: command_1.flags.string({
+        char: 'w',
+        description: 'set weekly UTC maintenance window (format: "Day HH:MM", where MM is 00 or 30)',
+        hasValue: true,
+        required: false,
+    }),
+    run: command_1.flags.boolean({ description: 'start maintenance', required: false }),
+    force: command_1.flags.boolean({
+        char: 'f',
+        description: 'start maintenance without entering application maintenance mode',
+        required: false,
+    }),
+};
+Maintenance.args = {
+    database: core_1.Args.string({ required: false }),
+};

package/lib/commands/redis/maxmemory.d.ts

@@ -0,0 +1,14 @@
+import { Command } from '@heroku-cli/command';
+export default class MaxMemory 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>;
+        policy: 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/redis/maxmemory.js

@@ -0,0 +1,40 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const command_1 = require("@heroku-cli/command");
+const core_1 = require("@oclif/core");
+const api_1 = require("../../lib/redis/api");
+class MaxMemory extends command_1.Command {
+    async run() {
+        const { flags, args } = await this.parse(MaxMemory);
+        const { app, policy } = flags;
+        const { database } = args;
+        const addon = await (0, api_1.default)(app, database, false, this.heroku).getRedisAddon();
+        const { body: config } = await (0, api_1.default)(app, database, false, this.heroku)
+            .request(`/redis/v0/databases/${addon.name}/config`, 'PATCH', { maxmemory_policy: policy });
+        const configVars = addon.config_vars || [];
+        core_1.ux.log(`Maxmemory policy for ${addon.name} (${configVars.join(', ')}) set to ${config.maxmemory_policy.value}.`);
+        core_1.ux.log(`${config.maxmemory_policy.value} ${config.maxmemory_policy.values[config.maxmemory_policy.value]}.`);
+    }
+}
+exports.default = MaxMemory;
+MaxMemory.topic = 'redis';
+MaxMemory.description = `set the key eviction policy when instances reach their storage limit
+  Available policies for key eviction include:
+
+  noeviction      # returns errors when memory limit is reached
+  allkeys-lfu     # removes less frequently used keys first
+  volatile-lfu    # removes less frequently used keys first that have an expiry set
+  allkeys-lru     # removes less recently used keys first
+  volatile-lru    # removes less recently used keys first that have an expiry set
+  allkeys-random  # evicts random keys
+  volatile-random # evicts random keys but only those that have an expiry set
+  volatile-ttl    # only evicts keys with an expiry set and a short TTL
+`;
+MaxMemory.flags = {
+    app: command_1.flags.app({ required: true }),
+    policy: command_1.flags.string({ char: 'p', description: 'set policy name', required: true }),
+    remote: command_1.flags.remote(),
+};
+MaxMemory.args = {
+    database: core_1.Args.string(),
+};

package/lib/commands/redis/promote.d.ts

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

@@ -0,0 +1,39 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const command_1 = require("@heroku-cli/command");
+const core_1 = require("@oclif/core");
+const api_1 = require("../../lib/redis/api");
+class Promote extends command_1.Command {
+    async run() {
+        const { flags, args } = await this.parse(Promote);
+        const api = (0, api_1.default)(flags.app, args.database, false, this.heroku);
+        const { body: addonsList } = await this.heroku.get(`/apps/${flags.app}/addons`);
+        const addon = await api.getRedisAddon(addonsList);
+        const redisFilter = api.makeAddonsFilter('REDIS_URL');
+        const redis = redisFilter(addonsList);
+        if (redis.length === 1 && redis[0].config_vars.filter((c) => c.endsWith('_URL')).length === 1) {
+            const attachment = redis[0];
+            await this.heroku.post('/addon-attachments', {
+                body: {
+                    app: { name: flags.app }, addon: { name: attachment.name }, confirm: flags.app,
+                },
+            });
+        }
+        core_1.ux.log(`Promoting ${addon.name} to REDIS_URL on ${flags.app}`);
+        await this.heroku.post('/addon-attachments', {
+            body: {
+                app: { name: flags.app }, addon: { name: addon.name }, confirm: flags.app, name: 'REDIS',
+            },
+        });
+    }
+}
+exports.default = Promote;
+Promote.topic = 'redis';
+Promote.description = 'sets DATABASE as your REDIS_URL';
+Promote.flags = {
+    app: command_1.flags.app({ required: true }),
+    remote: command_1.flags.remote(),
+};
+Promote.args = {
+    database: core_1.Args.string({ required: false }),
+};

package/lib/commands/redis/stats-reset.d.ts

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

@@ -0,0 +1,36 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const command_1 = require("@heroku-cli/command");
+const core_1 = require("@oclif/core");
+const api_1 = require("../../lib/redis/api");
+const confirmCommand_1 = require("../../lib/confirmCommand");
+const tsheredoc_1 = require("tsheredoc");
+const color_1 = require("@heroku-cli/color");
+class StatsReset extends command_1.Command {
+    async run() {
+        const { flags, args } = await this.parse(StatsReset);
+        const { app, confirm } = flags;
+        const { database } = args;
+        const addon = await (0, api_1.default)(app, database, false, this.heroku).getRedisAddon();
+        const warning = (0, tsheredoc_1.default)(`
+      WARNING: Irreversible action.
+      All stats covered by RESETSTAT will be reset on ${color_1.default.addon(addon.name || '')}.
+    `);
+        await (0, confirmCommand_1.default)(app, confirm, warning);
+        core_1.ux.action.start(`Resetting stats on ${color_1.default.addon(addon.name || '')}`);
+        const { body: response } = await (0, api_1.default)(app, database, false, this.heroku)
+            .request(`/redis/v0/databases/${addon.id}/stats/reset`, 'POST');
+        core_1.ux.action.stop(response.message);
+    }
+}
+exports.default = StatsReset;
+StatsReset.topic = 'redis';
+StatsReset.description = 'reset all stats covered by RESETSTAT (https://redis.io/commands/config-resetstat)';
+StatsReset.flags = {
+    app: command_1.flags.app({ required: true }),
+    remote: command_1.flags.remote(),
+    confirm: command_1.flags.string({ char: 'c' }),
+};
+StatsReset.args = {
+    database: core_1.Args.string(),
+};

package/lib/commands/redis/timeout.d.ts

@@ -0,0 +1,14 @@
+import { Command } from '@heroku-cli/command';
+export default class Timeout 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>;
+        seconds: import("@oclif/core/lib/interfaces").OptionFlag<number, 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/redis/timeout.js

@@ -0,0 +1,35 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const command_1 = require("@heroku-cli/command");
+const core_1 = require("@oclif/core");
+const api_1 = require("../../lib/redis/api");
+class Timeout extends command_1.Command {
+    async run() {
+        const { flags, args } = await this.parse(Timeout);
+        const { app, seconds } = flags;
+        const { database } = args;
+        const addon = await (0, api_1.default)(app, database, false, this.heroku).getRedisAddon();
+        const { body: response } = await (0, api_1.default)(app, database, false, this.heroku)
+            .request(`/redis/v0/databases/${addon.id}/config`, 'PATCH', { timeout: seconds });
+        core_1.ux.log(`Timeout for ${addon.name} (${addon.config_vars.join(', ')}) set to ${response.timeout.value} seconds.`);
+        if (response.timeout.value === 0) {
+            core_1.ux.log('Connections to the Redis instance can idle indefinitely.');
+        }
+        else {
+            core_1.ux.log(`Connections to the Redis instance will be stopped after idling for ${response.timeout.value} seconds.`);
+        }
+    }
+}
+exports.default = Timeout;
+Timeout.topic = 'redis';
+Timeout.description = `set the number of seconds to wait before killing idle connections
+    A value of zero means that connections will not be closed.
+  `;
+Timeout.flags = {
+    app: command_1.flags.app({ required: true }),
+    remote: command_1.flags.remote(),
+    seconds: command_1.flags.integer({ char: 's', description: 'set timeout value', required: true }),
+};
+Timeout.args = {
+    database: core_1.Args.string(),
+};