@jsnw/nestjs-ioredis 1.3.0 → 2.0.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.js → lib/index.js}

@@ -1,9 +1,9 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.RedisLock = exports.InjectRedis = exports.RedisModule = void 0;
+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_decorators_1 = require("./redis.decorators");
-Object.defineProperty(exports, "InjectRedis", { enumerable: true, get: function () { return redis_decorators_1.InjectRedis; } });
+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

@@ -0,0 +1,70 @@
+"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

@@ -0,0 +1,47 @@
+"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/{redis-lock.js → lib/redis-lock.js}

@@ -7,7 +7,6 @@ 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;
@@ -18,11 +17,13 @@ class RedisLock {
     /**
      * @param {Redis} redis
      * @param {string} name
+     * @param {string} locksHashKey
+     * @protected
      */
-    constructor(redis, name) {
+    constructor(redis, name, locksHashKey) {
         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.locksHashKey = locksHashKey;
         this.value = (0, node_crypto_1.randomUUID)();
     }
     /**

package/dist/lib/redis.consts.js

@@ -0,0 +1,6 @@
+"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/{redis.helpers.js → lib/redis.helpers.js}

@@ -1,29 +1,7 @@
 "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}

package/dist/lib/redis.module.js

@@ -0,0 +1,30 @@
+"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/types/index.d.ts

@@ -1,4 +1,4 @@
 export { RedisModule } from './redis.module';
-export type { RedisForRootParams } from './redis.types';
-export { InjectRedis } from './redis.decorators';
+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,13 +1,18 @@
 import { type DynamicModule } from '@nestjs/common';
-import type { RedisForRootParams } from './redis.types';
+import type { RedisRegisterOptions } from './redis.types';
 export declare class RedisCoreModule {
     /**
-     * @param {RedisForRootParams} params
+     * @param {RedisRegisterOptions} options
      * @return {DynamicModule}
      */
-    static forRoot(params: RedisForRootParams): DynamicModule;
+    static register(options: RedisRegisterOptions): DynamicModule;
+    /**
+     * @param {RedisRegisterOptions} options
+     * @return {ValueProvider}
+     * @private
+     */
+    private static createOptionsProvider;
     /**
-     * @param {RedisForRootParams} params
      * @return {FactoryProvider}
      * @private
      */

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

@@ -1,4 +1,4 @@
-import { type Redis } from 'ioredis';
+import Redis from 'ioredis';
 export type RedisLockWaitAcquireParams = {
     lockTTL: number;
     retryInterval?: number | number[] | ((iteration: number) => number);
@@ -18,8 +18,10 @@ export declare class RedisLock {
     /**
      * @param {Redis} redis
      * @param {string} name
+     * @param {string} locksHashKey
+     * @protected
      */
-    constructor(redis: Redis, name: string);
+    constructor(redis: Redis, name: string, locksHashKey: string);
     /**
      * @param {RedisLockWaitAcquireParams} params
      * @return {Promise<boolean>}

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

@@ -0,0 +1,17 @@
+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,5 +1,3 @@
-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_OPTIONS_TOKEN: unique symbol;
 export declare const REDIS_DEFAULT_LOCKS_HASH_KEY = "__locks__";
-export declare const REDIS_DEFAULT_LOCK_ACQUIRE_RETRY_DELAY_MS = 100;
+export declare const REDIS_DEFAULT_LOCK_ACQUIRE_RETRY_DELAY_MS = 500;

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

@@ -1,9 +1,4 @@
-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}

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

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

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

@@ -1,13 +1,5 @@
-export type RedisForRootParams = {
-    connectionName?: string;
-    hostname: string;
-    port: number;
-    username: string;
-    password: string;
+import { type RedisOptions } from 'ioredis';
+export type RedisRegisterOptions = RedisOptions & {
     keyPrefix?: string;
-    db?: number;
-    connectionTimeout?: number;
-    lazy?: boolean;
-    isDefault?: boolean;
     locksHashKey?: string;
 };

package/package.json

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

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.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.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/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.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;