heroku 11.0.0-alpha.11 → 11.0.0-alpha.13

package/lib/lib/pipelines/setup/poll-app-setups.js

@@ -1,6 +1,6 @@
-import * as api from '../../api.js';
+import { color } from '@heroku/heroku-cli-util';
 import { ux } from '@oclif/core';
-import { color } from '@heroku-cli/color';
+import * as api from '../../api.js';
 function wait(ms) {
     return new Promise((resolve) => setTimeout(resolve, ms));
 }
@@ -13,9 +13,7 @@ function pollAppSetup(heroku, appSetup) {
             throw new Error(`Couldn't create application ${color.app(setup.app.name)}: ${setup.failure_message}`);
         }
         return wait(1000).then(() => pollAppSetup(heroku, appSetup));
-    }).catch((error) => {
-        return ux.error(error, { exit: 1 });
-    });
+    }).catch((error) => ux.error(error, { exit: 1 }));
 }
 export default function pollAppSetups(heroku, appSetups) {
     return Promise.all(appSetups.map((appSetup) => pollAppSetup(heroku, appSetup)));

package/lib/lib/pipelines/setup/setup-pipeline.js

@@ -4,9 +4,7 @@ export default function setupPipeline(kolkrabbi, app, settings, pipelineID, ciSe
     if (ciSettings.ci) {
         promises.push(kolkrabbi.updatePipelineRepository(pipelineID, ciSettings));
     }
-    return Promise.all(promises).then(([appLink]) => {
-        return appLink;
-    }, error => {
+    return Promise.all(promises).then(([appLink]) => appLink, error => {
         ux.error(error.body.message || error.message);
     });
 }

package/lib/lib/pipelines/setup/validate.d.ts

@@ -1,5 +1,5 @@
 export declare const STAGING_APP_INDICATOR = "-staging";
-declare type ValidatedResponse = [true] | [false, string];
+declare type ValidatedResponse = [false, string] | [true];
 export declare function pipelineName(name: any): ValidatedResponse;
 export declare function repoName(repo: any): ValidatedResponse;
 export declare function nameAndRepo({ name, repo }: {

package/lib/lib/pipelines/setup/validate.js

@@ -5,8 +5,8 @@ const ERR_PIPELINE_NAME_LENGTH = `Please choose a pipeline name between 2 and ${
 const ERR_REPO_FORMAT = 'Repository name must be in the format organization/repo';
 const REPO_REGEX = /.+\/.+/;
 export function pipelineName(name) {
-    const isValid = name.length >= PIPELINE_MIN_LENGTH &&
-        name.length <= PIPELINE_MAX_LENGTH;
+    const isValid = name.length >= PIPELINE_MIN_LENGTH
+        && name.length <= PIPELINE_MAX_LENGTH;
     return isValid ? [isValid] : [isValid, ERR_PIPELINE_NAME_LENGTH];
 }
 export function repoName(repo) {

package/lib/lib/pipelines/stages.d.ts

@@ -1,7 +1,7 @@
 declare const INFERRABLE_STAGES: {
-    name: string;
     inferRegex: RegExp;
+    name: string;
 }[];
 declare const INFERRABLE_STAGE_NAMES: string[];
 declare const STAGE_NAMES: string[];
-export { INFERRABLE_STAGES as inferrableStages, INFERRABLE_STAGE_NAMES as inferrableStageNames, STAGE_NAMES as names, };
+export { INFERRABLE_STAGE_NAMES as inferrableStageNames, INFERRABLE_STAGES as inferrableStages, STAGE_NAMES as names, };

package/lib/lib/pipelines/stages.js

@@ -1,17 +1,17 @@
 const INFERRABLE_STAGES = [
     {
-        name: 'development',
         inferRegex: /-(dev|development|uat|tst|test|qa)$/,
+        name: 'development',
     },
     {
-        name: 'staging',
         inferRegex: /-(stg|staging)$/,
+        name: 'staging',
     },
     {
-        name: 'production',
         inferRegex: /-(prd|prod|production|admin|demo)$/,
+        name: 'production',
     },
 ];
 const INFERRABLE_STAGE_NAMES = INFERRABLE_STAGES.map(stage => stage.name);
 const STAGE_NAMES = ['review'].concat(INFERRABLE_STAGE_NAMES);
-export { INFERRABLE_STAGES as inferrableStages, INFERRABLE_STAGE_NAMES as inferrableStageNames, STAGE_NAMES as names, };
+export { INFERRABLE_STAGE_NAMES as inferrableStageNames, INFERRABLE_STAGES as inferrableStages, STAGE_NAMES as names, };

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

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

package/lib/lib/redis/api.js

@@ -1,49 +1,9 @@
+import { hux } from '@heroku/heroku-cli-util';
 import { ux } from '@oclif/core';
 export default (app, database, json, heroku) => {
     const HOST = process.env.HEROKU_DATA_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 = null) {
-            const headers = {};
-            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) {
-                const redisAddons = [];
-                for (const addon of addons) {
-                    const service = addon?.addon_service?.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`));
@@ -54,9 +14,7 @@ export default (app, database, json, heroku) => {
                 ux.error('No Redis instances found.', { exit: 1 });
             }
             else if (redisAddons.length > 1) {
-                const names = redisAddons.map(function (addon) {
-                    return addon.name;
-                });
+                const names = redisAddons.map(addon => addon.name);
                 ux.error(`Please specify a single instance. Found: ${names.join(', ')}`, { exit: 1 });
             }
             return redisAddons[0];
@@ -66,17 +24,15 @@ export default (app, database, json, heroku) => {
             // 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;
-                    }),
-                };
-            });
+            const databases = addons.map(addon => ({
+                addon,
+                redis: this.request(`/redis/v0/databases/${addon.name}`).catch(error => {
+                    if (error.statusCode !== 404) {
+                        throw error;
+                    }
+                    return null;
+                }),
+            }));
             if (json) {
                 const redii = [];
                 for (const db of databases) {
@@ -90,7 +46,7 @@ export default (app, database, json, heroku) => {
                     const { formation, metaas_source, port, ...filteredRedis } = json_data;
                     redii.push(filteredRedis);
                 }
-                // hux.styledJSON(redii)
+                hux.styledJSON(redii);
                 return;
             }
             // print out the info of the addon and redis db info
@@ -103,18 +59,57 @@ export default (app, database, json, heroku) => {
                 if (db.addon && db.addon.config_vars) {
                     uxHeader += ` (${db.addon.config_vars.join(', ')})`;
                 }
-                // if (uxHeader) {
-                //   hux.styledHeader(uxHeader)
-                //   hux.styledObject(
-                //     // eslint-disable-next-line unicorn/no-array-reduce
-                //     redis.info.reduce(function (memo: { [x: string]: any }, row: { name: string | number; values: any }) {
-                //       memo[row.name] = row.values
-                //       return memo
-                //     }, {}),
-                //     redis.info.map(row => row.name),
-                //   )
-                // }
+                if (uxHeader) {
+                    hux.styledHeader(uxHeader);
+                    hux.styledObject(
+                    // eslint-disable-next-line unicorn/no-array-reduce
+                    redis.info.reduce((memo, row) => {
+                        memo[row.name] = row.values;
+                        return memo;
+                    }, {}), redis.info.map(row => row.name));
+                }
+            }
+        },
+        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) {
+                const redisAddons = [];
+                for (const addon of addons) {
+                    const service = addon?.addon_service?.name;
+                    if (service && service.indexOf(ADDON) === 0 && (!filter || matches(addon))) {
+                        redisAddons.push(addon);
+                    }
+                }
+                return redisAddons;
             }
+            return onResponse;
+        },
+        request(path, method = 'GET', body = null) {
+            const headers = {};
+            if (process.env.HEROKU_HEADERS) {
+                Object.assign(headers, JSON.parse(process.env.HEROKU_HEADERS));
+            }
+            return heroku.request(path, {
+                body,
+                headers,
+                hostname: HOST,
+                method,
+            });
         },
     };
 };

package/lib/lib/releases/output.js

@@ -1,6 +1,6 @@
 import got from 'got';
 export const stream = function (url) {
-    return new Promise(function (resolve, reject) {
+    return new Promise((resolve, reject) => {
         const stream = got.stream(url);
         stream.on('error', reject);
         stream.on('end', resolve);

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

@@ -2,4 +2,4 @@ export declare const description: (release: {
     [k: string]: any;
     status?: string | undefined;
 }) => "" | "release command executing" | "release command failed" | "release expired";
-export declare const color: (s?: string) => "red" | "yellow" | "gray" | "cyan";
+export declare const color: (s?: string) => "gray" | "red" | "yellow" | "cyan";

package/lib/lib/releases/status_helper.js

@@ -1,24 +1,32 @@
 export const description = function (release) {
     switch (release.status) {
-        case 'pending':
+        case 'pending': {
             return 'release command executing';
-        case 'failed':
+        }
+        case 'failed': {
             return 'release command failed';
-        case 'expired':
+        }
+        case 'expired': {
             return 'release expired';
-        default:
+        }
+        default: {
             return '';
+        }
     }
 };
 export const color = function (s) {
     switch (s) {
-        case 'pending':
+        case 'pending': {
             return 'yellow';
-        case 'failed':
+        }
+        case 'failed': {
             return 'red';
-        case 'expired':
+        }
+        case 'expired': {
             return 'gray';
-        default:
+        }
+        default: {
             return 'cyan';
+        }
     }
 };

package/lib/lib/run/colorize.js

@@ -1,4 +1,4 @@
-import { color } from '@heroku-cli/color';
+import { color } from '@heroku/heroku-cli-util';
 import { ux } from '@oclif/core';
 export const COLORS = [
     s => color.yellow(s),
@@ -27,22 +27,21 @@ getColorForIdentifier('web');
 getColorForIdentifier('postgres');
 getColorForIdentifier('heroku-postgres');
 const lineRegex = /^(.*?\[([\w-]+)([\d.]+)?]:)(.*)?$/;
-const red = color.red;
 const dim = (i) => color.dim(i);
 const other = dim;
 const path = (i) => color.green(i);
-const method = (i) => color.bold.magenta(i);
+const method = (i) => color.magenta(i);
 const status = (code) => {
     if (code < 200)
         return code;
     if (code < 300)
-        return color.green(code);
+        return color.success(code);
     if (code < 400)
-        return color.cyan(code);
+        return color.info(code);
     if (code < 500)
-        return color.yellow(code);
+        return color.warning(code);
     if (code < 600)
-        return color.red(code);
+        return color.failure(code);
     return code;
 };
 const ms = (s) => {
@@ -52,25 +51,43 @@ const ms = (s) => {
     if (ms < 100)
         return color.greenBright(s);
     if (ms < 500)
-        return color.green(s);
+        return color.success(s);
     if (ms < 5000)
-        return color.yellow(s);
+        return color.warning(s);
     if (ms < 10000)
         return color.yellowBright(s);
-    return color.red(s);
+    return color.failure(s);
 };
 function colorizeRouter(body) {
     const encodeColor = ([k, v]) => {
         switch (k) {
-            case 'at': return [k, v === 'error' ? red(v) : other(v)];
-            case 'code': return [k, red.bold(v)];
-            case 'method': return [k, method(v)];
-            case 'dyno': return [k, getColorForIdentifier(v)(v)];
-            case 'status': return [k, status(v)];
-            case 'path': return [k, path(v)];
-            case 'connect': return [k, ms(v)];
-            case 'service': return [k, ms(v)];
-            default: return [k, other(v)];
+            case 'at': {
+                return [k, v === 'error' ? color.failure(v) : other(v)];
+            }
+            case 'code': {
+                return [k, color.failure(color.label(v))];
+            }
+            case 'method': {
+                return [k, method(v)];
+            }
+            case 'dyno': {
+                return [k, getColorForIdentifier(v)(v)];
+            }
+            case 'status': {
+                return [k, status(v)];
+            }
+            case 'path': {
+                return [k, path(v)];
+            }
+            case 'connect': {
+                return [k, ms(v)];
+            }
+            case 'service': {
+                return [k, ms(v)];
+            }
+            default: {
+                return [k, other(v)];
+            }
         }
     };
     try {
@@ -98,22 +115,32 @@ function colorizeRouter(body) {
 }
 const state = (s) => {
     switch (s) {
-        case 'down': return red(s);
-        case 'up': return color.greenBright(s);
-        case 'starting': return color.yellowBright(s);
-        case 'complete': return color.greenBright(s);
-        default: return s;
+        case 'down': {
+            return color.failure(s);
+        }
+        case 'up': {
+            return color.success(s);
+        }
+        case 'starting': {
+            return color.yellowBright(s);
+        }
+        case 'complete': {
+            return color.success(s);
+        }
+        default: {
+            return s;
+        }
     }
 };
 function colorizeRun(body) {
     try {
         if (body.match(/^Stopping all processes with SIGTERM$/))
-            return color.red(body);
+            return color.failure(body);
         const starting = body.match(/^(Starting process with command )(`.+`)(by user )?(.*)?$/);
         if (starting) {
             return [
                 starting[1],
-                color.cmd(starting[2]),
+                color.code(starting[2]),
                 starting[3] || '',
                 color.green(starting[4] || ''),
             ].join('');
@@ -131,7 +158,7 @@ function colorizeRun(body) {
         if (exited) {
             return [
                 exited[1],
-                exited[2] === '0' ? color.greenBright(exited[2]) : color.red(exited[2]),
+                exited[2] === '0' ? color.success(exited[2]) : color.failure(exited[2]),
             ].join('');
         }
     }
@@ -147,12 +174,12 @@ function colorizeWeb(body) {
         if (body.match(/^Restarting$/))
             return color.yellow(body);
         if (body.match(/^Stopping all processes with SIGTERM$/))
-            return color.red(body);
+            return color.failure(body);
         const starting = body.match(/^(Starting process with command )(`.+`)(by user )?(.*)?$/);
         if (starting) {
             return [
                 (starting[1]),
-                color.cmd(starting[2]),
+                color.code(starting[2]),
                 (starting[3] || ''),
                 color.green(starting[4] || ''),
             ].join('');
@@ -161,7 +188,7 @@ function colorizeWeb(body) {
         if (exited) {
             return [
                 exited[1],
-                exited[2] === '0' ? color.greenBright(exited[2]) : color.red(exited[2]),
+                exited[2] === '0' ? color.success(exited[2]) : color.failure(exited[2]),
             ].join('');
         }
         const stateChange = body.match(/^(State changed from )(\w+)( to )(\w+)$/);
@@ -203,10 +230,9 @@ function colorizeWeb(body) {
 }
 function colorizeAPI(body) {
     if (body.match(/^Build succeeded$/))
-        return color.greenBright(body);
-    // eslint-disable-next-line unicorn/prefer-starts-ends-with
+        return color.success(body);
     if (body.match(/^Build failed/))
-        return color.red(body);
+        return color.failure(body);
     const build = body.match(/^(Build started by user )(.+)$/);
     if (build) {
         return [
@@ -236,7 +262,7 @@ function colorizeAPI(body) {
     if (starting) {
         return [
             (starting[1]),
-            color.cmd(starting[2]),
+            color.code(starting[2]),
             (starting[3] || ''),
             color.green(starting[4] || ''),
         ].join('');
@@ -273,24 +299,31 @@ export default function colorize(line) {
     const identifier = parsed[2];
     let body = (parsed[4] || '').trim();
     switch (identifier) {
-        case 'api':
+        case 'api': {
             body = colorizeAPI(body);
             break;
-        case 'router':
+        }
+        case 'router': {
             body = colorizeRouter(body);
             break;
-        case 'run':
+        }
+        case 'run': {
             body = colorizeRun(body);
             break;
-        case 'web':
+        }
+        case 'web': {
             body = colorizeWeb(body);
             break;
-        case 'heroku-redis':
+        }
+        case 'heroku-redis': {
             body = colorizeRedis(body);
             break;
+        }
         case 'heroku-postgres':
-        case 'postgres':
+        case 'postgres': {
             body = colorizePG(body);
+            break;
+        }
     }
     return getColorForIdentifier(identifier)(header) + ' ' + body;
 }