🚀 Error-Cure: The Ultimate Error Handling Solution for Node.js & Express

Tired of messy error handling, inconsistent API responses, and fragile Node.js applications? Error-Cure is your one-stop solution for building robust, production-ready, and developer-friendly APIs with Express.

Error-Cure provides a comprehensive suite of tools to streamline your error handling workflow, from custom error classes to a powerful global middleware. It's designed to be lightweight, easy to use, and highly configurable, allowing you to focus on what matters most: building great applications.

🤔 Why Error-Cure?

| Feature | Benefit | | ------------------------ | --------------------------------------------------------------------------------------------------- | | Centralized Handling | Manage all errors in one place, ensuring consistent and predictable API responses. | | Improved Debugging | Differentiate between operational errors (user-facing) and programming errors (internal bugs). | | Enhanced User Experience | Provide clear, meaningful error messages to your users without exposing sensitive stack traces. | | Increased Stability | Gracefully handle unhandled promise rejections and uncaught exceptions to prevent crashes. | | Accelerated Development | Reduce boilerplate code and focus on your core application logic. | | TypeScript & JS Support | Seamlessly integrate with both TypeScript and JavaScript projects (CommonJS & ESM). |

✨ Features

• 🔪 Custom Error Classes: A set of pre-built, extensible error classes for common scenarios:
  • AppError: The base class for all operational errors.
  • ValidationError: For input validation failures (400).
  • AuthError: For authentication/authorization issues (401).
  • NotFoundError: For missing resources (404).
  • DatabaseError: For database-related failures (500).
• 🛡️ Global Error Middleware: A powerful Express middleware that catches all errors and sends beautiful, environment-aware responses.
• 📝 Error Logging: A simple yet effective utility to log errors to a file for easy debugging and monitoring.
• 🚨 Unhandled Rejection/Exception Handling: Automatically catches and logs unhandled promise rejections and uncaught exceptions.
• ✅ TypeScript Ready: Written entirely in TypeScript with type definitions included.
• 📦 Dual Module Support: Supports both CommonJS (require) and ES Modules (import).

📦 Installation

# Using npm
npm install error-cure

# Using yarn
yarn add error-cure

📂 Project Structure

error-cure/
├── dist/
│   ├── cjs/                # CommonJS output
│   └── esm/                # ES Module output
├── src/
│   ├── index.ts            # Main entry point
│   ├── errors/
│   │   ├── AppError.ts
│   │   ├── AuthError.ts
│   │   ├── DataBaseError.ts
│   │   ├── NotFoundError.ts
│   │   └── ValidationError.ts
│   ├── middleware/
│   │   └── globalErrorHandler.ts
│   └── utils/
│       ├── handleRejections.ts
│       └── logError.ts
├── tests/
└── ...

💡 Usage

Error-Cure is designed to be intuitive and easy to integrate. Here’s how you can use it in your projects:

ES Modules (import/export)

// app.ts
import express from 'express';
import { AppError, globalErrorHandler, handleUnhandledRejections } from 'error-cure';

// Handle unhandled rejections and exceptions
handleUnhandledRejections();

const app = express();

app.get('/users/:id', (req, res, next) => {
  if (req.params.id === '0') {
    return next(new AppError('Invalid user ID.', 400));
  }
  res.json({ id: req.params.id, name: 'John Doe' });
});

// Handle 404 errors
app.all('*', (req, res, next) => {
  next(new AppError(`Can't find ${req.originalUrl} on this server!`, 404));
});

// Global error handling middleware (must be last)
app.use(globalErrorHandler);

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

CommonJS (require/module.exports)

// server.js
const express = require('express');
const { AppError, globalErrorHandler, handleUnhandledRejections } = require('error-cure');

// Handle unhandled rejections and exceptions
handleUnhandledRejections();

const app = express();

app.get('/users/:id', (req, res, next) => {
  if (req.params.id === '0') {
    return next(new AppError('Invalid user ID.', 400));
  }
  res.json({ id: req.params.id, name: 'John Doe' });
});

// Handle 404 errors
app.all('*', (req, res, next) => {
  next(new AppError(`Can't find ${req.originalUrl} on this server!`, 404));
});

// Global error handling middleware (must be last)
app.use(globalErrorHandler);

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

⚙️ Configuration

The globalErrorHandler automatically adapts its response based on the NODE_ENV environment variable:

• development: Provides detailed error information, including stack traces.
• production: Sends minimal, user-friendly error messages.

Always set NODE_ENV=production in your production environment.

🤝 Contributing

Contributions are welcome! Please follow these steps:

1. Fork the repository.
2. Create a new branch (git checkout -b feature/your-feature).
3. Make your changes and add tests.
4. Ensure all tests pass (npm test).
5. Commit your changes (git commit -m 'feat: Add some feature').
6. Push to the branch (git push origin feature/your-feature).
7. Open a Pull Request.

📄 License

This project is licensed under the MIT License. See the LICENSE.txt file for details.

🔑 Keywords

error-handling, express, node.js, middleware, error-management, custom-errors, api-errors, unhandled-rejection, uncaught-exception, logging, typescript, javascript, commonjs, esm, express-middleware, nodejs, error-logger, production-ready, developer-tools, api, backend, rest-api, error-response, json-errors