memory-cacheable

cacheable

I built this because I had the need to store expensive and frequently called functions into memory. It's not a framework for caches, it's not really a class, or a cache wrapper. It's minimal, and encourages you to decide how you want to interact with the available states of your cached collections. Think of this as a function that keeps state of points in time, with a couple helpers to manage cached collections.

install

npm install --save memory-cacheable

api

cacheable({ key, cache, ttl, offset, verbose })

see below table for options:

key	required	summary
key	false	key for debugging purposes, mostly
ttl	false	defaults to 1 hour, uses the ms module for easy formatting
cache	false	defaults to an array, but will also support cleaning out objects
offset	false	defaults to 0.65 (roughly 2/3 the ttl), used to create the stale value by multiplying the ttl by offset
verbose	false	defaults to false turn this on for really noisey cache stats and debugging

cacheable api

function	summary
cacheable(store).debug()	debug logging, noisey, expensive stuff
cacheable(store).expired()	check if cache state is expired
cacheable(store).fetch()	fetches the cached collection
cacheable(store).flush()	flush cache, supports Objects and Arrays
cacheable(store).set(collection)	sets cached collection from provided param
cacheable(store).size()	gets the cache size, if an object Object.keys() is called
cacheable(store).stale()	determines if the cache is stale or not
cacheable(store).state()	returns whether the cache is expired or not, if cache is expired, state will reset and flush the cache
cacheable(store).reset()	restarts timers, will not flush cache

example

const { cacheable } = require('memory-cacheable');

const store = {
  key: 'expensiveCacheExample',
  ttl: '1h'
};

const expired = cacheable(store).state; // pulls state out to manage state and check if expired
const { stale, reset, flush } = cacheable(store); // other helpful tings

// simplest example usage
function doSomethingExpensive(fn) {
  if (!expired()) return fn(null, store.cache);
  return funcToExpensiveThings((err, resp) => {
    if (err) return fn(new Error(err), null);
    store.cache = resp;
    return fn(null, resp);
  });
}

// example usage for expensive or long running functions with 
// stale support
function doSomethingExpensive(fn) {
  const isStale = stale();
  if (!expired() && !isStale) return fn(null, store.cache);
  if (isStale) fn(null, store.cache);
  return funcToExpensiveThings((err, resp) => {
    if (err) return fn(new Error(err), null);
    store.cache = resp;
    if (isStale) return reset();
    return fn(null, resp);
  });
}

debugging

Uses the debug module, and you can set the following environment variable:

export DEBUG=cacheable:*

test

npm install --save-dev && npm test

Made with ♥