@contrast/contrast 1.0.0 → 1.0.3

package/dist/audit/nodeAnalysisEngine/parseYarn2LockFileContents.js

@@ -0,0 +1,51 @@
+"use strict";
+const i18n = require('i18n');
+module.exports = exports = ({ language: { lockFilename }, node }, next) => {
+    if (node.rawYarnLockFileContents == undefined || node.yarnVersion == 1) {
+        next();
+    }
+    else {
+        try {
+            node.yarnLockFile = {};
+            node.yarnLockFile['object'] = node.rawYarnLockFileContents;
+            delete node.yarnLockFile['object'].__metadata;
+            node.yarnLockFile['type'] = 'success';
+            Object.entries(node.rawYarnLockFileContents).forEach(([key, value]) => {
+                const rawKeyNames = key.split(',');
+                const keyNames = formatKey(rawKeyNames);
+                keyNames.forEach(name => {
+                    node.yarnLockFile.object[name] = value;
+                });
+            });
+        }
+        catch (err) {
+            next(new Error(i18n.__('NodeParseYarn2', lockFilename.lockFilePath) +
+                `${err.message}`));
+            return;
+        }
+        next();
+    }
+};
+function formatKey(keyNames) {
+    let name = '';
+    let formattedNames = [];
+    keyNames.forEach(dummyString => {
+        let nameArr = dummyString.split('@');
+        if (nameArr.length > 1) {
+            if (nameArr.length == 2) {
+                name = nameArr[0];
+            }
+            if (nameArr.length == 3) {
+                name = '@' + nameArr[1];
+            }
+            let version = dummyString.split(':').pop('');
+            if (version.length == 1 && version != '*') {
+                version = version + '.0';
+            }
+            let reformattedKey = name.trim() + '@' + version;
+            formattedNames.push(reformattedKey);
+        }
+    });
+    return formattedNames;
+}
+exports.formatKey = formatKey;

package/dist/audit/nodeAnalysisEngine/parseYarnLockFileContents.js

@@ -0,0 +1,18 @@
+"use strict";
+const yarnParser = require('@yarnpkg/lockfile');
+const i18n = require('i18n');
+module.exports = exports = ({ language: { lockFilename }, node }, next) => {
+    if (node.rawYarnLockFileContents === undefined || node.yarnVersion === 2) {
+        next();
+    }
+    else {
+        try {
+            node.yarnLockFile = yarnParser.parse(node.rawYarnLockFileContents);
+        }
+        catch (err) {
+            next(new Error(i18n.__('NodeParseYarn', lockFilename.lockFilePath ? lockFilename.lockFilePath : 'undefined') + `${err.message}`));
+            return;
+        }
+        next();
+    }
+};

package/dist/audit/nodeAnalysisEngine/readNPMLockFileContents.js

@@ -0,0 +1,17 @@
+"use strict";
+const fs = require('fs');
+const i18n = require('i18n');
+module.exports = exports = ({ language: { lockFilePath }, node }, next) => {
+    if (!lockFilePath || !lockFilePath.includes('package-lock.json')) {
+        next();
+        return;
+    }
+    try {
+        node.rawLockFileContents = fs.readFileSync(lockFilePath);
+    }
+    catch (err) {
+        next(new Error(i18n.__('NodeReadNpmError', lockFilePath) + `${err.message}`));
+        return;
+    }
+    next();
+};

package/dist/audit/nodeAnalysisEngine/readProjectFileContents.js

@@ -0,0 +1,14 @@
+"use strict";
+const fs = require('fs');
+const i18n = require('i18n');
+module.exports = exports = (analysis, next) => {
+    const { language: { projectFilePath }, node } = analysis;
+    try {
+        node.packageJSON = JSON.parse(fs.readFileSync(projectFilePath, 'utf8'));
+    }
+    catch (err) {
+        next(new Error(i18n.__('nodeReadProjectFileError', projectFilePath) + `${err.message}`));
+        return;
+    }
+    next();
+};

package/dist/audit/nodeAnalysisEngine/readYarnLockFileContents.js

@@ -0,0 +1,24 @@
+"use strict";
+const fs = require('fs');
+const yaml = require('js-yaml');
+const i18n = require('i18n');
+module.exports = exports = ({ language: { lockFilePath }, node }, next) => {
+    if (!lockFilePath || !lockFilePath.includes('yarn.lock')) {
+        next();
+        return;
+    }
+    try {
+        node.rawYarnLockFileContents = fs.readFileSync(lockFilePath, 'utf8');
+        node.yarnVersion = 1;
+        if (!node.rawYarnLockFileContents.includes('lockfile v1') ||
+            node.rawYarnLockFileContents.includes('__metadata')) {
+            node.rawYarnLockFileContents = yaml.load(fs.readFileSync(lockFilePath, 'utf8'));
+            node.yarnVersion = 2;
+        }
+    }
+    catch (err) {
+        next(new Error(i18n.__('nodeReadYarnLockFileError', lockFilePath) + `${err.message}`));
+        return;
+    }
+    next();
+};

package/dist/audit/nodeAnalysisEngine/sanitizer.js

@@ -0,0 +1,9 @@
+"use strict";
+module.exports = exports = ({ node }, next) => {
+    delete node.rawProjectFileContents;
+    delete node.projectFileJSON;
+    delete node.projectLockFileJSON;
+    delete node.rawLockFileContents;
+    delete node.rawYarnLockFileContents;
+    next();
+};

package/dist/audit/phpAnalysisEngine/index.js

@@ -0,0 +1,23 @@
+"use strict";
+const AnalysisEngine = require('../AnalysisEngine');
+const readProjectFileContents = require('./readProjectFileContents');
+const readLockFileContents = require('./readLockFileContents');
+const parseLockFileContents = require('./parseLockFileContents');
+const sanitizer = require('./sanitizer');
+const i18n = require('i18n');
+module.exports = exports = (language, config, callback) => {
+    const ae = new AnalysisEngine({ language, config, php: {} });
+    ae.use([
+        readProjectFileContents,
+        readLockFileContents,
+        parseLockFileContents,
+        sanitizer
+    ]);
+    ae.analyze((err, analysis) => {
+        if (err) {
+            callback(new Error(i18n.__('phpAnalysisFailure') + `${err.message}`));
+            return;
+        }
+        callback(null, analysis);
+    });
+};

package/dist/audit/phpAnalysisEngine/parseLockFileContents.js

@@ -0,0 +1,52 @@
+"use strict";
+const i18n = require('i18n');
+const _ = require('lodash');
+module.exports = exports = ({ language: { lockFilePath }, php }, next) => {
+    try {
+        php.lockFile = php.rawLockFileContents;
+        let packages = _.keyBy(php.lockFile.packages, 'name');
+        let packagesDev = _.keyBy(php.lockFile['packages-dev'], 'name');
+        php.lockFile.dependencies = _.merge(packages, packagesDev);
+        const listOfTopDep = Object.keys(php.lockFile.dependencies);
+        Object.entries(php.lockFile.dependencies).forEach(([key, value]) => {
+            if (value.require) {
+                const listOfRequiresDep = Object.keys(value.require);
+                listOfRequiresDep.forEach(dep => {
+                    if (!listOfTopDep.includes(dep)) {
+                        addChildDepToLockFileAsOwnObj(value['require'], dep);
+                    }
+                });
+            }
+            if (value['require-dev']) {
+                const listOfRequiresDep = Object.keys(value['require-dev']);
+                listOfRequiresDep.forEach(dep => {
+                    if (!listOfTopDep.includes(dep)) {
+                        addChildDepToLockFileAsOwnObj(value['require-dev'], dep);
+                    }
+                });
+            }
+        });
+        formatParentDepToLockFile();
+    }
+    catch (err) {
+        next(new Error(i18n.__('phpParseComposerLock', lockFilePath) + `${err.message}`));
+        return;
+    }
+    next();
+    function addChildDepToLockFileAsOwnObj(depObj, key) {
+        php.lockFile.dependencies[key] = { version: depObj[key] };
+    }
+    function formatParentDepToLockFile() {
+        for (const [key, value] of Object.entries(php.lockFile.dependencies)) {
+            let requires = {};
+            for (const [childKey, childValue] of Object.entries(value)) {
+                if (childKey === 'require' || childKey === 'require-dev') {
+                    requires = _.merge(requires, childValue);
+                    php.lockFile.dependencies[key].requires = requires;
+                    delete php.lockFile.dependencies[key].require;
+                    delete php.lockFile.dependencies[key]['require-dev'];
+                }
+            }
+        }
+    }
+};

package/dist/audit/phpAnalysisEngine/readLockFileContents.js

@@ -0,0 +1,13 @@
+"use strict";
+const fs = require('fs');
+const i18n = require('i18n');
+module.exports = exports = ({ language: { lockFilePath }, php }, next) => {
+    try {
+        php.rawLockFileContents = JSON.parse(fs.readFileSync(lockFilePath));
+    }
+    catch (err) {
+        next(new Error(i18n.__('phpReadError', lockFilePath) + `${err.message}`));
+        return;
+    }
+    next();
+};

package/dist/audit/phpAnalysisEngine/readProjectFileContents.js

@@ -0,0 +1,16 @@
+"use strict";
+const fs = require('fs');
+const i18n = require('i18n');
+module.exports = exports = (analysis, next) => {
+    const { language: { projectFilePath }, php } = analysis;
+    try {
+        php.composerJSON = JSON.parse(fs.readFileSync(projectFilePath, 'utf8'));
+        php.composerJSON.dependencies = php.composerJSON.require;
+        php.composerJSON.devDependencies = php.composerJSON['require-dev'];
+    }
+    catch (err) {
+        next(new Error(i18n.__('phpReadProjectFileError', projectFilePath) + `${err.message}`));
+        return;
+    }
+    next();
+};

package/dist/audit/phpAnalysisEngine/sanitizer.js

@@ -0,0 +1,5 @@
+"use strict";
+module.exports = exports = ({ php }, next) => {
+    delete php.rawLockFileContents;
+    next();
+};

package/dist/audit/pythonAnalysisEngine/index.js

@@ -0,0 +1,25 @@
+"use strict";
+const AnalysisEngine = require('./../AnalysisEngine');
+const readPythonProjectFileContents = require('./readPythonProjectFileContents');
+const readPipfileLockFileContents = require('./readPipfileLockFileContents');
+const parseProjectFileContents = require('./parseProjectFileContents');
+const parsePipfileLockContents = require('./parsePipfileLockContents');
+const sanitizer = require('./sanitizer');
+const i18n = require('i18n');
+module.exports = exports = (language, config, callback) => {
+    const ae = new AnalysisEngine({ language, config, python: {} });
+    ae.use([
+        readPythonProjectFileContents,
+        parseProjectFileContents,
+        readPipfileLockFileContents,
+        parsePipfileLockContents,
+        sanitizer
+    ]);
+    ae.analyze((err, analysis) => {
+        if (err) {
+            callback(new Error(i18n.__('pythonAnalysisEngineError') + `${err.message}`));
+            return;
+        }
+        callback(null, analysis);
+    });
+};

package/dist/audit/pythonAnalysisEngine/parsePipfileLockContents.js

@@ -0,0 +1,17 @@
+"use strict";
+const i18n = require('i18n');
+module.exports = exports = ({ language: { lockFilePath }, python }, next) => {
+    if (python.rawLockFileContents === undefined) {
+        return next();
+    }
+    try {
+        let parsedPipLock = JSON.parse(python.rawLockFileContents);
+        parsedPipLock['defaults'] = parsedPipLock['default'];
+        python.pipfileLock = parsedPipLock;
+    }
+    catch (err) {
+        next(new Error(i18n.__('pythonAnalysisEnginePipError', lockFilePath ? lockFilePath : 'undefined') + `${err.message}`));
+        return;
+    }
+    next();
+};

package/dist/audit/pythonAnalysisEngine/parseProjectFileContents.js

@@ -0,0 +1,21 @@
+"use strict";
+const multiReplace = require('string-multiple-replace');
+const i18n = require('i18n');
+module.exports = exports = ({ python }, next) => {
+    const { rawProjectFileContents } = python;
+    try {
+        const matcherObj = { '"': '' };
+        const sequencer = ['"'];
+        const parsedPipfile = multiReplace(rawProjectFileContents, matcherObj, sequencer);
+        const pythonArray = parsedPipfile.split('\n');
+        python.pipfilDependanceies = pythonArray.filter(element => {
+            return element != '' && !element.includes('#');
+        });
+        next();
+    }
+    catch (err) {
+        next(new Error(i18n.__('pythonAnalysisParseProjectFileError', rawProjectFileContents) +
+            `${err.message}`));
+        return;
+    }
+};

package/dist/audit/pythonAnalysisEngine/readPipfileLockFileContents.js

@@ -0,0 +1,13 @@
+"use strict";
+const fs = require('fs');
+const i18n = require('i18n');
+module.exports = exports = ({ language: { lockFilePath }, python }, next) => {
+    try {
+        python.rawLockFileContents = fs.readFileSync(lockFilePath);
+    }
+    catch (err) {
+        next(new Error(i18n.__('pythonAnalysisReadPipFileError', lockFilePath) +
+            `${err.message}`));
+    }
+    next();
+};

package/dist/audit/pythonAnalysisEngine/readPythonProjectFileContents.js

@@ -0,0 +1,14 @@
+"use strict";
+const fs = require('fs');
+const i18n = require('i18n');
+module.exports = exports = ({ language: { projectFilePath }, python }, next) => {
+    try {
+        python.rawProjectFileContents = fs.readFileSync(projectFilePath, 'utf8');
+        next();
+    }
+    catch (err) {
+        next(new Error(i18n.__('pythonAnalysisReadPythonProjectFileError', projectFilePath) +
+            `${err.message}`));
+        return;
+    }
+};

package/dist/audit/pythonAnalysisEngine/sanitizer.js

@@ -0,0 +1,7 @@
+"use strict";
+module.exports = exports = ({ python }, next) => {
+    delete python.rawProjectFileContents;
+    delete python.rawLockFileContents;
+    delete python.pipfileLock.default;
+    next();
+};

package/dist/audit/rubyAnalysisEngine/index.js

@@ -0,0 +1,25 @@
+"use strict";
+const AnalysisEngine = require('./../AnalysisEngine');
+const readGemfileContents = require('./readGemfileContents');
+const readGemfileLockContents = require('./readGemfileLockContents');
+const parsedGemfile = require('./parsedGemfile');
+const parseGemfileLockFileContents = require('./parseGemfileLockContents');
+const sanitizer = require('./sanitizer');
+const i18n = require('i18n');
+module.exports = exports = (language, config, callback) => {
+    const ae = new AnalysisEngine({ language, config, ruby: {} });
+    ae.use([
+        readGemfileContents,
+        parsedGemfile,
+        readGemfileLockContents,
+        parseGemfileLockFileContents,
+        sanitizer
+    ]);
+    ae.analyze((err, analysis) => {
+        if (err) {
+            callback(new Error(i18n.__('rubyAnalysisEngineError') + `${err.message}`));
+            return;
+        }
+        callback(null, analysis);
+    });
+};

package/dist/audit/rubyAnalysisEngine/parseGemfileLockContents.js

@@ -0,0 +1,176 @@
+"use strict";
+const whitespaceRegx = /^(\s*)/;
+let index = 0;
+const depReg = /^\s*([A-Za-z0-9.!@#$%\-^&*_+]*)\s*(\((.*?)\))/;
+const i18n = require('i18n');
+const GEMFILE_KEY_VALUE = /^\s*([^:(]*)\s*\:*\s*(.*)/;
+let rubyObj = {};
+rubyObj.dependencies = {};
+module.exports = exports = ({ ruby }, next) => {
+    const { rawLockFileContents } = ruby;
+    let lines = rawLockFileContents.split('\n');
+    try {
+        ruby.gemfileLock = {};
+        getDirectDepencies(lines, ruby.gemfileLock);
+        getRubyVersion(lines, ruby.gemfileLock);
+        getSourceArr(lines, ruby.gemfileLock);
+        next();
+    }
+    catch (err) {
+        next(new Error(i18n.__('rubyAnalysisEngineParsedGemLockFileError') + `${err.message}`));
+    }
+};
+const populateSourceType = (line, rubyObj) => {
+    return (rubyObj.sourceType = line);
+};
+const nonDependencyKeys = (line, rubyObj) => {
+    let parts = GEMFILE_KEY_VALUE.exec(line);
+    let key = parts[1].trim();
+    let value = parts[2] || '';
+    return (rubyObj[key] = value);
+};
+const populateResolveAndPlatform = (dependency, rubyObj) => {
+    const depArr = dependency.split('-');
+    rubyObj.resolved = depArr[0];
+    rubyObj.platform = depArr.length > 1 ? depArr[1] : 'UNSPECIFIED';
+    return rubyObj;
+};
+const isUpperCase = str => {
+    return str === str.toUpperCase();
+};
+const getDirectDepencies = (lines, ruby) => {
+    let depIndex = 0;
+    for (let i = 0; i < lines.length; i++) {
+        if (lines[i] == 'DEPENDENCIES') {
+            depIndex = i;
+        }
+    }
+    const getDepArray = lines.slice(depIndex);
+    ruby.dependencies = {};
+    for (let j = 1; j < getDepArray.length; j++) {
+        const element = getDepArray[j];
+        if (!isUpperCase(element)) {
+            const isDependencyWithVersion = depReg.test(element);
+            if (isDependencyWithVersion) {
+                const dependency = depReg.exec(element);
+                let name = dependency[1];
+                name = name.replace('!', '');
+                ruby.dependencies[name.trim()] = dependency[3];
+            }
+            else {
+                let name = element;
+                name = name.replace('!', ' ');
+                ruby.dependencies[name.trim()] = 'UNSPECIFIED';
+            }
+        }
+        else {
+            return;
+        }
+    }
+};
+const getRubyVersion = (lines, ruby) => {
+    let rubVersionIndex = 0;
+    for (let i = 0; i < lines.length; i++) {
+        if (lines[i] == 'RUBY VERSION') {
+            rubVersionIndex = i;
+            break;
+        }
+    }
+    if (rubVersionIndex !== 0) {
+        const getRubyVersionArray = lines.slice(rubVersionIndex);
+        ruby.runtimeDetails = {};
+        for (let j = 1; j < getRubyVersionArray.length; j++) {
+            let element = getRubyVersionArray[j];
+            if (!isUpperCase(element)) {
+                element = element.trim();
+                if (/^([ruby\s0-9.*]+)/.test(element)) {
+                    let splitElement = element.split(' ');
+                    ruby.runtimeDetails['version'] = splitElement[1];
+                }
+                if (/^([p0-9]+)/.test(element)) {
+                    ruby.runtimeDetails['patchLevel'] = element.substring(1);
+                }
+                if (element.includes('engine')) {
+                    let splitElement = element.split(' ');
+                    ruby.runtimeDetails[splitElement[0]] = splitElement[1];
+                }
+            }
+            else {
+                return;
+            }
+        }
+    }
+};
+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 getSourceArr = (lines, ruby) => {
+    let line = 0;
+    let source = [];
+    while ((line = lines[index++]) !== undefined) {
+        let currentWS = whitespaceRegx.exec(line)[1].length;
+        if (!line.includes(' bundler (')) {
+            if (currentWS === 0 && !line.includes(':') && line != '') {
+                populateSourceType(line, rubyObj);
+            }
+            if (currentWS !== 0 && line.includes(':')) {
+                nonDependencyKeys(line, rubyObj);
+            }
+            if (currentWS > 2) {
+                const isDependencyWithVersion = depReg.test(line);
+                let nexlineWS = whitespaceRegx.exec(lines[index])[1].length;
+                if (currentWS === 6) {
+                    const dependency = depReg.exec(line);
+                    if (isDependencyWithVersion) {
+                        if (rubyObj.name !== dependency[1]) {
+                            rubyObj.dependencies[dependency[1]] = dependency[3];
+                        }
+                    }
+                    else {
+                        rubyObj.dependencies[line.trim()] = 'UNSPECIFIED';
+                    }
+                }
+                if (currentWS === 4 && rubyObj.depthLevel === undefined) {
+                    const dependency = depReg.exec(line);
+                    rubyObj.name = dependency[1];
+                    rubyObj.depthLevel = currentWS;
+                    populateResolveAndPlatform(dependency[3], rubyObj);
+                }
+                if (currentWS === 4 && rubyObj.depthLevel) {
+                    const dependency = depReg.exec(line);
+                    rubyObj.name = dependency[1];
+                    rubyObj.depthLevel = currentWS;
+                    populateResolveAndPlatform(dependency[3], rubyObj);
+                }
+                if ((currentWS === 4 && nexlineWS === 4) ||
+                    (currentWS === 6 && nexlineWS === 4) ||
+                    nexlineWS == '') {
+                    let newObj = {};
+                    newObj = JSON.parse(JSON.stringify(rubyObj));
+                    source.push(newObj);
+                    rubyObj.dependencies = {};
+                }
+            }
+        }
+    }
+    ruby.sources = formatSourceArr(source);
+};
+exports.getSourceArr = getSourceArr;

package/dist/audit/rubyAnalysisEngine/parsedGemfile.js

@@ -0,0 +1,22 @@
+"use strict";
+const i18n = require('i18n');
+module.exports = exports = ({ ruby }, next) => {
+    const { rawProjectFileContents } = ruby;
+    try {
+        const rubyArray = rawProjectFileContents.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();
+        }
+        ruby.gemfilesDependanceies = filteredRubyDep;
+        next();
+    }
+    catch (err) {
+        next(new Error(i18n.__('rubyAnalysisEngineParsedGemFileError', rawProjectFileContents) + `${err.message}`));
+        return;
+    }
+};

package/dist/audit/rubyAnalysisEngine/readGemfileContents.js

@@ -0,0 +1,14 @@
+"use strict";
+const fs = require('fs');
+const i18n = require('i18n');
+module.exports = exports = ({ language: { projectFilePath }, ruby }, next) => {
+    try {
+        ruby.rawProjectFileContents = fs.readFileSync(projectFilePath, 'utf8');
+        next();
+    }
+    catch (err) {
+        next(new Error(i18n.__('rubyAnalysisEngineReadGemFileError', projectFilePath) +
+            `${err.message}`));
+        return;
+    }
+};

package/dist/audit/rubyAnalysisEngine/readGemfileLockContents.js

@@ -0,0 +1,14 @@
+"use strict";
+const fs = require('fs');
+const i18n = require('i18n');
+module.exports = exports = ({ language: { lockFilePath }, ruby }, next) => {
+    try {
+        ruby.rawLockFileContents = fs.readFileSync(lockFilePath, 'utf8');
+        next();
+    }
+    catch (err) {
+        next(new Error(i18n.__('rubyAnalysisEngineReadGemLockFileError', lockFilePath) +
+            `${err.message}`));
+        return;
+    }
+};

package/dist/audit/rubyAnalysisEngine/sanitizer.js

@@ -0,0 +1,6 @@
+"use strict";
+module.exports = exports = ({ ruby }, next) => {
+    delete ruby.rawProjectFileContents;
+    delete ruby.rawLockFileContents;
+    next();
+};

package/dist/commands/audit/auditConfig.js

@@ -0,0 +1,25 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getAuditConfig = void 0;
+const paramHandler_1 = __importDefault(require("../../utils/paramsUtil/paramHandler"));
+const constants_1 = __importDefault(require("../../constants"));
+const parsedCLIOptions_1 = __importDefault(require("../../utils/parsedCLIOptions"));
+const constants_2 = __importDefault(require("../../audit/languageAnalysisEngine/constants"));
+const { supportedLanguages: { NODE, JAVASCRIPT } } = constants_2.default;
+const getAuditConfig = (argv) => {
+    const auditParameters = parsedCLIOptions_1.default.getCommandLineArgsCustom(argv, constants_1.default.commandLineDefinitions.auditOptionDefinitions);
+    const paramsAuth = paramHandler_1.default.getAuth(auditParameters);
+    if (auditParameters.language === undefined ||
+        auditParameters.language === null) {
+        console.log('error, --language parameter is required');
+        process.exit(1);
+    }
+    else if (auditParameters.language.toUpperCase() === JAVASCRIPT) {
+        auditParameters.language = NODE.toLowerCase();
+    }
+    return { ...paramsAuth, ...auditParameters };
+};
+exports.getAuditConfig = getAuditConfig;