@jsnw/nestjs-ioredis 1.0.0

package/README.md

@@ -0,0 +1,207 @@
+# @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
+
+## Installation
+
+```bash
+npm i -s @jsnw/nestjs-ioredis ioredis
+```
+
+## Quick Start
+
+### Basic Usage
+
+Import `RedisModule` in your app module and configure it with `forRoot()`:
+
+```typescript
+import { Module } from '@nestjs/common';
+import { RedisModule } from '@jsnw/nestjs-ioredis';
+
+@Module({
+  imports: [
+    RedisModule.forRoot({
+      hostname: 'localhost',
+      port: 6379,
+      username: 'default',
+      password: 'your-password',
+      isDefault: true,
+    }),
+  ],
+})
+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
+
+## Author
+
+Pavlo Baliuk (jsnow0177@gmail.com)

package/dist/index.js

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

package/dist/redis-core.module.js

@@ -0,0 +1,114 @@
+"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
+                    });
+                    im.addInstance(redisToken, instance);
+                    return instance;
+                },
+                inject: [
+                    redis_instances_manager_1.RedisInstancesManager
+                ]
+            };
+        }
+    };
+    return RedisCoreModule = _classThis;
+})();
+exports.RedisCoreModule = RedisCoreModule;

package/dist/redis-instances-manager.js

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

@@ -0,0 +1,5 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+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';

package/dist/redis.decorators.js

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

package/dist/redis.helpers.js

@@ -0,0 +1,42 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.resolveKeyPrefix = void 0;
+exports.resolveConnectionName = resolveConnectionName;
+exports.getRedisToken = getRedisToken;
+const redis_consts_1 = require("./redis.consts");
+/**
+ * @param {string | RedisForRootParams} arg
+ * @return {string}
+ */
+function resolveConnectionName(arg) {
+    if (typeof arg === 'string')
+        return arg.toUpperCase();
+    if (arg.connectionName && arg.connectionName.trim() !== '')
+        return arg.connectionName.trim().toUpperCase();
+    return `${arg.hostname}:${arg.port}/db${arg.db ?? 0}>${arg.keyPrefix ?? ''}`.toUpperCase();
+}
+/**
+ * @param {string | RedisForRootParams} arg
+ * @return {string}
+ */
+function getRedisToken(arg) {
+    if (typeof arg === 'string')
+        return `${redis_consts_1.REDIS_INSTANCE_TOKEN_PREFIX}${arg}`.toUpperCase();
+    return `${redis_consts_1.REDIS_INSTANCE_TOKEN_PREFIX}${resolveConnectionName(arg)}`.toUpperCase();
+}
+/**
+ * @param {string} prefix
+ * @return {string}
+ */
+const resolveKeyPrefix = (prefix) => {
+    if (!prefix)
+        return '';
+    prefix = prefix.trim();
+    if (prefix.endsWith(':')) {
+        if (prefix.length === 1)
+            return '';
+        return prefix;
+    }
+    return prefix + ':';
+};
+exports.resolveKeyPrefix = resolveKeyPrefix;

package/dist/redis.module.js

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

package/dist/redis.types.js

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

package/dist/types/index.d.ts

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

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

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

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

@@ -0,0 +1,24 @@
+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.consts.d.ts

@@ -0,0 +1,2 @@
+export declare const REDIS_INSTANCE_TOKEN_PREFIX: "REDIS_INSTANCE_";
+export declare const REDIS_DEFAULT_CONNECTION_NAME = "default";

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

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

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

@@ -0,0 +1,10 @@
+import { RedisForRootParams } from './redis.types';
+export declare function resolveConnectionName(instanceName: string): string;
+export declare function resolveConnectionName(params: RedisForRootParams): string;
+export declare function getRedisToken(connectionName: string): string;
+export declare function getRedisToken(params: RedisForRootParams): string;
+/**
+ * @param {string} prefix
+ * @return {string}
+ */
+export declare const resolveKeyPrefix: (prefix?: string) => string;

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

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

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

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

package/package.json

@@ -0,0 +1,55 @@
+{
+  "name": "@jsnw/nestjs-ioredis",
+  "version": "1.0.0",
+  "description": "NestJS module for integrating Redis using ioredis with support for multiple connections and dependency injection",
+  "main": "./dist/index.js",
+  "types": "./dist/types/index.d.ts",
+  "exports": {
+    ".": {
+      "require": "./dist/index.js",
+      "types": "./dist/types/index.d.ts"
+    }
+  },
+  "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"
+  ],
+  "repository": {
+    "type": "git",
+    "url": "git+ssh://git@github.com/pvbaliuk/jsnw-nestjs-ioredis"
+  },
+  "bugs": {
+    "url": "https://github.com/pvbaliuk/jsnw-nestjs-ioredis/issues"
+  },
+  "homepage": "https://github.com/pvbaliuk/jsnw-nestjs-ioredis#readme",
+  "keywords": [
+    "nestjs",
+    "redis",
+    "ioredis"
+  ],
+  "author": {
+    "name": "Pavlo Baliuk",
+    "email": "jsnow0177@gmail.com"
+  },
+  "license": "MIT",
+  "peerDependencies": {
+    "@nestjs/common": "^11.1.14",
+    "ioredis": "^5.9.3"
+  },
+  "devDependencies": {
+    "@nestjs/common": "^11.1.14",
+    "ioredis": "^5.9.3",
+    "jest": "^30.2.0",
+    "rimraf": "^6.1.3",
+    "ts-jest": "^29.4.6",
+    "typescript": "^5.9.3"
+  }
+}