Memoize With TTL and Bounded Cache Size

// Memoize with two production guards: an LRU bound on the cache, and a TTL
// per entry. JS Map preserves insertion order, which gives us LRU recency
// 'for free' as long as we re-insert on every hit.

function memoize(fn, { ttlMs = Infinity, maxSize = 1000, keyOf = JSON.stringify } = {}) {
    const cache = new Map();  // key -> { value, expiresAt }
    return function memoized(...args) {
        const key = keyOf(args);
        const now = Date.now();
        const hit = cache.get(key);
        if (hit && hit.expiresAt > now) {
            // Refresh recency: delete + set moves the key to the back.
            cache.delete(key);
            cache.set(key, hit);
            return hit.value;
        }
        const value = fn.apply(this, args);
        cache.set(key, { value, expiresAt: now + ttlMs });
        // Trim oldest if over budget. Map iterator yields insertion order.
        while (cache.size > maxSize) {
            const oldestKey = cache.keys().next().value;
            cache.delete(oldestKey);
        }
        return value;
    };
}

// Pretend this is a slow lookup.
let calls = 0;
function lookupUser(id) { calls++; return { id, name: `user_${id}` }; }

const memoized = memoize(lookupUser, { ttlMs: 60_000, maxSize: 3 });
memoized(1); memoized(2); memoized(3); memoized(1);  // 1 stays warm
memoized(4);  // evicts oldest (which is now 2 because 1 was touched)
console.log('calls:', calls);  // 4 distinct ids, only 4 underlying calls
console.log('alive:', [...new Set([1,2,3,4]).values()].map(id => [id, memoized(id) && true]));
console.log('total calls:', calls);

// The bug in 'cache the resolved value' for async functions: a thundering herd.
// Five callers each call memoizedLookup(123) before the first call resolves;
// without care, each one fires a fresh request. Cache the PROMISE so concurrent
// callers share a single in-flight resolution.

function memoizeAsync(fn, { ttlMs = Infinity, maxSize = 1000 } = {}) {
    const cache = new Map();  // key -> { promise, expiresAt }
    return async function memoized(...args) {
        const key = JSON.stringify(args);
        const now = Date.now();
        const hit = cache.get(key);
        if (hit && hit.expiresAt > now) {
            cache.delete(key); cache.set(key, hit);
            return hit.promise;
        }
        // Start the work; immediately seat the promise so concurrent callers wait.
        const promise = fn(...args).catch((err) => {
            // On error, evict so the next call retries instead of caching the failure.
            cache.delete(key);
            throw err;
        });
        cache.set(key, { promise, expiresAt: now + ttlMs });
        while (cache.size > maxSize) {
            cache.delete(cache.keys().next().value);
        }
        return promise;
    };
}

let underlyingCalls = 0;
async function fetchUser(id) {
    underlyingCalls++;
    await new Promise((r) => setTimeout(r, 30));
    return { id, name: `user_${id}` };
}

(async () => {
    const memoized = memoizeAsync(fetchUser, { ttlMs: 1_000 });
    // Five concurrent calls for the same id. Should result in ONE fetch.
    const results = await Promise.all([1, 1, 1, 1, 1].map((id) => memoized(id)));
    console.log('results:', results.length, 'underlying calls:', underlyingCalls);
})();

// Production memoizers need an escape hatch: 'I know this entry is stale, force
// a fresh call'. Build it as a method on the memoized function.

function memoize(fn, { ttlMs = Infinity, maxSize = 1000 } = {}) {
    const cache = new Map();
    function memoized(...args) {
        const key = JSON.stringify(args);
        const now = Date.now();
        const hit = cache.get(key);
        if (hit && hit.expiresAt > now) {
            cache.delete(key); cache.set(key, hit);
            return hit.value;
        }
        const value = fn(...args);
        cache.set(key, { value, expiresAt: now + ttlMs });
        while (cache.size > maxSize) cache.delete(cache.keys().next().value);
        return value;
    }
    memoized.invalidate = (...args) => cache.delete(JSON.stringify(args));
    memoized.clear = () => cache.clear();
    memoized.peek = () => [...cache.keys()];
    return memoized;
}

let calls = 0;
function expensiveStat(userId) { calls++; return { userId, score: Math.floor(Math.random() * 100) }; }

const memoized = memoize(expensiveStat, { ttlMs: 60_000 });
const a = memoized(123);
const b = memoized(123);
console.log('same:', a.score === b.score, 'calls:', calls);

memoized.invalidate(123);  // forced refresh
const c = memoized(123);
console.log('refreshed; calls now:', calls);
console.log('peek:', memoized.peek());