@jsnw/nestjs-ioredis 1.3.0 → 2.1.0

package/README.md

@@ -1,26 +1,15 @@
 # @jsnw/nestjs-ioredis
 
-NestJS module for integrating Redis using [ioredis](https://www.npmjs.com/package/ioredis) with support for multiple connections and dependency injection.
-
-## Features
-
-- 🚀 Easy integration with NestJS applications
-- 🔌 Support for multiple named Redis connections
-- 💉 Dependency injection with `@InjectRedis()` decorator
-- 🔄 Automatic connection lifecycle management
-- 🏷️ Key prefix support with automatic formatting
-- 🛡️ TypeScript support with full type definitions
+NestJS module for integrating Redis using [ioredis](https://www.npmjs.com/package/ioredis)
 
 ## Installation
 
 ```bash
-npm i -s @jsnw/nestjs-ioredis ioredis
+npm i -s @jsnw/nestjs-ioredis ioredis @nestjs/common@11
 ```
 
 ## Quick Start
 
-### Basic Usage
-
 Import `RedisModule` in your app module and configure it with `forRoot()`:
 
 ```typescript
@@ -33,171 +22,13 @@ import { RedisModule } from '@jsnw/nestjs-ioredis';
       hostname: 'localhost',
       port: 6379,
       username: 'default',
-      password: 'your-password',
-      isDefault: true,
+      password: 'your-password'
     }),
   ],
 })
 export class AppModule {}
 ```
 
-### Inject Redis in Services
-
-Use the `@InjectRedis()` decorator to inject Redis instances into your services:
-
-```typescript
-import { Injectable } from '@nestjs/common';
-import { InjectRedis } from '@jsnw/nestjs-ioredis';
-import type { Redis } from 'ioredis';
-
-@Injectable()
-export class UserService {
-  constructor(
-    @InjectRedis() private readonly redis: Redis,
-  ) {}
-
-  async cacheUser(userId: string, userData: any): Promise<void> {
-    await this.redis.set(`user:${userId}`, JSON.stringify(userData));
-  }
-
-  async getUser(userId: string): Promise<any> {
-    const data = await this.redis.get(`user:${userId}`);
-    return data ? JSON.parse(data) : null;
-  }
-}
-```
-
-## Configuration
-
-### RedisForRootParams
-
-| Parameter | Type | Required | Default | Description |
-|-----------|------|----------|---------|-------------|
-| `hostname` | `string` | Yes | - | Redis server hostname |
-| `port` | `number` | Yes | - | Redis server port |
-| `username` | `string` | Yes | - | Redis username |
-| `password` | `string` | Yes | - | Redis password |
-| `connectionName` | `string` | No | Auto-generated | Unique name for the connection |
-| `db` | `number` | No | `0` | Redis database index |
-| `keyPrefix` | `string` | No | `''` | Prefix for all keys (automatically adds ':' separator) |
-| `connectionTimeout` | `number` | No | `10000` | Connection timeout in milliseconds |
-| `lazy` | `boolean` | No | `false` | Enable lazy connection (connect on first command) |
-| `isDefault` | `boolean` | No | `false` | Mark this connection as the default |
-
-## Advanced Usage
-
-### Multiple Named Connections
-
-You can configure multiple Redis connections with different names:
-
-```typescript
-import { Module } from '@nestjs/common';
-import { RedisModule } from '@jsnw/nestjs-ioredis';
-
-@Module({
-  imports: [
-    RedisModule.forRoot({
-      connectionName: 'cache',
-      hostname: 'cache.redis.local',
-      port: 6379,
-      username: 'default',
-      password: 'cache-password',
-      isDefault: true, // This is the default connection
-    }),
-    RedisModule.forRoot({
-      connectionName: 'sessions',
-      hostname: 'sessions.redis.local',
-      port: 6379,
-      username: 'default',
-      password: 'sessions-password',
-      db: 1,
-    }),
-  ],
-})
-export class AppModule {}
-```
-
-### Inject Named Connections
-
-```typescript
-import { Injectable } from '@nestjs/common';
-import { InjectRedis } from '@jsnw/nestjs-ioredis';
-import type { Redis } from 'ioredis';
-
-@Injectable()
-export class AppService {
-  constructor(
-    @InjectRedis('cache') private readonly cacheRedis: Redis,
-    @InjectRedis('sessions') private readonly sessionRedis: Redis,
-    @InjectRedis() private readonly defaultRedis: Redis, // Uses default connection
-  ) {}
-
-  async cacheData(key: string, value: string): Promise<void> {
-    await this.cacheRedis.set(key, value);
-  }
-
-  async saveSession(sessionId: string, data: any): Promise<void> {
-    await this.sessionRedis.set(sessionId, JSON.stringify(data), 'EX', 3600);
-  }
-}
-```
-
-### Key Prefix
-
-The `keyPrefix` option automatically adds a prefix to all keys with proper colon formatting:
-
-```typescript
-RedisModule.forRoot({
-  hostname: 'localhost',
-  port: 6379,
-  username: 'default',
-  password: 'password',
-  keyPrefix: 'myapp', // Will become 'myapp:'
-  isDefault: true,
-})
-```
-
-Now when you use Redis commands:
-
-```typescript
-await redis.set('user:123', 'data'); // Actually stored as 'myapp:user:123'
-```
-
-### Lazy Connection
-
-Enable lazy connection to defer the actual Redis connection until the first command:
-
-```typescript
-RedisModule.forRoot({
-  hostname: 'localhost',
-  port: 6379,
-  username: 'default',
-  password: 'password',
-  lazy: true,
-  isDefault: true,
-})
-```
-
-## Automatic Cleanup
-
-The module automatically closes all Redis connections when the NestJS application shuts down. No manual cleanup is required.
-
-## API Reference
-
-### `RedisModule`
-
-#### `forRoot(params: RedisForRootParams): DynamicModule`
-
-Configures the Redis module with the provided connection parameters.
-
-### `@InjectRedis(connectionName?: string)`
-
-Decorator for injecting Redis instances into your services. If no connection name is provided, the default connection will be injected.
-
-### `RedisForRootParams`
-
-TypeScript interface for configuring Redis connections. See [Configuration](#configuration) section for details.
-
 ## License
 
 MIT

package/dist/index.cjs

@@ -0,0 +1,263 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+//#region \0rolldown/runtime.js
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __copyProps = (to, from, except, desc) => {
+	if (from && typeof from === "object" || typeof from === "function") for (var keys = __getOwnPropNames(from), i = 0, n = keys.length, key; i < n; i++) {
+		key = keys[i];
+		if (!__hasOwnProp.call(to, key) && key !== except) __defProp(to, key, {
+			get: ((k) => from[k]).bind(null, key),
+			enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
+		});
+	}
+	return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", {
+	value: mod,
+	enumerable: true
+}) : target, mod));
+//#endregion
+let _nestjs_common = require("@nestjs/common");
+let ioredis = require("ioredis");
+ioredis = __toESM(ioredis);
+let node_crypto = require("node:crypto");
+let node_timers_promises = require("node:timers/promises");
+let dedent = require("dedent");
+dedent = __toESM(dedent);
+//#region src/redis.consts.ts
+const REDIS_OPTIONS_TOKEN = Symbol("REDIS_OPTIONS");
+//#endregion
+//#region src/redis.helpers.ts
+/**
+* @param {string} prefix
+* @return {string}
+*/
+const resolveKeyPrefix = (prefix) => {
+	if (!prefix) return "";
+	prefix = prefix.trim();
+	if (prefix.endsWith(":")) {
+		if (prefix.length === 1) return "";
+		return prefix;
+	}
+	return prefix + ":";
+};
+/**
+* @param {number} iteration
+* @param {RedisLockWaitAcquireParams["retryInterval"]} [retryInterval]
+* @return {number}
+*/
+const getRetryInterval = (iteration, retryInterval) => {
+	if (retryInterval === void 0) return 500;
+	if (typeof retryInterval === "number") return Math.max(1, retryInterval);
+	if (Array.isArray(retryInterval)) {
+		if (retryInterval.length === 0) return 500;
+		if (retryInterval.length === 1) return retryInterval[0];
+		return iteration < retryInterval.length ? retryInterval[iteration] : retryInterval[retryInterval.length - 1];
+	}
+	if (typeof retryInterval === "function") return Math.max(1, retryInterval(iteration) ?? 500);
+	return 500;
+};
+//#endregion
+//#region src/redis-lock.ts
+var RedisLock = class {
+	redis;
+	locksHashKey;
+	name;
+	value;
+	acquireLockPromise = null;
+	/**
+	* @param {Redis} redis
+	* @param {string} name
+	* @param {string} locksHashKey
+	* @protected
+	*/
+	constructor(redis, name, locksHashKey) {
+		this.redis = redis;
+		this.name = name;
+		this.locksHashKey = locksHashKey;
+		this.value = (0, node_crypto.randomUUID)();
+	}
+	/**
+	* @param {RedisLockWaitAcquireParams} params
+	* @return {Promise<boolean>}
+	*/
+	async waitAcquire(params) {
+		const startedAt = Date.now();
+		let iteration = 0;
+		while (true) {
+			const acquired = await this.acquire(params.lockTTL), RETRY_DELAY_MS = getRetryInterval(iteration, params.retryInterval);
+			if (acquired) return true;
+			if (params.signal?.aborted) return false;
+			let delayMs = RETRY_DELAY_MS;
+			if (params.waitTimeout !== void 0) {
+				const elapsed = Date.now() - startedAt, timeLeft = params.waitTimeout - elapsed;
+				if (timeLeft <= 0) return false;
+				delayMs = Math.max(1, Math.min(RETRY_DELAY_MS, timeLeft));
+			}
+			try {
+				await (0, node_timers_promises.setTimeout)(delayMs, void 0, { signal: params.signal });
+			} catch (e) {
+				if (e instanceof Error && e.name === "AbortError") return false;
+				throw e;
+			}
+		}
+	}
+	/**
+	* @param {number} ttlMs
+	* @return {Promise<boolean>}
+	*/
+	acquire(ttlMs) {
+		if (this.acquireLockPromise) return this.acquireLockPromise;
+		this.acquireLockPromise = new Promise((resolve, reject) => {
+			this.redis.call("HSETEX", this.locksHashKey, "FNX", "PX", ttlMs, "FIELDS", 1, this.name, this.value).then((res) => {
+				if (res === 1) return resolve(true);
+				return resolve(false);
+			}).catch(reject);
+		});
+		this.acquireLockPromise.finally(() => {
+			this.acquireLockPromise = null;
+		});
+		return this.acquireLockPromise;
+	}
+	/**
+	* @return {Promise<void>}
+	*/
+	async release() {
+		await this.redis.eval(dedent.default`
+        if redis.call("hget", KEYS[1], ARGV[1]) == ARGV[2]
+        then
+            return redis.call("hdel", KEYS[1], ARGV[1])
+        else
+            return 0
+        end
+        `, 1, this.locksHashKey, this.name, this.value);
+	}
+};
+//#endregion
+//#region \0@oxc-project+runtime@0.137.0/helpers/esm/decorateMetadata.js
+function __decorateMetadata(k, v) {
+	if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+}
+//#endregion
+//#region \0@oxc-project+runtime@0.137.0/helpers/esm/decorateParam.js
+function __decorateParam(paramIndex, decorator) {
+	return function(target, key) {
+		decorator(target, key, paramIndex);
+	};
+}
+//#endregion
+//#region \0@oxc-project+runtime@0.137.0/helpers/esm/decorate.js
+function __decorate(decorators, target, key, desc) {
+	var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+	if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+	else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+	return c > 3 && r && Object.defineProperty(target, key, r), r;
+}
+//#endregion
+//#region src/redis-lock.factory.ts
+let RedisLockFactory = class RedisLockFactory {
+	options;
+	redis;
+	/**
+	* @param {RedisRegisterOptions} options
+	* @param {Redis} redis
+	*/
+	constructor(options, redis) {
+		this.options = options;
+		this.redis = redis;
+	}
+	/**
+	* @param {string} name
+	* @return {RedisLock}
+	*/
+	create(name) {
+		return new RedisLock(this.redis, name, this.options.locksHashKey);
+	}
+};
+RedisLockFactory = __decorate([
+	(0, _nestjs_common.Injectable)(),
+	__decorateParam(0, (0, _nestjs_common.Inject)(REDIS_OPTIONS_TOKEN)),
+	__decorateMetadata("design:paramtypes", [Object, typeof ioredis.default === "undefined" ? Object : ioredis.default])
+], RedisLockFactory);
+//#endregion
+//#region src/redis-core.module.ts
+var _RedisCoreModule;
+let RedisCoreModule = _RedisCoreModule = class RedisCoreModule {
+	/**
+	* @param {RedisRegisterOptions} options
+	* @return {DynamicModule}
+	*/
+	static register(options) {
+		const optionsProvider = this.createOptionsProvider(options), redisProvider = this.createRedisProvider();
+		return {
+			module: _RedisCoreModule,
+			providers: [
+				optionsProvider,
+				redisProvider,
+				RedisLockFactory
+			],
+			exports: [redisProvider, RedisLockFactory]
+		};
+	}
+	/**
+	* @param {RedisRegisterOptions} options
+	* @return {ValueProvider}
+	* @private
+	*/
+	static createOptionsProvider(options) {
+		return {
+			provide: REDIS_OPTIONS_TOKEN,
+			useValue: {
+				...options,
+				keyPrefix: resolveKeyPrefix(options.keyPrefix),
+				locksHashKey: options.locksHashKey ?? "__locks__"
+			}
+		};
+	}
+	/**
+	* @return {FactoryProvider}
+	* @private
+	*/
+	static createRedisProvider() {
+		return {
+			provide: ioredis.default,
+			useFactory: (options) => new ioredis.default(options),
+			inject: [REDIS_OPTIONS_TOKEN]
+		};
+	}
+};
+RedisCoreModule = _RedisCoreModule = __decorate([(0, _nestjs_common.Global)(), (0, _nestjs_common.Module)({})], RedisCoreModule);
+//#endregion
+//#region src/redis.module.ts
+var _RedisModule;
+let RedisModule = _RedisModule = class RedisModule {
+	/**
+	* @param {RedisRegisterOptions} options
+	* @return {DynamicModule}
+	*/
+	static register(options) {
+		return {
+			module: _RedisModule,
+			imports: [RedisCoreModule.register(options)]
+		};
+	}
+};
+RedisModule = _RedisModule = __decorate([(0, _nestjs_common.Module)({})], RedisModule);
+//#endregion
+exports.RedisLock = RedisLock;
+Object.defineProperty(exports, "RedisLockFactory", {
+	enumerable: true,
+	get: function() {
+		return RedisLockFactory;
+	}
+});
+Object.defineProperty(exports, "RedisModule", {
+	enumerable: true,
+	get: function() {
+		return RedisModule;
+	}
+});

package/dist/index.d.cts

@@ -0,0 +1,75 @@
+import { DynamicModule } from "@nestjs/common";
+import Redis, { RedisOptions } from "ioredis";
+
+//#region src/redis.types.d.ts
+type RedisRegisterOptions = RedisOptions & {
+  keyPrefix?: string;
+  locksHashKey?: string;
+};
+//#endregion
+//#region src/redis.module.d.ts
+declare class RedisModule {
+  /**
+   * @param {RedisRegisterOptions} options
+   * @return {DynamicModule}
+   */
+  static register(options: RedisRegisterOptions): DynamicModule;
+}
+//#endregion
+//#region src/redis-lock.d.ts
+type RedisLockWaitAcquireParams = {
+  lockTTL: number;
+  retryInterval?: number | number[] | ((iteration: number) => number);
+} & ({
+  signal: AbortSignal;
+  waitTimeout?: number;
+} | {
+  signal?: AbortSignal;
+  waitTimeout: number;
+});
+declare class RedisLock {
+  private readonly redis;
+  private readonly locksHashKey;
+  readonly name: string;
+  private readonly value;
+  private acquireLockPromise;
+  /**
+   * @param {Redis} redis
+   * @param {string} name
+   * @param {string} locksHashKey
+   * @protected
+   */
+  constructor(redis: Redis, name: string, locksHashKey: string);
+  /**
+   * @param {RedisLockWaitAcquireParams} params
+   * @return {Promise<boolean>}
+   */
+  waitAcquire(params: RedisLockWaitAcquireParams): Promise<boolean>;
+  /**
+   * @param {number} ttlMs
+   * @return {Promise<boolean>}
+   */
+  acquire(ttlMs: number): Promise<boolean>;
+  /**
+   * @return {Promise<void>}
+   */
+  release(): Promise<void>;
+}
+//#endregion
+//#region src/redis-lock.factory.d.ts
+declare class RedisLockFactory {
+  private readonly options;
+  private readonly redis;
+  /**
+   * @param {RedisRegisterOptions} options
+   * @param {Redis} redis
+   */
+  constructor(options: RedisRegisterOptions, redis: Redis);
+  /**
+   * @param {string} name
+   * @return {RedisLock}
+   */
+  create(name: string): RedisLock;
+}
+//#endregion
+export { RedisLock, RedisLockFactory, type RedisLockWaitAcquireParams, RedisModule, type RedisRegisterOptions };

package/package.json

@@ -1,23 +1,13 @@
 {
   "name": "@jsnw/nestjs-ioredis",
-  "version": "1.3.0",
-  "description": "NestJS module for integrating Redis using ioredis with support for multiple connections and dependency injection",
-  "main": "./dist/index.js",
-  "types": "./dist/types/index.d.ts",
+  "version": "2.1.0",
+  "description": "NestJS module for integrating Redis",
   "exports": {
-    ".": {
-      "require": "./dist/index.js",
-      "types": "./dist/types/index.d.ts"
+    "require": {
+      "default": "./dist/index.cjs",
+      "types": "./dist/index.d.cts"
     }
   },
-  "scripts": {
-    "clean": "rimraf ./dist",
-    "build": "npm run clean && tsc -p tsconfig.json",
-    "test": "jest --passWithNoTests",
-    "test:watch": "jest --watch",
-    "test:coverage": "jest --coverage",
-    "prepublishOnly": "npm run build"
-  },
   "files": [
     "./dist",
     "README.md"
@@ -40,19 +30,20 @@
     "email": "jsnow0177@gmail.com"
   },
   "license": "MIT",
+  "dependencies": {
+    "dedent": "^1.7.2"
+  },
   "peerDependencies": {
-    "@nestjs/common": "^11.1.14",
-    "ioredis": "^5.9.3"
+    "@nestjs/common": "^11.1.27",
+    "ioredis": "^5.11.1"
   },
   "devDependencies": {
-    "@nestjs/common": "^11.1.14",
-    "ioredis": "^5.9.3",
-    "jest": "^30.2.0",
-    "rimraf": "^6.1.3",
-    "ts-jest": "^29.4.6",
+    "@nestjs/common": "^11.1.27",
+    "ioredis": "^5.11.1",
+    "tsdown": "^0.22.3",
     "typescript": "^5.9.3"
   },
-  "dependencies": {
-    "dedent": "^1.7.1"
+  "scripts": {
+    "build": "tsdown"
   }
-}
+}

package/dist/index.js

@@ -1,9 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.RedisLock = exports.InjectRedis = exports.RedisModule = void 0;
-var redis_module_1 = require("./redis.module");
-Object.defineProperty(exports, "RedisModule", { enumerable: true, get: function () { return redis_module_1.RedisModule; } });
-var redis_decorators_1 = require("./redis.decorators");
-Object.defineProperty(exports, "InjectRedis", { enumerable: true, get: function () { return redis_decorators_1.InjectRedis; } });
-var redis_lock_1 = require("./redis-lock");
-Object.defineProperty(exports, "RedisLock", { enumerable: true, get: function () { return redis_lock_1.RedisLock; } });

package/dist/redis-core.module.js

@@ -1,115 +0,0 @@
-"use strict";
-var __esDecorate = (this && this.__esDecorate) || function (ctor, descriptorIn, decorators, contextIn, initializers, extraInitializers) {
-    function accept(f) { if (f !== void 0 && typeof f !== "function") throw new TypeError("Function expected"); return f; }
-    var kind = contextIn.kind, key = kind === "getter" ? "get" : kind === "setter" ? "set" : "value";
-    var target = !descriptorIn && ctor ? contextIn["static"] ? ctor : ctor.prototype : null;
-    var descriptor = descriptorIn || (target ? Object.getOwnPropertyDescriptor(target, contextIn.name) : {});
-    var _, done = false;
-    for (var i = decorators.length - 1; i >= 0; i--) {
-        var context = {};
-        for (var p in contextIn) context[p] = p === "access" ? {} : contextIn[p];
-        for (var p in contextIn.access) context.access[p] = contextIn.access[p];
-        context.addInitializer = function (f) { if (done) throw new TypeError("Cannot add initializers after decoration has completed"); extraInitializers.push(accept(f || null)); };
-        var result = (0, decorators[i])(kind === "accessor" ? { get: descriptor.get, set: descriptor.set } : descriptor[key], context);
-        if (kind === "accessor") {
-            if (result === void 0) continue;
-            if (result === null || typeof result !== "object") throw new TypeError("Object expected");
-            if (_ = accept(result.get)) descriptor.get = _;
-            if (_ = accept(result.set)) descriptor.set = _;
-            if (_ = accept(result.init)) initializers.unshift(_);
-        }
-        else if (_ = accept(result)) {
-            if (kind === "field") initializers.unshift(_);
-            else descriptor[key] = _;
-        }
-    }
-    if (target) Object.defineProperty(target, contextIn.name, descriptor);
-    done = true;
-};
-var __runInitializers = (this && this.__runInitializers) || function (thisArg, initializers, value) {
-    var useValue = arguments.length > 2;
-    for (var i = 0; i < initializers.length; i++) {
-        value = useValue ? initializers[i].call(thisArg, value) : initializers[i].call(thisArg);
-    }
-    return useValue ? value : void 0;
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.RedisCoreModule = void 0;
-const common_1 = require("@nestjs/common");
-const ioredis_1 = require("ioredis");
-const redis_instances_manager_1 = require("./redis-instances-manager");
-const redis_consts_1 = require("./redis.consts");
-const redis_helpers_1 = require("./redis.helpers");
-let RedisCoreModule = (() => {
-    let _classDecorators = [(0, common_1.Global)(), (0, common_1.Module)({
-            providers: [
-                redis_instances_manager_1.RedisInstancesManager
-            ]
-        })];
-    let _classDescriptor;
-    let _classExtraInitializers = [];
-    let _classThis;
-    var RedisCoreModule = class {
-        static { _classThis = this; }
-        static {
-            const _metadata = typeof Symbol === "function" && Symbol.metadata ? Object.create(null) : void 0;
-            __esDecorate(null, _classDescriptor = { value: _classThis }, _classDecorators, { kind: "class", name: _classThis.name, metadata: _metadata }, null, _classExtraInitializers);
-            RedisCoreModule = _classThis = _classDescriptor.value;
-            if (_metadata) Object.defineProperty(_classThis, Symbol.metadata, { enumerable: true, configurable: true, writable: true, value: _metadata });
-            __runInitializers(_classThis, _classExtraInitializers);
-        }
-        /**
-         * @param {RedisForRootParams} params
-         * @return {DynamicModule}
-         */
-        static forRoot(params) {
-            const providers = [];
-            const redisProvider = this.createRedisProvider(params);
-            providers.push(redisProvider);
-            if (!!params.isDefault)
-                providers.push({
-                    provide: (0, redis_helpers_1.getRedisToken)(redis_consts_1.REDIS_DEFAULT_CONNECTION_NAME),
-                    useExisting: (0, redis_helpers_1.getRedisToken)(params)
-                });
-            return {
-                module: RedisCoreModule,
-                providers: providers,
-                exports: providers
-            };
-        }
-        /**
-         * @param {RedisForRootParams} params
-         * @return {FactoryProvider}
-         * @private
-         */
-        static createRedisProvider(params) {
-            const redisToken = (0, redis_helpers_1.getRedisToken)(params), keyPrefix = (0, redis_helpers_1.resolveKeyPrefix)(params.keyPrefix);
-            return {
-                provide: redisToken,
-                useFactory: (im) => {
-                    const existingInstance = im.getInstance(redisToken);
-                    if (existingInstance)
-                        return existingInstance;
-                    const instance = new ioredis_1.Redis({
-                        host: params.hostname,
-                        port: params.port,
-                        username: params.username,
-                        password: params.password,
-                        db: params.db ?? 0,
-                        connectTimeout: params.connectionTimeout ?? 10_000,
-                        lazyConnect: !!params.lazy,
-                        keyPrefix: keyPrefix
-                    });
-                    instance[redis_consts_1.REDIS_LOCKS_HASH_KEY_PROP_NAME] = params.locksHashKey;
-                    im.addInstance(redisToken, instance);
-                    return instance;
-                },
-                inject: [
-                    redis_instances_manager_1.RedisInstancesManager
-                ]
-            };
-        }
-    };
-    return RedisCoreModule = _classThis;
-})();
-exports.RedisCoreModule = RedisCoreModule;

package/dist/redis-instances-manager.js

@@ -1,101 +0,0 @@
-"use strict";
-var __esDecorate = (this && this.__esDecorate) || function (ctor, descriptorIn, decorators, contextIn, initializers, extraInitializers) {
-    function accept(f) { if (f !== void 0 && typeof f !== "function") throw new TypeError("Function expected"); return f; }
-    var kind = contextIn.kind, key = kind === "getter" ? "get" : kind === "setter" ? "set" : "value";
-    var target = !descriptorIn && ctor ? contextIn["static"] ? ctor : ctor.prototype : null;
-    var descriptor = descriptorIn || (target ? Object.getOwnPropertyDescriptor(target, contextIn.name) : {});
-    var _, done = false;
-    for (var i = decorators.length - 1; i >= 0; i--) {
-        var context = {};
-        for (var p in contextIn) context[p] = p === "access" ? {} : contextIn[p];
-        for (var p in contextIn.access) context.access[p] = contextIn.access[p];
-        context.addInitializer = function (f) { if (done) throw new TypeError("Cannot add initializers after decoration has completed"); extraInitializers.push(accept(f || null)); };
-        var result = (0, decorators[i])(kind === "accessor" ? { get: descriptor.get, set: descriptor.set } : descriptor[key], context);
-        if (kind === "accessor") {
-            if (result === void 0) continue;
-            if (result === null || typeof result !== "object") throw new TypeError("Object expected");
-            if (_ = accept(result.get)) descriptor.get = _;
-            if (_ = accept(result.set)) descriptor.set = _;
-            if (_ = accept(result.init)) initializers.unshift(_);
-        }
-        else if (_ = accept(result)) {
-            if (kind === "field") initializers.unshift(_);
-            else descriptor[key] = _;
-        }
-    }
-    if (target) Object.defineProperty(target, contextIn.name, descriptor);
-    done = true;
-};
-var __runInitializers = (this && this.__runInitializers) || function (thisArg, initializers, value) {
-    var useValue = arguments.length > 2;
-    for (var i = 0; i < initializers.length; i++) {
-        value = useValue ? initializers[i].call(thisArg, value) : initializers[i].call(thisArg);
-    }
-    return useValue ? value : void 0;
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.RedisInstancesManager = void 0;
-const common_1 = require("@nestjs/common");
-const redis_helpers_1 = require("./redis.helpers");
-let RedisInstancesManager = (() => {
-    let _classDecorators = [(0, common_1.Injectable)()];
-    let _classDescriptor;
-    let _classExtraInitializers = [];
-    let _classThis;
-    var RedisInstancesManager = class {
-        static { _classThis = this; }
-        static {
-            const _metadata = typeof Symbol === "function" && Symbol.metadata ? Object.create(null) : void 0;
-            __esDecorate(null, _classDescriptor = { value: _classThis }, _classDecorators, { kind: "class", name: _classThis.name, metadata: _metadata }, null, _classExtraInitializers);
-            RedisInstancesManager = _classThis = _classDescriptor.value;
-            if (_metadata) Object.defineProperty(_classThis, Symbol.metadata, { enumerable: true, configurable: true, writable: true, value: _metadata });
-            __runInitializers(_classThis, _classExtraInitializers);
-        }
-        /**
-         * @type {Map<string, Redis>}
-         * @private
-         */
-        instances = new Map();
-        /**
-         * @param {string | RedisForRootParams} token
-         * @param {Redis} instance
-         */
-        addInstance(token, instance) {
-            token = typeof token === 'string' ? token : (0, redis_helpers_1.getRedisToken)(token);
-            if (this.instances.has(token))
-                return;
-            this.instances.set(token, instance);
-        }
-        /**
-         * @param {string | RedisForRootParams} token
-         * @return {Redis | null}
-         */
-        getInstance(token) {
-            token = typeof token === 'string' ? token : (0, redis_helpers_1.getRedisToken)(token);
-            return this.instances.get(token) ?? null;
-        }
-        /**
-         * @param {string | RedisForRootParams} token
-         * @return {boolean}
-         */
-        hasInstance(token) {
-            token = typeof token === 'string' ? token : (0, redis_helpers_1.getRedisToken)(token);
-            return this.instances.has(token);
-        }
-        /**
-         * @return {Redis[]}
-         */
-        getAllInstances() {
-            return Array.from(this.instances.values());
-        }
-        /**
-         * @return {Promise<void>}
-         */
-        async onApplicationShutdown() {
-            await Promise.allSettled(this.getAllInstances()
-                .map(instance => instance.quit()));
-        }
-    };
-    return RedisInstancesManager = _classThis;
-})();
-exports.RedisInstancesManager = RedisInstancesManager;

package/dist/redis-lock.js

@@ -1,93 +0,0 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.RedisLock = void 0;
-const node_crypto_1 = require("node:crypto");
-const promises_1 = require("node:timers/promises");
-const dedent_1 = __importDefault(require("dedent"));
-const redis_consts_1 = require("./redis.consts");
-const redis_helpers_1 = require("./redis.helpers");
-class RedisLock {
-    redis;
-    locksHashKey;
-    name;
-    value;
-    acquireLockPromise = null;
-    /**
-     * @param {Redis} redis
-     * @param {string} name
-     */
-    constructor(redis, name) {
-        this.redis = redis;
-        this.name = name;
-        this.locksHashKey = this.redis?.[redis_consts_1.REDIS_LOCKS_HASH_KEY_PROP_NAME] ?? redis_consts_1.REDIS_DEFAULT_LOCKS_HASH_KEY;
-        this.value = (0, node_crypto_1.randomUUID)();
-    }
-    /**
-     * @param {RedisLockWaitAcquireParams} params
-     * @return {Promise<boolean>}
-     */
-    async waitAcquire(params) {
-        const startedAt = Date.now();
-        let iteration = 0;
-        while (true) {
-            const acquired = await this.acquire(params.lockTTL), RETRY_DELAY_MS = (0, redis_helpers_1.getRetryInterval)(iteration, params.retryInterval);
-            if (acquired)
-                return true;
-            if (params.signal?.aborted)
-                return false;
-            let delayMs = RETRY_DELAY_MS;
-            if (params.waitTimeout !== undefined) {
-                const elapsed = Date.now() - startedAt, timeLeft = params.waitTimeout - elapsed;
-                if (timeLeft <= 0)
-                    return false;
-                delayMs = Math.max(1, Math.min(RETRY_DELAY_MS, timeLeft));
-            }
-            try {
-                await (0, promises_1.setTimeout)(delayMs, undefined, { signal: params.signal });
-            }
-            catch (e) {
-                if (e instanceof Error && e.name === 'AbortError')
-                    return false;
-                throw e;
-            }
-        }
-    }
-    /**
-     * @param {number} ttlMs
-     * @return {Promise<boolean>}
-     */
-    acquire(ttlMs) {
-        if (this.acquireLockPromise)
-            return this.acquireLockPromise;
-        this.acquireLockPromise = new Promise((resolve, reject) => {
-            this.redis.call('HSETEX', this.locksHashKey, 'FNX', 'PX', ttlMs, 'FIELDS', 1, this.name, this.value)
-                .then(res => {
-                if (res === 1)
-                    return resolve(true);
-                return resolve(false);
-            })
-                .catch(reject);
-        });
-        this.acquireLockPromise.finally(() => {
-            this.acquireLockPromise = null;
-        });
-        return this.acquireLockPromise;
-    }
-    /**
-     * @return {Promise<void>}
-     */
-    async release() {
-        await this.redis.eval((0, dedent_1.default) `
-        if redis.call("hget", KEYS[1], ARGV[1]) == ARGV[2]
-        then
-            return redis.call("hdel", KEYS[1], ARGV[1])
-        else
-            return 0
-        end
-        `, 1, this.locksHashKey, this.name, this.value);
-    }
-}
-exports.RedisLock = RedisLock;

package/dist/redis.consts.js

@@ -1,8 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.REDIS_DEFAULT_LOCK_ACQUIRE_RETRY_DELAY_MS = exports.REDIS_DEFAULT_LOCKS_HASH_KEY = exports.REDIS_LOCKS_HASH_KEY_PROP_NAME = exports.REDIS_DEFAULT_CONNECTION_NAME = exports.REDIS_INSTANCE_TOKEN_PREFIX = void 0;
-exports.REDIS_INSTANCE_TOKEN_PREFIX = 'REDIS_INSTANCE_';
-exports.REDIS_DEFAULT_CONNECTION_NAME = 'default';
-exports.REDIS_LOCKS_HASH_KEY_PROP_NAME = '__$__locksHashKey__';
-exports.REDIS_DEFAULT_LOCKS_HASH_KEY = '__locks__';
-exports.REDIS_DEFAULT_LOCK_ACQUIRE_RETRY_DELAY_MS = 100;

package/dist/redis.decorators.js

@@ -1,13 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.InjectRedis = void 0;
-const common_1 = require("@nestjs/common");
-const redis_consts_1 = require("./redis.consts");
-const redis_helpers_1 = require("./redis.helpers");
-/**
- * @param {string} [connectionName = REDIS_DEFAULT_CONNECTION_NAME]
- * @return {PropertyDecorator & ParameterDecorator}
- * @constructor
- */
-const InjectRedis = (connectionName = redis_consts_1.REDIS_DEFAULT_CONNECTION_NAME) => (0, common_1.Inject)((0, redis_helpers_1.getRedisToken)(connectionName));
-exports.InjectRedis = InjectRedis;

package/dist/redis.helpers.js

@@ -1,66 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.getRetryInterval = exports.resolveKeyPrefix = void 0;
-exports.resolveConnectionName = resolveConnectionName;
-exports.getRedisToken = getRedisToken;
-const redis_consts_1 = require("./redis.consts");
-/**
- * @param {string | RedisForRootParams} arg
- * @return {string}
- */
-function resolveConnectionName(arg) {
-    if (typeof arg === 'string')
-        return arg.toUpperCase();
-    if (arg.connectionName && arg.connectionName.trim() !== '')
-        return arg.connectionName.trim().toUpperCase();
-    return `${arg.hostname}:${arg.port}/db${arg.db ?? 0}>${arg.keyPrefix ?? ''}`.toUpperCase();
-}
-/**
- * @param {string | RedisForRootParams} arg
- * @return {string}
- */
-function getRedisToken(arg) {
-    if (typeof arg === 'string')
-        return `${redis_consts_1.REDIS_INSTANCE_TOKEN_PREFIX}${arg}`.toUpperCase();
-    return `${redis_consts_1.REDIS_INSTANCE_TOKEN_PREFIX}${resolveConnectionName(arg)}`.toUpperCase();
-}
-/**
- * @param {string} prefix
- * @return {string}
- */
-const resolveKeyPrefix = (prefix) => {
-    if (!prefix)
-        return '';
-    prefix = prefix.trim();
-    if (prefix.endsWith(':')) {
-        if (prefix.length === 1)
-            return '';
-        return prefix;
-    }
-    return prefix + ':';
-};
-exports.resolveKeyPrefix = resolveKeyPrefix;
-/**
- * @param {number} iteration
- * @param {RedisLockWaitAcquireParams["retryInterval"]} [retryInterval]
- * @return {number}
- */
-const getRetryInterval = (iteration, retryInterval) => {
-    if (retryInterval === undefined)
-        return redis_consts_1.REDIS_DEFAULT_LOCK_ACQUIRE_RETRY_DELAY_MS;
-    if (typeof retryInterval === 'number')
-        return Math.max(1, retryInterval);
-    if (Array.isArray(retryInterval)) {
-        if (retryInterval.length === 0)
-            return redis_consts_1.REDIS_DEFAULT_LOCK_ACQUIRE_RETRY_DELAY_MS;
-        if (retryInterval.length === 1)
-            return retryInterval[0];
-        return iteration < retryInterval.length
-            ? retryInterval[iteration]
-            : retryInterval[retryInterval.length - 1];
-    }
-    if (typeof retryInterval === 'function')
-        return Math.max(1, retryInterval(iteration) ?? redis_consts_1.REDIS_DEFAULT_LOCK_ACQUIRE_RETRY_DELAY_MS);
-    return redis_consts_1.REDIS_DEFAULT_LOCK_ACQUIRE_RETRY_DELAY_MS;
-};
-exports.getRetryInterval = getRetryInterval;

package/dist/redis.module.js

@@ -1,69 +0,0 @@
-"use strict";
-var __esDecorate = (this && this.__esDecorate) || function (ctor, descriptorIn, decorators, contextIn, initializers, extraInitializers) {
-    function accept(f) { if (f !== void 0 && typeof f !== "function") throw new TypeError("Function expected"); return f; }
-    var kind = contextIn.kind, key = kind === "getter" ? "get" : kind === "setter" ? "set" : "value";
-    var target = !descriptorIn && ctor ? contextIn["static"] ? ctor : ctor.prototype : null;
-    var descriptor = descriptorIn || (target ? Object.getOwnPropertyDescriptor(target, contextIn.name) : {});
-    var _, done = false;
-    for (var i = decorators.length - 1; i >= 0; i--) {
-        var context = {};
-        for (var p in contextIn) context[p] = p === "access" ? {} : contextIn[p];
-        for (var p in contextIn.access) context.access[p] = contextIn.access[p];
-        context.addInitializer = function (f) { if (done) throw new TypeError("Cannot add initializers after decoration has completed"); extraInitializers.push(accept(f || null)); };
-        var result = (0, decorators[i])(kind === "accessor" ? { get: descriptor.get, set: descriptor.set } : descriptor[key], context);
-        if (kind === "accessor") {
-            if (result === void 0) continue;
-            if (result === null || typeof result !== "object") throw new TypeError("Object expected");
-            if (_ = accept(result.get)) descriptor.get = _;
-            if (_ = accept(result.set)) descriptor.set = _;
-            if (_ = accept(result.init)) initializers.unshift(_);
-        }
-        else if (_ = accept(result)) {
-            if (kind === "field") initializers.unshift(_);
-            else descriptor[key] = _;
-        }
-    }
-    if (target) Object.defineProperty(target, contextIn.name, descriptor);
-    done = true;
-};
-var __runInitializers = (this && this.__runInitializers) || function (thisArg, initializers, value) {
-    var useValue = arguments.length > 2;
-    for (var i = 0; i < initializers.length; i++) {
-        value = useValue ? initializers[i].call(thisArg, value) : initializers[i].call(thisArg);
-    }
-    return useValue ? value : void 0;
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.RedisModule = void 0;
-const common_1 = require("@nestjs/common");
-const redis_core_module_1 = require("./redis-core.module");
-let RedisModule = (() => {
-    let _classDecorators = [(0, common_1.Module)({})];
-    let _classDescriptor;
-    let _classExtraInitializers = [];
-    let _classThis;
-    var RedisModule = class {
-        static { _classThis = this; }
-        static {
-            const _metadata = typeof Symbol === "function" && Symbol.metadata ? Object.create(null) : void 0;
-            __esDecorate(null, _classDescriptor = { value: _classThis }, _classDecorators, { kind: "class", name: _classThis.name, metadata: _metadata }, null, _classExtraInitializers);
-            RedisModule = _classThis = _classDescriptor.value;
-            if (_metadata) Object.defineProperty(_classThis, Symbol.metadata, { enumerable: true, configurable: true, writable: true, value: _metadata });
-            __runInitializers(_classThis, _classExtraInitializers);
-        }
-        /**
-         * @param {RedisForRootParams} params
-         * @return {DynamicModule}
-         */
-        static forRoot(params) {
-            return {
-                module: RedisModule,
-                imports: [
-                    redis_core_module_1.RedisCoreModule.forRoot(params)
-                ]
-            };
-        }
-    };
-    return RedisModule = _classThis;
-})();
-exports.RedisModule = RedisModule;

package/dist/redis.types.js

@@ -1,2 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });

package/dist/types/index.d.ts

@@ -1,4 +0,0 @@
-export { RedisModule } from './redis.module';
-export type { RedisForRootParams } from './redis.types';
-export { InjectRedis } from './redis.decorators';
-export { RedisLock, type RedisLockWaitAcquireParams } from './redis-lock';

package/dist/types/redis-core.module.d.ts

@@ -1,15 +0,0 @@
-import { type DynamicModule } from '@nestjs/common';
-import type { RedisForRootParams } from './redis.types';
-export declare class RedisCoreModule {
-    /**
-     * @param {RedisForRootParams} params
-     * @return {DynamicModule}
-     */
-    static forRoot(params: RedisForRootParams): DynamicModule;
-    /**
-     * @param {RedisForRootParams} params
-     * @return {FactoryProvider}
-     * @private
-     */
-    private static createRedisProvider;
-}

package/dist/types/redis-instances-manager.d.ts

@@ -1,24 +0,0 @@
-import { type OnApplicationShutdown } from '@nestjs/common';
-import { type Redis } from 'ioredis';
-import type { RedisForRootParams } from './redis.types';
-export declare class RedisInstancesManager implements OnApplicationShutdown {
-    /**
-     * @type {Map<string, Redis>}
-     * @private
-     */
-    private readonly instances;
-    addInstance(resolvedToken: string, instance: Redis): void;
-    addInstance(unresolvedToken: RedisForRootParams, instance: Redis): void;
-    getInstance(resolvedToken: string): Redis | null;
-    getInstance(unresolvedToken: RedisForRootParams): Redis | null;
-    hasInstance(resolvedToken: string): boolean;
-    hasInstance(unresolvedToken: RedisForRootParams): boolean;
-    /**
-     * @return {Redis[]}
-     */
-    getAllInstances(): Redis[];
-    /**
-     * @return {Promise<void>}
-     */
-    onApplicationShutdown(): Promise<void>;
-}

package/dist/types/redis-lock.d.ts

@@ -1,37 +0,0 @@
-import { type Redis } from 'ioredis';
-export type RedisLockWaitAcquireParams = {
-    lockTTL: number;
-    retryInterval?: number | number[] | ((iteration: number) => number);
-} & ({
-    signal: AbortSignal;
-    waitTimeout?: number;
-} | {
-    signal?: AbortSignal;
-    waitTimeout: number;
-});
-export declare class RedisLock {
-    private readonly redis;
-    private readonly locksHashKey;
-    readonly name: string;
-    private readonly value;
-    private acquireLockPromise;
-    /**
-     * @param {Redis} redis
-     * @param {string} name
-     */
-    constructor(redis: Redis, name: string);
-    /**
-     * @param {RedisLockWaitAcquireParams} params
-     * @return {Promise<boolean>}
-     */
-    waitAcquire(params: RedisLockWaitAcquireParams): Promise<boolean>;
-    /**
-     * @param {number} ttlMs
-     * @return {Promise<boolean>}
-     */
-    acquire(ttlMs: number): Promise<boolean>;
-    /**
-     * @return {Promise<void>}
-     */
-    release(): Promise<void>;
-}

package/dist/types/redis.consts.d.ts

@@ -1,5 +0,0 @@
-export declare const REDIS_INSTANCE_TOKEN_PREFIX: "REDIS_INSTANCE_";
-export declare const REDIS_DEFAULT_CONNECTION_NAME = "default";
-export declare const REDIS_LOCKS_HASH_KEY_PROP_NAME = "__$__locksHashKey__";
-export declare const REDIS_DEFAULT_LOCKS_HASH_KEY = "__locks__";
-export declare const REDIS_DEFAULT_LOCK_ACQUIRE_RETRY_DELAY_MS = 100;

package/dist/types/redis.decorators.d.ts

@@ -1,6 +0,0 @@
-/**
- * @param {string} [connectionName = REDIS_DEFAULT_CONNECTION_NAME]
- * @return {PropertyDecorator & ParameterDecorator}
- * @constructor
- */
-export declare const InjectRedis: (connectionName?: string) => PropertyDecorator & ParameterDecorator;

package/dist/types/redis.helpers.d.ts

@@ -1,17 +0,0 @@
-import type { RedisForRootParams } from './redis.types';
-import { type RedisLockWaitAcquireParams } from './redis-lock';
-export declare function resolveConnectionName(instanceName: string): string;
-export declare function resolveConnectionName(params: RedisForRootParams): string;
-export declare function getRedisToken(connectionName: string): string;
-export declare function getRedisToken(params: RedisForRootParams): string;
-/**
- * @param {string} prefix
- * @return {string}
- */
-export declare const resolveKeyPrefix: (prefix?: string) => string;
-/**
- * @param {number} iteration
- * @param {RedisLockWaitAcquireParams["retryInterval"]} [retryInterval]
- * @return {number}
- */
-export declare const getRetryInterval: (iteration: number, retryInterval?: RedisLockWaitAcquireParams["retryInterval"]) => number;

package/dist/types/redis.module.d.ts

@@ -1,9 +0,0 @@
-import { type DynamicModule } from '@nestjs/common';
-import type { RedisForRootParams } from './redis.types';
-export declare class RedisModule {
-    /**
-     * @param {RedisForRootParams} params
-     * @return {DynamicModule}
-     */
-    static forRoot(params: RedisForRootParams): DynamicModule;
-}

package/dist/types/redis.types.d.ts

@@ -1,13 +0,0 @@
-export type RedisForRootParams = {
-    connectionName?: string;
-    hostname: string;
-    port: number;
-    username: string;
-    password: string;
-    keyPrefix?: string;
-    db?: number;
-    connectionTimeout?: number;
-    lazy?: boolean;
-    isDefault?: boolean;
-    locksHashKey?: string;
-};