All Errors

This warning occurs when promises remain unresolved indefinitely, preventing JavaScript's garbage collector from freeing memory. Long-lived or infinite promise chains accumulate in memory, eventually leading to performance degradation or out-of-memory crashes.

This error occurs when your Node.js application or npm tries to connect through a proxy server that requires authentication credentials. The request is rejected because no valid username and password were provided to the proxy.

This error occurs when code attempts to use a non-function value as a function, or when a function is expected to return a promise but returns a non-thenable value instead. It commonly happens in promise chains, async/await operations, or when working with promise constructors.

Node.js throws this error when require() or import attempts to load a module from a directory path that does not exist in the filesystem. This commonly happens due to incorrect paths, missing installations, or misconfigured module resolution.

A segmentation fault occurs when Node.js or a native addon attempts to access memory it is not permitted to access, causing the process to crash with a "Segmentation fault (core dumped)" message. This typically indicates a bug in native C/C++ modules rather than JavaScript code.

The spawn EACCES error occurs when Node.js attempts to spawn a child process but lacks execute permissions on the target executable. This commonly happens with binary files in node_modules or custom scripts that are missing the executable bit.

Your setImmediate() callback threw an unhandled exception or failed during execution. This error occurs because exceptions in setImmediate callbacks cannot be caught with try-catch and propagate unchecked through the Node.js event loop, crashing your process.

This error occurs when Node.js cannot verify the SSL/TLS certificate of a server you are trying to connect to. It typically happens with self-signed certificates, expired certificates, or missing intermediate certificates. The fix depends on whether you are in a development environment or production.

Node.js StringDecoder throws an error when you pass an unsupported or misspelled encoding. This happens when working with streams or buffers with invalid encoding specifications.

This error occurs when Node.js receives a malformed or unrecognized timezone string from the TZ environment variable. The TZ variable expects valid IANA timezone identifiers (like "America/New_York" or "Europe/London") or POSIX timezone strings, but receives an invalid or misspelled value instead. This causes date and time operations to fail or behave unpredictably.

A TLS handshake timeout occurs when the client and server fail to complete the SSL/TLS negotiation within the timeout period (default 120 seconds). This typically indicates network delays, server resource constraints, or infrastructure issues.

This error occurs when the hostname sent during TLS handshake (Server Name Indication) does not match the hostname on the SSL/TLS certificate. The server receives a different SNI name than what the certificate is valid for, causing verification to fail.

This error occurs when attempting to call cluster.fork() from a worker process instead of the primary (master) process. The cluster module enforces a strict master-worker hierarchy where only the primary process can spawn new workers.

This error occurs when Node.js receives an HTTP response with malformed chunked transfer encoding. The HTTP parser cannot properly decode the response body because the chunk format violates HTTP/1.1 specifications.

This error occurs when an exception is thrown inside a deferred callback (setTimeout, setImmediate, or process.nextTick) without proper error handling, potentially crashing the Node.js process.

The EAGAIN error indicates that a requested I/O operation cannot be completed immediately because the resource is temporarily unavailable. This is a recoverable error that signals Node.js to retry the operation later rather than failing permanently.

This error occurs when a TCP connection is forcibly closed by the remote server or peer before the operation completes. It typically happens during HTTP requests when the server closes the connection unexpectedly, often due to timeout mismatches, keep-alive issues, or network problems.

This error occurs when a file or directory name exceeds the maximum length allowed by the operating system's filesystem. Most filesystems limit individual filename components to 255 bytes, and Node.js throws ENAMETOOLONG when attempting filesystem operations with paths that exceed this limit.

Occurs when using require() or import with relative paths (./ or ../) to modules that don't exist or have incorrect paths.

PostgreSQL does not support nesting aggregate functions directly (such as AVG(MAX(column))). Use subqueries or Common Table Expressions (CTEs) to perform multi-level aggregations.