heroku 9.0.0-alpha.1 → 9.0.0-alpha.3

package/lib/lib/pg/types.d.ts

@@ -0,0 +1,230 @@
+import * as Heroku from '@heroku-cli/schema';
+export declare type TransferSchedule = {
+    hour: number;
+    name: string;
+    timezone: string;
+    uuid: string;
+};
+export declare type PublicUrlResponse = {
+    url: string;
+};
+declare type TransferTargetType = 'pg_dump' | 'pg_restore' | 'gof3r' | 'htcat';
+export declare type BackupTransfer = {
+    uuid: string;
+    num: number;
+    from_name: string;
+    from_type: TransferTargetType;
+    from_url: string;
+    to_name: string;
+    to_type: TransferTargetType;
+    to_url: string;
+    options: {
+        [k: string]: unknown;
+    };
+    source_bytes: number;
+    processed_bytes: number;
+    succeeded: boolean;
+    warnings: number;
+    created_at: string;
+    started_at: string;
+    canceled_at: string;
+    updated_at: string;
+    finished_at: string;
+    deleted_at: string;
+    purged_at: string;
+    num_keep: number;
+    schedule?: {
+        uuid: string;
+    };
+    logs: Array<{
+        created_at: string;
+        level: string;
+        message: string;
+    }>;
+};
+export declare type AddOnWithRelatedData = Required<Heroku.AddOnAttachment['addon']> & {
+    attachment_names?: string[];
+    links?: Link[];
+    plan: Required<Heroku.AddOn['plan']>;
+};
+declare type ServiceInfo = 'Status' | 'Fork/Follow' | 'Rollback' | 'Created' | 'Region' | 'Data Encryption' | 'Continuous Protection' | 'Enhanced Certificates' | 'Upgradable Extensions' | 'Plan' | 'HA Status' | 'Behind By' | 'Data Size' | 'Tables' | 'PG Version' | 'Connections' | 'Connection Pooling' | 'Credentials' | 'Restricted Credentials' | 'Mutual TLS' | 'Customer Encryption Key' | 'Following' | 'Forked From' | 'Followers' | 'Forks' | 'Maintenance' | 'Maintenance window' | 'Infrastructure' | 'Warning';
+export declare type PgDatabaseService = {
+    addon_id: string;
+    name: string;
+    heroku_resource_id: string;
+    formation?: {
+        id: string;
+        primary: string;
+    };
+    metaas_source: string;
+    num_tables: number;
+    num_connections: number;
+    num_connections_waiting: number;
+    num_bytes: number;
+    postgres_version: string;
+    current_transaction: number;
+    is_in_recovery?: boolean;
+    plan: {
+        id: number;
+        name: string;
+    };
+    created_at: string;
+    'standalone?'?: boolean;
+    port: number;
+    database_name: string;
+    database_user: string;
+    'hot_standby?'?: boolean;
+    status_updated_at?: string;
+    following?: string;
+    forked_from: string;
+    target_transaction: string | null;
+    available_for_ingress: boolean;
+    resource_url: string;
+    database_password: string;
+    'waiting?': boolean;
+    credentials: number;
+    leader: string | null;
+    info: Array<{
+        name: ServiceInfo;
+        values: string[];
+    }>;
+};
+export declare type PgStatus = {
+    'waiting?': boolean;
+    'error?': boolean;
+    message: string;
+};
+declare type TenantInfoNames = 'Plan' | 'Status' | 'Connections' | 'PG Version' | 'Created' | 'Data Size' | 'Tables' | 'Fork/Follow' | 'Rollback' | 'Continuous Protection' | 'Billing App' | 'Add-on';
+export declare type TenantInfo = {
+    name: TenantInfoNames;
+    values: string[];
+    resolve_db_name?: boolean;
+};
+export declare type PgDatabaseTenant = {
+    addon_id: string;
+    name: string;
+    plan: string;
+    created_at: string;
+    database_user: string;
+    database_name: string;
+    following?: string;
+    resource_url: string;
+    'waiting?': boolean;
+    num_bytes: number;
+    info: Array<TenantInfo>;
+};
+export declare type PgDatabase = PgDatabaseService & PgDatabaseTenant;
+export declare type AddOnWithPlan = Required<Heroku.AddOnAttachment['addon']> & {
+    plan: Required<Heroku.AddOn['plan']>;
+};
+export declare type AddOnAttachmentWithConfigVarsAndPlan = Required<Heroku.AddOnAttachment> & {
+    config_vars: Heroku.AddOn['config_vars'];
+    addon: AddOnWithRelatedData;
+};
+export declare type Link = {
+    attachment_name?: string;
+    created_at: string;
+    message: string;
+    name: string;
+    remote?: Link;
+};
+declare type CredentialState = 'enabling' | 'active' | 'revoking' | 'revoked' | 'archived';
+export declare type Credential = {
+    user: string;
+    password: string;
+    state: CredentialState;
+    connections?: number | null;
+};
+declare type CredentialStoreState = 'provisioning' | 'wait_for_provisioning' | 'active' | 'rotating' | 'rotation_completed' | 'revoking' | 'archived';
+export declare type CredentialInfo = {
+    uuid: string;
+    name: string;
+    state: CredentialStoreState;
+    database: string;
+    host: string;
+    port: number;
+    credentials: Array<Credential>;
+};
+export declare type CredentialsInfo = Array<CredentialInfo>;
+export declare type MaintenanceApiResponse = {
+    message: string;
+};
+export declare type PgDatabaseConfig = {
+    [key: string]: any;
+    'log_lock_waits': {
+        value: boolean;
+    };
+};
+export declare type SettingKey = 'log_lock_waits' | 'log_connections' | 'log_min_duration_statement' | 'log_statement' | 'track_functions' | 'pgbouncer_max_client_conn' | 'pg_bouncer_max_db_conns' | 'pg_bouncer_default_pool_size' | 'auto_explain' | 'auto_explain.log_min_duration' | 'auto_explain.log_analyze' | 'auto_explain.log_triggers' | 'auto_explain.log_buffers' | 'auto_explain.log_verbose' | 'auto_explain.log_nested_statements';
+export declare type Setting<T> = {
+    value: T;
+    values: Record<string, string>;
+    desc: string;
+    default: T;
+};
+export declare type SettingsResponse = Record<SettingKey, Setting<unknown>>;
+export declare type PGDiagnoseResponse = {
+    id: string;
+    app: string;
+    database: string;
+    created_at: string;
+    checks: [
+        PGDiagnoseCheck<ConnCountResult>,
+        PGDiagnoseCheck<QueriesResult>,
+        PGDiagnoseCheck<QueriesResult>,
+        PGDiagnoseCheck<UnusedIndexesResult>,
+        PGDiagnoseCheck<BloatResult>,
+        PGDiagnoseCheck<HitRateResult>,
+        PGDiagnoseCheck<BlockingResult>
+    ];
+};
+export declare type PGDiagnoseCheck<T extends PGDiagnoseResult = PGDiagnoseResult> = {
+    name: string;
+    status: 'red' | 'yellow' | 'green';
+    results: T[];
+};
+export declare type PGDiagnoseResult = ConnCountResult | QueriesResult | UnusedIndexesResult | BloatResult | HitRateResult | BlockingResult;
+export declare type ConnCountResult = {
+    count: number;
+};
+export declare type QueriesResult = {
+    pid: number;
+    duration: string;
+    query: string;
+};
+export declare type UnusedIndexesResult = {
+    reason: string;
+    index: string;
+    index_scan_pct: string;
+    scans_per_write: string;
+    index_size: string;
+    table_size: string;
+};
+export declare type BloatResult = {
+    type: string;
+    object: string;
+    bloat: number;
+    waste: string;
+};
+export declare type HitRateResult = {
+    name: string;
+    ratio: number;
+};
+export declare type BlockingResult = {
+    blocked_pid: number;
+    blocking_statement: string;
+    blocking_duration: string;
+    blocking_pid: number;
+    blocked_statement: string;
+    blocked_duration: string;
+};
+export declare type PGDiagnoseRequest = {
+    url: string;
+    plan: string;
+    app: string;
+    database: string;
+    metrics?: unknown[];
+    burst_data_present?: boolean;
+    burst_status?: string;
+};
+export {};

package/lib/lib/pg/types.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/lib/lib/pg/util.d.ts

@@ -0,0 +1,36 @@
+/// <reference types="node" />
+import type { AddOnAttachment } from '@heroku-cli/schema';
+import type { AddOnAttachmentWithConfigVarsAndPlan, CredentialsInfo } from './types';
+import { Server } from 'net';
+export declare function getConfigVarName(configVars: string[]): string;
+export declare const essentialNumPlan: (addon: AddOnAttachmentWithConfigVarsAndPlan) => boolean;
+export declare const legacyEssentialPlan: (addon: AddOnAttachmentWithConfigVarsAndPlan) => boolean;
+export declare function essentialPlan(addon: AddOnAttachmentWithConfigVarsAndPlan): boolean;
+export declare function getConfigVarNameFromAttachment(attachment: Required<AddOnAttachment & {
+    addon: AddOnAttachmentWithConfigVarsAndPlan;
+}>, config?: Record<string, string>): string;
+export declare function presentCredentialAttachments(app: string, credAttachments: Required<AddOnAttachment>[], credentials: CredentialsInfo, cred: string): string;
+export declare type ConnectionDetails = {
+    user: string;
+    password: string;
+    database: string;
+    host: string;
+    port: string;
+    pathname: string;
+    url: string;
+    bastionKey?: string;
+    bastionHost?: string;
+    _tunnel?: Server;
+};
+export declare type ConnectionDetailsWithAttachment = ConnectionDetails & {
+    attachment: Required<AddOnAttachment & {
+        addon: AddOnAttachmentWithConfigVarsAndPlan;
+    }>;
+};
+export declare const getConnectionDetails: (attachment: Required<AddOnAttachment & {
+    addon: AddOnAttachmentWithConfigVarsAndPlan;
+}>, configVars?: Record<string, string>) => ConnectionDetailsWithAttachment;
+export declare const bastionKeyPlan: (a: AddOnAttachmentWithConfigVarsAndPlan) => boolean;
+export declare const configVarNamesFromValue: (config: Record<string, string>, value: string) => string[];
+export declare const databaseNameFromUrl: (uri: string, config: Record<string, string>) => any;
+export declare const parsePostgresConnectionString: (db: string) => ConnectionDetails;

package/lib/lib/pg/util.js

@@ -0,0 +1,183 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parsePostgresConnectionString = exports.databaseNameFromUrl = exports.configVarNamesFromValue = exports.bastionKeyPlan = exports.getConnectionDetails = exports.presentCredentialAttachments = exports.getConfigVarNameFromAttachment = exports.essentialPlan = exports.legacyEssentialPlan = exports.essentialNumPlan = exports.getConfigVarName = void 0;
+const color_1 = require("@heroku-cli/color");
+const core_1 = require("@oclif/core");
+const debug_1 = require("debug");
+const addons_1 = require("../../commands/addons");
+const multisort_1 = require("../utils/multisort");
+const bastion_1 = require("./bastion");
+const process_1 = require("process");
+function getConfigVarName(configVars) {
+    const connStringVars = configVars.filter(cv => (cv.endsWith('_URL')));
+    if (connStringVars.length === 0)
+        throw new Error('Database URL not found for this addon');
+    return connStringVars[0];
+}
+exports.getConfigVarName = getConfigVarName;
+const essentialNumPlan = (addon) => { var _a, _b; return Boolean((_b = (_a = addon === null || addon === void 0 ? void 0 : addon.plan) === null || _a === void 0 ? void 0 : _a.name) === null || _b === void 0 ? void 0 : _b.split(':')[1].match(/^essential/)); };
+exports.essentialNumPlan = essentialNumPlan;
+const legacyEssentialPlan = (addon) => { var _a, _b; return Boolean((_b = (_a = addon === null || addon === void 0 ? void 0 : addon.plan) === null || _a === void 0 ? void 0 : _a.name) === null || _b === void 0 ? void 0 : _b.split(':')[1].match(/(dev|basic|mini)$/)); };
+exports.legacyEssentialPlan = legacyEssentialPlan;
+function essentialPlan(addon) {
+    return (0, exports.essentialNumPlan)(addon) || (0, exports.legacyEssentialPlan)(addon);
+}
+exports.essentialPlan = essentialPlan;
+function getConfigVarNameFromAttachment(attachment, config = {}) {
+    var _a, _b;
+    const configVars = (_b = (_a = attachment.config_vars) === null || _a === void 0 ? void 0 : _a.filter((cv) => {
+        var _a;
+        return (_a = config[cv]) === null || _a === void 0 ? void 0 : _a.startsWith('postgres://');
+    })) !== null && _b !== void 0 ? _b : [];
+    if (configVars.length === 0) {
+        core_1.ux.error(`No config vars found for ${attachment.name}; perhaps they were removed as a side effect of ${color_1.default.cmd('heroku rollback')}? Use ${color_1.default.cmd('heroku addons:attach')} to create a new attachment and then ${color_1.default.cmd('heroku addons:detach')} to remove the current attachment.`);
+    }
+    const configVarName = `${attachment.name}_URL`;
+    if (configVars.includes(configVarName) && configVarName in config) {
+        return configVarName;
+    }
+    return getConfigVarName(configVars);
+}
+exports.getConfigVarNameFromAttachment = getConfigVarNameFromAttachment;
+function presentCredentialAttachments(app, credAttachments, credentials, cred) {
+    const isForeignApp = (attOrAddon) => attOrAddon.app.name === app ? 0 : 1;
+    const comparators = [
+        (a, b) => {
+            const fa = isForeignApp(a);
+            const fb = isForeignApp(b);
+            return fa < fb ? -1 : (fb < fa ? 1 : 0);
+        },
+        (a, b) => a.name.localeCompare(b.name),
+        (a, b) => { var _a, _b, _c, _d, _e; return (_e = (_b = (_a = a.app) === null || _a === void 0 ? void 0 : _a.name) === null || _b === void 0 ? void 0 : _b.localeCompare((_d = (_c = b.app) === null || _c === void 0 ? void 0 : _c.name) !== null && _d !== void 0 ? _d : '')) !== null && _e !== void 0 ? _e : 0; },
+    ];
+    credAttachments.sort((0, multisort_1.multiSortCompareFn)(comparators));
+    // render each attachment under the credential
+    const attLines = credAttachments.map(function (attachment, idx) {
+        const isLast = (idx === credAttachments.length - 1);
+        return (0, addons_1.renderAttachment)(attachment, app, isLast);
+    });
+    const rotationLines = [];
+    const credentialStore = credentials.find(a => a.name === cred);
+    if ((credentialStore === null || credentialStore === void 0 ? void 0 : credentialStore.state) === 'rotating') {
+        const formatted = credentialStore === null || credentialStore === void 0 ? void 0 : credentialStore.credentials.map(credential => {
+            return {
+                user: credential.user,
+                state: credential.state,
+                connections: credential.connections,
+            };
+        });
+        // eslint-disable-next-line no-eq-null, eqeqeq
+        const connectionInformationAvailable = formatted.some(c => c.connections != null);
+        if (connectionInformationAvailable) {
+            const prefix = '       ';
+            rotationLines.push(`${prefix}Usernames currently active for this credential:`);
+            core_1.ux.table(formatted, {
+                user: {
+                    get(row) {
+                        return `${prefix}${row.user}`;
+                    },
+                },
+                state: {
+                    get(row) {
+                        return row.state === 'revoking' ? 'waiting for no connections to be revoked' : row.state;
+                    },
+                },
+                connections: {
+                    get(row) {
+                        return `${row.connections} connections`;
+                    },
+                },
+            }, {
+                'no-header': true,
+                printLine(line) {
+                    rotationLines.push(line);
+                },
+            });
+        }
+    }
+    return [cred, ...attLines, ...rotationLines].join('\n');
+}
+exports.presentCredentialAttachments = presentCredentialAttachments;
+const getConnectionDetails = (attachment, configVars = {}) => {
+    const connStringVar = getConfigVarNameFromAttachment(attachment, configVars);
+    // remove _URL from the end of the config var name
+    const baseName = connStringVar.slice(0, -4);
+    // build the default payload for non-bastion dbs
+    (0, debug_1.default)(`Using "${connStringVar}" to connect to your database…`);
+    const conn = (0, exports.parsePostgresConnectionString)(configVars[connStringVar]);
+    const payload = {
+        user: conn.user,
+        password: conn.password,
+        database: conn.database,
+        host: conn.host,
+        port: conn.port,
+        pathname: conn.pathname,
+        url: conn.url,
+        attachment,
+    };
+    // If bastion creds exist, graft it into the payload
+    const bastion = (0, bastion_1.getBastion)(configVars, baseName);
+    if (bastion) {
+        Object.assign(payload, bastion);
+    }
+    return payload;
+};
+exports.getConnectionDetails = getConnectionDetails;
+const bastionKeyPlan = (a) => Boolean(a.plan.name.match(/private/));
+exports.bastionKeyPlan = bastionKeyPlan;
+const configVarNamesFromValue = (config, value) => {
+    const keys = [];
+    for (const key of Object.keys(config)) {
+        const configVal = config[key];
+        if (configVal === value) {
+            keys.push(key);
+        }
+        else if (configVal.startsWith('postgres://')) {
+            try {
+                const configURL = new URL(configVal);
+                const ourURL = new URL(value);
+                const components = ['protocol', 'hostname', 'port', 'pathname'];
+                if (components.every(component => ourURL[component] === configURL[component])) {
+                    keys.push(key);
+                }
+            }
+            catch (_a) {
+                // ignore -- this is not a valid URL so not a matching URL
+            }
+        }
+    }
+    const comparator = (a, b) => {
+        const isDatabaseUrlA = Number(a === 'DATABASE_URL');
+        const isDatabaseUrlB = Number(b === 'DATABASE_URL');
+        return isDatabaseUrlA < isDatabaseUrlB ? -1 : (isDatabaseUrlB < isDatabaseUrlA ? 1 : 0);
+    };
+    return keys.sort(comparator);
+};
+exports.configVarNamesFromValue = configVarNamesFromValue;
+const databaseNameFromUrl = (uri, config) => {
+    const names = (0, exports.configVarNamesFromValue)(config, uri);
+    let name = names.pop();
+    while (names.length > 0 && name === 'DATABASE_URL')
+        name = names.pop();
+    if (name) {
+        return color_1.default.configVar(name.replace(/_URL$/, ''));
+    }
+    const conn = (0, exports.parsePostgresConnectionString)(uri);
+    return `${conn.host}:${conn.port}${conn.pathname}`;
+};
+exports.databaseNameFromUrl = databaseNameFromUrl;
+const parsePostgresConnectionString = (db) => {
+    const dbPath = db.match(/:\/\//) ? db : `postgres:///${db}`;
+    const url = new URL(dbPath);
+    const { username, password, hostname, pathname, port } = url;
+    return {
+        user: username,
+        password,
+        database: pathname.charAt(0) === '/' ? pathname.slice(1) : pathname,
+        host: hostname,
+        port: port || process_1.env.PGPORT || (hostname && '5432'),
+        pathname,
+        url: dbPath,
+    };
+};
+exports.parsePostgresConnectionString = parsePostgresConnectionString;

package/lib/lib/redis/api.d.ts

@@ -0,0 +1,65 @@
+import * as Heroku from '@heroku-cli/schema';
+import { APIClient } from '@heroku-cli/command';
+export declare type RedisFormationResponse = {
+    addon_id: string;
+    name: string;
+    plan: string;
+    created_at: string;
+    formation: {
+        id: string;
+        primary: string | null;
+    };
+    metaas_source: string;
+    port: number;
+    resource_url: string;
+    info: {
+        name: string;
+        values: string[];
+    }[];
+    version: string;
+    prefer_native_tls: boolean;
+    customer_encryption_key?: string;
+};
+declare type RedisEvictionPolicies = 'noeviction' | 'allkeys-lru' | 'volatile-lru' | 'allkeys-random' | 'volatile-random' | 'volatile-ttl' | 'allkeys-lfu' | 'volatile-lfu';
+export declare type RedisApiResponse = {
+    message: string;
+};
+export declare type RedisFormationConfigResponse = {
+    maxmemory_policy: {
+        desc: string;
+        value: RedisEvictionPolicies;
+        default: RedisEvictionPolicies;
+        values: Record<RedisEvictionPolicies, string>;
+    };
+    notify_keyspace_events: {
+        desc: string;
+        value: string;
+        default: string;
+    };
+    timeout: {
+        desc: string;
+        value: number;
+        default: number;
+    };
+    standby_segv_workaround: {
+        desc: string;
+        value: boolean;
+        default: boolean;
+    };
+};
+export declare type RedisMaintenanceWindowResponse = {
+    window: string | null;
+    scheduled_at?: string;
+};
+export declare type RedisFormationWaitResponse = {
+    message: string;
+    'waiting?': boolean;
+};
+declare type HttpVerb = 'GET' | 'POST' | 'PATCH' | 'DELETE' | 'PUT';
+declare const _default: (app: string, database: string | undefined, json: boolean, heroku: APIClient) => {
+    request<T>(path: string, method?: HttpVerb, body?: {}): Promise<import("http-call").HTTP<T>>;
+    makeAddonsFilter(filter: string | undefined): (addons: Required<Heroku.AddOn>[]) => Required<Heroku.AddOn>[];
+    getRedisAddon(addons?: Required<Heroku.AddOn>[]): Promise<Required<Heroku.AddOn>>;
+    info(): Promise<void>;
+};
+export default _default;

package/lib/lib/redis/api.js

@@ -0,0 +1,122 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const tslib_1 = require("tslib");
+const core_1 = require("@oclif/core");
+exports.default = (app, database, json, heroku) => {
+    const HOST = process.env.HEROKU_REDIS_HOST || 'api.data.heroku.com';
+    const ADDON = process.env.HEROKU_REDIS_ADDON_NAME || 'heroku-redis';
+    return {
+        request(path, method = 'GET', body = {}) {
+            const headers = { Accept: 'application/json' };
+            if (process.env.HEROKU_HEADERS) {
+                Object.assign(headers, JSON.parse(process.env.HEROKU_HEADERS));
+            }
+            return heroku.request(path, {
+                hostname: HOST,
+                method,
+                headers,
+                body,
+            });
+        },
+        makeAddonsFilter(filter) {
+            if (filter) {
+                filter = filter.toUpperCase();
+            }
+            function matches(addon) {
+                const configVars = addon.config_vars || [];
+                for (const configVar of configVars) {
+                    const cfgName = configVar.toUpperCase();
+                    if (filter && cfgName.includes(filter)) {
+                        return true;
+                    }
+                }
+                if (addon.name && filter && addon.name.toUpperCase().includes(filter)) {
+                    return true;
+                }
+                return false;
+            }
+            function onResponse(addons) {
+                var _a;
+                const redisAddons = [];
+                for (const addon of addons) {
+                    const service = (_a = addon === null || addon === void 0 ? void 0 : addon.addon_service) === null || _a === void 0 ? void 0 : _a.name;
+                    if (service && service.indexOf(ADDON) === 0 && (!filter || matches(addon))) {
+                        redisAddons.push(addon);
+                    }
+                }
+                return redisAddons;
+            }
+            return onResponse;
+        },
+        async getRedisAddon(addons) {
+            if (!addons) {
+                ({ body: addons } = await heroku.get(`/apps/${app}/addons`));
+            }
+            const addonsFilter = this.makeAddonsFilter(database);
+            const redisAddons = addonsFilter(addons);
+            if (redisAddons.length === 0) {
+                core_1.ux.error('No Redis instances found.', { exit: 1 });
+            }
+            else if (redisAddons.length > 1) {
+                const names = redisAddons.map(function (addon) {
+                    return addon.name;
+                });
+                core_1.ux.error(`Please specify a single instance. Found: ${names.join(', ')}`, { exit: 1 });
+            }
+            return redisAddons[0];
+        },
+        async info() {
+            let { body: addons } = await heroku.get(`/apps/${app}/addons`);
+            // filter out non-redis addons
+            addons = this.makeAddonsFilter(database)(addons);
+            // get info for each db
+            const databases = addons.map(addon => {
+                return {
+                    addon: addon,
+                    redis: this.request(`/redis/v0/databases/${addon.name}`).catch(function (error) {
+                        if (error.statusCode !== 404) {
+                            throw error;
+                        }
+                        return null;
+                    }),
+                };
+            });
+            if (json) {
+                const redii = [];
+                for (const db of databases) {
+                    const { body: redis } = await db.redis || {};
+                    if (!redis) {
+                        continue;
+                    }
+                    const json_data = redis;
+                    json_data.app = db.addon.app;
+                    json_data.config_vars = db.addon.config_vars;
+                    const { formation, metaas_source, port } = json_data, filteredRedis = tslib_1.__rest(json_data, ["formation", "metaas_source", "port"]);
+                    redii.push(filteredRedis);
+                }
+                core_1.ux.styledJSON(redii);
+                return;
+            }
+            // print out the info of the addon and redis db info
+            for (const db of databases) {
+                const { body: redis } = await db.redis || {};
+                if (!redis) {
+                    continue;
+                }
+                let uxHeader = db.addon.name;
+                if (db.addon && db.addon.config_vars) {
+                    uxHeader += ` (${db.addon.config_vars.join(', ')})`;
+                }
+                if (uxHeader) {
+                    core_1.ux.styledHeader(uxHeader);
+                    core_1.ux.styledObject(
+                    // eslint-disable-next-line unicorn/no-array-reduce
+                    redis.info.reduce(function (memo, row) {
+                        memo[row.name] = row.values;
+                        return memo;
+                    }, {}), redis.info.map(row => row.name));
+                }
+            }
+        },
+    };
+};

package/lib/lib/releases/output.d.ts

@@ -0,0 +1 @@
+export declare const stream: (url: string) => Promise<unknown>;

package/lib/lib/releases/output.js

@@ -0,0 +1,14 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.stream = void 0;
+const got_1 = require("got");
+const stream = function (url) {
+    return new Promise(function (resolve, reject) {
+        const stream = got_1.default.stream(url);
+        stream.on('error', reject);
+        stream.on('end', resolve);
+        const piped = stream.pipe(process.stdout);
+        piped.on('error', reject);
+    });
+};
+exports.stream = stream;

package/lib/lib/releases/releases.d.ts

@@ -0,0 +1,6 @@
+import { APIClient } from '@heroku-cli/command';
+import * as Heroku from '@heroku-cli/schema';
+export declare const findRelease: (heroku: APIClient, app: string, search: (releases: Heroku.Release[]) => Heroku.Release) => Promise<Heroku.Release>;
+export declare const getRelease: (heroku: APIClient, app: string, release: string) => Promise<Heroku.Release>;
+export declare const findByLatestOrId: (heroku: APIClient, app: string, release?: string) => Promise<Heroku.Release>;
+export declare const findByPreviousOrId: (heroku: APIClient, app: string, release?: string) => Promise<Heroku.Release>;