@keyv/redis 5.0.0 → 5.1.0

package/README.md

@@ -35,11 +35,14 @@ Redis storage adapter for [Keyv](https://github.com/jaredwray/keyv).
 * [High Memory Usage on Redis Server](#high-memory-usage-on-redis-server)
 * [Gracefully Handling Errors and Timeouts](#gracefully-handling-errors-and-timeouts)
 * [Using Cacheable with Redis](#using-cacheable-with-redis)
-* [Clustering and TLS Support](#clustering-and-tls-support)
+* [Clustering](#clustering)
+* [Sentinel](#sentinel)
+* [TLS Support](#tls-support)
 * [API](#api)
 * [Using Custom Redis Client Events](#using-custom-redis-client-events)
 * [Migrating from v3 to v4](#migrating-from-v3-to-v4)
 * [About Redis Sets and its Support in v4](#about-redis-sets-and-its-support-in-v4)
+* [Using with NestJS](#using-with-nestjs)
 * [License](#license)
 
 # Installation
@@ -379,9 +382,9 @@ const cache = new Cacheable( { secondary, nonBlocking: true } );
 
 This will make it so that the secondary does not block the primary cache and will be very fast. 🚀
 
-# Clustering and TLS Support
+# Clustering
 
-If you are using a Redis Cluster or need to use TLS, you can pass in the `redisOptions` directly. Here is an example of how to do that:
+If you are using a Redis Cluster, you can pass in the `redisOptions` directly. Here is an example of how to do that:
 
 ```js
 import Keyv from 'keyv';
@@ -404,9 +407,42 @@ const cluster = createCluster({
 const keyv = new Keyv({ store: new KeyvRedis(cluster) });
 ```
 
-You can learn more about the `createCluster` function in the [documentation](https://github.com/redis/node-redis/blob/master/docs/clustering.md) at https://github.com/redis/node-redis/tree/master/docs. 
+You can learn more about the `createCluster` function in the [documentation](https://github.com/redis/node-redis/blob/master/docs/clustering.md) at https://github.com/redis/node-redis/tree/master/docs.
 
-Here is an example of how to use TLS:
+# Sentinel
+
+If you are using Sentinel to provide high availability for your Redis instances, you can pass in the `redisOptions` directly. Here is an example of how to do that:
+
+```js
+import Keyv from 'keyv';
+import KeyvRedis, { createSentinel } from '@keyv/redis';
+
+const sentinel = createSentinel({
+    name: 'sentinel-db',
+    sentinelRootNodes: [
+      {
+        host: '127.0.0.1',
+        port: 26379,
+      },
+      {
+        host: '127.0.0.1',
+        port: 26380,
+      },
+      {
+        host: '127.0.0.1',
+        port: 26381,
+      },
+    ],
+});
+
+const keyv = new Keyv({ store: new KeyvRedis(sentinel) });
+```
+
+You can learn more about the `createSentinel` function in the [documentation](https://github.com/redis/node-redis/blob/master/docs/sentinel.md) at https://github.com/redis/node-redis/tree/master/docs.
+
+# TLS Support
+
+Here is an example of how to use TLS using the `redisOptions`:
 
 ```js
 import Keyv from 'keyv';
@@ -500,6 +536,165 @@ This will make it so the storage adapter `@keyv/redis` will handle the namespace
 
 We no longer support redis sets. This is due to the fact that it caused significant performance issues and was not a good fit for the library.
 
+
+
+# Using with NestJS
+
+> You can integrate `@keyv/redis` with NestJS by creating a custom `CacheModule`. This allows you to use Keyv as a cache store in your application.
+
+### 1. Install Dependencies
+
+```bash
+npm install @keyv/redis keyv @nestjs/cache-manager cache-manager cacheable
+```
+
+### 2. Create a Cache Module
+
+Create a file `cache.module.ts`:
+
+```ts
+import { Module } from '@nestjs/common';
+import { CacheModule as NestCacheModule } from '@nestjs/cache-manager';
+import { createKeyv } from '@keyv/redis';
+
+@Module({
+  imports: [
+    NestCacheModule.registerAsync({
+      useFactory: () => ({
+        stores: [createKeyv('redis://localhost:6379')],
+      }),
+    }),
+  ],
+  providers: [],
+  exports: [],
+})
+export class CacheModule {}
+```
+
+### 3. Import the Cache Module in AppModule
+Update `app.module.ts`:
+
+```ts
+import { Module } from '@nestjs/common';
+import { CacheModule } from './modules/config/cache/cache.module';
+
+@Module({
+  imports: [
+    CacheModule, // Import your custom cache module
+    // other modules...
+  ],
+})
+export class AppModule {}
+```
+
+### 4. Create the Cache Service
+Create a file `cache.service.ts`:
+
+```ts
+import { CACHE_MANAGER } from '@nestjs/cache-manager';
+import { Inject, Injectable } from '@nestjs/common';
+import { Cache } from 'cache-manager';
+
+@Injectable()
+export class CacheService {
+  constructor(@Inject(CACHE_MANAGER) private cacheManager: Cache) {}
+
+  async get<T>(key: string): Promise<T | undefined> {
+    return this.cacheManager.get<T>(key);
+  }
+
+  async set<T>(key: string, value: T, ttl?: number): Promise<void> {
+    await this.cacheManager.set(key, value, ttl);
+  }
+
+  async delete(key: string): Promise<void> {
+    await this.cacheManager.del(key);
+  }
+}
+```
+
+### 5. Register CacheService in CacheModule
+Update `cache.module.ts`:
+
+```ts
+import { Module } from '@nestjs/common';
+import { CacheModule as NestCacheModule } from '@nestjs/cache-manager';
+import { createKeyv } from '@keyv/redis';
+import { CacheService } from './services/cache.service';
+
+@Module({
+  imports: [
+    NestCacheModule.registerAsync({
+      useFactory: () => ({
+        stores: [createKeyv('redis://localhost:6379')],
+      }),
+    }),
+  ],
+  providers: [CacheService],
+  exports: [CacheService],
+})
+export class CacheModule {}
+```
+### 6. Import CacheModule in the Target Module (e.g. TaskModule)
+```ts
+import { Module } from '@nestjs/common';
+import { TaskService } from './task.service';
+import { TaskRepository } from './repositories/task.repository';
+import { CacheModule } from 'src/modules/config/cache/cache.module';
+
+@Module({
+  imports: [CacheModule],
+  providers: [TaskService, TaskRepository],
+})
+export class TaskModule {}
+```
+
+### 7. Using the Cache in a Service
+
+```ts
+import { Injectable, NotFoundException } from '@nestjs/common';
+import { TaskRepository } from '../repositories/task.repository';
+import { TaskDto } from '../dto/task.dto';
+import { CacheService } from 'src/modules/config/cache/services/cache.service';
+
+@Injectable()
+export class TaskService {
+  constructor(
+    private readonly taskRepository: TaskRepository,
+    private readonly cache: CacheService, // Inject the CacheService
+  ) {}
+
+  async findById(id: number): Promise<TaskDto> {
+    const cacheKey = `task:${id}`;
+
+    // 1. Try to get from cache
+    const cached = await this.cache.get<TaskDto>(cacheKey);
+    
+	if (cached) {
+      return cached;
+    }
+
+    // 2. If not found in cache, fetch from database
+    const task = await this.taskRepository.findById(id);
+
+    if (!task) {
+      throw new NotFoundException('Task not found');
+    }
+
+    // 3. Set in cache for future requests
+    await this.cache.set(cacheKey, task, 300 * 1000); // 5 minutes TTL
+    return task;
+  }
+}
+```
+
+
+You can learn more about caching in NestJS in the [official documentation](https://docs.nestjs.com/techniques/caching#in-memory-cache).
+
+
+---
+
+
 # License
 
 [MIT © Jared Wray](LISCENCE)

package/dist/index.cjs

@@ -36,6 +36,7 @@ __export(index_exports, {
   createCluster: () => import_client2.createCluster,
   createKeyv: () => createKeyv,
   createKeyvNonBlocking: () => createKeyvNonBlocking,
+  createSentinel: () => import_client2.createSentinel,
   default: () => KeyvRedis,
   defaultReconnectStrategy: () => defaultReconnectStrategy
 });
@@ -80,9 +81,21 @@ var KeyvRedis = class extends import_hookified.Hookified {
       if (typeof connect === "string") {
         this._client = (0, import_client.createClient)({ url: connect, socket });
       } else if (connect.connect !== void 0) {
-        this._client = this.isClientCluster(connect) ? connect : connect;
+        if (this.isClientSentinel(connect)) {
+          this._client = connect;
+        } else if (this.isClientCluster(connect)) {
+          this._client = connect;
+        } else {
+          this._client = connect;
+        }
       } else if (connect instanceof Object) {
-        this._client = connect.rootNodes === void 0 ? (0, import_client.createClient)(connect) : (0, import_client.createCluster)(connect);
+        if (connect.sentinelRootNodes !== void 0) {
+          this._client = (0, import_client.createSentinel)(connect);
+        } else if (connect.rootNodes === void 0) {
+          this._client = (0, import_client.createClient)(connect);
+        } else {
+          this._client = (0, import_client.createCluster)(connect);
+        }
       }
     }
     this.setOptions(options);
@@ -506,6 +519,13 @@ var KeyvRedis = class extends import_hookified.Hookified {
   isCluster() {
     return this.isClientCluster(this._client);
   }
+  /**
+   * Is the client a sentinel.
+   * @returns {boolean} - true if the client is a sentinel, false if not
+   */
+  isSentinel() {
+    return this.isClientSentinel(this._client);
+  }
   /**
    * Get the master nodes in the cluster. If not a cluster, it will return the single client.
    *
@@ -648,6 +668,9 @@ var KeyvRedis = class extends import_hookified.Hookified {
   isClientCluster(client) {
     return client.slots !== void 0;
   }
+  isClientSentinel(client) {
+    return client.getSentinelNode !== void 0;
+  }
   setOptions(options) {
     if (!options) {
       return;
@@ -747,5 +770,6 @@ function createKeyvNonBlocking(connect, options) {
   createCluster,
   createKeyv,
   createKeyvNonBlocking,
+  createSentinel,
   defaultReconnectStrategy
 });

package/dist/index.d.cts

@@ -1,5 +1,5 @@
-import { RedisClientOptions, RedisClusterOptions, RedisClientType, RedisModules, RedisFunctions, RedisScripts, RespVersions, TypeMapping, RedisClusterType } from '@redis/client';
-export { RedisClientOptions, RedisClientType, RedisClusterOptions, RedisClusterType, createClient, createCluster } from '@redis/client';
+import { RedisClientOptions, RedisClusterOptions, RedisSentinelOptions, RedisClientType, RedisModules, RedisFunctions, RedisScripts, RespVersions, TypeMapping, RedisClusterType, RedisSentinelType } from '@redis/client';
+export { RedisClientOptions, RedisClientType, RedisClusterOptions, RedisClusterType, RedisSentinelType, createClient, createCluster, createSentinel } from '@redis/client';
 import { Hookified } from 'hookified';
 import { KeyvStoreAdapter, KeyvEntry, Keyv } from 'keyv';
 export { Keyv } from 'keyv';
@@ -80,7 +80,8 @@ declare enum RedisErrorMessages {
 declare const defaultReconnectStrategy: (attempts: number) => number | Error;
 type RedisConnectionClientType = RedisClientType | RedisClientType<RedisModules, RedisFunctions, RedisScripts, RespVersions> | RedisClientType<RedisModules, RedisFunctions, RedisScripts, RespVersions, TypeMapping>;
 type RedisConnectionClusterType = RedisClusterType | RedisClusterType<RedisModules, RedisFunctions, RedisScripts, RespVersions> | RedisClusterType<RedisModules, RedisFunctions, RedisScripts, RespVersions, TypeMapping>;
-type RedisClientConnectionType = RedisConnectionClientType | RedisConnectionClusterType;
+type RedisConnectionSentinelType = RedisSentinelType | RedisSentinelType<RedisModules, RedisFunctions, RedisScripts, RespVersions> | RedisSentinelType<RedisModules, RedisFunctions, RedisScripts, RespVersions, TypeMapping>;
+type RedisClientConnectionType = RedisConnectionClientType | RedisConnectionClusterType | RedisConnectionSentinelType;
 declare class KeyvRedis<T> extends Hookified implements KeyvStoreAdapter {
     private _client;
     private _namespace;
@@ -96,7 +97,7 @@ declare class KeyvRedis<T> extends Hookified implements KeyvStoreAdapter {
      * @param {string | RedisClientOptions | RedisClientType} [connect] How to connect to the Redis server. If string pass in the url, if object pass in the options, if RedisClient pass in the client.
      * @param {KeyvRedisOptions} [options] Options for the adapter such as namespace, keyPrefixSeparator, and clearBatchSize.
      */
-    constructor(connect?: string | RedisClientOptions | RedisClusterOptions | RedisClientConnectionType, options?: KeyvRedisOptions);
+    constructor(connect?: string | RedisClientOptions | RedisClusterOptions | RedisSentinelOptions | RedisClientConnectionType, options?: KeyvRedisOptions);
     /**
      * Get the Redis client.
      */
@@ -278,6 +279,11 @@ declare class KeyvRedis<T> extends Hookified implements KeyvStoreAdapter {
      * @returns {boolean} - true if the client is a cluster, false if not
      */
     isCluster(): boolean;
+    /**
+     * Is the client a sentinel.
+     * @returns {boolean} - true if the client is a sentinel, false if not
+     */
+    isSentinel(): boolean;
     /**
      * Get the master nodes in the cluster. If not a cluster, it will return the single client.
      *
@@ -320,6 +326,7 @@ declare class KeyvRedis<T> extends Hookified implements KeyvStoreAdapter {
      */
     private getSlotMap;
     private isClientCluster;
+    private isClientSentinel;
     private setOptions;
     private initClient;
     private createTimeoutPromise;
@@ -333,4 +340,4 @@ declare class KeyvRedis<T> extends Hookified implements KeyvStoreAdapter {
 declare function createKeyv(connect?: string | RedisClientOptions | RedisClientType, options?: KeyvRedisOptions): Keyv;
 declare function createKeyvNonBlocking(connect?: string | RedisClientOptions | RedisClientType, options?: KeyvRedisOptions): Keyv;
 
-export { type KeyvRedisEntry, type KeyvRedisOptions, type KeyvRedisPropertyOptions, type RedisClientConnectionType, type RedisConnectionClientType, type RedisConnectionClusterType, RedisErrorMessages, createKeyv, createKeyvNonBlocking, KeyvRedis as default, defaultReconnectStrategy };
+export { type KeyvRedisEntry, type KeyvRedisOptions, type KeyvRedisPropertyOptions, type RedisClientConnectionType, type RedisConnectionClientType, type RedisConnectionClusterType, type RedisConnectionSentinelType, RedisErrorMessages, createKeyv, createKeyvNonBlocking, KeyvRedis as default, defaultReconnectStrategy };

package/dist/index.d.ts

@@ -1,5 +1,5 @@
-import { RedisClientOptions, RedisClusterOptions, RedisClientType, RedisModules, RedisFunctions, RedisScripts, RespVersions, TypeMapping, RedisClusterType } from '@redis/client';
-export { RedisClientOptions, RedisClientType, RedisClusterOptions, RedisClusterType, createClient, createCluster } from '@redis/client';
+import { RedisClientOptions, RedisClusterOptions, RedisSentinelOptions, RedisClientType, RedisModules, RedisFunctions, RedisScripts, RespVersions, TypeMapping, RedisClusterType, RedisSentinelType } from '@redis/client';
+export { RedisClientOptions, RedisClientType, RedisClusterOptions, RedisClusterType, RedisSentinelType, createClient, createCluster, createSentinel } from '@redis/client';
 import { Hookified } from 'hookified';
 import { KeyvStoreAdapter, KeyvEntry, Keyv } from 'keyv';
 export { Keyv } from 'keyv';
@@ -80,7 +80,8 @@ declare enum RedisErrorMessages {
 declare const defaultReconnectStrategy: (attempts: number) => number | Error;
 type RedisConnectionClientType = RedisClientType | RedisClientType<RedisModules, RedisFunctions, RedisScripts, RespVersions> | RedisClientType<RedisModules, RedisFunctions, RedisScripts, RespVersions, TypeMapping>;
 type RedisConnectionClusterType = RedisClusterType | RedisClusterType<RedisModules, RedisFunctions, RedisScripts, RespVersions> | RedisClusterType<RedisModules, RedisFunctions, RedisScripts, RespVersions, TypeMapping>;
-type RedisClientConnectionType = RedisConnectionClientType | RedisConnectionClusterType;
+type RedisConnectionSentinelType = RedisSentinelType | RedisSentinelType<RedisModules, RedisFunctions, RedisScripts, RespVersions> | RedisSentinelType<RedisModules, RedisFunctions, RedisScripts, RespVersions, TypeMapping>;
+type RedisClientConnectionType = RedisConnectionClientType | RedisConnectionClusterType | RedisConnectionSentinelType;
 declare class KeyvRedis<T> extends Hookified implements KeyvStoreAdapter {
     private _client;
     private _namespace;
@@ -96,7 +97,7 @@ declare class KeyvRedis<T> extends Hookified implements KeyvStoreAdapter {
      * @param {string | RedisClientOptions | RedisClientType} [connect] How to connect to the Redis server. If string pass in the url, if object pass in the options, if RedisClient pass in the client.
      * @param {KeyvRedisOptions} [options] Options for the adapter such as namespace, keyPrefixSeparator, and clearBatchSize.
      */
-    constructor(connect?: string | RedisClientOptions | RedisClusterOptions | RedisClientConnectionType, options?: KeyvRedisOptions);
+    constructor(connect?: string | RedisClientOptions | RedisClusterOptions | RedisSentinelOptions | RedisClientConnectionType, options?: KeyvRedisOptions);
     /**
      * Get the Redis client.
      */
@@ -278,6 +279,11 @@ declare class KeyvRedis<T> extends Hookified implements KeyvStoreAdapter {
      * @returns {boolean} - true if the client is a cluster, false if not
      */
     isCluster(): boolean;
+    /**
+     * Is the client a sentinel.
+     * @returns {boolean} - true if the client is a sentinel, false if not
+     */
+    isSentinel(): boolean;
     /**
      * Get the master nodes in the cluster. If not a cluster, it will return the single client.
      *
@@ -320,6 +326,7 @@ declare class KeyvRedis<T> extends Hookified implements KeyvStoreAdapter {
      */
     private getSlotMap;
     private isClientCluster;
+    private isClientSentinel;
     private setOptions;
     private initClient;
     private createTimeoutPromise;
@@ -333,4 +340,4 @@ declare class KeyvRedis<T> extends Hookified implements KeyvStoreAdapter {
 declare function createKeyv(connect?: string | RedisClientOptions | RedisClientType, options?: KeyvRedisOptions): Keyv;
 declare function createKeyvNonBlocking(connect?: string | RedisClientOptions | RedisClientType, options?: KeyvRedisOptions): Keyv;
 
-export { type KeyvRedisEntry, type KeyvRedisOptions, type KeyvRedisPropertyOptions, type RedisClientConnectionType, type RedisConnectionClientType, type RedisConnectionClusterType, RedisErrorMessages, createKeyv, createKeyvNonBlocking, KeyvRedis as default, defaultReconnectStrategy };
+export { type KeyvRedisEntry, type KeyvRedisOptions, type KeyvRedisPropertyOptions, type RedisClientConnectionType, type RedisConnectionClientType, type RedisConnectionClusterType, type RedisConnectionSentinelType, RedisErrorMessages, createKeyv, createKeyvNonBlocking, KeyvRedis as default, defaultReconnectStrategy };

package/dist/index.js

@@ -1,14 +1,16 @@
 // src/index.ts
 import {
   createClient,
-  createCluster
+  createCluster,
+  createSentinel
 } from "@redis/client";
 import { Hookified } from "hookified";
 import { Keyv } from "keyv";
 import calculateSlot from "cluster-key-slot";
 import {
   createClient as createClient2,
-  createCluster as createCluster2
+  createCluster as createCluster2,
+  createSentinel as createSentinel2
 } from "@redis/client";
 import {
   Keyv as Keyv2
@@ -47,9 +49,21 @@ var KeyvRedis = class extends Hookified {
       if (typeof connect === "string") {
         this._client = createClient({ url: connect, socket });
       } else if (connect.connect !== void 0) {
-        this._client = this.isClientCluster(connect) ? connect : connect;
+        if (this.isClientSentinel(connect)) {
+          this._client = connect;
+        } else if (this.isClientCluster(connect)) {
+          this._client = connect;
+        } else {
+          this._client = connect;
+        }
       } else if (connect instanceof Object) {
-        this._client = connect.rootNodes === void 0 ? createClient(connect) : createCluster(connect);
+        if (connect.sentinelRootNodes !== void 0) {
+          this._client = createSentinel(connect);
+        } else if (connect.rootNodes === void 0) {
+          this._client = createClient(connect);
+        } else {
+          this._client = createCluster(connect);
+        }
       }
     }
     this.setOptions(options);
@@ -473,6 +487,13 @@ var KeyvRedis = class extends Hookified {
   isCluster() {
     return this.isClientCluster(this._client);
   }
+  /**
+   * Is the client a sentinel.
+   * @returns {boolean} - true if the client is a sentinel, false if not
+   */
+  isSentinel() {
+    return this.isClientSentinel(this._client);
+  }
   /**
    * Get the master nodes in the cluster. If not a cluster, it will return the single client.
    *
@@ -615,6 +636,9 @@ var KeyvRedis = class extends Hookified {
   isClientCluster(client) {
     return client.slots !== void 0;
   }
+  isClientSentinel(client) {
+    return client.getSentinelNode !== void 0;
+  }
   setOptions(options) {
     if (!options) {
       return;
@@ -713,6 +737,7 @@ export {
   createCluster2 as createCluster,
   createKeyv,
   createKeyvNonBlocking,
+  createSentinel2 as createSentinel,
   KeyvRedis as default,
   defaultReconnectStrategy
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@keyv/redis",
-  "version": "5.0.0",
+  "version": "5.1.0",
   "description": "Redis storage adapter for Keyv",
   "type": "module",
   "main": "dist/index.cjs",
@@ -34,12 +34,12 @@
   },
   "homepage": "https://github.com/jaredwray/keyv",
   "dependencies": {
-    "@redis/client": "^5.6.0",
+    "@redis/client": "^5.7.0",
     "cluster-key-slot": "^1.1.2",
-    "hookified": "^1.10.0"
+    "hookified": "^1.11.0"
   },
   "peerDependencies": {
-    "keyv": "^5.4.0"
+    "keyv": "^5.5.0"
   },
   "devDependencies": {
     "@faker-js/faker": "^9.9.0",
@@ -48,8 +48,8 @@
     "timekeeper": "^2.3.1",
     "tsd": "^0.32.0",
     "vitest": "^3.2.4",
-    "xo": "^1.1.1",
-    "@keyv/test-suite": "^2.0.9"
+    "xo": "^1.2.1",
+    "@keyv/test-suite": "^2.1.0"
   },
   "tsd": {
     "directory": "test"