lru-memoizer

This package does exactly what it promises: wraps functions with memoization backed by an LRU cache. The standout feature is proper async/promise support with configurable key generation and TTL per-cache-entry. In production, it handles concurrent requests well—multiple calls with the same args while a promise is pending will share the same promise rather than spawning duplicate work, which is critical for expensive operations like database queries or API calls.

Configuration is straightforward with sensible defaults. You get control over cache size (max), TTL, and custom hash functions for complex argument serialization. The load/normalizeArguments pattern lets you intercept and transform arguments before hashing, useful when dealing with objects that need deep comparison. Error handling is transparent—rejected promises aren't cached by default, so transient failures don't poison your cache.

The main limitation is observability. There's no built-in metrics for hit/miss rates, evictions, or cache size monitoring. You'll need to wrap it or instrument separately if you need production visibility. Also, the clone option for cached values can surprise you with memory usage if you're caching large objects without realizing it creates deep copies on every hit.

I've used lru-memoizer across several Node.js projects for caching expensive database queries and API calls. The API is refreshingly simple - you wrap your function and configure basic options like max cache size and TTL. It just works. The async support is particularly solid, handling promises naturally without the awkward callback wrappers some older memoization libraries require.

The documentation is minimal but sufficient for straightforward use cases. The README covers the essentials with clear examples. I did have to dig into the source code once when dealing with custom cache key generation, which could be better documented. Error messages are generally clear when you misconfigure options, though debugging cache misses requires adding your own logging.

Community support is sparse - don't expect quick answers on Stack Overflow. However, the package is stable enough that I've rarely needed help. The biggest gotcha is understanding how the `hash` function works for generating cache keys with complex arguments - this tripped me up initially when objects weren't being cached as expected.

lru-memoizer does exactly what it promises: wraps functions with memoization backed by an LRU cache. The core API is straightforward—pass your function and options, get a memoized version back. It handles async functions well and the cache eviction works reliably. For simple use cases, it gets the job done without much ceremony.

The developer experience falls short of modern standards, though. TypeScript support is minimal—there are community-maintained types but they're basic and don't preserve your function signatures properly, forcing you to re-annotate return types. Error messages when you misconfigure options are cryptic at best. The documentation covers the basics but lacks practical examples for common scenarios like custom key generation or handling complex argument types.

The API for customizing cache keys (the `hash` option) works but isn't intuitive—you have to understand it stringifies by default, which can cause issues with objects. There's also a sync vs async mode that trips people up initially. It's serviceable for backend services where you need simple function-level caching, but you'll spend time reading the source code to understand edge cases.