06 - RESPONSE NORMALIZATION STRATEGIES

Question 1

creating a currentUser route handler

Answer 1

export { router as currentUserrouter }
app.use(currrentUserRouter);

Question 2

validating requests with express-validator

Answer 2

import body, validationResult

Question 3

how to handle and structure errors

Answer 3

consistent structure for validation and other type of errors in a middleware

Question 4

error handler

Answer 4

import { Request, Response, NextFunction } from “response”;

export const errorHandler = (
err: Error,
req: Request,
res: Response,
next: NextFunction
) => {

};

Question 5

creating a RequestValidationError class

Answer 5

import { ValidationError } from “express-validator”;

export class RequestValidationError extends Error {
constructor(public errors: ValidationError[ ] ) {
super( );

  // only when extending a build in class
  Object.setPrototypeOf(this, RequestValidationError.prototype);    } }

Question 6

database connection error class

Answer 6

export class DatabaseConnectionError extends Error {
reason = “Error connecting to database”;

constructor( ) {
  super( );
   
  // only when extending a build in class
  Object.setPrototypeOf(this, DatabaseConnectionError.prototype);    } }

Question 7

throwing custom error classes

Answer 7

throw new RequestValidationError(errors.array( ));
throw new DatabaseConnectionError( );

Question 8

common response error structure

Answer 8

{
errors: {
message: string, field?: string
}[ ]
}

Question 9

add serializeErrors method to each error class

Answer 9

serializeErrors( ) {
return [
{ message: “reason” }
];
}
}

Question 10

serialize method in RequestValidationError class

Answer 10

serializeErrors( ) {
return this.errors.map(err => {
return { message: err.msg, field: err.param }
});
}

Question 11

create CustomError Abstract class

Answer 11

export abstract class CustomError extends Error {
abstract statusCode: number;

constructor( ) {
  super( );
   
  Object.setPrototypeOf(this, CustomError.prototype);    }

abstract serializeErrors( ): { message: string; field?: string } [ ] }

Question 12

using CustomError in errorHandler middleware

Answer 12

if (err instanceOf CustomError) {
return status(err.statusCode).send({ errors: err.serializeErrors( ) });
}

Question 13

create a route not found custom error

Answer 13

import { CustomError } from “custom-error”;

export class NotFoundError extends CustomError {
statusCode = 404;

constructor( ) {
  super("Route not found");
   
  Object.setPrototypeOf(this, NotFoundError.prototype);    }

 serializeErrors( ) {
     return [ { message: "Not Found" } ]
 } }

app.get(“*”, ( ) => {
throw new NotFoundError( )
});

Question 14

install express-async-errors

Answer 14

app.all(“*”, async (req, res, next ) => {
next ( new NotFoundError( ));
});