@jsnw/nestjs-ioredis 2.0.0 → 2.1.0

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": "2.0.0",
+  "version": "2.1.0",
   "description": "NestJS module for integrating Redis",
-  "main": "./dist/lib/index.js",
-  "types": "./dist/types/index.d.ts",
   "exports": {
-    ".": {
-      "require": "./dist/lib/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/lib/index.js

@@ -1,9 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.RedisLock = exports.RedisLockFactory = 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_lock_factory_1 = require("./redis-lock.factory");
-Object.defineProperty(exports, "RedisLockFactory", { enumerable: true, get: function () { return redis_lock_factory_1.RedisLockFactory; } });
-var redis_lock_1 = require("./redis-lock");
-Object.defineProperty(exports, "RedisLock", { enumerable: true, get: function () { return redis_lock_1.RedisLock; } });

package/dist/lib/redis-core.module.js

@@ -1,70 +0,0 @@
-"use strict";
-var __decorate = (this && this.__decorate) || function (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;
-};
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-var RedisCoreModule_1;
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.RedisCoreModule = void 0;
-const common_1 = require("@nestjs/common");
-const ioredis_1 = __importDefault(require("ioredis"));
-const redis_consts_1 = require("./redis.consts");
-const redis_helpers_1 = require("./redis.helpers");
-const redis_lock_factory_1 = require("./redis-lock.factory");
-let RedisCoreModule = RedisCoreModule_1 = class RedisCoreModule {
-    /**
-     * @param {RedisRegisterOptions} options
-     * @return {DynamicModule}
-     */
-    static register(options) {
-        const optionsProvider = this.createOptionsProvider(options), redisProvider = this.createRedisProvider();
-        return {
-            module: RedisCoreModule_1,
-            providers: [
-                optionsProvider,
-                redisProvider,
-                redis_lock_factory_1.RedisLockFactory
-            ],
-            exports: [
-                redisProvider,
-                redis_lock_factory_1.RedisLockFactory
-            ]
-        };
-    }
-    /**
-     * @param {RedisRegisterOptions} options
-     * @return {ValueProvider}
-     * @private
-     */
-    static createOptionsProvider(options) {
-        return {
-            provide: redis_consts_1.REDIS_OPTIONS_TOKEN,
-            useValue: {
-                ...options,
-                keyPrefix: (0, redis_helpers_1.resolveKeyPrefix)(options.keyPrefix),
-                locksHashKey: options.locksHashKey ?? redis_consts_1.REDIS_DEFAULT_LOCKS_HASH_KEY
-            }
-        };
-    }
-    /**
-     * @return {FactoryProvider}
-     * @private
-     */
-    static createRedisProvider() {
-        return {
-            provide: ioredis_1.default,
-            useFactory: (options) => new ioredis_1.default(options),
-            inject: [redis_consts_1.REDIS_OPTIONS_TOKEN]
-        };
-    }
-};
-exports.RedisCoreModule = RedisCoreModule;
-exports.RedisCoreModule = RedisCoreModule = RedisCoreModule_1 = __decorate([
-    (0, common_1.Global)(),
-    (0, common_1.Module)({})
-], RedisCoreModule);

package/dist/lib/redis-lock.factory.js

@@ -1,47 +0,0 @@
-"use strict";
-var __decorate = (this && this.__decorate) || function (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;
-};
-var __metadata = (this && this.__metadata) || function (k, v) {
-    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
-};
-var __param = (this && this.__param) || function (paramIndex, decorator) {
-    return function (target, key) { decorator(target, key, paramIndex); }
-};
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.RedisLockFactory = void 0;
-const common_1 = require("@nestjs/common");
-const ioredis_1 = __importDefault(require("ioredis"));
-const redis_consts_1 = require("./redis.consts");
-const redis_lock_1 = require("./redis-lock");
-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 redis_lock_1.RedisLock(this.redis, name, this.options.locksHashKey);
-    }
-};
-exports.RedisLockFactory = RedisLockFactory;
-exports.RedisLockFactory = RedisLockFactory = __decorate([
-    (0, common_1.Injectable)(),
-    __param(0, (0, common_1.Inject)(redis_consts_1.REDIS_OPTIONS_TOKEN)),
-    __metadata("design:paramtypes", [Object, ioredis_1.default])
-], RedisLockFactory);

package/dist/lib/redis-lock.js

@@ -1,94 +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_helpers_1 = require("./redis.helpers");
-class RedisLock {
-    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_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/lib/redis.consts.js

@@ -1,6 +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_OPTIONS_TOKEN = void 0;
-exports.REDIS_OPTIONS_TOKEN = Symbol('REDIS_OPTIONS');
-exports.REDIS_DEFAULT_LOCKS_HASH_KEY = '__locks__';
-exports.REDIS_DEFAULT_LOCK_ACQUIRE_RETRY_DELAY_MS = 500;

package/dist/lib/redis.helpers.js

@@ -1,44 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.getRetryInterval = exports.resolveKeyPrefix = void 0;
-const redis_consts_1 = require("./redis.consts");
-/**
- * @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/lib/redis.module.js

@@ -1,30 +0,0 @@
-"use strict";
-var __decorate = (this && this.__decorate) || function (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;
-};
-var RedisModule_1;
-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 = RedisModule_1 = class RedisModule {
-    /**
-     * @param {RedisRegisterOptions} options
-     * @return {DynamicModule}
-     */
-    static register(options) {
-        return {
-            module: RedisModule_1,
-            imports: [
-                redis_core_module_1.RedisCoreModule.register(options)
-            ]
-        };
-    }
-};
-exports.RedisModule = RedisModule;
-exports.RedisModule = RedisModule = RedisModule_1 = __decorate([
-    (0, common_1.Module)({})
-], RedisModule);

package/dist/lib/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 { RedisRegisterOptions } from './redis.types';
-export { RedisLockFactory } from './redis-lock.factory';
-export { RedisLock, type RedisLockWaitAcquireParams } from './redis-lock';

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

@@ -1,20 +0,0 @@
-import { type DynamicModule } from '@nestjs/common';
-import type { RedisRegisterOptions } from './redis.types';
-export declare class RedisCoreModule {
-    /**
-     * @param {RedisRegisterOptions} options
-     * @return {DynamicModule}
-     */
-    static register(options: RedisRegisterOptions): DynamicModule;
-    /**
-     * @param {RedisRegisterOptions} options
-     * @return {ValueProvider}
-     * @private
-     */
-    private static createOptionsProvider;
-    /**
-     * @return {FactoryProvider}
-     * @private
-     */
-    private static createRedisProvider;
-}

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

@@ -1,39 +0,0 @@
-import 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
-     * @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>;
-}

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

@@ -1,17 +0,0 @@
-import Redis from 'ioredis';
-import type { RedisRegisterOptions } from './redis.types';
-import { RedisLock } from './redis-lock';
-export 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;
-}

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

@@ -1,3 +0,0 @@
-export declare const REDIS_OPTIONS_TOKEN: unique symbol;
-export declare const REDIS_DEFAULT_LOCKS_HASH_KEY = "__locks__";
-export declare const REDIS_DEFAULT_LOCK_ACQUIRE_RETRY_DELAY_MS = 500;

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

@@ -1,12 +0,0 @@
-import { type RedisLockWaitAcquireParams } from './redis-lock';
-/**
- * @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 { RedisRegisterOptions } from './redis.types';
-export declare class RedisModule {
-    /**
-     * @param {RedisRegisterOptions} options
-     * @return {DynamicModule}
-     */
-    static register(options: RedisRegisterOptions): DynamicModule;
-}

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

@@ -1,5 +0,0 @@
-import { type RedisOptions } from 'ioredis';
-export type RedisRegisterOptions = RedisOptions & {
-    keyPrefix?: string;
-    locksHashKey?: string;
-};