asynchronous-cache v1.1.0

Asynchronous in-memory cache

This library helps you with executing asynchronous functions only once. When you are calling asynchronous function repeatedly, result from first call is returned.

This library does not have any dependencies.

Install

Install with npm

npm i asynchronous-cache --save

or install with yarn

yarn add asynchronous-cache

Usage

import { Cache } from 'asynchronous-cache' // or CommonJS (nodeJs) -> const Cache = require('asynchronous-cache').Cache
const cache = new Cache()

let executedCounter = 0
const functionToExecute = async () => { return ++executedCounter }

Promise.all([
    cache.executeWithCache('someKey', functionToExecute),
    cache.executeWithCache('someKey', functionToExecute),
]).then(result => {
    console.log(result) // [ 1, 1 ] -> function is executed only once
})

API

cache.executeWithCache(key, functionToExecute, options = {})

Returns a result for passed key from in-memory cache. If there is no record for this key, then functionToExecute is executed and result is returned and stored for next calls.

Params

• key string - Key is used as an identifier for same functions. Caching is based on this key, so same function should have same key.
• functionToExecute asynchronous function reference - Any asynchronous function reference (without the parentheses). This function will be executed and result will be cached for another calls.
• options (optional) object - Default is an empty object. Possible options:
  • TTL - Record will be removed from cache after TTL milliseconds.

cache.delete(key)

Delete key from the cache. Returns true if key was found and removed, otherwise false is returned.

Params

• key string - Key you want to remove from cache

cache.clear()

Clears whole cache. All keys and records are deleted from memory.

How it works

There is an example from test

import { Cache } from 'asynchronous-cache'
const cache = new Cache()

const resultOfAsyncMock = 'ok'
// asyncMock is a reference for function returning a promise
const asyncMock = jest.fn(() => {
    return new Promise(resolve => setTimeout(() => resolve(resultOfAsyncMock), 50))
})

test('async function should be executed only once in async calls', async () => {
    const promiseAll = Promise.all([
        cache.executeWithCache(key, asyncMock),
        cache.executeWithCache(key, asyncMock),
        cache.executeWithCache(key, asyncMock),
    ])
    const result = await promiseAll
    // asyncMock is called only once
    expect(asyncMock.mock.calls.length).toBe(1)
    // result from first call is cached and reused for next calls
    expect(result).toEqual([resultOfAsyncMock, resultOfAsyncMock, resultOfAsyncMock])
})