@testim/testim-cli/commons/npmWrapper.js

const util = require('util');
const { getCliLocation } = require('../utils');
const exec = util.promisify(require('child_process').exec);
const spawn = require('child_process').spawn;
const path = require('path');
const { NpmPackageError } = require('../errors');
const Promise = require('bluebird');
const fse = require('fs-extra');
const logger = require('./logger').getLogger("cli-service");
const { requireWithFallback } = require("./requireWithFallback")

async function getLatestPackageVersion(packageName) {
    const result = await exec(`npm view ${packageName} version`);
    return result.stdout.trim();
}

function getPackageIfInstalledLocally(packageName) {
    try {
        // note: this code fails is require itself throws here
        // rather than an ENOENT - but since lazy dependencies are all controlled
        // by us that's probably fine.
        return requireWithFallback(packageName);
    } catch (err) {
        return false;
    }
}

function getLocallyInstalledPackageVersion(rootPath, packageName) {
    return require(path.join(rootPath, `./node_modules/${packageName}/package.json`)).version;
}

function installPackageLocally(rootPath, packageName) {
    return exec(`npm install ${packageName} --no-save --no-package-lock --no-prune`, {cwd: rootPath});
}

function installPackagesLocally(rootPath, packageNames) {
    return exec(`npm i ${packageNames.join(' ')} --no-save --no-package-lock --no-prune`, {cwd: rootPath});
}

const cliLocation = getCliLocation();
const localNpmLocationUnderNpm = path.resolve(cliLocation, 'node_modules', 'npm', 'bin', 'npm-cli.js');
const localNpmLocationUnderYarn = path.resolve(cliLocation, '../../', 'npm', 'bin', 'npm-cli.js');

let localNpmLocation;
fse.exists(localNpmLocationUnderNpm).then(exists => {
    if (exists) {
        localNpmLocation  = localNpmLocationUnderNpm;
    } else {
        fse.exists(localNpmLocationUnderYarn).then(yarnExists => {
            if (yarnExists) { 
                localNpmLocation = localNpmLocationUnderYarn; 
            } else {
                throw new Error('Can\'t find local NPM package');
            }
        });
    }
});

function installPackages(prefix, packageNames, proxyUri, timeoutMs) {
    return new Promise((resolve, reject) => {
        const proxyFlag = proxyUri ? ['--proxy', proxyUri] : [];

        const envVars = proxyUri ? {env: Object.assign(process.env, {'HTTP_PROXY': proxyUri, 'HTTPS_PROXY': proxyUri })} : {};

        let stdout = '';
        let stderr = '';

        const npmInstall = spawn('node', [localNpmLocation, 'i', '--prefix', prefix,  '--prefer-offline', '--no-audit', ...packageNames, ...proxyFlag], envVars);
        npmInstall.stderr.pipe(process.stderr);
        npmInstall.stdout.pipe(process.stdout);

        npmInstall.stdout.on('data', (data) => {
            stdout += data;
        });

        npmInstall.stderr.on('data', (data) => {
            stderr += data;
        });

        npmInstall.on('close', (code) => {
            if (code) {

                let errorString;
                try {
                    const packageVersion = /npm ERR! 404  '(.+)' is not in the npm registry/gm.exec(stderr)[1];
                    const packageName = packageVersion.split('@')[0];
                    errorString = `404 Not Found - GET https://registry.npmjs.org/${packageName} - Not found`;
                } catch(err) {
                    errorString = `Npm Install closed with exit code ${code}\n stdout: ${stdout} stderr: ${stderr}` ;
                }
                
                logger.debug(`Npm Install closed with exit code ${code}`, {message: errorString});

                reject(new NpmPackageError(errorString));
            } else {
                resolve(stdout);
            }
        });

        setTimeout(() => {
            try {
                npmInstall.kill();
            } finally {
                reject(new Promise.TimeoutError());
            }
        }, timeoutMs);
    });
}

module.exports = {
    getLatestPackageVersion,
    getPackageIfInstalledLocally,
    getLocallyInstalledPackageVersion,
    installPackageLocally,
    installPackagesLocally,
    installPackages
};