How to debug and step into the code "module.exports.handler = (event, context, cb) => {" ?

[avenger200]

When I debug the index.js file, the cursor always skip the "module.exports.handler = (event, context, cb) => {" function. Can someone please let me know how to debug the lamda function.

'use strict';

process.env.NODE_ENV = 'test';
process.env.RUNNING_SWAGGER_TOOLS_TESTS = 'true';
console.log("Hello");

const jsonlint = require("jsonlint");
const rp = require('request-promise-native');
var _ = require('lodash');

const swaggerTools = require('./swagger-lint');

const errorHandlerModule = require("./components/error-handler.js");
const responseObj = require("./components/response.js");
const configObj = require("./components/config.js");
const logger = require("./components/logger.js");
const secretHandlerModule = require("./components/secret-handler.js");
const contextObj = require("./components/context.js");

module.exports.handler = (event, context, cb) => {
var serviceContext = contextObj(event);
var errorHandler = errorHandlerModule();
var config = configObj(serviceContext);
var secretHandler = secretHandlerModule();
logger.init(serviceContext, context);
try {
logger.info ('Applying swagger lint..');
validateInput(event)
.then(function(result) {
return getSwagger(result);
})
.then(function(result){
return validateSwagger(result);
})
.then(function(result) {
return prepareResponse(config, event.body, result);
})
.then(function(result) {
return cb(null, result);
}).catch(function(err){
logger.error('Error occured while validating swagger document, error: ' + JSON.stringify(err));
if (err.errorType) {
return cb(JSON.stringify(err));
}else {
if (err.code) {
return cb(JSON.stringify(errorHandler.throwInputValidationError(err.code, err.message)));
}
return cb(JSON.stringify(errorHandler.throwInternalServerError("106",'Unknown error occured while validating swagger document: ' + err.message)));
}});
} catch (e) {
logger.error('Unhandled exception while validating swagger document ' + JSON.stringify(e));
return cb(JSON.stringify(errorHandler.throwInternalServerError("106", 'Intenal error occured while validating swagger document: ' + e.message)));
}};

function validateInput(userInput) {
var errorHandler = errorHandlerModule();
return new Promise((resolve, reject) => {
// logger.info(JSON.stringify(userInput));
if (!userInput || !userInput.method) {
return reject(errorHandler.throwInputValidationError("101", "invalid or missing arguments"));
}
if (userInput.method !== 'POST' ) {
return reject(errorHandler.throwInputValidationError("102", "Service operation not supported"));
}
if (!userInput.body || (!userInput.body.url && !userInput.body.swaggerDoc)) {
return reject(errorHandler.throwInputValidationError("103", "Required params - url/swaggerDoc"));
}
resolve(userInput.body);
});
}

function getSwagger(userInput) {

var errorHandler = errorHandlerModule();
return new Promise((resolve, reject) => {

  if (userInput.swaggerDoc) {
    return resolve(userInput.swaggerDoc);
  }

  rp({ url: userInput.url, json: true, rejectUnauthorized: false, method: 'GET'})
  .then(function(result) {
    resolve(result);
  })
  .catch(function(err) {
    logger.error("Failed to get swagger, error: " + JSON.stringify(err));

    if (err.statusCode) {
      return reject(errorHandler.throwInputValidationError("104", "Failed to download swagger, status code: " + err.statusCode + ", error mesage: " + err.message));
    } else if (err.message) {
      return reject(errorHandler.throwInputValidationError("104", "Failed to download swagger, error message: " + err.message));
    } else{
      return reject(errorHandler.throwInputValidationError("105", "Unknown error occured while downloading swagger"));
    }
  });
});

}

function validateSwagger(swaggerDoc) {
if (!_.isPlainObject(swaggerDoc)) {
swaggerDoc = jsonlint.parse(swaggerDoc);
}
var errorHandler = errorHandlerModule();
return new Promise((resolve, reject) => {
try{
swaggerTools.initializeMiddleware(swaggerDoc, function(middleware) {
var errors = false;

    _.each(Object.keys(middleware), function (key) {
        if (!_.isFunction(middleware[key])) {
          errors = true;
        }
    });
    
    var op = {};
    
    if (errors) {
      op.message = 'Swagger validation failed';
      op.errorDetails = middleware.results;

    } else {
      op.message = 'Successfully validated swagger of length: ' + JSON.stringify(swaggerDoc).length + '.'; 
    }

    return resolve(op);
  });
}
catch (e){
    logger.error(e);
    return reject(errorHandler.throwInternalServerError("106", "Unknown internal error occured while validating swagger document" + ": " + e.message));
}

});
}

function prepareResponse(config, userInput, swaggerEvalResults) {
return new Promise((resolve, reject) => {

var op = {
  version: config.VERSION,
  timestamp: new Date()
};

if (userInput.swaggerDoc) {
  if (userInput.swaggerDoc.info && userInput.swaggerDoc.info.title) {
    op.resource = "SwaggerDoc - '" + userInput.swaggerDoc.info.title + "' of version: " + userInput.swaggerDoc.info.version;
  }else {
    op.resource = "SwaggerDoc of length: " + JSON.stringify(userInput.swaggerDoc).length;
  }
}else{
  op.resource = userInput.url;
}

op.results = { message: swaggerEvalResults.message};
op.results.score = { current: 100, organizationGoal: 100, organizationAverage: 78};

if (swaggerEvalResults.errorDetails) {
  op.results.errors = swaggerEvalResults.errorDetails.errors ? swaggerEvalResults.errorDetails.errors.length : 0;
  op.results.warnings = swaggerEvalResults.errorDetails.warnings ? swaggerEvalResults.errorDetails.warnings.length : 0;
  
  var resultDetails = {};

  var uniqueViolations = {};

  var errorDetails = getIssueDetails(config.SWAGGER_ERROR_MAP, swaggerEvalResults.errorDetails.errors, true);

  errorDetails = _.uniqBy(errorDetails, function (e) {
      return e.name + e.location;
  });

  errorDetails = _.remove(errorDetails, function (e1) {
    return (!(!e1.location || 0 === e1.location.length));    
  });

  _.each(errorDetails, function(errorDetail){
            
    if (!uniqueViolations[errorDetail.name]) {
      uniqueViolations[errorDetail.name] = errorDetail.score;
      op.results.score.current += errorDetail.score;

      var errorCategory = { score: errorDetail.score, status: "error", description: errorDetail.description, issues: []};
      
      resultDetails[errorDetail.name] = errorCategory;
    }

    resultDetails[errorDetail.name].issues.push({ message: errorDetail.message, location: errorDetail.location});
  });
  
  var warnDetails = getIssueDetails(config.SWAGGER_ERROR_MAP, swaggerEvalResults.errorDetails.warnings, false);
  _.each(warnDetails, function(warnDetail){
    
    if (!uniqueViolations[warnDetail.name]) {
      uniqueViolations[warnDetail.name] = warnDetail.score;
      op.results.score.current += warnDetail.score;

      var errorCategory = { score: warnDetail.score, status: "warning", description: warnDetail.description, issues: []};
      
      resultDetails[warnDetail.name] = errorCategory;
    }
    resultDetails[warnDetail.name].issues.push({ message: warnDetail.message, location: warnDetail.location});
  });

  op.results.errors = errorDetails.length;
  op.results.warnings = warnDetails.length;
  op.results.details = resultDetails;
}

return resolve(op);

});
}

function getIssueDetails(swaggerErrorMap, issues, isError) {
var details = [];
var loc = "";
var sanitizeError = function(key){
var mappedError = swaggerErrorMap[key.code];

var errorDetail = {"message": key.message, location: ""};

// Capturing location if possible
if (key.path && Array.isArray(key.path) && key.path.length > 0){
  errorDetail.location = "/" + key.path.join('/');
} 

if (mappedError){
  errorDetail.name = mappedError.name;
  errorDetail.description = mappedError.description;
  errorDetail.score = mappedError.score;
  errorDetail.status = mappedError.status;
} else{
  console.log (JSON.stringify(key));
  errorDetail.name = "Unmapped";
  errorDetail.description = isError ? "Unmapped error": "Unmapped warning";
  errorDetail.score = isError ? -10: -5;
}

if (!key.inner){
  if (loc){
    errorDetail.location = loc;
    loc = "";
  }
  details.push(errorDetail);
}else{
  loc = errorDetail.location;
  _.each(key.inner, function(innerError) {
    sanitizeError(innerError);
  });
}

};

_.each(issues, function(key) {
// reset the location
loc = "";
sanitizeError(key);
});

return details;
}