heroku 8.1.9 → 8.2.0-beta.1

package/lib/lib/pipelines/setup/create-apps.d.ts

@@ -0,0 +1 @@
+export default function createApps(heroku: any, archiveURL: any, pipeline: any, pipelineName: any, stagingAppName: any, organization: any): Promise<void | import("http-call").HTTP<unknown>[]>;

package/lib/lib/pipelines/setup/create-apps.js

@@ -0,0 +1,44 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const core_1 = require("@oclif/core");
+const api_1 = require("../api");
+function createApp(heroku, { archiveURL, name, organization, pipeline, stage }) {
+    const params = {
+        source_blob: { url: archiveURL },
+        app: { name },
+        pipeline_coupling: {
+            stage,
+            pipeline: pipeline.id,
+        },
+    };
+    if (organization) {
+        params.app.organization = organization;
+    }
+    else {
+        params.app.personal = true;
+    }
+    return (0, api_1.createAppSetup)(heroku, params).then(setup => setup);
+}
+function createApps(heroku, archiveURL, pipeline, pipelineName, stagingAppName, organization) {
+    const prodAppSetupPromise = createApp(heroku, {
+        archiveURL,
+        pipeline,
+        name: pipelineName,
+        stage: 'production',
+        organization,
+    });
+    const stagingAppSetupPromise = createApp(heroku, {
+        archiveURL,
+        pipeline,
+        name: stagingAppName,
+        stage: 'staging',
+        organization,
+    });
+    const promises = [prodAppSetupPromise, stagingAppSetupPromise];
+    return Promise.all(promises).then(appSetups => {
+        return appSetups;
+    }, error => {
+        core_1.ux.error(error, { exit: 1 });
+    });
+}
+exports.default = createApps;

package/lib/lib/pipelines/setup/get-ci-settings.d.ts

@@ -0,0 +1,4 @@
+export default function getCISettings(yes: any, organization: any): Promise<{
+    ci: boolean;
+    organization: undefined;
+}>;

package/lib/lib/pipelines/setup/get-ci-settings.js

@@ -0,0 +1,19 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const core_1 = require("@oclif/core");
+async function getCISettings(yes, organization) {
+    const settings = {
+        ci: true,
+        organization: undefined,
+    };
+    if (yes) {
+        delete settings.organization;
+        return settings;
+    }
+    settings.ci = await core_1.ux.confirm('Enable automatic Heroku CI test runs?');
+    if (settings.ci && organization) {
+        settings.organization = organization;
+    }
+    return settings;
+}
+exports.default = getCISettings;

package/lib/lib/pipelines/setup/get-github-token.d.ts

@@ -0,0 +1 @@
+export default function getGitHubToken(kolkrabbi: any): any;

package/lib/lib/pipelines/setup/get-github-token.js

@@ -0,0 +1,10 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+function getGitHubToken(kolkrabbi) {
+    return kolkrabbi.getAccount().then((account) => {
+        return account.github.token;
+    }, () => {
+        throw new Error('Account not connected to GitHub.');
+    });
+}
+exports.default = getGitHubToken;

package/lib/lib/pipelines/setup/get-name-and-repo.d.ts

@@ -0,0 +1 @@
+export default function getNameAndRepo(args: any): Promise<any>;

package/lib/lib/pipelines/setup/get-name-and-repo.js

@@ -0,0 +1,47 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const core_1 = require("@oclif/core");
+const validate_1 = require("./validate");
+function filter(obj) {
+    const ret = {};
+    Object.keys(obj)
+        .filter((key) => obj[key] !== undefined)
+        .forEach((key) => {
+        ret[key] = obj[key];
+    });
+    return ret;
+}
+async function getNameAndRepo(args) {
+    const answer = {
+        name: '',
+        repo: '',
+    };
+    if (!args.name) {
+        const name = await core_1.ux.prompt('Pipeline name', {
+            required: true,
+        });
+        const [valid, msg] = (0, validate_1.pipelineName)(name);
+        if (valid) {
+            answer.name = name;
+        }
+        else {
+            core_1.ux.error(msg);
+        }
+    }
+    if (!args.repo) {
+        const repo = await core_1.ux.prompt('GitHub repository to connect to (e.g. rails/rails)', {
+            required: true,
+        });
+        const [valid, msg] = (0, validate_1.repoName)(repo);
+        if (valid) {
+            answer.repo = repo;
+        }
+        else {
+            core_1.ux.error(msg);
+        }
+    }
+    const reply = Object.assign(filter(answer), filter(args));
+    reply.name = reply.name.toLowerCase().replace(/\s/g, '-');
+    return reply;
+}
+exports.default = getNameAndRepo;

package/lib/lib/pipelines/setup/get-repo.d.ts

@@ -0,0 +1 @@
+export default function getRepo(github: any, name: any): any;

package/lib/lib/pipelines/setup/get-repo.js

@@ -0,0 +1,8 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+function getRepo(github, name) {
+    return github.getRepo(name).catch(() => {
+        throw new Error(`Could not access the ${name} repo`);
+    });
+}
+exports.default = getRepo;

package/lib/lib/pipelines/setup/get-settings.d.ts

@@ -0,0 +1,9 @@
+export default function getSettings(yes: any, branch: any): Promise<{
+    auto_deploy: boolean;
+    wait_for_ci: boolean;
+    pull_requests: {
+        enabled: boolean;
+        auto_deploy: boolean;
+        auto_destroy: boolean;
+    };
+}>;

package/lib/lib/pipelines/setup/get-settings.js

@@ -0,0 +1,39 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const core_1 = require("@oclif/core");
+const DEFAULT_SETTINGS = {
+    auto_deploy: true,
+    wait_for_ci: true,
+    pull_requests: {
+        enabled: true,
+        auto_deploy: true,
+        auto_destroy: true,
+    },
+};
+async function getSettings(yes, branch) {
+    if (yes) {
+        return DEFAULT_SETTINGS;
+    }
+    const settings = {
+        auto_deploy: true,
+        wait_for_ci: true,
+        pull_requests: {
+            enabled: true,
+            auto_deploy: true,
+            auto_destroy: true,
+        },
+    };
+    settings.auto_deploy = await core_1.ux.confirm(`Automatically deploy the ${branch} branch to staging?`);
+    if (settings.auto_deploy) {
+        settings.wait_for_ci = await core_1.ux.confirm(`Wait for CI to pass before deploying the ${branch} branch to staging?`);
+    }
+    settings.pull_requests.enabled = await core_1.ux.confirm('Enable review apps?');
+    if (settings.pull_requests.enabled) {
+        settings.pull_requests.auto_deploy = await core_1.ux.confirm('Automatically create review apps for every PR?');
+    }
+    if (settings.pull_requests.enabled) {
+        settings.pull_requests.auto_destroy = await core_1.ux.confirm('Automatically destroy idle review apps after 5 days?');
+    }
+    return settings;
+}
+exports.default = getSettings;

package/lib/lib/pipelines/setup/poll-app-setups.d.ts

@@ -0,0 +1 @@
+export default function pollAppSetups(heroku: any, appSetups: any): Promise<any[]>;

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

@@ -0,0 +1,25 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const api = require("../api");
+const core_1 = require("@oclif/core");
+const color_1 = require("@heroku-cli/color");
+function wait(ms) {
+    return new Promise((resolve) => setTimeout(resolve, ms));
+}
+function pollAppSetup(heroku, appSetup) {
+    return api.getAppSetup(heroku, appSetup.id).then(({ body: setup }) => {
+        if (setup.status === 'succeeded') {
+            return setup;
+        }
+        if (setup.status === 'failed') {
+            throw new Error(`Couldn't create application ${color_1.default.app(setup.app.name)}: ${setup.failure_message}`);
+        }
+        return wait(1000).then(() => pollAppSetup(heroku, appSetup));
+    }).catch((error) => {
+        return core_1.ux.error(error, { exit: 1 });
+    });
+}
+function pollAppSetups(heroku, appSetups) {
+    return Promise.all(appSetups.map((appSetup) => pollAppSetup(heroku, appSetup)));
+}
+exports.default = pollAppSetups;

package/lib/lib/pipelines/setup/setup-pipeline.d.ts

@@ -0,0 +1 @@
+export default function setupPipeline(kolkrabbi: any, app: any, settings: any, pipelineID: any, ciSettings?: any): Promise<any>;

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

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const core_1 = require("@oclif/core");
+function setupPipeline(kolkrabbi, app, settings, pipelineID, ciSettings = {}) {
+    const promises = [kolkrabbi.updateAppLink(app, settings)];
+    if (ciSettings.ci) {
+        promises.push(kolkrabbi.updatePipelineRepository(pipelineID, ciSettings));
+    }
+    return Promise.all(promises).then(([appLink]) => {
+        return appLink;
+    }, error => {
+        core_1.ux.error(error.body.message || error.message);
+    });
+}
+exports.default = setupPipeline;

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

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

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

@@ -0,0 +1,31 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.nameAndRepo = exports.repoName = exports.pipelineName = exports.STAGING_APP_INDICATOR = void 0;
+exports.STAGING_APP_INDICATOR = '-staging';
+const PIPELINE_MIN_LENGTH = 2;
+const PIPELINE_MAX_LENGTH = 30 - exports.STAGING_APP_INDICATOR.length;
+const ERR_PIPELINE_NAME_LENGTH = `Please choose a pipeline name between 2 and ${PIPELINE_MAX_LENGTH} characters long`;
+const ERR_REPO_FORMAT = 'Repository name must be in the format organization/repo';
+const REPO_REGEX = /.+\/.+/;
+function pipelineName(name) {
+    const isValid = name.length >= PIPELINE_MIN_LENGTH &&
+        name.length <= PIPELINE_MAX_LENGTH;
+    return isValid ? [isValid] : [isValid, ERR_PIPELINE_NAME_LENGTH];
+}
+exports.pipelineName = pipelineName;
+function repoName(repo) {
+    const isValid = Boolean(repo.match(REPO_REGEX));
+    return isValid ? [isValid] : [isValid, ERR_REPO_FORMAT];
+}
+exports.repoName = repoName;
+function nameAndRepo({ name, repo }) {
+    const errors = [];
+    const [nameIsValid, nameMsg] = pipelineName(name || '');
+    const [repoIsValid, repoMsg] = repoName(repo || '');
+    if (name && !nameIsValid)
+        errors.push(nameMsg);
+    if (repo && !repoIsValid)
+        errors.push(repoMsg);
+    return errors;
+}
+exports.nameAndRepo = nameAndRepo;

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

@@ -0,0 +1,7 @@
+declare const INFERRABLE_STAGES: {
+    name: string;
+    inferRegex: RegExp;
+}[];
+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, };

package/lib/lib/pipelines/stages.js

@@ -0,0 +1,22 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.names = exports.inferrableStageNames = exports.inferrableStages = void 0;
+const INFERRABLE_STAGES = [
+    {
+        name: 'development',
+        inferRegex: /-(dev|development|uat|tst|test|qa)$/,
+    },
+    {
+        name: 'staging',
+        inferRegex: /-(stg|staging)$/,
+    },
+    {
+        name: 'production',
+        inferRegex: /-(prd|prod|production|admin|demo)$/,
+    },
+];
+exports.inferrableStages = INFERRABLE_STAGES;
+const INFERRABLE_STAGE_NAMES = INFERRABLE_STAGES.map(stage => stage.name);
+exports.inferrableStageNames = INFERRABLE_STAGE_NAMES;
+const STAGE_NAMES = ['review'].concat(INFERRABLE_STAGE_NAMES);
+exports.names = STAGE_NAMES;

package/lib/lib/run/colorize.d.ts

@@ -0,0 +1,2 @@
+export declare const COLORS: Array<(s: string) => string>;
+export default function colorize(line: string): string;

package/lib/lib/run/colorize.js

@@ -0,0 +1,300 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.COLORS = void 0;
+const color_1 = require("@heroku-cli/color");
+const core_1 = require("@oclif/core");
+exports.COLORS = [
+    s => color_1.default.yellow(s),
+    s => color_1.default.green(s),
+    s => color_1.default.cyan(s),
+    s => color_1.default.magenta(s),
+    s => color_1.default.blue(s),
+    s => color_1.default.bold.green(s),
+    s => color_1.default.bold.cyan(s),
+    s => color_1.default.bold.magenta(s),
+    s => color_1.default.bold.yellow(s),
+    s => color_1.default.bold.blue(s),
+];
+const assignedColors = {};
+function getColorForIdentifier(i) {
+    i = i.split('.')[0];
+    if (assignedColors[i])
+        return assignedColors[i];
+    assignedColors[i] = exports.COLORS[Object.keys(assignedColors).length % exports.COLORS.length];
+    return assignedColors[i];
+}
+// get initial colors so they are the same every time
+getColorForIdentifier('run');
+getColorForIdentifier('router');
+getColorForIdentifier('web');
+getColorForIdentifier('postgres');
+getColorForIdentifier('heroku-postgres');
+const lineRegex = /^(.*?\[([\w-]+)([\d.]+)?]:)(.*)?$/;
+const red = color_1.default.red;
+const dim = (i) => color_1.default.dim(i);
+const other = dim;
+const path = (i) => color_1.default.green(i);
+const method = (i) => color_1.default.bold.magenta(i);
+const status = (code) => {
+    if (code < 200)
+        return code;
+    if (code < 300)
+        return color_1.default.green(code);
+    if (code < 400)
+        return color_1.default.cyan(code);
+    if (code < 500)
+        return color_1.default.yellow(code);
+    if (code < 600)
+        return color_1.default.red(code);
+    return code;
+};
+const ms = (s) => {
+    const ms = Number.parseInt(s, 10);
+    if (!ms)
+        return s;
+    if (ms < 100)
+        return color_1.default.greenBright(s);
+    if (ms < 500)
+        return color_1.default.green(s);
+    if (ms < 5000)
+        return color_1.default.yellow(s);
+    if (ms < 10000)
+        return color_1.default.yellowBright(s);
+    return color_1.default.red(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)];
+        }
+    };
+    try {
+        const tokens = body.split(/\s+/).map(sub => {
+            const parts = sub.split('=');
+            if (parts.length === 1) {
+                return parts;
+            }
+            if (parts.length === 2) {
+                return encodeColor(parts);
+            }
+            return encodeColor([parts[0], parts.splice(1).join('=')]);
+        });
+        return tokens.map(([k, v]) => {
+            if (v === undefined) {
+                return other(k);
+            }
+            return other(k + '=') + v;
+        }).join(' ');
+    }
+    catch (error) {
+        core_1.ux.warn(error);
+        return body;
+    }
+}
+const state = (s) => {
+    switch (s) {
+        case 'down': return red(s);
+        case 'up': return color_1.default.greenBright(s);
+        case 'starting': return color_1.default.yellowBright(s);
+        case 'complete': return color_1.default.greenBright(s);
+        default: return s;
+    }
+};
+function colorizeRun(body) {
+    try {
+        if (body.match(/^Stopping all processes with SIGTERM$/))
+            return color_1.default.red(body);
+        const starting = body.match(/^(Starting process with command )(`.+`)(by user )?(.*)?$/);
+        if (starting) {
+            return [
+                starting[1],
+                color_1.default.cmd(starting[2]),
+                starting[3] || '',
+                color_1.default.green(starting[4] || ''),
+            ].join('');
+        }
+        const stateChange = body.match(/^(State changed from )(\w+)( to )(\w+)$/);
+        if (stateChange) {
+            return [
+                stateChange[1],
+                state(stateChange[2]),
+                stateChange[3] || '',
+                state(stateChange[4] || ''),
+            ].join('');
+        }
+        const exited = body.match(/^(Process exited with status )(\d+)$/);
+        if (exited) {
+            return [
+                exited[1],
+                exited[2] === '0' ? color_1.default.greenBright(exited[2]) : color_1.default.red(exited[2]),
+            ].join('');
+        }
+    }
+    catch (error) {
+        core_1.ux.warn(error);
+    }
+    return body;
+}
+function colorizeWeb(body) {
+    try {
+        if (body.match(/^Unidling$/))
+            return color_1.default.yellow(body);
+        if (body.match(/^Restarting$/))
+            return color_1.default.yellow(body);
+        if (body.match(/^Stopping all processes with SIGTERM$/))
+            return color_1.default.red(body);
+        const starting = body.match(/^(Starting process with command )(`.+`)(by user )?(.*)?$/);
+        if (starting) {
+            return [
+                (starting[1]),
+                color_1.default.cmd(starting[2]),
+                (starting[3] || ''),
+                color_1.default.green(starting[4] || ''),
+            ].join('');
+        }
+        const exited = body.match(/^(Process exited with status )(\d+)$/);
+        if (exited) {
+            return [
+                exited[1],
+                exited[2] === '0' ? color_1.default.greenBright(exited[2]) : color_1.default.red(exited[2]),
+            ].join('');
+        }
+        const stateChange = body.match(/^(State changed from )(\w+)( to )(\w+)$/);
+        if (stateChange) {
+            return [
+                stateChange[1],
+                state(stateChange[2]),
+                stateChange[3],
+                state(stateChange[4]),
+            ].join('');
+        }
+        const apache = body.match(/^(\d+\.\d+\.\d+\.\d+ -[^-]*- \[[^\]]+] ")(\w+)( )([^ ]+)( HTTP\/\d+\.\d+" )(\d+)( .+$)/);
+        if (apache) {
+            const [, ...tokens] = apache;
+            return [
+                other(tokens[0]),
+                method(tokens[1]),
+                other(tokens[2]),
+                path(tokens[3]),
+                other(tokens[4]),
+                status(tokens[5]),
+                other(tokens[6]),
+            ].join('');
+        }
+        const route = body.match(/^(.* ")(\w+)(.+)(HTTP\/\d+\.\d+" .*)$/);
+        if (route) {
+            return [
+                route[1],
+                method(route[2]),
+                path(route[3]),
+                route[4],
+            ].join('');
+        }
+    }
+    catch (error) {
+        core_1.ux.warn(error);
+    }
+    return body;
+}
+function colorizeAPI(body) {
+    if (body.match(/^Build succeeded$/))
+        return color_1.default.greenBright(body);
+    // eslint-disable-next-line unicorn/prefer-starts-ends-with
+    if (body.match(/^Build failed/))
+        return color_1.default.red(body);
+    const build = body.match(/^(Build started by user )(.+)$/);
+    if (build) {
+        return [
+            build[1],
+            color_1.default.green(build[2]),
+        ].join('');
+    }
+    const deploy = body.match(/^(Deploy )([\w]+)( by user )(.+)$/);
+    if (deploy) {
+        return [
+            deploy[1],
+            color_1.default.cyan(deploy[2]),
+            deploy[3],
+            color_1.default.green(deploy[4]),
+        ].join('');
+    }
+    const release = body.match(/^(Release )(v[\d]+)( created by user )(.+)$/);
+    if (release) {
+        return [
+            release[1],
+            color_1.default.magenta(release[2]),
+            release[3],
+            color_1.default.green(release[4]),
+        ].join('');
+    }
+    const starting = body.match(/^(Starting process with command )(`.+`)(by user )?(.*)?$/);
+    if (starting) {
+        return [
+            (starting[1]),
+            color_1.default.cmd(starting[2]),
+            (starting[3] || ''),
+            color_1.default.green(starting[4] || ''),
+        ].join('');
+    }
+    return body;
+}
+function colorizeRedis(body) {
+    if (body.match(/source=\w+ sample#/)) {
+        body = dim(body);
+    }
+    return body;
+}
+function colorizePG(body) {
+    const create = body.match(/^(\[DATABASE].*)(CREATE TABLE)(.*)$/);
+    if (create) {
+        return [
+            other(create[1]),
+            color_1.default.magenta(create[2]),
+            color_1.default.cyan(create[3]),
+        ].join('');
+    }
+    if (body.match(/source=\w+ sample#/)) {
+        body = dim(body);
+    }
+    return body;
+}
+function colorize(line) {
+    if (process.env.HEROKU_LOGS_COLOR === '0')
+        return line;
+    const parsed = line.match(lineRegex);
+    if (!parsed)
+        return line;
+    const header = parsed[1];
+    const identifier = parsed[2];
+    let body = (parsed[4] || '').trim();
+    switch (identifier) {
+        case 'api':
+            body = colorizeAPI(body);
+            break;
+        case 'router':
+            body = colorizeRouter(body);
+            break;
+        case 'run':
+            body = colorizeRun(body);
+            break;
+        case 'web':
+            body = colorizeWeb(body);
+            break;
+        case 'heroku-redis':
+            body = colorizeRedis(body);
+            break;
+        case 'heroku-postgres':
+        case 'postgres':
+            body = colorizePG(body);
+    }
+    return getColorForIdentifier(identifier)(header) + ' ' + body;
+}
+exports.default = colorize;