Error response in JSON format

[mrslnv]

UC: Implementing an async request.

• while processing the request, an error condition occurs and it is necessary to inform client about the problem (preferably JSON)
• when an error occurs in the service, there are 2 cases:

1. rejecting the returned promise => content type is set to: text/html
2. an exception is thrown => again, content type is set to: text/html

Desired behavior:

• when an object is returned via reject(object), send back JSON (as for regular response)
• when an exception is thrown, allow service to set content type and respond with JSON

Suggested workaround:
app.use((err: any, req: express.Request, res: express.Response, next: express.NextFunction) => {
if (err instanceof BadRequestError){
res.set("Content-Type", "application/json")
res.status(err.statusCode)
res.json({info : err.message, data: err.data});
} else {
next(err);
}
});

This works fine here:
@path("dummy1")
@get
dummy1(): Promise {
return new Promise(function (resolve, reject) {
throw new BadRequestError("Works fine, JSON is sent",{some:"data"});
});
}

But it does not work here:
@path("dummy2")
@get
dummy2(): Promise {
return new Promise(function (resolve, reject) {
setTimeout(()=>{
throw new BadRequestError("error handling not applied",{some:"data"});
},1000);
});
}

[krazar]

👍

For the moment I use your workaround.

[thiagobustamante]

Hi,

Express uses an error handler middleware that is called to process exceptions that are not handled by its routes.

It has a default error handler middleware (see this) that uses a module called finalhandler to process all uncaught errors.

As you can see in the finalhandler documentation, it will always send an HTML page containing the description of the error (the error message) and, if not running in a production environment, a stack trace.

This is not implemented by typescript-rest, but is the default behavior of expressjs itself. So, if we want to override this behavior, we need to provide our own error handler implementation, that would handle the error before it is raised to the express default middleware.

This can be done, as @mrslnv already posted previously, writing something like:

import { HttpError } from 'typescript-rest';
app.use((err: any, req: express.Request, res: express.Response, next: express.NextFunction) => {
  if (err instanceof HttpError){
    if (res.headersSent) { // important to allow default error handler to close connection if headers already sent
      return next(err)
    }
    res.set("Content-Type", "application/json")
    res.status(err.statusCode)
    res.json({error : err.message, code: err.statusCode});
  } else {
    next(err);
  }
});

However, the last situation showed by @mrslnv will never work:

@path("dummy2")
@get
dummy2(): Promise {
  return new Promise(function (resolve, reject) {
    setTimeout(()=>{
      throw new BadRequestError("error handling not applied",{some:"data"});
    },1000);
  });
}

That code are not catching the exception and rejecting the promise. The exception will be lost and can not be sent to express error handling. To this code work, it needs to be refactored to something like:

@path("dummy2")
@get
dummy2(): Promise {
  return new Promise(function (resolve, reject) {
    setTimeout(()=>{
      try {
        throw new BadRequestError("error handling not applied",{some:"data"});
      } catch(e) {
        return reject(e);
      }
    },1000);
  });
}

We could create an errorHandler like that one above and register it in typescript-rest library (maybe through some method like Server.useJsonErrorHandler(); or something like this. But I don't know if it is a good idea.

Some people will need to sent a json like:

{ "error": "my message"}

... while others will prefer:

{ "message": "my message", "status": 403}

And so on...

So I think that the most reasonable solution is to allow the developer to specify how he wants to sent his error.... And express already allow it through a custom error handler. So, do you think that it is already necessary to create another method for this?

EDIT
Just to clarify, the first code showed by @mrslnv works because the exception is not occurring asynchronously:

@path("dummy1")
@get
dummy1(): Promise {
  return new Promise(function (resolve, reject) {
    // this is a sync error and will be caught and redirected to the promise reject method
    throw new BadRequestError("Works fine, JSON is sent",{some:"data"});
  });
}

[mrslnv]

Thanks for extensive explanation!

I agree that it would be enough if this case is discussed and described in the documentation (which is very good).

[krazar]

Excuse me for my stupid question but:

 throw new BadRequestError("Works fine, JSON is sent",{some:"data"});

Is it possible to send some custom object in the constructor without rewriting the class HttpError ?

[mate-h]

How about using JSON.stringify and JSON.parse?

app.use(
      (
        err: any,
        req: express.Request,
        res: express.Response,
        next: express.NextFunction
      ) => {
        if (err instanceof Errors.HttpError) {
          res.set("Content-Type", "application/json");
          res.status(err.statusCode);
          try {
            const parsed = JSON.parse(err.message);
            res.json(parsed);
            return;
          }
          catch (e) {
            res.json({ message: err.message });
            return;
          }
        } else {
          next(err);
        }
      }
    );

throw new Errors.ForbiddenError(JSON.stringify({ message: "Error msg", code: "error-code" }));