npm package discovery and stats viewer.

Discover Tips

  • General search

    [free text search, go nuts!]

  • Package details

    pkg:[package-name]

  • User packages

    @[username]

Sponsor

Optimize Toolset

I’ve always been into building performant and accessible sites, but lately I’ve been taking it extremely seriously. So much so that I’ve been building a tool to help me optimize and monitor the sites that I build to make sure that I’m making an attempt to offer the best experience to those who visit them. If you’re into performant, accessible and SEO friendly sites, you might like it too! You can check it out at Optimize Toolset.

About

Hi, 👋, I’m Ryan Hefner  and I built this site for me, and you! The goal of this site was to provide an easy way for me to check the stats on my npm packages, both for prioritizing issues and updates, and to give me a little kick in the pants to keep up on stuff.

As I was building it, I realized that I was actually using the tool to build the tool, and figured I might as well put this out there and hopefully others will find it to be a fast and useful way to search and browse npm packages as I have.

If you’re interested in other things I’m working on, follow me on Twitter or check out the open source projects I’ve been publishing on GitHub.

I am also working on a Twitter bot for this site to tweet the most popular, newest, random packages from npm. Please follow that account now and it will start sending out packages soon–ish.

Open Software & Tools

This site wouldn’t be possible without the immense generosity and tireless efforts from the people who make contributions to the world and share their work via open source initiatives. Thank you 🙏

© 2024 – Pkg Stats / Ryan Hefner

@hokify/node-ts-cache

v6.0.1

Published

Simple and extensible caching module supporting decorators

Downloads

971

Readme

npm The MIT License

NPM

@hokify/node-ts-cache

Simple and extensible caching module supporting decorators

Install

npm install --save @ħokify/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)

Standard method to cache an async method.

  • strategy: A supported caching Strategy (Async)
  • 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.

E.g.

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

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

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

@SyncCache(strategy, options) Method to use only sync caches. This allows you to use caching without a promise function.

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

E.g.

import { SyncCache, ExpirationStrategy, MemoryStorage } from "@hokify/node-ts-cache";

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

class MyService {
  @SyncCache(myStrategy, { ttl: 60 })
  public getUsers(): string[] {
    return ["Max", "User"];
  }
}

@MultiCache(strategy, parameterIndex, cacheKey, options) This method uses multi get and multi set of the cache providers if supported and therefore can use different input paramters and still cache each variation.

  • strategies: A list of caching Strategy, which is handled by provided order
  • parameterIndex: The parameter index of the array
  • cacheKey: a custom cache key function for each element of the cache
  • options: Options passed to the strategy for this particular method

E.g.

import { MultiCache } from "@hokify/node-ts-cache";
import NodeCacheStorage from '@hokify/node-ts-cache-node-cache-storage'; 
import RedisIOStorage from '@hokify/node-ts-cache-redisio-storage';

const localStrategy = new NodeCacheStorage();
const centralStrategy = new RedisIOStorage({/*..*/});

class MyService {
  @MultiCache([localStrategy, centralStrategy], 0)
  public getUserNames(userIds: string[]): Promise<string>[] {
    return getUserNamesFromDatabase(userIds); // beware: return same order and number of userIds -> name
        // e.g. 1,2,3 .. shoudl return [userName1, userName2, userName3] (or null for entries that do not exist)
        // if you return undefined (instead of null) for one entry, it is queried the next time again. 
  }
}

const a = new MyService();
/**
* this call checks local cache if it has user id1, 2 or 3..
* all cache misses are then checked by the central cache
* if there are still some missing entries, they are retrieved with the original getUsers method.
*/
const result = await a.getUsers([1,2,3]);

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,
  ISyncKeyStrategy,
  MemoryStorage
} from "@hokify/node-ts-cache";

class MyKeyStrategy implements ISyncKeyStrategy {
  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 "@hokify/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.
  • isCachedForever: (Default: false) If true, cache entry has no expiration.

Storages

| Storage | Needed library | | ---------------- | :--------------------------------------------: | | FsStorage | (bundled) | | MemoryStorage | (bundled) | | RedisStorage | npm install @hokify/node-ts-cache-redis-storage | | RedisIOStorage | npm install @hokify/node-ts-cache-redisio-storage | | NodeCacheStorage | npm install @hokify/node-ts-cache-node-cache-storage | | LRUStorage | npm install node-ts-lru-storage |

MemoryStorage()

in memory

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

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

FsJsonStorage(fileName: string)

file based

import { Cache, ExpirationStrategy, FileStorage } from "@hokify/node-ts-cache";

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

RedisStorage(clientOpts: RedisClientOptions)

redis client backend

import { Cache, ExpirationStrategy } from "@hokify/node-ts-cache";
import RedisStorage from 'node-ts-cache-redis-storage';

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

RedisIOStorage(clientOpts: RedisIOClientOptions)

redis io client backend

import { Cache, ExpirationStrategy } from "@hokify/node-ts-cache";
import RedisIOStorage from 'node-ts-cache-redisio-storage';

const myStrategy = new RedisIOStorage();

NodeCacheStorage(options: NodeCacheOptions)

wrapper for node-cache

import { Cache, ExpirationStrategy } from "@hokify/node-ts-cache";
import NodeCacheStorage from 'node-ts-cache-node-cache-storage';

const myStrategy = new NodeCacheStorage();

LRUStorage(options: LRUCacheOptions)

wrapper for lru-cache

import { Cache, ExpirationStrategy } from "@hokify/node-ts-cache";
import LRUStorage from 'node-ts-cache-lru-storage';

const myStrategy = new LRUStorage();

LRURedisStorage(options: LRUCacheOptions, () => Redis.Redis)

wrapper for lru-cache with a remote cache redis backend

import { Cache, ExpirationStrategy } from "@hokify/node-ts-cache";
import LRUStorage from 'node-ts-cache-lru-redis-storage';

const myStrategy = new LRUStorage({}, () => RedisConnectionInstance);

Test

npm test