heroku 8.1.9 → 8.2.0-beta.0

package/lib/lib/autocomplete/completions.d.ts

@@ -0,0 +1,37 @@
+import { Completion, CompletionContext } from '@oclif/core/lib/interfaces/parser';
+export declare const oneDay: number;
+export declare const herokuGet: (resource: string, ctx: CompletionContext) => Promise<string[]>;
+export declare const AppCompletion: Completion;
+export declare const AppAddonCompletion: Completion;
+export declare const AppDynoCompletion: Completion;
+export declare const BuildpackCompletion: Completion;
+export declare const DynoSizeCompletion: Completion;
+export declare const FileCompletion: Completion;
+export declare const PipelineCompletion: Completion;
+export declare const ProcessTypeCompletion: Completion;
+export declare const RegionCompletion: Completion;
+export declare const RemoteCompletion: Completion;
+export declare const RoleCompletion: Completion;
+export declare const ScopeCompletion: Completion;
+export declare const SpaceCompletion: Completion;
+export declare const StackCompletion: Completion;
+export declare const StageCompletion: Completion;
+export declare const TeamCompletion: Completion;
+export declare const CompletionMapping: {
+    [key: string]: Completion;
+};
+export declare class CompletionLookup {
+    private readonly cmdId;
+    private readonly name;
+    private readonly description?;
+    private get key();
+    private readonly blocklistMap;
+    private readonly keyAliasMap;
+    private readonly commandArgsMap;
+    constructor(cmdId: string, name: string, description?: string | undefined);
+    run(): Completion | undefined;
+    private argAlias;
+    private keyAlias;
+    private descriptionAlias;
+    private blocklisted;
+}

package/lib/lib/autocomplete/completions.js

@@ -0,0 +1,261 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CompletionLookup = exports.CompletionMapping = exports.TeamCompletion = exports.StageCompletion = exports.StackCompletion = exports.SpaceCompletion = exports.ScopeCompletion = exports.RoleCompletion = exports.RemoteCompletion = exports.RegionCompletion = exports.ProcessTypeCompletion = exports.PipelineCompletion = exports.FileCompletion = exports.DynoSizeCompletion = exports.BuildpackCompletion = exports.AppDynoCompletion = exports.AppAddonCompletion = exports.AppCompletion = exports.herokuGet = exports.oneDay = void 0;
+const command_1 = require("@heroku-cli/command");
+const deps_1 = require("@heroku-cli/command/lib/deps");
+const git_1 = require("@heroku-cli/command/lib/git");
+const path = require("path");
+const lodash_1 = require("lodash");
+exports.oneDay = 60 * 60 * 24;
+const herokuGet = async (resource, ctx) => {
+    const heroku = new command_1.APIClient(ctx.config);
+    let { body } = await heroku.get(`/${resource}`, { retryAuth: false });
+    if (typeof body === 'string')
+        body = JSON.parse(body);
+    return body.map((a) => a.name).sort();
+};
+exports.herokuGet = herokuGet;
+exports.AppCompletion = {
+    cacheDuration: exports.oneDay,
+    options: async (ctx) => {
+        const teams = await (0, exports.herokuGet)('teams', ctx);
+        const apps = {
+            personal: await (0, exports.herokuGet)('users/~/apps', ctx),
+            teams: (0, lodash_1.flatten)(await Promise.all(teams.map((team) => (0, exports.herokuGet)(`teams/${team}/apps`, ctx)))),
+        };
+        return apps.personal.concat(apps.teams);
+    },
+};
+exports.AppAddonCompletion = {
+    cacheDuration: exports.oneDay,
+    cacheKey: async (ctx) => {
+        return ctx.flags && ctx.flags.app ? `${ctx.flags.app}_addons` : '';
+    },
+    options: async (ctx) => {
+        const addons = ctx.flags && ctx.flags.app ? await (0, exports.herokuGet)(`apps/${ctx.flags.app}/addons`, ctx) : [];
+        return addons;
+    },
+};
+exports.AppDynoCompletion = {
+    cacheDuration: exports.oneDay,
+    cacheKey: async (ctx) => {
+        return ctx.flags && ctx.flags.app ? `${ctx.flags.app}_dynos` : '';
+    },
+    options: async (ctx) => {
+        const dynos = ctx.flags && ctx.flags.app ? await (0, exports.herokuGet)(`apps/${ctx.flags.app}/dynos`, ctx) : [];
+        return dynos;
+    },
+};
+exports.BuildpackCompletion = {
+    skipCache: true,
+    options: async () => {
+        return [
+            'heroku/ruby',
+            'heroku/nodejs',
+            'heroku/clojure',
+            'heroku/python',
+            'heroku/java',
+            'heroku/gradle',
+            'heroku/scala',
+            'heroku/php',
+            'heroku/go',
+        ];
+    },
+};
+const ConfigCompletion = {
+    cacheDuration: 60 * 60 * 24 * 7,
+    cacheKey: async (ctx) => {
+        return ctx.flags && ctx.flags.app ? `${ctx.flags.app}_config_vars` : '';
+    },
+    options: async (ctx) => {
+        const heroku = new command_1.APIClient(ctx.config);
+        if (ctx.flags && ctx.flags.app) {
+            const { body: configs } = await heroku.get(`/apps/${ctx.flags.app}/config-vars`, { retryAuth: false });
+            return Object.keys(configs);
+        }
+        return [];
+    },
+};
+const ConfigSetCompletion = {
+    cacheDuration: 60 * 60 * 24 * 7,
+    cacheKey: async (ctx) => {
+        return ctx.flags && ctx.flags.app ? `${ctx.flags.app}_config_set_vars` : '';
+    },
+    options: async (ctx) => {
+        const heroku = new command_1.APIClient(ctx.config);
+        if (ctx.flags && ctx.flags.app) {
+            const { body: configs } = await heroku.get(`/apps/${ctx.flags.app}/config-vars`, { retryAuth: false });
+            return Object.keys(configs).map(k => `${k}=`);
+        }
+        return [];
+    },
+};
+exports.DynoSizeCompletion = {
+    cacheDuration: exports.oneDay * 90,
+    options: async (ctx) => {
+        let sizes = await (0, exports.herokuGet)('dyno-sizes', ctx);
+        if (sizes)
+            sizes = sizes.map(s => s.toLowerCase());
+        return sizes;
+    },
+};
+exports.FileCompletion = {
+    skipCache: true,
+    options: async () => {
+        const files = await deps_1.deps.file.readdir(process.cwd());
+        return files;
+    },
+};
+exports.PipelineCompletion = {
+    cacheDuration: exports.oneDay,
+    options: async (ctx) => {
+        const pipelines = await (0, exports.herokuGet)('pipelines', ctx);
+        return pipelines;
+    },
+};
+exports.ProcessTypeCompletion = {
+    skipCache: true,
+    options: async () => {
+        let types = [];
+        const procfile = path.join(process.cwd(), 'Procfile');
+        try {
+            const buff = await deps_1.deps.file.readFile(procfile);
+            types = buff
+                .toString()
+                .split('\n')
+                .map(s => {
+                if (!s)
+                    return false;
+                const m = s.match(/^([A-Za-z0-9_-]+)/);
+                return m ? m[0] : false;
+            })
+                .filter(t => t);
+        }
+        catch (error) {
+            if (error.code !== 'ENOENT')
+                throw error;
+        }
+        return types;
+    },
+};
+exports.RegionCompletion = {
+    cacheDuration: exports.oneDay * 7,
+    options: async (ctx) => {
+        const regions = await (0, exports.herokuGet)('regions', ctx);
+        return regions;
+    },
+};
+exports.RemoteCompletion = {
+    skipCache: true,
+    options: async () => {
+        const remotes = (0, git_1.getGitRemotes)((0, git_1.configRemote)());
+        return remotes.map(r => r.remote);
+    },
+};
+exports.RoleCompletion = {
+    skipCache: true,
+    options: async () => {
+        return ['admin', 'collaborator', 'member', 'owner'];
+    },
+};
+exports.ScopeCompletion = {
+    skipCache: true,
+    options: async () => {
+        return ['global', 'identity', 'read', 'write', 'read-protected', 'write-protected'];
+    },
+};
+exports.SpaceCompletion = {
+    cacheDuration: exports.oneDay,
+    options: async (ctx) => {
+        const spaces = await (0, exports.herokuGet)('spaces', ctx);
+        return spaces;
+    },
+};
+exports.StackCompletion = {
+    cacheDuration: exports.oneDay,
+    options: async (ctx) => {
+        const stacks = await (0, exports.herokuGet)('stacks', ctx);
+        return stacks;
+    },
+};
+exports.StageCompletion = {
+    skipCache: true,
+    options: async () => {
+        return ['test', 'review', 'development', 'staging', 'production'];
+    },
+};
+exports.TeamCompletion = {
+    cacheDuration: exports.oneDay,
+    options: async (ctx) => {
+        const teams = await (0, exports.herokuGet)('teams', ctx);
+        return teams;
+    },
+};
+exports.CompletionMapping = {
+    app: exports.AppCompletion,
+    addon: exports.AppAddonCompletion,
+    dyno: exports.AppDynoCompletion,
+    buildpack: exports.BuildpackCompletion,
+    config: ConfigCompletion,
+    configSet: ConfigSetCompletion,
+    dynosize: exports.DynoSizeCompletion,
+    pipeline: exports.PipelineCompletion,
+    processtype: exports.ProcessTypeCompletion,
+    region: exports.RegionCompletion,
+    remote: exports.RemoteCompletion,
+    role: exports.RoleCompletion,
+    scope: exports.ScopeCompletion,
+    space: exports.SpaceCompletion,
+    stack: exports.StackCompletion,
+    stage: exports.StageCompletion,
+    team: exports.TeamCompletion,
+};
+class CompletionLookup {
+    // eslint-disable-next-line no-useless-constructor
+    constructor(cmdId, name, description) {
+        this.cmdId = cmdId;
+        this.name = name;
+        this.description = description;
+        this.blocklistMap = {
+            app: ['apps:create'],
+            space: ['spaces:create'],
+        };
+        this.keyAliasMap = {
+            key: {
+                'config:get': 'config',
+            },
+        };
+        this.commandArgsMap = {
+            key: {
+                'config:set': 'configSet',
+            },
+        };
+    }
+    get key() {
+        return this.argAlias() || this.keyAlias() || this.descriptionAlias() || this.name;
+    }
+    run() {
+        if (this.blocklisted())
+            return;
+        return exports.CompletionMapping[this.key];
+    }
+    argAlias() {
+        return this.commandArgsMap[this.name] && this.commandArgsMap[this.name][this.cmdId];
+    }
+    keyAlias() {
+        return this.keyAliasMap[this.name] && this.keyAliasMap[this.name][this.cmdId];
+    }
+    descriptionAlias() {
+        const d = this.description;
+        // eslint-disable-next-line unicorn/prefer-starts-ends-with
+        if (d.match(/^dyno size/))
+            return 'dynosize';
+        // eslint-disable-next-line unicorn/prefer-starts-ends-with
+        if (d.match(/^process type/))
+            return 'processtype';
+    }
+    blocklisted() {
+        return this.blocklistMap[this.name] && this.blocklistMap[this.name].includes(this.cmdId);
+    }
+}
+exports.CompletionLookup = CompletionLookup;

package/lib/lib/buildpacks/buildpacks.d.ts

@@ -0,0 +1,32 @@
+import { APIClient } from '@heroku-cli/command';
+import { BuildpackRegistry } from '@heroku/buildpack-registry';
+export declare type BuildpackResponse = {
+    buildpack: {
+        url: string;
+        name: string;
+    };
+    ordinal: number;
+};
+export declare class BuildpackCommand {
+    heroku: APIClient;
+    registry: BuildpackRegistry;
+    constructor(heroku: APIClient);
+    fetch(app: string): Promise<any[]>;
+    mapBuildpackResponse(buildpacks: {
+        body: any;
+    }): BuildpackResponse[];
+    display(buildpacks: BuildpackResponse[], indent: string): void;
+    registryNameToUrl(buildpack: string): Promise<string>;
+    findUrl(buildpacks: BuildpackResponse[], buildpack: string): Promise<number>;
+    validateUrlNotSet(buildpacks: BuildpackResponse[], buildpack: string): Promise<void>;
+    findIndex(buildpacks: BuildpackResponse[], index?: number): number;
+    mutate(app: string, buildpacks: BuildpackResponse[], spliceIndex: number, buildpack: string, command: 'add' | 'set' | 'remove'): Promise<BuildpackResponse[]>;
+    put(app: string, buildpackUpdates: {
+        buildpack: string;
+    }[]): Promise<BuildpackResponse[]>;
+    displayUpdate(app: string, remote: string, buildpacks: BuildpackResponse[], action: 'added' | 'set' | 'removed'): void;
+    registryUrlToName(buildpack: string, registryOnly?: boolean): string;
+    clear(app: string, command: 'clear' | 'remove', action: 'cleared' | 'removed'): Promise<void>;
+    validateIndexInRange(buildpacks: BuildpackResponse[], index: number): void;
+    validateIndex(index: number): void;
+}

package/lib/lib/buildpacks/buildpacks.js

@@ -0,0 +1,161 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BuildpackCommand = void 0;
+const color_1 = require("@heroku-cli/color");
+const buildpack_registry_1 = require("@heroku/buildpack-registry");
+const core_1 = require("@oclif/core");
+const lodash_1 = require("lodash");
+const true_myth_1 = require("true-myth");
+// eslint-disable-next-line node/no-missing-require
+const push = require('./push');
+const validUrl = require('valid-url');
+class BuildpackCommand {
+    constructor(heroku) {
+        this.heroku = heroku;
+        this.registry = new buildpack_registry_1.BuildpackRegistry();
+    }
+    async fetch(app) {
+        const buildpacks = await this.heroku.get(`/apps/${app}/buildpack-installations`);
+        return this.mapBuildpackResponse(buildpacks);
+    }
+    mapBuildpackResponse(buildpacks) {
+        const body = buildpacks.body;
+        return body.map((bp) => {
+            bp.buildpack.url = bp.buildpack.url.replace(/^urn:buildpack:/, '');
+            return bp;
+        });
+    }
+    display(buildpacks, indent) {
+        if (buildpacks.length === 1) {
+            core_1.ux.log(this.registryUrlToName(buildpacks[0].buildpack.url, true));
+        }
+        else {
+            buildpacks.forEach((b, i) => {
+                core_1.ux.log(`${indent}${i + 1}. ${this.registryUrlToName(b.buildpack.url, true)}`);
+            });
+        }
+    }
+    async registryNameToUrl(buildpack) {
+        if (validUrl.isWebUri(buildpack)) {
+            return buildpack;
+        }
+        true_myth_1.Result.match({
+            Ok: _ => { },
+            Err: err => {
+                core_1.ux.error(`Could not find the buildpack: ${buildpack}. ${err}`, { exit: 1 });
+            },
+        }, buildpack_registry_1.BuildpackRegistry.isValidBuildpackSlug(buildpack));
+        try {
+            const response = await this.registry.buildpackExists(buildpack);
+            const body = await response.json();
+            return body.blob_url;
+        }
+        catch (error) {
+            if (error.statusCode === 404) {
+                core_1.ux.error(`${buildpack} is not in the buildpack registry.`, { exit: 1 });
+            }
+            else if (error.statusCode) {
+                core_1.ux.error(`${error.statusCode}: ${error.message}`, { exit: 1 });
+            }
+            else {
+                core_1.ux.error(error.message, { exit: 1 });
+            }
+        }
+        return '';
+    }
+    async findUrl(buildpacks, buildpack) {
+        const mappedUrl = await this.registryNameToUrl(buildpack);
+        return (0, lodash_1.findIndex)(buildpacks, (b) => {
+            return b.buildpack.url === buildpack || b.buildpack.url === mappedUrl;
+        });
+    }
+    async validateUrlNotSet(buildpacks, buildpack) {
+        if (await this.findUrl(buildpacks, buildpack) !== -1) {
+            core_1.ux.error(`The buildpack ${buildpack} is already set on your app.`, { exit: 1 });
+        }
+    }
+    findIndex(buildpacks, index) {
+        if (index) {
+            return (0, lodash_1.findIndex)(buildpacks, function (b) {
+                return b.ordinal + 1 === index;
+            });
+        }
+        return -1;
+    }
+    async mutate(app, buildpacks, spliceIndex, buildpack, command) {
+        const buildpackUpdates = buildpacks.map(function (b) {
+            return { buildpack: b.buildpack.url };
+        });
+        const howmany = (command === 'add') ? 0 : 1;
+        const urls = (command === 'remove') ? [] : [{ buildpack: await this.registryNameToUrl(buildpack) }];
+        const indexes = [spliceIndex, howmany];
+        const array = indexes.concat(urls);
+        Array.prototype.splice.apply(buildpackUpdates, array);
+        return this.put(app, buildpackUpdates);
+    }
+    async put(app, buildpackUpdates) {
+        const buildpacks = await this.heroku.put(`/apps/${app}/buildpack-installations`, {
+            headers: { Range: '' },
+            body: { updates: buildpackUpdates },
+        });
+        return this.mapBuildpackResponse(buildpacks);
+    }
+    displayUpdate(app, remote, buildpacks, action) {
+        if (buildpacks.length === 1) {
+            core_1.ux.log(`Buildpack ${action}. Next release on ${app} will use ${this.registryUrlToName(buildpacks[0].buildpack.url)}.`);
+            core_1.ux.log(`Run ${color_1.default.magenta(push(remote))} to create a new release using this buildpack.`);
+        }
+        else {
+            core_1.ux.log(`Buildpack ${action}. Next release on ${app} will use:`);
+            this.display(buildpacks, '  ');
+            core_1.ux.log(`Run ${color_1.default.magenta(push(remote))} to create a new release using these buildpacks.`);
+        }
+    }
+    registryUrlToName(buildpack, registryOnly = false) {
+        // eslint-disable-next-line no-useless-escape
+        let match = /^https:\/\/buildpack\-registry\.s3\.amazonaws\.com\/buildpacks\/([\w\-]+\/[\w\-]+).tgz$/.exec(buildpack);
+        if (match) {
+            return match[1];
+        }
+        if (!registryOnly) {
+            // eslint-disable-next-line no-useless-escape
+            match = /^https:\/\/codon\-buildpacks\.s3\.amazonaws\.com\/buildpacks\/heroku\/([\w\-]+).tgz$/.exec(buildpack);
+            if (match) {
+                return `heroku/${match[1]}`;
+            }
+        }
+        return buildpack;
+    }
+    async clear(app, command, action) {
+        await this.put(app, []);
+        const configVars = await this.heroku.get(`/apps/${app}/config-vars`);
+        const message = `Buildpack${command === 'clear' ? 's' : ''} ${action}.`;
+        if (configVars.body.BUILDPACK_URL) {
+            core_1.ux.log(message);
+            core_1.ux.warn('The BUILDPACK_URL config var is still set and will be used for the next release');
+        }
+        else if (configVars.body.LANGUAGE_PACK_URL) {
+            core_1.ux.log(message);
+            core_1.ux.warn('The LANGUAGE_PACK_URL config var is still set and will be used for the next release');
+        }
+        else {
+            core_1.ux.log(`${message} Next release on ${app} will detect buildpacks normally.`);
+        }
+    }
+    validateIndexInRange(buildpacks, index) {
+        if (index < 0 || index > buildpacks.length) {
+            if (buildpacks.length === 1) {
+                core_1.ux.error('Invalid index. Only valid value is 1.', { exit: 1 });
+            }
+            else {
+                core_1.ux.error(`Invalid index. Please choose a value between 1 and ${buildpacks.length}`, { exit: 1 });
+            }
+        }
+    }
+    validateIndex(index) {
+        if (Number.isNaN(index) || index <= 0) {
+            core_1.ux.error('Invalid index. Must be greater than 0.', { exit: 1 });
+        }
+    }
+}
+exports.BuildpackCommand = BuildpackCommand;

package/lib/lib/buildpacks/push.js

@@ -0,0 +1,4 @@
+"use strict";
+module.exports = function (remote) {
+    return `git push ${remote || 'heroku'} main`;
+};

package/lib/lib/ci/git.d.ts

@@ -0,0 +1,8 @@
+declare function createArchive(ref: string): Promise<any>;
+declare function githubRepository(): Promise<any>;
+declare function readCommit(commit: string): Promise<{
+    branch: string | undefined;
+    ref: string | undefined;
+    message: string | undefined;
+}>;
+export { createArchive, githubRepository, readCommit, };

package/lib/lib/ci/git.js

@@ -0,0 +1,71 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.readCommit = exports.githubRepository = exports.createArchive = void 0;
+const fs = require("fs-extra");
+const gh = require('github-url-to-object');
+const spawn = require('child_process').spawn;
+const tmp = require('tmp');
+const NOT_A_GIT_REPOSITORY = 'not a git repository';
+const RUN_IN_A_GIT_REPOSITORY = 'Please run this command from the directory containing your project\'s git repo';
+const NOT_ON_A_BRANCH = 'not a symbolic ref';
+const CHECKOUT_A_BRANCH = 'Please checkout a branch before running this command';
+function runGit(...args) {
+    const git = spawn('git', args);
+    return new Promise((resolve, reject) => {
+        git.on('exit', (exitCode) => {
+            if (exitCode === 0) {
+                return;
+            }
+            const error = (git.stderr.read() || 'unknown error').toString().trim();
+            if (error.toLowerCase().includes(NOT_A_GIT_REPOSITORY)) {
+                reject(RUN_IN_A_GIT_REPOSITORY);
+                return;
+            }
+            if (error.includes(NOT_ON_A_BRANCH)) {
+                reject(CHECKOUT_A_BRANCH);
+                return;
+            }
+            reject(new Error(`Error while running 'git ${args.join(' ')}' (${error})`));
+        });
+        git.stdout.on('data', (data) => resolve(data.toString().trim()));
+    });
+}
+async function getRef(branch) {
+    return runGit('rev-parse', branch || 'HEAD');
+}
+async function getBranch(symbolicRef) {
+    return runGit('symbolic-ref', '--short', symbolicRef);
+}
+async function getCommitTitle(ref) {
+    return runGit('log', ref || '', '-1', '--pretty=format:%s');
+}
+async function createArchive(ref) {
+    const tar = spawn('git', ['archive', '--format', 'tar.gz', ref]);
+    const file = tmp.fileSync({ postfix: '.tar.gz' });
+    const write = tar.stdout.pipe(fs.createWriteStream(file.name));
+    return new Promise((resolve, reject) => {
+        write.on('close', () => resolve(file.name));
+        write.on('error', reject);
+    });
+}
+exports.createArchive = createArchive;
+async function githubRepository() {
+    const remote = await runGit('remote', 'get-url', 'origin');
+    const repository = gh(remote);
+    if (repository === null) {
+        throw new Error('Not a GitHub repository');
+    }
+    return repository;
+}
+exports.githubRepository = githubRepository;
+async function readCommit(commit) {
+    const branch = await getBranch('HEAD');
+    const ref = await getRef(commit);
+    const message = await getCommitTitle(ref);
+    return Promise.resolve({
+        branch,
+        ref,
+        message,
+    });
+}
+exports.readCommit = readCommit;