@contrast/contrast 1.0.6 → 1.0.7

package/dist/scaAnalysis/python/analysis.js

@@ -0,0 +1,41 @@
+"use strict";
+const multiReplace = require('string-multiple-replace');
+const fs = require('fs');
+const readAndParseProjectFile = projectPath => {
+    const filePath = filePathForWindows(projectPath + '/Pipfile');
+    const pipFile = fs.readFileSync(filePath, 'utf8');
+    const matcherObj = { '"': '' };
+    const sequencer = ['"'];
+    const parsedPipfile = multiReplace(pipFile, matcherObj, sequencer);
+    const pythonArray = parsedPipfile.split('\n');
+    return pythonArray.filter(element => element !== '' && !element.includes('#'));
+};
+const readAndParseLockFile = projectPath => {
+    const filePath = filePathForWindows(projectPath + '/Pipfile.lock');
+    const lockFile = fs.readFileSync(filePath, 'utf8');
+    let parsedPipLock = JSON.parse(lockFile);
+    parsedPipLock['defaults'] = parsedPipLock['default'];
+    return parsedPipLock;
+};
+const getPythonDeps = config => {
+    try {
+        const parseProject = readAndParseProjectFile(config.projectPath);
+        const parsePip = readAndParseLockFile(config.projectPath);
+        return { pipfileLock: parseProject, pipfilDependanceies: parsePip };
+    }
+    catch (err) {
+        console.log(err.message.toString());
+        process.exit(1);
+    }
+};
+const filePathForWindows = path => {
+    if (process.platform === 'win32') {
+        path = path.replace(/\//g, '\\');
+    }
+    return path;
+};
+module.exports = {
+    getPythonDeps,
+    readAndParseProjectFile,
+    readAndParseLockFile
+};

package/dist/scaAnalysis/python/index.js

@@ -0,0 +1,10 @@
+"use strict";
+const { createPythonTSMessage } = require('../common/formatMessage');
+const { getPythonDeps } = require('./analysis');
+const pythonAnalysis = (config, languageFiles) => {
+    const pythonDeps = getPythonDeps(config, languageFiles.PYTHON);
+    return createPythonTSMessage(pythonDeps);
+};
+module.exports = {
+    pythonAnalysis
+};

package/dist/scaAnalysis/ruby/analysis.js

@@ -0,0 +1,226 @@
+"use strict";
+const fs = require('fs');
+const readAndParseGemfile = projectPath => {
+    const fileName = filePathForWindows(projectPath + '/Gemfile');
+    const gemFile = fs.readFileSync(fileName, 'utf8');
+    const rubyArray = gemFile.split('\n');
+    let filteredRubyDep = rubyArray.filter(element => {
+        return (!element.includes('#') &&
+            element.includes('gem') &&
+            !element.includes('source'));
+    });
+    for (let i = 0; i < filteredRubyDep.length; i++) {
+        filteredRubyDep[i] = filteredRubyDep[i].trim();
+    }
+    return filteredRubyDep;
+};
+const readAndParseGemLockFile = projectPath => {
+    const fileName = filePathForWindows(projectPath + '/Gemfile.lock');
+    const lockFile = fs.readFileSync(fileName, 'utf8');
+    const dependencyRegEx = /^\s*([A-Za-z0-9.!@#$%\-^&*_+]*)\s*(\((.*?)\))/;
+    const lines = lockFile.split('\n');
+    return {
+        dependencies: getDirectDependencies(lines, dependencyRegEx),
+        runtimeDetails: getLockFileRuntimeInfo(lines),
+        sources: getSourceArray(lines, dependencyRegEx)
+    };
+};
+const nonDependencyKeys = (line, sourceObject) => {
+    const GEMFILE_KEY_VALUE = /^\s*([^:(]*)\s*\s*(.*)/;
+    let parts = GEMFILE_KEY_VALUE.exec(line);
+    let key = parts[1].trim();
+    let value = parts[2] || '';
+    sourceObject[key] = value;
+    return sourceObject;
+};
+const populateResolveAndPlatform = (version, sourceObject) => {
+    const depArr = version.split('-');
+    sourceObject.resolved = depArr[0];
+    sourceObject.platform = depArr.length > 1 ? depArr[1] : 'UNSPECIFIED';
+    return sourceObject;
+};
+const isUpperCase = str => {
+    return str === str.toUpperCase();
+};
+const getDirectDependencies = (lines, dependencyRegEx) => {
+    const dependencies = {};
+    let depIndex = 0;
+    for (let i = 0; i < lines.length; i++) {
+        if (lines[i] === 'DEPENDENCIES') {
+            depIndex = i;
+        }
+    }
+    const getDepArray = lines.slice(depIndex);
+    for (let j = 1; j < getDepArray.length; j++) {
+        const element = getDepArray[j];
+        if (!isUpperCase(element)) {
+            const isDependencyWithVersion = dependencyRegEx.test(element);
+            if (isDependencyWithVersion) {
+                const dependency = dependencyRegEx.exec(element);
+                let name = dependency[1];
+                name = name.replace('!', '');
+                dependencies[name.trim()] = dependency[3];
+            }
+            else {
+                let name = element;
+                name = name.replace('!', ' ');
+                dependencies[name.trim()] = 'UNSPECIFIED';
+            }
+        }
+    }
+    return dependencies;
+};
+const getLockFileRuntimeInfo = lines => {
+    let rubVersionIndex = 0;
+    for (let i = 0; i < lines.length; i++) {
+        if (lines[i] === 'RUBY VERSION') {
+            rubVersionIndex = i;
+            break;
+        }
+    }
+    const runtimeDetails = {};
+    if (rubVersionIndex !== 0) {
+        const getRubyVersionArray = lines.slice(rubVersionIndex);
+        for (let element of getRubyVersionArray) {
+            if (!isUpperCase(element)) {
+                runtimeDetails['version'] = getVersion(element);
+                runtimeDetails['patchLevel'] = getPatchLevel(element);
+                if (element.includes('engine')) {
+                    let splitElement = element.split(' ');
+                    runtimeDetails[splitElement[0]] = splitElement[1];
+                }
+            }
+        }
+    }
+    return runtimeDetails;
+};
+const getVersion = element => {
+    const versionRegex = /^([ruby\s0-9.*]+)/;
+    if (versionRegex.test(element)) {
+        let version = versionRegex.exec(element)[0];
+        if (version.includes('ruby')) {
+            return trimWhiteSpace(version.replace('ruby', ''));
+        }
+    }
+};
+const getPatchLevel = element => {
+    const patchLevelRegex = /(p\d+)/;
+    if (patchLevelRegex.test(element)) {
+        return patchLevelRegex.exec(element)[0];
+    }
+};
+const formatSourceArr = sourceArr => {
+    return sourceArr.map(element => {
+        if (element.sourceType === 'GIT') {
+            delete element.specs;
+        }
+        if (element.sourceType === 'GEM') {
+            delete element.branch;
+            delete element.revision;
+            delete element.depthLevel;
+            delete element.specs;
+        }
+        if (element.sourceType === 'PATH') {
+            delete element.branch;
+            delete element.revision;
+            delete element.depthLevel;
+            delete element.specs;
+            delete element.platform;
+        }
+        return element;
+    });
+};
+const getSourceArray = (lines, dependencyRegEx) => {
+    const sourceObject = {
+        dependencies: {}
+    };
+    const whitespaceRegx = /^(\s*)/;
+    let index = 0;
+    let line = 0;
+    const sources = [];
+    while ((line = lines[index++]) !== undefined) {
+        let currentWS = whitespaceRegx.exec(line)[1].length;
+        if (!line.includes(' bundler (')) {
+            if (currentWS === 0 && !line.includes(':') && line !== '') {
+                sourceObject.sourceType = line;
+            }
+            if (currentWS !== 0 && line.includes(':')) {
+                nonDependencyKeys(line, sourceObject);
+            }
+            if (currentWS > 2) {
+                let nexlineWS = whitespaceRegx.exec(lines[index])[1].length;
+                sourceObject.dependencies = buildSourceDependencyWithVersion(whitespaceRegx, dependencyRegEx, line, currentWS, sourceObject.name, sourceObject.dependencies);
+                if (currentWS === 4 && sourceObject.depthLevel === undefined) {
+                    const dependency = dependencyRegEx.exec(line);
+                    sourceObject.name = dependency[1];
+                    sourceObject.depthLevel = currentWS;
+                    populateResolveAndPlatform(dependency[3], sourceObject);
+                }
+                if (currentWS === 4 && sourceObject.depthLevel) {
+                    const dependency = dependencyRegEx.exec(line);
+                    sourceObject.name = dependency[1];
+                    sourceObject.depthLevel = currentWS;
+                    populateResolveAndPlatform(dependency[3], sourceObject);
+                }
+                if ((currentWS === 4 && nexlineWS === 4) ||
+                    (currentWS === 6 && nexlineWS === 4) ||
+                    nexlineWS === '') {
+                    let newObj = {};
+                    newObj = JSON.parse(JSON.stringify(sourceObject));
+                    sources.push(newObj);
+                    sourceObject.dependencies = {};
+                }
+            }
+        }
+    }
+    return formatSourceArr(sources);
+};
+const buildSourceDependencyWithVersion = (whitespaceRegx, dependencyRegEx, line, currentWhiteSpace, name, dependencies) => {
+    const isDependencyWithVersion = dependencyRegEx.test(line);
+    if (currentWhiteSpace === 6) {
+        const dependency = dependencyRegEx.exec(line);
+        if (isDependencyWithVersion) {
+            if (name !== dependency[1]) {
+                dependencies[dependency[1]] = dependency[3];
+            }
+        }
+        else {
+            dependencies[line.trim()] = 'UNSPECIFIED';
+        }
+    }
+    return dependencies;
+};
+const getRubyDeps = config => {
+    try {
+        const parsedGem = readAndParseGemfile(config.projectPath);
+        const parsedLock = readAndParseGemLockFile(config.projectPath);
+        return { gemfilesDependanceies: parsedGem, gemfileLock: parsedLock };
+    }
+    catch (err) {
+        console.log(err.message);
+        process.exit(1);
+    }
+};
+const trimWhiteSpace = string => {
+    return string.replace(/\s+/g, '');
+};
+const filePathForWindows = path => {
+    if (process.platform === 'win32') {
+        path = path.replace(/\//g, '\\');
+    }
+    return path;
+};
+module.exports = {
+    getRubyDeps,
+    readAndParseGemfile,
+    readAndParseGemLockFile,
+    nonDependencyKeys,
+    populateResolveAndPlatform,
+    isUpperCase,
+    getDirectDependencies,
+    getLockFileRuntimeInfo,
+    getVersion,
+    getPatchLevel,
+    formatSourceArr,
+    getSourceArray
+};

package/dist/scaAnalysis/ruby/index.js

@@ -0,0 +1,10 @@
+"use strict";
+const { getRubyDeps } = require('./analysis');
+const { createRubyTSMessage } = require('../common/formatMessage');
+const rubyAnalysis = (config, languageFiles) => {
+    const rubyDeps = getRubyDeps(config, languageFiles.RUBY);
+    return createRubyTSMessage(rubyDeps);
+};
+module.exports = {
+    rubyAnalysis
+};

package/dist/scan/autoDetection.js

@@ -11,6 +11,10 @@ const autoDetectFileAndLanguage = async (configToUse) => {
             console.log(i18n.__('fileHasWhiteSpacesError'));
             process.exit(1);
         }
+        if (fileFinder.fileIsEmpty(entries[0])) {
+            console.log(i18n.__('scanFileIsEmpty'));
+            process.exit(1);
+        }
         configToUse.file = entries[0];
         if (configToUse.name === undefined) {
             configToUse.name = entries[0];
@@ -36,8 +40,8 @@ const autoDetectAuditFilesAndLanguages = async () => {
         console.log('found multiple languages, please specify one using --file to run SCA analysis');
     }
 };
-const manualDetectAuditFilesAndLanguages = async (projectPath) => {
-    let projectRootFilenames = await rootFile.getProjectRootFilenames(projectPath);
+const manualDetectAuditFilesAndLanguages = projectPath => {
+    let projectRootFilenames = rootFile.getProjectRootFilenames(projectPath);
     let identifiedLanguages = languageResolver.deduceLanguageScaAnalysis(projectRootFilenames);
     if (Object.keys(identifiedLanguages).length === 0) {
         console.log(i18n.__('languageAnalysisNoLanguage', projectPath));

package/dist/scan/fileUtils.js

@@ -17,7 +17,7 @@ const findFilesJava = async (languagesFound) => {
         onlyFiles: true
     });
     if (result.length > 0) {
-        return languagesFound.push({ java: result });
+        return languagesFound.push({ JAVA: result });
     }
     return languagesFound;
 };
@@ -28,7 +28,7 @@ const findFilesJavascript = async (languagesFound) => {
         onlyFiles: true
     });
     if (result.length > 0) {
-        return languagesFound.push({ javascript: result });
+        return languagesFound.push({ JAVASCRIPT: result });
     }
     return languagesFound;
 };
@@ -39,7 +39,7 @@ const findFilesPython = async (languagesFound) => {
         onlyFiles: true
     });
     if (result.length > 0) {
-        return languagesFound.push({ python: result });
+        return languagesFound.push({ PYTHON: result });
     }
     return languagesFound;
 };
@@ -50,7 +50,7 @@ const findFilesGo = async (languagesFound) => {
         onlyFiles: true
     });
     if (result.length > 0) {
-        return languagesFound.push({ go: result });
+        return languagesFound.push({ GO: result });
     }
     return languagesFound;
 };
@@ -61,7 +61,7 @@ const findFilesRuby = async (languagesFound) => {
         onlyFiles: true
     });
     if (result.length > 0) {
-        return languagesFound.push({ ruby: result });
+        return languagesFound.push({ RUBY: result });
     }
     return languagesFound;
 };
@@ -72,7 +72,7 @@ const findFilesPhp = async (languagesFound) => {
         onlyFiles: true
     });
     if (result.length > 0) {
-        return languagesFound.push({ php: result });
+        return languagesFound.push({ PHP: result });
     }
     return languagesFound;
 };
@@ -90,6 +90,12 @@ const checkFilePermissions = file => {
 const fileExists = path => {
     return fs.existsSync(path);
 };
+const fileIsEmpty = path => {
+    if (fileExists(path) && checkFilePermissions(path)) {
+        return fs.readFileSync(path).length === 0;
+    }
+    return false;
+};
 module.exports = {
     findFile,
     fileExists,
@@ -99,5 +105,6 @@ module.exports = {
     findFilesPython,
     findFilesGo,
     findFilesPhp,
-    findFilesRuby
+    findFilesRuby,
+    fileIsEmpty
 };

package/dist/scan/formatScanOutput.js

@@ -12,7 +12,7 @@ const cli_table3_1 = __importDefault(require("cli-table3"));
 const constants_1 = require("../constants/constants");
 function formatScanOutput(scanResults) {
     const { scanResultsInstances } = scanResults;
-    let projectOverview = getProjectOverview(scanResultsInstances);
+    const projectOverview = getProjectOverview(scanResultsInstances);
     if (scanResultsInstances.content.length === 0) {
         console.log(i18n_1.default.__('scanNoVulnerabilitiesFound'));
         console.log(i18n_1.default.__('scanNoVulnerabilitiesFoundSecureCode'));
@@ -52,7 +52,7 @@ function formatScanOutput(scanResults) {
             });
             let learnRow = [];
             let adviceRow = [];
-            let headerRow = [
+            const headerRow = [
                 chalk_1.default
                     .hex(entry.colour)
                     .bold(`CONTRAST-${count.toString().padStart(3, '0')}`),
@@ -60,12 +60,13 @@ function formatScanOutput(scanResults) {
                 chalk_1.default.hex(entry.colour).bold(`[${entry.severity}] ${entry.ruleId}`) +
                     entry.message
             ];
-            let codeRow = [
+            const codePath = entry.codePath?.replace(/^@/, '');
+            const codeRow = [
                 chalk_1.default.hex('#F6F5F5').bold(`Code`),
                 chalk_1.default.hex('#F6F5F5').bold(`:`),
-                chalk_1.default.hex('#F6F5F5').bold(`${entry.codePath}`)
+                chalk_1.default.hex('#F6F5F5').bold(`${codePath}`)
             ];
-            let issueRow = [chalk_1.default.bold(`Issue`), chalk_1.default.bold(`:`), `${entry.issue}`];
+            const issueRow = [chalk_1.default.bold(`Issue`), chalk_1.default.bold(`:`), `${entry.issue}`];
             table.push(headerRow, codeRow, issueRow);
             if (entry?.advice) {
                 adviceRow = [
@@ -98,7 +99,7 @@ function printVulnInfo(projectOverview) {
     console.log(i18n_1.default.__('foundDetailedVulnerabilities', String(projectOverview.critical), String(projectOverview.high), String(projectOverview.medium), String(projectOverview.low), String(projectOverview.note)));
 }
 function getProjectOverview(scanResultsInstances) {
-    let acc = {
+    const acc = {
         critical: 0,
         high: 0,
         medium: 0,
@@ -118,7 +119,7 @@ function getProjectOverview(scanResultsInstances) {
 }
 exports.getProjectOverview = getProjectOverview;
 function formatLinks(objName, entry) {
-    let line = chalk_1.default.bold(objName + '  : ');
+    const line = chalk_1.default.bold(objName + '  : ');
     if (entry.length === 1) {
         console.log(line + chalk_1.default.hex('#97DCF7').bold.underline(entry[0]));
     }
@@ -179,10 +180,7 @@ function getCodeFlowInfo(resultEntry) {
 }
 exports.getCodeFlowInfo = getCodeFlowInfo;
 function stripTags(oldString) {
-    return oldString
-        .replace(/\n/g, ' ')
-        .replace(/\s+/g, ' ')
-        .trim();
+    return oldString.replace(/\n/g, ' ').replace(/\s+/g, ' ').trim();
 }
 exports.stripTags = stripTags;
 function assignBySeverity(entry, assignedObj) {

package/dist/scan/models/groupedResultsModel.js

@@ -5,7 +5,7 @@ class GroupedResultsModel {
     constructor(ruleId) {
         this.ruleId = ruleId;
         this.colour = '#999999';
-        this.codePathSet = new Set;
+        this.codePathSet = new Set();
     }
 }
 exports.GroupedResultsModel = GroupedResultsModel;

package/dist/scan/models/scanResultsModel.js

@@ -5,7 +5,9 @@ class ScanResultsModel {
     constructor(scan) {
         this.projectOverview = scan.projectOverview;
         this.scanDetail = scan.scanDetail;
-        this.scanResultsInstances = scan.scanResultsInstances;
+        this.scanResultsInstances =
+            scan.scanResultsInstances;
+        this.newProject = scan.newProject;
     }
 }
 exports.ScanResultsModel = ScanResultsModel;

package/dist/scan/populateProjectIdAndProjectName.js

@@ -8,8 +8,9 @@ const populateProjectId = async (config) => {
         proj = await getExistingProjectIdByName(config, client).then(res => {
             return res;
         });
+        return { projectId: proj, isNewProject: false };
     }
-    return proj;
+    return { projectId: proj, isNewProject: true };
 };
 const createProjectId = async (config, client) => {
     return client

package/dist/scan/scan.js

@@ -55,6 +55,7 @@ const sendScan = async (config) => {
             }
         })
             .catch(err => {
+            oraWrapper_1.default.stopSpinner(startUploadSpinner);
             console.log(err);
         });
     }

package/dist/scan/scanConfig.js

@@ -21,10 +21,15 @@ const getScanConfig = argv => {
             process.exit(1);
         }
     }
+    let projectNameSource;
     if (!scanParams.name && scanParams.file) {
         scanParams.name = getFileName(scanParams.file);
+        projectNameSource = 'AUTO';
     }
-    return { ...paramsAuth, ...scanParams };
+    else {
+        projectNameSource = 'USER';
+    }
+    return { ...paramsAuth, ...scanParams, projectNameSource };
 };
 const getFileName = file => {
     return file.split(path.sep).pop();

package/dist/scan/scanController.js

@@ -24,6 +24,10 @@ const fileAndLanguageLogic = async (configToUse) => {
             console.log(i18n.__('fileNotExist'));
             process.exit(1);
         }
+        if (fileFunctions.fileIsEmpty(configToUse.file)) {
+            console.log(i18n.__('scanFileIsEmpty'));
+            process.exit(1);
+        }
         return configToUse;
     }
     else {
@@ -35,14 +39,20 @@ const fileAndLanguageLogic = async (configToUse) => {
 const startScan = async (configToUse) => {
     const startTime = performance.now();
     await fileAndLanguageLogic(configToUse);
+    let newProject;
     if (!configToUse.projectId) {
-        configToUse.projectId = await populateProjectIdAndProjectName.populateProjectId(configToUse);
+        const { projectId, isNewProject } = await populateProjectIdAndProjectName.populateProjectId(configToUse);
+        configToUse.projectId = projectId;
+        newProject = isNewProject;
+    }
+    else {
+        newProject = false;
     }
     const codeArtifactId = await scan.sendScan(configToUse);
     if (!configToUse.ff) {
         const startScanSpinner = returnOra('🚀 Contrast Scan started');
         startSpinner(startScanSpinner);
-        const scanDetail = await scanResults.returnScanResults(configToUse, codeArtifactId, getTimeout(configToUse), startScanSpinner);
+        const scanDetail = await scanResults.returnScanResults(configToUse, codeArtifactId, newProject, getTimeout(configToUse), startScanSpinner);
         const scanResultsInstances = await scanResults.returnScanResultsInstances(configToUse, scanDetail.id);
         const endTime = performance.now();
         const scanDurationMs = endTime - startTime;
@@ -54,7 +64,10 @@ const startScan = async (configToUse) => {
         else {
             succeedSpinner(startScanSpinner, 'Contrast Scan complete');
             console.log(`----- Scan completed in ${(scanDurationMs / 1000).toFixed(2)}s -----`);
-            return { scanDetail, scanResultsInstances: scanResultsInstances.body };
+            return {
+                scanDetail,
+                scanResultsInstances: scanResultsInstances.body
+            };
         }
     }
 };

package/dist/scan/scanResults.js

@@ -26,9 +26,13 @@ const pollScanResults = async (config, scanId, client) => {
         console.log(err);
     });
 };
-const returnScanResults = async (config, codeArtifactId, timeout, startScanSpinner) => {
+const returnScanResults = async (config, codeArtifactId, newProject, timeout, startScanSpinner) => {
     const client = commonApi.getHttpClient(config);
     let scanId = await getScanId(config, codeArtifactId, client);
+    if (process.env.CODESEC_INVOCATION_ENVIRONMENT &&
+        process.env.CODESEC_INVOCATION_ENVIRONMENT.toUpperCase() === 'GITHUB') {
+        await client.createNewEvent(config, scanId, newProject);
+    }
     let startTime = new Date();
     let complete = false;
     if (!_.isNil(scanId)) {

package/dist/utils/commonApi.js

@@ -1,6 +1,6 @@
 "use strict";
 const HttpClient = require('./../common/HTTPClient');
-const { badRequestError, unauthenticatedError, forbiddenError, proxyError, genericError } = require('../common/errorHandling');
+const { badRequestError, unauthenticatedError, forbiddenError, proxyError, genericError, maxAppError } = require('../common/errorHandling');
 const handleResponseErrors = (res, api) => {
     if (res.statusCode === 400) {
         api === 'catalogue' ? badRequestError(true) : badRequestError(false);
@@ -14,6 +14,9 @@ const handleResponseErrors = (res, api) => {
     else if (res.statusCode === 407) {
         proxyError();
     }
+    else if (res.statusCode === 412) {
+        maxAppError();
+    }
     else {
         genericError();
     }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@contrast/contrast",
-  "version": "1.0.6",
+  "version": "1.0.7",
   "description": "Contrast Security's command line tool",
   "main": "dist/index.js",
   "bin": {
@@ -24,8 +24,8 @@
     "test-int": "jest ./test-integration/",
     "test-int-scan": "jest ./test-integration/scan",
     "test-int-audit": "jest ./test-integration/audit",
-    "format": "prettier --write \"**/*.{ts,tsx,js,css,scss,json,md,yml}\" .eslintrc.* .babelrc",
-    "check-format": "prettier --check \"**/*.{ts,tsx,js,css,scss,json,md,yml}\" .eslintrc.* .babelrc",
+    "format": "prettier --write \"**/*.{ts,tsx,js,json,md,yml}\" .eslintrc.*",
+    "check-format": "prettier --check \"**/*.{ts,tsx,js,json,md,yml}\" .eslintrc.*",
     "coverage-local": "nyc --reporter=text mocha './test/**/*.spec.js'",
     "coverage": "yarn test --coverage",
     "lint": "eslint --config .eslintrc.json . --ext .ts",
@@ -74,12 +74,13 @@
     "@types/i18n": "^0.13.2",
     "@types/jest": "^27.4.1",
     "@types/lodash": "^4.14.182",
+    "@types/node": "*",
     "@typescript-eslint/eslint-plugin": "^5.21.0",
     "@typescript-eslint/parser": "^5.21.0",
     "csv-writer": "^1.6.0",
     "eslint": "^8.14.0",
     "eslint-config-prettier": "^8.5.0",
-    "eslint-plugin-prettier": "^4.0.0",
+    "eslint-plugin-prettier": "^4.2.1",
     "husky": "^3.1.0",
     "jest": "^27.5.1",
     "jest-junit": "^13.2.0",
@@ -87,7 +88,7 @@
     "npm-license-crawler": "^0.2.1",
     "nyc": "^15.1.0",
     "pkg": "^5.6.0",
-    "prettier": "^1.19.1",
+    "prettier": "^2.7.1",
     "tmp": "^0.2.1",
     "ts-jest": "^27.1.4",
     "ts-node": "^10.7.0",
@@ -103,12 +104,15 @@
   ],
   "prettier": {
     "semi": false,
+    "trailingComma": "none",
+    "arrowParens": "avoid",
+    "bracketSpacing": true,
     "singleQuote": true,
+    "bracketSameLine": true,
     "overrides": [
       {
         "files": [
-          ".eslintrc.ng",
-          ".babelrc"
+          ".eslintrc"
         ],
         "options": {
           "parser": "json"

package/src/audit/catalogueApplication/catalogueApplication.js

@@ -15,7 +15,6 @@ const catalogueApplication = async config => {
         //displaySuccessMessage(config, res.body.application.app_id)
         appId = res.body.application.app_id
       } else {
-        // console.log(res.statusCode)
         handleResponseErrors(res, 'catalogue')
       }
     })