cached-async-fnc

A typesafe function execution cache that prevents execution if the function gets the same arguments twice.

You can find the code for the demo here

Features

• ✅  Full type safety when using typescript
• ☀️  Lightweight. No other dependencies will come with this package
• ♻️  Supports concurrent requests. If the same query is executed twice all following queries will wait until the first one resolves and reuse the data
• 🛠  Available as CommonJS and ESM build

Install

1# For npm
2npm install --save cached-async-fnc
3
4# For yarn
5yarn add --save cached-async-fnc
6
7# For pnpm
8pnpm install --save cached-async-fnc

Node - import

1import { createCachedAsyncFnc } from "cached-async-fnc";
2
3const cache = createCachedAsyncFnc(/*...*/);

Node - require

1const cachedAsyncFnc = require("cached-async-fnc");
2
3const cache = cachedAsyncFnc.createCachedAsyncFnc(/*...*/);
4
5// OR
6
7const { createCachedAsyncFnc } = require("cached-async-fnc");
8
9const cache = createCachedAsyncFnc(/*...*/);

Getting started

1import { createCachedAsyncFnc } from "cached-async-fnc";
2
3// Small function to defer the promise for some time
4function wait(ms: number) {
5  return new Promise<void>((resolve) => {
6    setTimeout(() => resolve(), ms);
7  });
8}
9
10// This is the resolve function which will be executed. The types of the params and return are used later when you query the cache.
11const resolveFnc = async (name: string) => {
12  // Wait 1 seconds to simulate some async work
13  await wait(1000);
14
15  return "Hi " + name;
16};
17
18// Now we create the cache instance
19const cache = createCachedAsyncFnc(resolveFnc);
20
21// Wrap the code into so we can use await
22async function main() {
23  const req1 = await cache.get("Mark");
24  const req2 = await cache.get("Mark");
25
26  // The first request will trigger the resolve function
27  console.log(req1.data, req1.status); // "Hi Mark", "MISS"
28
29  // The seconds request will reuse the data from cache
30  console.log(req2.data, req2.status); // "Hi Mark", "HIT"
31}
32
33main();

API

createCachedAsyncFnc(resolverFunction, [options]): cacheInstance

This function creates a cache instance for the given function. The parameter and return types will be reused by the cache.

1const resolveFnc = async (name: string) => {
2  return "Hi " + name;
3};
4
5// optional config for the cache
6const config = {
7  debug: true,
8};
9
10// create the cache with the resolver function
11const cache = createCachedAsyncFnc(resolveFnc, config);

config

• debug: boolean => Send log messages to console.log

cache.get([...args]): Promise

Now you can query your configured resolverFunction with full type checks for the parameters.

1const resolveFnc = async (name: string, age: number) => {
2  return `${name} is ${age} years old`;
3};
4
5// create the cache with the resolver function
6const cache = createCachedAsyncFnc(resolveFnc);
7
8const response = await cache.get("Mark", 25);

Response

• status: string => The status tells you if the response were cached or not
• • "HIT" the request was already cached
• • "MISS" the request was not cached and must be resolved with your resolverFunction
• data: any => This is data your resolverFunction returns
• ms: number => Time in miliseconds of the request

TODO's

• Create a browser version
• Create a Deno version