HTTP Status Codes and Custom Errors

This NPM package provides HTTP status code constants and custom error classes for easy use in your Node.js applications. It simplifies the process of handling HTTP errors by allowing you to import predefined status codes and error classes.

Installation

Install the package via npm:

npm install http-status-errors

Usage

Importing HTTP Status Codes

You can import the HTTP status codes from the package:

import { status } from 'http-status-errors';

console.log(status.HTTP_BAD_REQUEST); // 400
console.log(status.HTTP_NOT_FOUND); // 404

Importing Custom Error Classes

The package provides custom error classes for common HTTP errors:

import {
  BadRequestError,
  InternalServerError,
  InvalidRequestError,
  NotFoundRequestError,
  UnauthorizedRequestError,
  ForbiddenRequestError,
} from 'http-status-errors';

// Example usage
try {
  throw new BadRequestError('This is a bad request');
} catch (error) {
  console.error(error.statusCode); // 400
  console.error(error.message); // 'This is a bad request'
}

API

HTTP Status Codes

The following status codes are available:

• HTTP_OK (200)
• HTTP_CREATED (201)
• HTTP_NO_CONTENT (204)
• HTTP_BAD_REQUEST (400)
• HTTP_BAD_REQUEST (400)
• HTTP_INTERNAL_SERVER_ERROR (500)
• HTTP_INVALID_REQUEST (422)
• HTTP_NOT_FOUND (404)
• HTTP_UNAUTHORIZED (401)
• HTTP_FORBIDDEN (403)

Custom Error Classes

BadRequestError

Represents a 400 Bad Request error.

class BadRequestError extends InternalServerError {
  public statusCode: number;
  constructor(message: string);
}

InternalServerError

Represents a 500 Internal Server Error.

class InternalServerError extends Error {
  public statusCode: number;
  constructor(message: string);
}

InvalidRequestError

Represents a 422 Unprocessable Entity error.

class InvalidRequestError extends InternalServerError {
  public statusCode: number;
  constructor(message: string);
}

NotFoundRequestError

Represents a 404 Not Found error.

class NotFoundRequestError extends InternalServerError {
  public statusCode: number;
  constructor(message: string);
}

UnauthorizedRequestError

Represents a 401 Unauthorized error.

class UnauthorizedRequestError extends InternalServerError {
  public statusCode: number;
  constructor(message: string);
}

ForbiddenRequestError

Represents a 403 Forbidden error.

class ForbiddenRequestError extends InternalServerError {
  public statusCode: number;
  constructor(message: string);
}

Example

Here’s an example of how to use this package in an Express application:

import express from 'express';
import { BadRequestError, NotFoundRequestError, status } from 'http-status-errors';

const app = express();

app.get('/', (req, res) => {
  res.send('Hello, world!');
});

// Return an HTTP error
app.get('/error', (req, res) => {
  try {
    throw new BadRequestError('This is a bad request');
  } catch (err) {
    res.status(err.statusCode).send(err.message)
  }
});

// Use error handling middleware
app.use((err, req, res, next) => {
  if (err instanceof BadRequestError) {
    res.status(err.statusCode).send({ error: err.message });
  } else {
    res.status(status.HTTP_INTERNAL_SERVER_ERROR).send({ error: 'An unexpected error occurred' });
  }
});

app.listen(3000, () => {
  console.log('Server is running on port 3000');
});

Contributing

Contributions are welcome! Please open an issue or submit a pull request if you would like to contribute to this project.

License

This project is licensed under the MIT License.