custom-errors.js

function handleRequest(req, res) {
  // all the important request logic...
  
  // send back the request id
  res.send(requestId)
  
  // if sending to an known sender...
  if (senderId) {
    await optInToExperiment(senderId)
  }
}

async function getCard(params) {
  if (!params.id) {
    let err = new Error("Missing ID")
    err.statuCode = 400
    throw err
  }
  // ...
}

async function getCard(params) {
  if (!params.id) {
     throw new Error("Missing ID")
  }
  // ...
}

async function getCard(params) {
  if (!params.id) {
     throw new ParamError("id")
  }
  // ...
}

class ParamError extends Error {
   constructor(field) {
      super(`Missing param: ${field}`)
      Error.captureStackTrace(this, ParamError)
      this.statusCode = 400
   }
}

function errorHandler(err, req, res, next) {
   let statusCode = err.statusCode || 500
   res.status(statusCode).send(err.message)
}

function badNews() {
   setTimeout(function() {
       throw new Error('💥')
   }, 500)
}


async function badNews() {
    throw new Error('bad news')
}

function badNews() {
    return Promise.reject(new Error('bad news'))
}



function decrypt(enctypedId) {
    return Service.decryptValue(encrytpedId)
}

function decrypt(encryptedId: string): Promise<string> {
    return Service.decryptValue(encrytpedId)
}

async function optInToExperiment(senderId) {
    let encrtypedId: string = decrypt(senderId)
    expService.addUser(encrtypedId, function(err, res) {
       if (err) return logger.log(res)
       // success
    })
}

async function onDebuggerPaused({ params }, session) {
  let callFrames = params.asyncStackTrace.callFrames;
  let trace = callFrames.map(
      frame => `  at ${frame.functionName} (${frame.url}:${frame.lineNumber}:${frame.columnNumber})`
  ).join("\n");
  console.log(trace);
}
async function onDebuggerPaused({ params }, session) {
  let callFrames = params.asyncStackTrace.callFrames;
  let { result } = await session.postAsync("Runtime.getProperties", {
    objectId: params.data.objectId
  });
  let name = result.find(x => x.name == "name").value.value;
  let message = result.find(x => x.name == "message").value.value;
  let trace = `${name}: ${message}\n${callFrames
    .map(
      frame => `  at ${frame.functionName} (${frame.url}:${frame.lineNumber}:${frame.columnNumber})`
    )
    .join("\n")}`;
  
  console.log(trace);
}

var session = new inspector.Session();

session.connect();

session.post("Runtime.enable");
session.post("Debugger.enable");

session.post("Debugger.setAsyncCallStackDepth", { maxDepth: 20 });
session.post("Debugger.setPauseOnExceptions", { state: "all" });

session.on("Debugger.paused", results => onDebuggerPaused(results, session));



async function onDebuggerPaused(results, session) {
  let callFrames = results.params.asyncStackTrace.callFrames;
  let { result } = await session.postAsync("Runtime.getProperties", {
    objectId: results.params.data.objectId
  });
  let name = result.find(x => x.name == "name").value.value;
  let message = result.find(x => x.name == "message").value.value;
  console.log(
    `${name}: ${message}\n`,
    callFrames.map(
      x => `    at ${x.functionName} (${x.url}:${x.lineNumber}:${x.columnNumber})`
    ).join("\n")
  );
}




var inspector = require('inspector')
inspector.open()

inspector.close()


var inspector = require('inspector')
var session = new inspector.Session()

session.connect()

session.post("Debugger.enable");
session.post('Debugger.setPauseOnExceptions', { state: 'all' })

// Listen for inspector events
session.on('Debugger.paused', ({ params }) => {
  // params.callFrames
  // params.reason
  // params.data
});

// Send messages to the inspector
session.post(message);

session.disconnect();



function handleAllTheErrors(err, req, res, next) {
  let statusCode = 500
  if (err.name === "TypeError") {
    statusCode = 400
  }
  console.err(err)
  res.status(statusCode).send(err.message)
}

class ParamError extends Error {
    constructor(message) {
        super(message)
        Error.captureStackTrace(this, ParamError)
        this.name = "ParamError"
        this.statusCode = 400
    }
}

function handleAllTheErrors(err, req, res, next) {
  let statusCode = err.statusCode || 500
  console.err(err)
  res.status(statusCode).send(err.message)
}