Estoy escribiendo un servicio en Nodejs en el que obtengo precios de una Api y la llamada a la API puede demorar más de un minuto, por lo que una de las cosas que pueden suceder es que puede ocurrir una solicitud de un artículo específico y el mismo artículo puede ser solicitado antes de que se devuelva el primer artículo y quiero detectar si hay una solicitud en curso para un artículo específico y, si hay una, necesito esperar a que finalice esta solicitud y devolver la misma respuesta para ambas solicitudes.
Un diagrama de ejemplo sería:
00.000 getCost('123') #1 call 00.001 getExternalCost('123') query 01.000 getCost('123') #2 call 90.001 getExternalCost('123') response 90.002 getCost('123') #1 response 90.003 getCost('123') #2 responseEste es el código que he escrito hasta ahora, que simplemente obtiene el costo del artículo.
let cache = new Map(); let addToCache = (key,val) => { if(!cache.has(key)){ cache.set(key,val); } } const getCost = async (itemId) => { if(cache.has(itemId)){ return cache.get(itemId); } const price = await getExternalCost(itemId); addToCache(itemId,price); return cost; }Esto se puede hacer si agrega promesas al caché en lugar de esperarlas. Al hacer esto, se puede redirigir una consulta entrante para recibir el valor de una consulta similar pendiente en la memoria caché.
const MAX_AGE = 1000; const cache = new Map(); const cacheContainsKey = key => { if (!cache.has(key)) { return false; } const { _ts } = cache.get(key); const age = Date.now() - _ts; if (age <= MAX_AGE) { return true; } console.log(`key ${key} age exceeds MAX_AGE: ${age}. Deleting key from cache.`); cache.delete(key); return false; }; const addToCache = (key, val) => { cache.set(key, { _ts: Date.now(), val }); }; const retrieveFromCache = async(itemId) => { try { const start = Date.now(); const price = await cache.get(itemId).val; const end = Date.now(); console.log(`Query for ${itemId}. Price: ${price}. Time spent: ${(end - start) / 1000} seconds.`); return price; } catch (err) { /* If required insert logic here to remove the itemId from the cache to allow new attempts to getExternalCost on this itemId. */ return err; } }; const getCost = async(itemId) => { if (cacheContainsKey(itemId)) { const price = await retrieveFromCache(itemId); return price; } const pricePromise = getExternalCost(itemId); addToCache(itemId, pricePromise); // all queries go through the cache const price = await retrieveFromCache(itemId); return price; }; // example code function getExternalCost(itemId) { return new Promise((resolve, __reject) => { setTimeout(() => { resolve(itemId * 100); }, 1000); }); } let counter = 0; const itemIds = [10, 10, 12, 12, 10, 1]; // mimic incoming queries let interval = setInterval(() => { getCost(itemIds[counter++]); if (counter === itemIds.length) { clearInterval(interval); } }, 500);