@xnestjs/ioredis 1.2.0 → 1.2.2

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2022 Panates
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/cjs/index.js

@@ -0,0 +1,8 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const tslib_1 = require("tslib");
+tslib_1.__exportStar(require("./redis.interface.js"), exports);
+tslib_1.__exportStar(require("./redis.module.js"), exports);
+tslib_1.__exportStar(require("./redis-client.js"), exports);
+tslib_1.__exportStar(require("./shared-lock.js"), exports);
+tslib_1.__exportStar(require("./types.js"), exports);

package/cjs/package.json

@@ -0,0 +1,3 @@
+{
+  "type": "commonjs"
+}

package/cjs/redis-client.js

@@ -0,0 +1,59 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RedisClient = void 0;
+const redis_semaphore_1 = require("redis-semaphore");
+const shared_lock_js_1 = require("./shared-lock.js");
+class RedisClient {
+    constructor(options) {
+        this.locks = new Map();
+        this.cluster = options.cluster;
+        this.standalone = options.standalone;
+        if (!(this.cluster || this.standalone))
+            throw new TypeError('One of "cluster" or "standalone" must be set');
+    }
+    get isCluster() {
+        return !!this.cluster;
+    }
+    get redis() {
+        return (this.cluster || this.standalone);
+    }
+    quit() {
+        return this.redis.quit();
+    }
+    _getLock(kind, key) {
+        const lock = this.locks.get(key);
+        if (lock) {
+            if (lock.refCount > 0) {
+                if (lock._kind !== kind)
+                    throw new Error(`Lock "${key}" is already in use by a different kind of lock (${lock._kind})`);
+                return lock;
+            }
+            this.locks.delete(key);
+        }
+    }
+    obtainMutex(key, options) {
+        let lock = this._getLock('mutex', key);
+        if (lock)
+            return lock;
+        lock = (0, shared_lock_js_1.sharedLock)(new redis_semaphore_1.Mutex(this.redis, key, options));
+        this.locks.set(key, lock);
+        return lock;
+    }
+    obtainSemaphore(key, limit, options) {
+        let lock = this._getLock('semaphore', key);
+        if (lock)
+            return lock;
+        lock = (0, shared_lock_js_1.sharedLock)(new redis_semaphore_1.Semaphore(this.redis, key, limit, options));
+        this.locks.set(key, lock);
+        return lock;
+    }
+    obtainMultiSemaphore(key, limit, options) {
+        let lock = this._getLock('multi-semaphore', key);
+        if (lock)
+            return lock;
+        lock = (0, shared_lock_js_1.sharedLock)(new redis_semaphore_1.Semaphore(this.redis, key, limit, options));
+        this.locks.set(key, lock);
+        return lock;
+    }
+}
+exports.RedisClient = RedisClient;

package/cjs/redis-core.module.js

@@ -0,0 +1,125 @@
+"use strict";
+var RedisCoreModule_1;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RedisCoreModule = void 0;
+const tslib_1 = require("tslib");
+const common_1 = require("@nestjs/common");
+const core_1 = require("@nestjs/core");
+const crypto = tslib_1.__importStar(require("crypto"));
+const ioredis_1 = tslib_1.__importStar(require("ioredis"));
+const redis_constants_js_1 = require("./redis.constants.js");
+const redis_client_js_1 = require("./redis-client.js");
+const utils_js_1 = require("./utils.js");
+let RedisCoreModule = RedisCoreModule_1 = class RedisCoreModule {
+    constructor(options, moduleRef) {
+        this.options = options;
+        this.moduleRef = moduleRef;
+    }
+    static forRoot(options) {
+        const optionsProvider = {
+            provide: redis_constants_js_1.IOREDIS_MODULE_OPTIONS,
+            useValue: options,
+        };
+        const token = options.token || redis_client_js_1.RedisClient;
+        const connectionProvider = {
+            provide: token,
+            useFactory: () => this._createClient(options),
+        };
+        return {
+            module: RedisCoreModule_1,
+            providers: [connectionProvider, optionsProvider],
+            exports: [connectionProvider],
+        };
+    }
+    static forRootAsync(asyncOptions) {
+        if (!asyncOptions.useFactory)
+            throw new Error('Invalid configuration. Must provide "useFactory"');
+        const token = asyncOptions.token || redis_client_js_1.RedisClient;
+        const connectionProvider = {
+            provide: token,
+            inject: [redis_constants_js_1.IOREDIS_MODULE_OPTIONS],
+            useFactory: async (moduleOptions) => this._createClient(moduleOptions),
+        };
+        return {
+            module: RedisCoreModule_1,
+            imports: asyncOptions.imports,
+            providers: [
+                {
+                    provide: redis_constants_js_1.IOREDIS_MODULE_OPTIONS,
+                    useFactory: asyncOptions.useFactory,
+                    inject: asyncOptions.inject || [],
+                },
+                {
+                    provide: redis_constants_js_1.IOREDIS_MODULE_TOKEN,
+                    useValue: crypto.randomUUID(),
+                },
+                connectionProvider,
+            ],
+            exports: [connectionProvider],
+        };
+    }
+    static async _createClient(options) {
+        if (options.host && options.nodes) {
+            throw new TypeError(`You should set either "host" or "nodes", not both`);
+        }
+        const opts = { ...options };
+        const isCluster = (0, utils_js_1.isClusterOptions)(opts);
+        let client;
+        if (isCluster) {
+            delete opts.name;
+            delete opts.nodes;
+            const cluster = new ioredis_1.Cluster(opts.nodes, opts);
+            client = new redis_client_js_1.RedisClient({ cluster });
+        }
+        else {
+            if (options.host && options.host.includes('://')) {
+                const url = new URL(options.host);
+                options.host = url.hostname;
+                if (url.port)
+                    options.port = parseInt(url.port, 10);
+                if (url.username)
+                    options.username = url.username;
+                if (url.password)
+                    options.password = url.password;
+                if (url.protocol === 'rediss:') {
+                    // @ts-ignore
+                    options.tls = true;
+                }
+                const db = parseInt(url.pathname.substring(1), 10);
+                if (db > 0)
+                    options.db = db;
+            }
+            const standalone = new ioredis_1.default(options);
+            client = new redis_client_js_1.RedisClient({ standalone });
+        }
+        if (!options.lazyConnect) {
+            await new Promise((resolve, reject) => {
+                client.redis.once('ready', () => {
+                    client.redis.removeListener('error', reject);
+                    resolve();
+                });
+                client.redis.once('error', e => {
+                    client.redis.removeListener('ready', resolve);
+                    reject(e);
+                });
+            });
+        }
+        return client;
+    }
+    async onApplicationShutdown() {
+        try {
+            const client = this.moduleRef.get(this.options.token || redis_client_js_1.RedisClient);
+            await client.quit();
+        }
+        catch {
+            //
+        }
+    }
+};
+exports.RedisCoreModule = RedisCoreModule;
+exports.RedisCoreModule = RedisCoreModule = RedisCoreModule_1 = tslib_1.__decorate([
+    (0, common_1.Global)(),
+    (0, common_1.Module)({}),
+    tslib_1.__param(0, (0, common_1.Inject)(redis_constants_js_1.IOREDIS_MODULE_OPTIONS)),
+    tslib_1.__metadata("design:paramtypes", [Object, core_1.ModuleRef])
+], RedisCoreModule);

package/cjs/redis.constants.js

@@ -0,0 +1,5 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.IOREDIS_MODULE_TOKEN = exports.IOREDIS_MODULE_OPTIONS = void 0;
+exports.IOREDIS_MODULE_OPTIONS = Symbol('IOREDIS_MODULE_OPTIONS');
+exports.IOREDIS_MODULE_TOKEN = Symbol('IOREDIS_MODULE_ID');

package/cjs/redis.interface.js

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

package/cjs/redis.module.js

@@ -0,0 +1,25 @@
+"use strict";
+var RedisModule_1;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RedisModule = void 0;
+const tslib_1 = require("tslib");
+const common_1 = require("@nestjs/common");
+const redis_core_module_js_1 = require("./redis-core.module.js");
+let RedisModule = RedisModule_1 = class RedisModule {
+    static forRoot(options) {
+        return {
+            module: RedisModule_1,
+            imports: [redis_core_module_js_1.RedisCoreModule.forRoot(options)],
+        };
+    }
+    static forRootAsync(options) {
+        return {
+            module: RedisModule_1,
+            imports: [redis_core_module_js_1.RedisCoreModule.forRootAsync(options)],
+        };
+    }
+};
+exports.RedisModule = RedisModule;
+exports.RedisModule = RedisModule = RedisModule_1 = tslib_1.__decorate([
+    (0, common_1.Module)({})
+], RedisModule);

package/cjs/shared-lock.js

@@ -0,0 +1,72 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.sharedLock = sharedLock;
+function sharedLock(lock) {
+    let _this;
+    const _sharedLock = (_this = {
+        get refCount() {
+            return _this._refCount;
+        },
+        async acquire(callback) {
+            if (callback) {
+                await this.acquire();
+                try {
+                    return await callback();
+                }
+                finally {
+                    await this.release();
+                }
+            }
+            if (_this._refCount <= 0) {
+                _this._refCount = 1;
+                await lock.acquire();
+                return;
+            }
+            _this._refCount++;
+        },
+        async tryAcquire(callback) {
+            if (callback) {
+                if (!(await this.tryAcquire()))
+                    return false;
+                try {
+                    return await callback();
+                }
+                finally {
+                    await this.release();
+                }
+            }
+            if (_this._refCount <= 0) {
+                _this._refCount = 1;
+                if (await lock.tryAcquire())
+                    return true;
+                _this._refCount = -1;
+                return false;
+            }
+            _this._refCount++;
+            return true;
+        },
+        async release(force) {
+            if (_this._refCount <= 0)
+                return;
+            if (force || _this._refCount === 1) {
+                try {
+                    _this._refCount = -1;
+                    await lock.release();
+                    return;
+                }
+                catch {
+                    // do nothing
+                }
+            }
+            _this._refCount--;
+        },
+    });
+    Object.setPrototypeOf(_sharedLock, lock);
+    Object.defineProperty(_sharedLock, '_refCount', {
+        value: 0,
+        writable: true,
+        enumerable: false,
+        configurable: false,
+    });
+    return lock;
+}

package/cjs/types.js

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

package/cjs/utils.js

@@ -0,0 +1,6 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isClusterOptions = isClusterOptions;
+function isClusterOptions(options) {
+    return options && typeof options === 'object' && Array.isArray(options.nodes);
+}

package/esm/index.js

@@ -0,0 +1,5 @@
+export * from './redis.interface.js';
+export * from './redis.module.js';
+export * from './redis-client.js';
+export * from './shared-lock.js';
+export * from './types.js';

package/esm/package.json

@@ -0,0 +1,3 @@
+{
+  "type": "module"
+}

package/esm/redis-client.js

@@ -0,0 +1,55 @@
+import { Mutex, Semaphore } from 'redis-semaphore';
+import { sharedLock } from './shared-lock.js';
+export class RedisClient {
+    constructor(options) {
+        this.locks = new Map();
+        this.cluster = options.cluster;
+        this.standalone = options.standalone;
+        if (!(this.cluster || this.standalone))
+            throw new TypeError('One of "cluster" or "standalone" must be set');
+    }
+    get isCluster() {
+        return !!this.cluster;
+    }
+    get redis() {
+        return (this.cluster || this.standalone);
+    }
+    quit() {
+        return this.redis.quit();
+    }
+    _getLock(kind, key) {
+        const lock = this.locks.get(key);
+        if (lock) {
+            if (lock.refCount > 0) {
+                if (lock._kind !== kind)
+                    throw new Error(`Lock "${key}" is already in use by a different kind of lock (${lock._kind})`);
+                return lock;
+            }
+            this.locks.delete(key);
+        }
+    }
+    obtainMutex(key, options) {
+        let lock = this._getLock('mutex', key);
+        if (lock)
+            return lock;
+        lock = sharedLock(new Mutex(this.redis, key, options));
+        this.locks.set(key, lock);
+        return lock;
+    }
+    obtainSemaphore(key, limit, options) {
+        let lock = this._getLock('semaphore', key);
+        if (lock)
+            return lock;
+        lock = sharedLock(new Semaphore(this.redis, key, limit, options));
+        this.locks.set(key, lock);
+        return lock;
+    }
+    obtainMultiSemaphore(key, limit, options) {
+        let lock = this._getLock('multi-semaphore', key);
+        if (lock)
+            return lock;
+        lock = sharedLock(new Semaphore(this.redis, key, limit, options));
+        this.locks.set(key, lock);
+        return lock;
+    }
+}

package/esm/redis-core.module.js

@@ -0,0 +1,122 @@
+var RedisCoreModule_1;
+import { __decorate, __metadata, __param } from "tslib";
+import { Global, Inject, Module } from '@nestjs/common';
+import { ModuleRef } from '@nestjs/core';
+import * as crypto from 'crypto';
+import Redis, { Cluster } from 'ioredis';
+import { IOREDIS_MODULE_OPTIONS, IOREDIS_MODULE_TOKEN } from './redis.constants.js';
+import { RedisClient } from './redis-client.js';
+import { isClusterOptions } from './utils.js';
+let RedisCoreModule = RedisCoreModule_1 = class RedisCoreModule {
+    constructor(options, moduleRef) {
+        this.options = options;
+        this.moduleRef = moduleRef;
+    }
+    static forRoot(options) {
+        const optionsProvider = {
+            provide: IOREDIS_MODULE_OPTIONS,
+            useValue: options,
+        };
+        const token = options.token || RedisClient;
+        const connectionProvider = {
+            provide: token,
+            useFactory: () => this._createClient(options),
+        };
+        return {
+            module: RedisCoreModule_1,
+            providers: [connectionProvider, optionsProvider],
+            exports: [connectionProvider],
+        };
+    }
+    static forRootAsync(asyncOptions) {
+        if (!asyncOptions.useFactory)
+            throw new Error('Invalid configuration. Must provide "useFactory"');
+        const token = asyncOptions.token || RedisClient;
+        const connectionProvider = {
+            provide: token,
+            inject: [IOREDIS_MODULE_OPTIONS],
+            useFactory: async (moduleOptions) => this._createClient(moduleOptions),
+        };
+        return {
+            module: RedisCoreModule_1,
+            imports: asyncOptions.imports,
+            providers: [
+                {
+                    provide: IOREDIS_MODULE_OPTIONS,
+                    useFactory: asyncOptions.useFactory,
+                    inject: asyncOptions.inject || [],
+                },
+                {
+                    provide: IOREDIS_MODULE_TOKEN,
+                    useValue: crypto.randomUUID(),
+                },
+                connectionProvider,
+            ],
+            exports: [connectionProvider],
+        };
+    }
+    static async _createClient(options) {
+        if (options.host && options.nodes) {
+            throw new TypeError(`You should set either "host" or "nodes", not both`);
+        }
+        const opts = { ...options };
+        const isCluster = isClusterOptions(opts);
+        let client;
+        if (isCluster) {
+            delete opts.name;
+            delete opts.nodes;
+            const cluster = new Cluster(opts.nodes, opts);
+            client = new RedisClient({ cluster });
+        }
+        else {
+            if (options.host && options.host.includes('://')) {
+                const url = new URL(options.host);
+                options.host = url.hostname;
+                if (url.port)
+                    options.port = parseInt(url.port, 10);
+                if (url.username)
+                    options.username = url.username;
+                if (url.password)
+                    options.password = url.password;
+                if (url.protocol === 'rediss:') {
+                    // @ts-ignore
+                    options.tls = true;
+                }
+                const db = parseInt(url.pathname.substring(1), 10);
+                if (db > 0)
+                    options.db = db;
+            }
+            const standalone = new Redis(options);
+            client = new RedisClient({ standalone });
+        }
+        if (!options.lazyConnect) {
+            await new Promise((resolve, reject) => {
+                client.redis.once('ready', () => {
+                    client.redis.removeListener('error', reject);
+                    resolve();
+                });
+                client.redis.once('error', e => {
+                    client.redis.removeListener('ready', resolve);
+                    reject(e);
+                });
+            });
+        }
+        return client;
+    }
+    async onApplicationShutdown() {
+        try {
+            const client = this.moduleRef.get(this.options.token || RedisClient);
+            await client.quit();
+        }
+        catch {
+            //
+        }
+    }
+};
+RedisCoreModule = RedisCoreModule_1 = __decorate([
+    Global(),
+    Module({}),
+    __param(0, Inject(IOREDIS_MODULE_OPTIONS)),
+    __metadata("design:paramtypes", [Object, ModuleRef])
+], RedisCoreModule);
+export { RedisCoreModule };

package/esm/redis.constants.js

@@ -0,0 +1,2 @@
+export const IOREDIS_MODULE_OPTIONS = Symbol('IOREDIS_MODULE_OPTIONS');
+export const IOREDIS_MODULE_TOKEN = Symbol('IOREDIS_MODULE_ID');

package/esm/redis.interface.js

@@ -0,0 +1 @@
+export {};

package/esm/redis.module.js

@@ -0,0 +1,22 @@
+var RedisModule_1;
+import { __decorate } from "tslib";
+import { Module } from '@nestjs/common';
+import { RedisCoreModule } from './redis-core.module.js';
+let RedisModule = RedisModule_1 = class RedisModule {
+    static forRoot(options) {
+        return {
+            module: RedisModule_1,
+            imports: [RedisCoreModule.forRoot(options)],
+        };
+    }
+    static forRootAsync(options) {
+        return {
+            module: RedisModule_1,
+            imports: [RedisCoreModule.forRootAsync(options)],
+        };
+    }
+};
+RedisModule = RedisModule_1 = __decorate([
+    Module({})
+], RedisModule);
+export { RedisModule };

package/esm/shared-lock.js

@@ -0,0 +1,69 @@
+export function sharedLock(lock) {
+    let _this;
+    const _sharedLock = (_this = {
+        get refCount() {
+            return _this._refCount;
+        },
+        async acquire(callback) {
+            if (callback) {
+                await this.acquire();
+                try {
+                    return await callback();
+                }
+                finally {
+                    await this.release();
+                }
+            }
+            if (_this._refCount <= 0) {
+                _this._refCount = 1;
+                await lock.acquire();
+                return;
+            }
+            _this._refCount++;
+        },
+        async tryAcquire(callback) {
+            if (callback) {
+                if (!(await this.tryAcquire()))
+                    return false;
+                try {
+                    return await callback();
+                }
+                finally {
+                    await this.release();
+                }
+            }
+            if (_this._refCount <= 0) {
+                _this._refCount = 1;
+                if (await lock.tryAcquire())
+                    return true;
+                _this._refCount = -1;
+                return false;
+            }
+            _this._refCount++;
+            return true;
+        },
+        async release(force) {
+            if (_this._refCount <= 0)
+                return;
+            if (force || _this._refCount === 1) {
+                try {
+                    _this._refCount = -1;
+                    await lock.release();
+                    return;
+                }
+                catch {
+                    // do nothing
+                }
+            }
+            _this._refCount--;
+        },
+    });
+    Object.setPrototypeOf(_sharedLock, lock);
+    Object.defineProperty(_sharedLock, '_refCount', {
+        value: 0,
+        writable: true,
+        enumerable: false,
+        configurable: false,
+    });
+    return lock;
+}

package/esm/types.js

@@ -0,0 +1 @@
+export {};

package/esm/utils.js

@@ -0,0 +1,3 @@
+export function isClusterOptions(options) {
+    return options && typeof options === 'object' && Array.isArray(options.nodes);
+}

package/package.json

@@ -1,26 +1,11 @@
 {
   "name": "@xnestjs/ioredis",
-  "version": "1.2.0",
+  "version": "1.2.2",
   "description": "NestJS extension library for ioredis",
   "author": "Panates",
   "license": "MIT",
-  "scripts": {
-    "compile": "tsc --noEmit",
-    "prebuild": "npm run lint && npm run clean",
-    "build": "npm run build:cjs && npm run build:esm",
-    "build:cjs": "tsc -b tsconfig-build-cjs.json && cp ../../support/package.cjs.json ./build/cjs/package.json",
-    "build:esm": "tsc -b tsconfig-build-esm.json && cp ../../support/package.esm.json ./build/esm/package.json",
-    "postbuild": "cp README.md ../../LICENSE ./build && node ../../support/postbuild.cjs",
-    "lint": "eslint . --max-warnings=0",
-    "lint:fix": "eslint . --max-warnings=0 --fix",
-    "format": "prettier . --write --log-level=warn",
-    "check": "madge --circular src/**",
-    "test": "jest",
-    "cover": "jest --collect-coverage",
-    "clean": "npm run clean:src && npm run clean:build && npm run clean:cover",
-    "clean:src": "ts-cleanup -s src --all && ts-cleanup -s test --all",
-    "clean:build": "rimraf build",
-    "clean:cover": "rimraf coverage"
+  "dependencies": {
+    "tslib": "^2.8.1"
   },
   "peerDependencies": {
     "@nestjs/common": "^10.0.0 || ^11.0.0",
@@ -28,9 +13,6 @@
     "ioredis": "^5.0.0",
     "redis-semaphore": "^5.0.0"
   },
-  "devDependencies": {
-    "@nestjs/testing": "^11.0.2"
-  },
   "type": "module",
   "exports": {
     ".": {

package/types/index.d.cts

@@ -0,0 +1,5 @@
+export * from './redis.interface.js';
+export * from './redis.module.js';
+export * from './redis-client.js';
+export * from './shared-lock.js';
+export * from './types.js';

package/types/index.d.ts

@@ -0,0 +1,5 @@
+export * from './redis.interface.js';
+export * from './redis.module.js';
+export * from './redis-client.js';
+export * from './shared-lock.js';
+export * from './types.js';

package/types/redis-client.d.ts

@@ -0,0 +1,22 @@
+import type { Cluster as IORedisCluster, Redis as IORedisClient } from 'ioredis';
+import { type LockOptions } from 'redis-semaphore';
+import type { SharedLock } from './types.js';
+export declare namespace RedisClient {
+    interface Options {
+        cluster?: IORedisCluster;
+        standalone?: IORedisClient;
+    }
+}
+export declare class RedisClient {
+    private locks;
+    cluster?: IORedisCluster;
+    standalone?: IORedisClient;
+    constructor(options: RedisClient.Options);
+    get isCluster(): boolean;
+    get redis(): IORedisCluster | IORedisClient;
+    quit(): Promise<"OK">;
+    protected _getLock(kind: string, key: string): SharedLock | undefined;
+    obtainMutex(key: string, options?: LockOptions): SharedLock;
+    obtainSemaphore(key: string, limit: number, options?: LockOptions): SharedLock;
+    obtainMultiSemaphore(key: string, limit: number, options?: LockOptions): SharedLock;
+}

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

@@ -0,0 +1,12 @@
+import { DynamicModule, OnApplicationShutdown } from '@nestjs/common';
+import { ModuleRef } from '@nestjs/core';
+import { RedisClientAsyncOptions, RedisClientOptions, RedisClusterAsyncOptions, RedisClusterOptions } from './redis.interface.js';
+export declare class RedisCoreModule implements OnApplicationShutdown {
+    private readonly options;
+    private readonly moduleRef;
+    constructor(options: RedisClientOptions | RedisClusterOptions, moduleRef: ModuleRef);
+    static forRoot(options: RedisClientOptions | RedisClusterOptions): DynamicModule;
+    static forRootAsync(asyncOptions: RedisClientAsyncOptions | RedisClusterAsyncOptions): DynamicModule;
+    private static _createClient;
+    onApplicationShutdown(): Promise<void>;
+}

package/types/redis.constants.d.ts

@@ -0,0 +1,2 @@
+export declare const IOREDIS_MODULE_OPTIONS: unique symbol;
+export declare const IOREDIS_MODULE_TOKEN: unique symbol;

package/types/redis.interface.d.ts

@@ -0,0 +1,47 @@
+import type { ModuleMetadata } from '@nestjs/common/interfaces';
+import type { RedisOptions } from 'ioredis';
+import type { ClusterOptions } from 'ioredis/built/cluster/ClusterOptions';
+import type { ClusterNode } from 'ioredis/built/cluster/index.js';
+export interface RedisClientOptions extends RedisOptions {
+    /**
+     * Injection token
+     */
+    token?: any;
+}
+export interface RedisClusterOptions extends ClusterOptions {
+    /**
+     * Injection token
+     */
+    token?: any;
+    nodes: ClusterNode[];
+}
+export interface RedisClientAsyncOptions extends Pick<ModuleMetadata, 'imports'> {
+    /**
+     * Injection token
+     */
+    token?: any;
+    useFactory?: (...args: any[]) => Promise<RedisClientOptions> | RedisClientOptions;
+    inject?: any[];
+}
+export interface RedisClusterAsyncOptions extends Pick<ModuleMetadata, 'imports'> {
+    /**
+     * Injection token
+     */
+    token?: any;
+    useFactory?: (...args: any[]) => Promise<RedisClusterOptions> | RedisClusterOptions;
+    inject?: any[];
+}
+export interface LockSettings {
+    /**
+     * This parameter is only used if lock has been acquired without leaseTimeout parameter definition.
+     * Lock expires after `lockWatchdogTimeout` if watchdog
+     * didn't extend it to next `lockWatchdogTimeout` time interval.
+     *
+     * This prevents against infinity locked locks due to Redisson client crush or
+     * any other reason when lock can't be released in proper way.
+     *
+     * - Unit: milliseconds
+     * - Default: 30000 milliseconds
+     */
+    lockWatchdogTimeout?: bigint;
+}

package/types/redis.module.d.ts

@@ -0,0 +1,6 @@
+import { DynamicModule } from '@nestjs/common';
+import { RedisClientAsyncOptions, RedisClientOptions, RedisClusterAsyncOptions, RedisClusterOptions } from './redis.interface.js';
+export declare class RedisModule {
+    static forRoot(options: RedisClientOptions | RedisClusterOptions): DynamicModule;
+    static forRootAsync(options: RedisClientAsyncOptions | RedisClusterAsyncOptions): DynamicModule;
+}

package/types/shared-lock.d.ts

@@ -0,0 +1,3 @@
+import type { Lock } from 'redis-semaphore/lib/Lock';
+import type { SharedLock } from './types.js';
+export declare function sharedLock(lock: Lock): SharedLock;

package/types/types.d.ts

@@ -0,0 +1,7 @@
+import type { Lock } from 'redis-semaphore/lib/Lock';
+export interface SharedLock extends Lock {
+    readonly refCount: number;
+    acquire(): Promise<void>;
+    acquire(callback: () => any): Promise<any>;
+    release(force?: boolean): Promise<void>;
+}

package/types/utils.d.ts

@@ -0,0 +1,2 @@
+import { RedisClusterOptions } from './redis.interface.js';
+export declare function isClusterOptions(options: any): options is RedisClusterOptions;