async-memoize

Nifty async function memoization.

Features:

• Featherweight implementation
• Async store (= cache) is configurable, in-memory by default
• Inversion of control: store is injected
• No active cache invalidation, resources are handled by the caller
• Composable: a memoized function can be memoized using a different store
• User-defined cache-key creation

Caution:

The default in-memory store is meant to be used in a local context. It grows indefinitely. Implement your own Store or use an existing one in order to get more control over the lifecycle of cached elements.

Installation

npm i @danieldietrich/async-memoize

Usage

The module supports ES6 import and CommonJS require style.

memoize(fn) creates a memoized version of the given function fn with the default in-memory store. It caches function calls. The function arguments are used as key.

import memoize from '@danieldietrich/async-memoize';

// A memoized version of the getLicense function (see below).
// By default, an in-memory cache is utilized.
// The memoized varion has the 
// Inferred type: (string) => Promise<License>
const getLicenseMemoized = memoize(getLicense);

// Calls the GitHub API because there is no cache hit for 'MIT'
getLicenseMemoized('MIT').then(console.log);

// Gets the result from in-memory cache for key 'MIT'
getLicenseMemoized('MIT').then(console.log);

// Example function, type declarations and helper functions omitted.
async function getLicense(spdxId: string): Promise<License> {
    return http_get(`https://api.github.com/licenses/${spdxId}`);
}

The memoization function is highly composable.

import memoize, { Store } from 'memoize';

const es6Store: Store<string, ReturnType<getLicense>> = {
    get: (key) => new Promise((resolve, reject) => {
        const value = /* TODO: retrieve value */
        (value === undefined) ? reject() : resolve(value);
    }),
    set: (key, value) => new Promise((resolve) => {
        /* TODO: store value */;
        resolve(value);
    }),
    toKey: (args) => new Promise((resolve) => {
        resolve(JSON.stringify(args));
    })
};

const es8Store: Store<string, ReturnType<getLicense>> = {
    get: async (key) => /* TODO: retrieve value */,
    set: async (key, value) => { /* TODO: store value */; return value; }
    toKey: async (args) => JSON.stringify(args);
};

const getLicenseMemoized = memoize(memoize(getLicense, es8Store));

Copyright © 2020 by Daniel Dietrich. Released under the MIT license.