node-ts-cache

Simple and extensible caching module supporting decorators

• node-ts-cache
• Install
• Usage
  • With decorator
  • Directly
• Strategies
  • ExpirationStrategy
• Storages
• Test

Install

npm install --save node-ts-cache

Usage

With decorator

Caches function response using the given options. Works with different strategies and storages. Uses all arguments to build an unique key.

@Cache(strategy, options)

• strategy: A supported caching Strategy
• options: Options passed to the strategy for this particular method

Note: @Cache always converts the method response to a promise because caching might be async.

import { Cache, ExpirationStrategy, MemoryStorage } from "node-ts-cache";

const myStrategy = new ExpirationStrategy(new MemoryStorage());

class MyService {
    
    @Cache(myStrategy, { ttl: 60 })
    public async getUsers(): Promise<string[]> {
        return ["Max", "User"];
    }
}

Cache decorator generates cache key according to class name, class method and args (with JSON.stringify). If you want another key creation logic you can bypass key creation strategy to the Cache decorator.

import { Cache, ExpirationStrategy, MemoryStorage, IKeyStrategy } from "node-ts-cache";

class MyKeyStrategy implements IKeyStrategy {
   public getKey(className: string, methodName: string, args: any[]): Promise<string> | string {
        // Here you can implement your own way of creating cache keys
        return `foo bar baz`;
   }
}

const myStrategy = new ExpirationStrategy(new MemoryStorage());
const myKeyStrategy = new MyKeyStrategy();

class MyService {
    
    @Cache(myStrategy, { ttl: 60 }, myKeyStrategy)
    public async getUsers(): Promise<string[]> {
        return ["Max", "User"];
    }
}

Directly

import { ExpirationStrategy, MemoryStorage } from "node-ts-cache";

const myCache = new ExpirationStrategy(new MemoryStorage());

class MyService {
    
    public async getUsers(): Promise<string[]> {
        const cachedUsers = await myCache.getItem<string[]>("users");
        if (cachedUsers) {
            return cachedUsers;
        }

        const newUsers = ["Max", "User"];
        await myCache.setItem("users", newUsers, {  ttl: 60 });

        return newUsers;
    }
}

Strategies

ExpirationStrategy

Cached items expire after a given amount of time.

• ttl: (Default: 60) Number of seconds to expire the cachte item
• isLazy: (Default: true) If true, expired cache entries will be deleted on touch. If false, entries will be deleted after the given ttl.
• isCachedForver: (Default: false) If true, cache entry has no expiration.

Storages

Note: For specific storages, client libraries must be installed:

| Storage | Needed client library | |--------------|:---------------------:| | RedisStorage | npm install redis |

MemoryStorage()

FsJsonStorage(fileName: string)

RedisStorage(clientOpts: RedisClientOptions)

Test

npm test