@sound-xyz/response-cache

Alternative to @envelop/response-cache with new features:

• Support for Distributed Redis Locks using RedLock (Opt-in), so your resolvers logic only get's executed once with identical queries
• Support for setting the response cache dynamically
• Leverage cached parsed documents for faster TTL calculation based on customs ttlPerSchemaCoordinate.
• Idempotent redis get calls (Multiple concurrent calls to redis re-use the same promise)

Install

1pnpm add @soundxyz/response-cache

1yarn add @soundxyz/response-cache

1npm install @soundxyz/response-cache

Peer dependencies

redlock is optional

1pnpm add ioredis redlock

1yarn add ioredis redlock

1npm install ioredis redlock

Usage

Configuration

Most of the configuration is the same as with @envelop/response-cache

1import Redis from "ioredis";
2import RedLock from "redlock";
3
4export const redis = new Redis();
5export const redLock = new RedLock([redis], {});

1import {
2  createRedisCache,
3  useResponseCache,
4  UseResponseCacheParameter,
5} from "@soundxyz/response-cache";
6import ms from "ms";
7
8import { redis, redLock } from "./redis";
9
10export const responseCache = createRedisCache({
11  // ioredis instance
12  redis,
13  // Don't specify or set to `null` to disable
14  redlock: {
15    // Client created calling the `redlock` package
16    client: redLock,
17    // The default is 5000ms
18    duration: 5000,
19    settings: {
20      // The default is ((duration / retryDelay) * 2)
21      retryCount: (5000 / 250) * 2,
22      // The default is 250ms
23      retryDelay: 250,
24    },
25  },
26});
27
28const cacheConfig: UseResponseCacheParameter = {
29  cache: responseCache,
30  // cache operations for 1 hour by default
31  ttl: ms("1 hour"),
32  ttlPerSchemaCoordinate: {
33    "Query.fooBar": 0,
34  },
35  includeExtensionMetadata: true,
36};
37
38// ...
39
40({
41  plugins: [
42    //...
43    useResponseCache(cacheConfig),
44  ],
45});

Dynamic TTL

We have to add the ResponseCache context type in your custom context:

1import type { ResponseCacheContext } from "@soundxyz/response-cache";
2
3export interface Context extends ResponseCacheContext {
4  // ...
5}

Then you can use it directly on your resolvers:

1// ...
2makeExecutableSchema({
3  typeDefs: `
4  type Query {
5    hello: String!
6  }
7  `,
8  resolvers: {
9    Query: {
10      hello(_root, _args, context: Context) {
11        // Get the current expiry to be used for the cache TTL
12        const expiry = ctx.$responseCache?.getExpiry();
13
14        // You can use any logic
15        if (expiry != null && expiry > 500) {
16          // Set the expiry to any arbitrary value in milliseconds
17          context.$responseCache?.setExpiry({
18            // TTL in ms
19            ttl: 1000,
20          });
21        }
22
23        return "Hello World";
24      },
25    },
26  },
27});