ehmicky/modern-errors
Modern Errors
This library provides a comprehensive framework for managing errors in JavaScript and TypeScript applications. It enables the creation of structured, type-safe error hierarchies, allowing developers to define custom error classes that ensure consistent behavior and categorization across a codebase.
The project distinguishes itself through a modular plugin architecture that allows for the extension of core error functionality, such as custom logging, serialization, and validation. It includes an exception normalization pipeline that converts non-standard or malformed errors into predictable instances, alongside mechanisms for aggregating multiple concurrent failures into a single parent object while preserving original stack traces.
Beyond core management, the library facilitates system-wide error handling by standardizing error responses for API communication and providing utilities for serializing error states across boundaries. It also includes features for property management, such as marking internal fields as non-enumerable to prevent sensitive data exposure, and provides tools for cleaning stack traces to improve debugging readability.
Features
- Error Handling Libraries - Provides a comprehensive framework for defining, wrapping, and normalizing custom error classes in JavaScript and TypeScript.
- Error Handling - Provides mechanisms and patterns for detecting, reporting, formatting, and resolving errors across various application layers.
- Error Management Utilities - Enables the creation of structured error hierarchies and aggregation of multiple exceptions while preserving stack traces.
- Custom Error Type Definitions - Supports the creation of specialized, type-safe error types to unify multiple failure modes.
- Error Wrapping - Encapsulates multiple exceptions within a single parent object for unified reporting while preserving stack traces.
- Error Code Hierarchies - Organizes error classes into a consistent hierarchy so callers can programmatically handle failures.
- Plugin Systems - Provides a modular plugin system to extend error functionality, including serialization, logging, and validation.
- Error Tracking and Exception Handling - Captures and formats process-level exceptions to ensure graceful exits and system stability.
- HTTP Error Normalization - Normalizes unknown exceptions and malformed error objects into defined, predictable error instances to prevent runtime bugs.
- Type Narrowing - Enables safe type narrowing of error instances within catch blocks to access custom properties and methods without runtime errors.
- Structured Error Responses - Provides standardized object formats for delivering API errors with consistent identifiers and detail fields.
- Error Handling Utilities - Offers a toolkit for building type-safe custom error classes with modular plugins for stack trace cleaning and output formatting.
- Error Aggregation - Merges multiple concurrent failures or nested exceptions into a single parent error object while preserving stack traces.
- Error Configuration Settings - Allows custom configuration of error behavior for specific classes or instances to control how errors are processed.
- Exception Handling Pipelines - Implements configurable sequences of handlers that intercept and modify exception data to ensure predictable error instances.
- JSON Error Serialization - Provides utilities to serialize complex error objects into structured formats for consistent cross-boundary communication.
- Modular Plugin Architectures - Provides an architectural framework designed for extensibility via plugins to handle logging, serialization, and custom logic.
- Modular Plugin Extensions - Provides a system for integrating third-party add-ons to extend the core functionality of an application.
