Node

How to use Redis and/or memory cache with node-cache-manager

Paul Wellner Bou

May 12, 2023 • 1 min read

Upgrading legacy libraries of a (server-side, running on Node) legacy JavaScript application, I had to upgrade (and replace) following libraries:

As there is missing documentation (node-cache-manager-redis-yet does not have any at all) and there is no current example using a memory cache and Redis at the same time, I spend some time finding the solution. So it might be a useful shortcut for you, if you need to do the same task.

TL;DR

The code I eventually came up with (in short, for more details read further):

	import { caching, multiCaching } from 'cache-manager';
	import { redisStore } from 'cache-manager-redis-yet';

	function createMemoryCache(max, ttl) {
	return caching('memory', { max, ttl });
	}

	async function createRedisCache(redisHost, ttl) {
	const redisConfig = { url: `redis://${redisHost}`, db: 0, ttl };
	const redisCacheStore = await redisStore(redisConfig);
	return caching(redisCacheStore);
	}

	const createCache = async ({ mode, max, ttl }, redisHost) => {
	if (mode === 'memory') {
	return createMemoryCache(max, ttl);
	}
	if (mode === 'redis' && redisHost) {
	return createRedisCache(redisHost, ttl);
	}
	if (mode === 'memory+redis' && redisHost) {
	return Promise.all([
	createMemoryCache(max, ttl),
	createRedisCache(redisHost, ttl),
	]).then(([memoryCache, redisCache]) => multiCaching([memoryCache, redisCache]));
	}
	return null;
	};

view raw CreateCache.js hosted with ❤ by GitHub

The problems and my solutions

cache-manager's API changed. It changed for better, so this is a good thing, just a bit of work and restructuring of code, as it relies on Promises now and the application I am working on is already relying on a working cache object on startup.
So I created a wrapper object taking care of the awaits.

	import { NoCacheableError, redisStore } from 'cache-manager-redis-yet';

	const cachePromise = createCache(); // this method is creating the actual cache promise object (see other code snippets)

	const CacheWrapper = {
	get: async (key) => {
	if (cachePromise) {
	const cache = await cachePromise;
	return cache.get(key);
	}
	return null;
	},

	set: (key, value) => {
	if (cachePromise) {
	cachePromise.then(cache => cache.set(key, value));
	}
	},

	wrap: async (key, fn, ttl) => {
	if (cachePromise) {
	const cache = await cachePromise;
	return cache.wrap(key, fn, ttl).catch((e) => {
	if (!(e instanceof NoCacheableError)) throw e;
	});
	}
	return new Promise(fn());
	},

	isCacheEnabled: () => cachePromise !== null,
	};

	export default CacheWrapper;

view raw CacheWrapper.js hosted with ❤ by GitHub

While the memory cache accepts null and undefined as result values of a wrapped function, cache-manager-redis-yet does not, and instead of omitting it, it throws an error. If you don't want this error to pop up in your application, you have to catch it (see line 24).
cache-manager-redis is not maintained any more, so I removed it completely.
cache-manager-redis-store is not "officially" supported by cache-manager, so I used the recommend one: node-cache-manager-redis-yet, which unfortunately has absolutely no documentation and no example.
It is a fork of cache-manager-redis-store, so we can use their example to create a Redis cache. Keep in mind, we need the full Redis URL here, including the schme redis://, just the host won't work.

	import { caching } from 'cache-manager';
	import { redisStore } from 'cache-manager-redis-yet';

	async function createRedisCache(redisHost, ttl) {
	const redisConfig = { url: `redis://${redisHost}`, db: 0, ttl };
	const redisCacheStore = await redisStore(redisConfig);
	return caching(redisCacheStore);
	}

view raw CreateRedisCache.js hosted with ❤ by GitHub

Inconsistencies in the API using cache-managers multiCache: While creating a cache with caching(...), which returns a Promise<MemoryCache>, multiCache(...) is only accepting Cache objects as parameters, no promises. So we either have to wait until the caches are created, or wrapping it into Promise.all(...)

	const createMultiCache = async (cachePromises) => {
	return Promise.all(cachePromises).then(caches => multiCaching(caches));
	}

view raw CreateMultiCache.js hosted with ❤ by GitHub