heroku 10.13.2-beta.0 → 11.0.0-alpha.1

package/lib/lib/container/docker_helper.js

@@ -1,188 +1,192 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.runImage = exports.pushImage = exports.buildImage = exports.chooseJobs = exports.filterByProcessType = exports.getJobs = exports.getDockerfiles = exports.pullImage = exports.version = exports.cmd = void 0;
-const Child = require("child_process");
-const debug_1 = require("./debug");
-const glob = require("glob");
-const Path = require("path");
-const inquirer = require("inquirer");
-const os = require("os");
-const core_1 = require("@oclif/core");
+import Child from 'node:child_process';
+import { debug } from './debug.js';
+import { glob } from 'glob';
+import Path from 'node:path';
+import inquirer from 'inquirer';
+import os from 'node:os';
+import { ux } from '@oclif/core';
 const DOCKERFILE_REGEX = /\bDockerfile(.\w*)?$/;
-const cmd = async function (cmd, args, options = {}) {
-    (0, debug_1.debug)(cmd, args);
-    const stdio = [
-        options.input ? 'pipe' : process.stdin,
-        options.output ? 'pipe' : process.stdout,
-        process.stderr,
-    ];
-    return new Promise((resolve, reject) => {
-        const child = Child.spawn(cmd, args, { stdio: stdio });
-        if (child.stdin) {
-            child.stdin.end(options.input);
-        }
-        let stdout;
-        if (child.stdout) {
-            stdout = '';
-            child.stdout.on('data', data => {
-                stdout += data.toString();
-            });
-        }
-        child.on('error', (err) => {
-            if (err.code === 'ENOENT' && err.path === 'docker') {
-                reject(new Error(`Cannot find docker, please ensure docker is installed.
-        If you need help installing docker, visit https://docs.docker.com/install/#supported-platforms`));
-            }
-            else {
-                reject(err);
+export class DockerHelper {
+    async cmd(cmd, args, options = {}) {
+        debug(cmd, args);
+        const stdio = [
+            options.input ? 'pipe' : process.stdin,
+            options.output ? 'pipe' : process.stdout,
+            process.stderr,
+        ];
+        return new Promise((resolve, reject) => {
+            const child = Child.spawn(cmd, args, { stdio: stdio });
+            if (child.stdin) {
+                child.stdin.end(options.input);
             }
-        });
-        child.on('exit', (code, signal) => {
-            if (signal || code) {
-                reject(new Error(signal || (code === null || code === void 0 ? void 0 : code.toString())));
-            }
-            else {
-                resolve(stdout);
+            let stdout;
+            if (child.stdout) {
+                stdout = '';
+                child.stdout.on('data', data => {
+                    stdout += data.toString();
+                });
             }
+            child.on('error', (err) => {
+                if (err.code === 'ENOENT' && err.path === 'docker') {
+                    reject(new Error(`Cannot find docker, please ensure docker is installed.
+          If you need help installing docker, visit https://docs.docker.com/install/#supported-platforms`));
+                }
+                else {
+                    reject(err);
+                }
+            });
+            child.on('exit', (code, signal) => {
+                if (signal || code) {
+                    reject(new Error(signal || code?.toString()));
+                }
+                else {
+                    resolve(stdout);
+                }
+            });
         });
-    });
-};
-exports.cmd = cmd;
-const version = async function () {
-    const version = await (0, exports.cmd)('docker', ['version', '-f', '{{.Client.Version}}'], { output: true });
-    const [major, minor] = version.split(/\./);
-    return [Number.parseInt(major, 10) || 0, Number.parseInt(minor, 10) || 0]; // ensure exactly 2 components
-};
-exports.version = version;
-const pullImage = function (resource) {
-    const args = ['pull', resource];
-    return (0, exports.cmd)('docker', args);
-};
-exports.pullImage = pullImage;
-const getDockerfiles = function (rootdir, recursive) {
-    const match = recursive ? './**/Dockerfile?(.)*' : 'Dockerfile*';
-    let dockerfiles = glob.sync(match, {
-        cwd: rootdir,
-        nodir: true,
-    });
-    if (recursive) {
-        dockerfiles = dockerfiles.filter(df => df.match(/Dockerfile\.[\w]+$/));
     }
-    else {
-        dockerfiles = dockerfiles.filter(df => df.match(/Dockerfile$/));
+    async version() {
+        const version = await this.cmd('docker', ['version', '-f', '{{.Client.Version}}'], { output: true });
+        const [major, minor] = version.split(/\./);
+        return [Number.parseInt(major, 10) || 0, Number.parseInt(minor, 10) || 0]; // ensure exactly 2 components
     }
-    return dockerfiles.map(file => Path.join(rootdir, file));
-};
-exports.getDockerfiles = getDockerfiles;
-const getJobs = function (resourceRoot, dockerfiles) {
-    const jobs = [];
-    dockerfiles.forEach(dockerfile => {
-        const match = dockerfile.match(DOCKERFILE_REGEX);
-        if (match) {
-            const proc = (match[1] || '.standard').slice(1);
-            jobs.push({
-                name: proc,
-                resource: `${resourceRoot}/${proc}`,
-                dockerfile: dockerfile,
-                postfix: Path.basename(dockerfile) === 'Dockerfile' ? 0 : 1,
-                depth: Path.normalize(dockerfile).split(Path.sep).length,
-            });
+    async pullImage(resource) {
+        const args = ['pull', resource];
+        return this.cmd('docker', args);
+    }
+    getDockerfiles(rootdir, recursive) {
+        const match = recursive ? './**/Dockerfile?(.)*' : 'Dockerfile*';
+        let dockerfiles = glob.sync(match, {
+            cwd: rootdir,
+            nodir: true,
+        });
+        if (recursive) {
+            dockerfiles = dockerfiles.filter(df => df.match(/Dockerfile\.[\w]+$/));
         }
-    });
-    // prefer closer Dockerfiles, then prefer Dockerfile over Dockerfile.web
-    jobs.sort((a, b) => {
-        return a.depth - b.depth || a.postfix - b.postfix;
-    });
-    // group all Dockerfiles for the same process type together
-    const groupedJobs = {};
-    jobs.forEach(job => {
-        groupedJobs[job.name] = groupedJobs[job.name] || [];
-        groupedJobs[job.name].push(job);
-    });
-    return groupedJobs;
-};
-exports.getJobs = getJobs;
-const filterByProcessType = function (jobs, processTypes) {
-    const filteredJobs = {};
-    processTypes.forEach(processType => {
-        filteredJobs[processType] = jobs[processType];
-    });
-    return filteredJobs;
-};
-exports.filterByProcessType = filterByProcessType;
-const chooseJobs = async function (jobs) {
-    const chosenJobs = [];
-    for (const processType in jobs) {
-        if (Object.prototype.hasOwnProperty.call(jobs, processType)) {
-            const group = jobs[processType];
-            if (group === undefined) {
-                core_1.ux.warn(`Dockerfile.${processType} not found`);
-                continue;
+        else {
+            dockerfiles = dockerfiles.filter(df => df.match(/Dockerfile$/));
+        }
+        return dockerfiles.map(file => Path.join(rootdir, file));
+    }
+    getJobs(resourceRoot, dockerfiles) {
+        const jobs = [];
+        dockerfiles.forEach(dockerfile => {
+            const match = dockerfile.match(DOCKERFILE_REGEX);
+            if (match) {
+                const proc = (match[1] || '.standard').slice(1);
+                jobs.push({
+                    name: proc,
+                    resource: `${resourceRoot}/${proc}`,
+                    dockerfile: dockerfile,
+                    postfix: Path.basename(dockerfile) === 'Dockerfile' ? 0 : 1,
+                    depth: Path.normalize(dockerfile).split(Path.sep).length,
+                });
             }
-            if (group.length > 1) {
-                const prompt = [{
-                        type: 'list',
-                        name: processType,
-                        choices: group.map(j => j.dockerfile),
-                        message: `Found multiple Dockerfiles with process type ${processType}. Please choose one to build and push `,
-                    }];
-                const answer = await inquirer.prompt(prompt);
-                const found = group.find(o => o.dockerfile === answer[processType]);
-                if (found) {
-                    chosenJobs.push(found);
+        });
+        // prefer closer Dockerfiles, then prefer Dockerfile over Dockerfile.web
+        jobs.sort((a, b) => {
+            return a.depth - b.depth || a.postfix - b.postfix;
+        });
+        // group all Dockerfiles for the same process type together
+        const groupedJobs = {};
+        jobs.forEach(job => {
+            groupedJobs[job.name] = groupedJobs[job.name] || [];
+            groupedJobs[job.name].push(job);
+        });
+        return groupedJobs;
+    }
+    filterByProcessType(jobs, processTypes) {
+        const filteredJobs = {};
+        processTypes.forEach(processType => {
+            filteredJobs[processType] = jobs[processType];
+        });
+        return filteredJobs;
+    }
+    async chooseJobs(jobs) {
+        const chosenJobs = [];
+        for (const processType in jobs) {
+            if (Object.prototype.hasOwnProperty.call(jobs, processType)) {
+                const group = jobs[processType];
+                if (group === undefined) {
+                    ux.warn(`Dockerfile.${processType} not found`);
+                    continue;
+                }
+                if (group.length > 1) {
+                    const prompt = [{
+                            type: 'list',
+                            name: processType,
+                            choices: group.map(j => j.dockerfile),
+                            message: `Found multiple Dockerfiles with process type ${processType}. Please choose one to build and push `,
+                        }];
+                    const answer = await inquirer.prompt(prompt);
+                    const found = group.find(o => o.dockerfile === answer[processType]);
+                    if (found) {
+                        chosenJobs.push(found);
+                    }
+                }
+                else {
+                    chosenJobs.push(group[0]);
                 }
             }
-            else {
-                chosenJobs.push(group[0]);
+        }
+        return chosenJobs;
+    }
+    async buildImage({ dockerfile, resource, buildArgs, path, arch }) {
+        const cwd = path || Path.dirname(dockerfile);
+        const args = ['build', '-f', dockerfile, '-t', resource];
+        // Older Docker versions don't allow for this flag, but we are
+        // adding it here when necessary to allow for pushing a docker build from m1/m2 Macs.
+        if (arch === 'arm64' || arch === 'aarch64')
+            args.push('--platform', 'linux/amd64');
+        // newer docker versions support attestations and software bill of materials, so we want to disable them to save time/space
+        // Heroku's container registry doesn't support pushing them right now
+        if (await this.version() >= [24, 0, 0]) {
+            args.push('--provenance', 'false');
+            args.push('--sbom', 'false');
+        }
+        for (const element of buildArgs) {
+            if (element.length > 0) {
+                args.push('--build-arg', element);
             }
         }
+        args.push(cwd);
+        return this.cmd('docker', args);
     }
-    return chosenJobs;
-};
-exports.chooseJobs = chooseJobs;
-const buildImage = async function ({ dockerfile, resource, buildArgs, path, arch }) {
-    const cwd = path || Path.dirname(dockerfile);
-    const args = ['build', '-f', dockerfile, '-t', resource];
-    // Older Docker versions don't allow for this flag, but we are
-    // adding it here when necessary to allow for pushing a docker build from m1/m2 Macs.
-    if (arch === 'arm64' || arch === 'aarch64')
-        args.push('--platform', 'linux/amd64');
-    // newer docker versions support attestations and software bill of materials, so we want to disable them to save time/space
-    // Heroku's container registry doesn't support pushing them right now
-    if (await (0, exports.version)() >= [24, 0, 0]) {
-        args.push('--provenance', 'false');
-        args.push('--sbom', 'false');
+    async pushImage(resource, arch) {
+        const args = ['push', resource];
+        // Older Docker versions don't allow for this flag, but we are
+        // adding it here when necessary to allow for pushing a docker build from m1/m2 Macs.
+        // Heroku's container registry doesn't support pushing multi-arch images so we need to push the expected arch
+        if (arch === 'arm64' || arch === 'aarch64')
+            args.push('--platform', 'linux/amd64');
+        return this.cmd('docker', args);
     }
-    for (const element of buildArgs) {
-        if (element.length > 0) {
-            args.push('--build-arg', element);
-        }
+    async runImage(resource, command, port) {
+        const args = [
+            'run',
+            '--user',
+            os.userInfo().uid.toString(),
+            '-e',
+            `PORT=${port}`,
+            '-it',
+            resource,
+            command,
+        ];
+        return this.cmd('docker', args);
     }
-    args.push(cwd);
-    return (0, exports.cmd)('docker', args);
-};
-exports.buildImage = buildImage;
-const pushImage = async function (resource, arch) {
-    const args = ['push', resource];
-    // Older Docker versions don't allow for this flag, but we are
-    // adding it here when necessary to allow for pushing a docker build from m1/m2 Macs.
-    // Heroku's container registry doesn't support pushing multi-arch images so we need to push the expected arch
-    if (arch === 'arm64' || arch === 'aarch64')
-        args.push('--platform', 'linux/amd64');
-    return (0, exports.cmd)('docker', args);
-};
-exports.pushImage = pushImage;
-const runImage = function (resource, command, port) {
-    const args = [
-        'run',
-        '--user',
-        os.userInfo().uid.toString(),
-        '-e',
-        `PORT=${port}`,
-        '-it',
-        resource,
-        command,
-    ];
-    return (0, exports.cmd)('docker', args);
-};
-exports.runImage = runImage;
+}
+// // Create a default instance for backward compatibility
+// const defaultDockerHelper = new DockerHelper()
+// // Export the class and default instance
+// export {defaultDockerHelper}
+// // Export all methods as standalone functions for backward compatibility
+// export const cmd = (cmd: string, args: string[], options: cmdOptions = {}) => defaultDockerHelper.cmd(cmd, args, options)
+// export const version = () => defaultDockerHelper.version()
+// export const pullImage = (resource: string) => defaultDockerHelper.pullImage(resource)
+// export const getDockerfiles = (rootdir: string, recursive: boolean) => defaultDockerHelper.getDockerfiles(rootdir, recursive)
+// export const getJobs = (resourceRoot: string, dockerfiles: string[]) => defaultDockerHelper.getJobs(resourceRoot, dockerfiles)
+// export const filterByProcessType = (jobs: groupedDockerJobs, processTypes: string[]) => defaultDockerHelper.filterByProcessType(jobs, processTypes)
+// export const chooseJobs = (jobs: groupedDockerJobs) => defaultDockerHelper.chooseJobs(jobs)
+// export const buildImage = (params: BuildImageParams) => defaultDockerHelper.buildImage(params)
+// export const pushImage = (resource: string) => defaultDockerHelper.pushImage(resource)
+// export const runImage = (resource: string, command: string, port: number) => defaultDockerHelper.runImage(resource, command, port)

package/lib/lib/container/helpers.js

@@ -1,8 +1,5 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.ensureContainerStack = void 0;
-const color_1 = require("@heroku-cli/color");
-const core_1 = require("@oclif/core");
+import { color } from '@heroku-cli/color';
+import { ux } from '@oclif/core';
 const stackLabelMap = {
     cnb: 'Cloud Native Buildpack',
 };
@@ -12,18 +9,16 @@ const stackLabelMap = {
  * @param cmd {String} command name
  * @returns {null} null
  */
-function ensureContainerStack(app, cmd) {
-    var _a, _b;
-    const buildStack = (_a = app.build_stack) === null || _a === void 0 ? void 0 : _a.name;
-    const appStack = (_b = app.stack) === null || _b === void 0 ? void 0 : _b.name;
+export function ensureContainerStack(app, cmd) {
+    const buildStack = app.build_stack?.name;
+    const appStack = app.stack?.name;
     const allowedStack = 'container';
     // either can be container stack and are allowed
     if (buildStack !== allowedStack && appStack !== allowedStack) {
         let message = 'This command is for Docker apps only.';
         if (['push', 'release'].includes(cmd)) {
-            message += ` Switch stacks by running ${color_1.default.cmd('heroku stack:set container')}. Or, to deploy ${color_1.default.app(app.name)} with ${color_1.default.yellow(appStack)}, run ${color_1.default.cmd('git push heroku main')} instead.`;
+            message += ` Switch stacks by running ${color.cmd('heroku stack:set container')}. Or, to deploy ${color.app(app.name)} with ${color.yellow(appStack)}, run ${color.cmd('git push heroku main')} instead.`;
         }
-        core_1.ux.error(message, { exit: 1 });
+        ux.error(message, { exit: 1 });
     }
 }
-exports.ensureContainerStack = ensureContainerStack;

package/lib/lib/container/streamer.js

@@ -1,11 +1,8 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.streamer = void 0;
+import { HTTP } from '@heroku/http-call';
 async function call(url, out, retries) {
-    const http = require('@heroku/http-call').HTTP;
     const maxRetries = 30;
     try {
-        const { response } = await http.stream(url);
+        const { response } = await HTTP.stream(url);
         response.on('data', function (d) {
             out.write(d);
         });
@@ -25,7 +22,6 @@ async function call(url, out, retries) {
         throw error;
     }
 }
-const streamer = function (url, out) {
+export const streamer = function (url, out) {
     return call(url, out, 0);
 };
-exports.streamer = streamer;

package/lib/lib/domains/domains.js

@@ -1,10 +1,7 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.waitForCertIssuedOnDomains = exports.printDomains = exports.waitForDomains = exports.getDomains = void 0;
-const psl_1 = require("psl");
-const core_1 = require("@oclif/core");
-const heroku_cli_util_1 = require("@heroku/heroku-cli-util");
-const color_1 = require("@heroku-cli/color");
+import { parse } from 'psl';
+import { ux } from '@oclif/core';
+import { hux } from '@heroku/heroku-cli-util';
+import { color } from '@heroku-cli/color';
 const wait = function (ms) {
     return new Promise(function (resolve) {
         setTimeout(resolve, ms);
@@ -13,25 +10,24 @@ const wait = function (ms) {
 function isParseError(parsed) {
     return parsed.error !== undefined;
 }
-async function getDomains(heroku, app) {
+export async function getDomains(heroku, app) {
     const { body: domains } = await heroku.get(`/apps/${app}/domains`);
     return domains;
 }
-exports.getDomains = getDomains;
 function type(domain) {
-    const parsed = (0, psl_1.parse)(domain.hostname);
+    const parsed = parse(domain.hostname);
     if (isParseError(parsed)) {
         throw new Error(parsed.error.message);
     }
     return parsed.subdomain === null ? 'ALIAS/ANAME' : 'CNAME';
 }
-async function waitForDomains(heroku, app) {
+export async function waitForDomains(heroku, app) {
     function someNull(domains) {
         return domains.some(domain => domain.kind === 'custom' && !domain.cname);
     }
     let apiDomains = await getDomains(heroku, app);
     if (someNull(apiDomains)) {
-        core_1.ux.action.start('Waiting for stable domains to be created');
+        ux.action.start('Waiting for stable domains to be created');
         let index = 0;
         do {
             // trying 30 times was easier for me to test that setTimeout
@@ -45,17 +41,17 @@ async function waitForDomains(heroku, app) {
     }
     return apiDomains;
 }
-exports.waitForDomains = waitForDomains;
-function printDomains(domains, message) {
+export function printDomains(domains, message) {
     domains = domains.filter(domain => domain.kind === 'custom');
     const domains_with_type = domains.map(domain => Object.assign({}, domain, { type: type(domain) }));
     if (domains_with_type.length === 0) {
-        heroku_cli_util_1.hux.styledHeader(`${message}  Add a custom domain to your app by running ${color_1.default.cmd('heroku domains:add <yourdomain.com>')}`);
+        hux.styledHeader(`${message}  Add a custom domain to your app by running ${color.cmd('heroku domains:add <yourdomain.com>')}`);
     }
     else {
-        heroku_cli_util_1.hux.styledHeader(`${message}  Update your application's DNS settings as follows`);
-        heroku_cli_util_1.hux.table(domains_with_type, {
+        hux.styledHeader(`${message}  Update your application's DNS settings as follows`);
+        hux.table(domains_with_type, {
             domain: {
+                header: 'Domain',
                 get: ({ hostname }) => hostname,
             },
             recordType: {
@@ -69,8 +65,7 @@ function printDomains(domains, message) {
         });
     }
 }
-exports.printDomains = printDomains;
-async function waitForCertIssuedOnDomains(heroku, app) {
+export async function waitForCertIssuedOnDomains(heroku, app) {
     function certIssuedOrFailedForAllCustomDomains(domains) {
         domains = domains.filter(domain => domain.kind === 'custom');
         return domains.every(domain => domain.acm_status === 'cert issued' || domain.acm_status === 'failed');
@@ -88,7 +83,7 @@ async function waitForCertIssuedOnDomains(heroku, app) {
     }
     let domains = await getDomains(heroku, app);
     if (!certIssuedOrFailedForAllCustomDomains(domains)) {
-        core_1.ux.action.start('Waiting until the certificate is issued to all domains');
+        ux.action.start('Waiting until the certificate is issued to all domains');
         let retries = 0;
         while (!certIssuedOrFailedForAllCustomDomains(domains)) {
             await wait(backoff(retries));
@@ -96,10 +91,9 @@ async function waitForCertIssuedOnDomains(heroku, app) {
             retries++;
         }
         if (someFailed(domains)) {
-            core_1.ux.action.stop(color_1.default.red('!'));
+            ux.action.stop(color.red('!'));
             throw new Error('ACM not enabled for some domains');
         }
-        core_1.ux.action.stop();
+        ux.action.stop();
     }
 }
-exports.waitForCertIssuedOnDomains = waitForCertIssuedOnDomains;

package/lib/lib/domains/wait-for-domain.js

@@ -1,19 +1,15 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-const color_1 = require("@heroku-cli/color");
-const heroku_cli_util_1 = require("@heroku/heroku-cli-util");
-const spinner_1 = require("@oclif/core/lib/cli-ux/action/spinner");
-async function waitForDomain(app, heroku, domain) {
-    const action = new spinner_1.default();
-    action.start(`Waiting for ${color_1.color.green(domain.hostname || 'domain')}`);
+import { color } from '@heroku-cli/color';
+import { hux } from '@heroku/heroku-cli-util';
+import { ux } from '@oclif/core';
+export default async function waitForDomain(app, heroku, domain) {
+    ux.action.start(`Waiting for ${color.green(domain.hostname || 'domain')}`);
     while (domain.status === 'pending') {
-        await heroku_cli_util_1.hux.wait(5000);
+        await hux.wait(5000);
         const { body: updatedDomain } = await heroku.get(`/apps/${app}/domains/${domain.id}`);
         domain = updatedDomain;
     }
-    action.stop();
+    ux.action.stop();
     if (domain.status === 'succeeded' || domain.status === 'none')
         return;
     throw new Error(`The domain creation finished with status ${domain.status}`);
 }
-exports.default = waitForDomain;

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

@@ -10,8 +10,8 @@ export default class Git {
     getCommitTitle(ref: string): Promise<string>;
     readCommit(commit: string): Promise<{
         branch: string;
-        ref: string;
         message: string;
+        ref: string;
     }>;
     inGitRepo(): true | undefined;
     hasGitRemote(remote: string): Promise<boolean>;