@xnestjs/ioredis 1.2.5 → 1.3.1

package/README.md

@@ -1,3 +1,142 @@
 # @xnestjs/ioredis
 
 NestJS extension library for ioredis
+
+## Install
+
+```sh
+npm install @xnestjs/ioredis
+# or using yarn
+yarn add @xnestjs/ioredis
+```
+
+## Usage
+
+### Register standalone sync
+
+An example of nestjs module that creates RedisClient with standalone connection.
+
+```ts
+// module.ts
+import { Module } from '@nestjs/common';
+import { RedisModule } from '@xnestjs/ioredis';
+
+@Module({
+    imports: [
+        RedisModule.forRoot({
+            useValue: {
+                host: 'localhost',
+                port: 6379
+            }
+        }),
+    ]
+})
+export class MyModule {
+}
+```
+
+### Register cluster sync
+
+An example of nestjs module that creates RedisClient with cluster connection.
+
+```ts
+// module.ts
+import { Module } from '@nestjs/common';
+import { RedisModule } from '@xnestjs/ioredis';
+
+@Module({
+    imports: [
+        RedisModule.forRoot({
+            useValue: {
+                nodes: ['localhost'],
+            }
+        }),
+    ]
+})
+export class MyModule {
+}
+```
+
+### Register standalone async
+
+An example of nestjs module that creates RedisClient with standalone connection async
+
+```ts
+// module.ts
+import { Module } from '@nestjs/common';
+import { RedisModule } from '@xnestjs/ioredis';
+
+@Module({
+    imports: [
+        ElasticsearchModule.forRootAsync({
+            inject: [ConfigModule],
+            useFactory: (config: ConfigService) => ({
+                host: config.get('REDIS_HOST'),
+            }),
+        }),
+    ]
+})
+export class MyModule {
+}
+```
+
+### Register cluster async
+
+An example of nestjs module that creates RedisClient with cluster connection async
+
+```ts
+// module.ts
+import { Module } from '@nestjs/common';
+import { RedisModule } from '@xnestjs/ioredis';
+
+@Module({
+    imports: [
+        ElasticsearchModule.forRootAsync({
+            inject: [ConfigModule],
+            useFactory: (config: ConfigService) => ({
+                nodes: config.get('REDIS_NODES'),
+            }),
+        }),
+    ]
+})
+export class MyModule {
+}
+```
+
+## Environment Variables
+
+The library supports configuration through environment variables. Environment variables below is accepted.
+All environment variables starts with prefix (REDIS_). This can be configured while registering the module.
+
+### Standalone Connection Variables
+
+The following environment variables apply to the standalone connection.
+
+| Environment Variable | Type   | Default   | Description |
+|----------------------|--------|-----------|-------------|
+| REDIS_HOST           | String | localhost |             |
+| REDIS_PORT           | Number | 6379      |             |
+
+### Cluster Connection Variables
+
+The following environment variables apply to the standalone connection.
+
+| Environment Variable | Type    | Default   | Description |
+|----------------------|---------|-----------|-------------|
+| NODES                | String! | localhost |             |
+
+### Common Variables
+
+| Environment Variable          | Type    | Default | Description                                                                                                                       |
+|-------------------------------|---------|---------|-----------------------------------------------------------------------------------------------------------------------------------|
+| REDIS_DB                      | Number  | 0       | Hostname for Redis Server                                                                                                         |
+| REDIS_USERNAME                | String  |         | Port number                                                                                                                       |
+| REDIS_PASSWORD                | String  |         | If set, client will send AUTH command with the value of this option as the first argument when connected.                         |
+| REDIS_CONNECTION_NAME         | String  |         | If set, client will send AUTH command with the value of this option when connected.                                               |
+| REDIS_AUTO_RESUBSCRIBE        | Boolean |         | When the client reconnects, channels subscribed in the previous connection will be resubscribed automatically if value is `true`. |
+| REDIS_RECONNECT_ON_ERROR      | Number  |         | One of [`0`, `1`, `2`]                                                                                                            |
+| REDIS_CONNECT_TIMEOUT         | Number  | 10000   | How long the client will wait before killing a socket due to inactivity during initial connection.                                |
+| REDIS_SOCKET_TIMEOUT          | Number  |         | Defines the socket timeout value                                                                                                  |
+| REDIS_KEEP_ALIVE              | Boolean |         | Enable/disable keep-alive functionality.                                                                                          |
+| REDIS_NO_DELAY                | Boolean |         | Enable/disable the use of Nagle's algorithm.                                                                                      |
+| REDIS_MAX_RETRIES_PER_REQUEST | Number  |         | Defines max retries per request value                                                                                             |

package/cjs/constants.js

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

package/cjs/index.js

@@ -1,7 +1,6 @@
 "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);

package/cjs/redis-core.module.js

@@ -3,105 +3,164 @@ var RedisCoreModule_1;
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.RedisCoreModule = void 0;
 const tslib_1 = require("tslib");
+const node_assert_1 = tslib_1.__importDefault(require("node:assert"));
 const node_process_1 = tslib_1.__importDefault(require("node:process"));
+const objects_1 = require("@jsopen/objects");
 const common_1 = require("@nestjs/common");
-const core_1 = require("@nestjs/core");
 const ansi_colors_1 = tslib_1.__importDefault(require("ansi-colors"));
 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 putil_varhelpers_1 = require("putil-varhelpers");
+const constants_js_1 = require("./constants.js");
 const redis_client_js_1 = require("./redis-client.js");
 const utils_js_1 = require("./utils.js");
+const CLIENT_TOKEN = Symbol('CLIENT_TOKEN');
 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 forRoot(moduleOptions) {
+        const connectionOptions = this._readConnectionOptions(moduleOptions.useValue, moduleOptions.envPrefix);
+        return this._createDynamicModule(moduleOptions, {
+            global: moduleOptions.global,
+            providers: [
+                {
+                    provide: constants_js_1.IOREDIS_CONNECTION_OPTIONS,
+                    useValue: connectionOptions,
+                },
+            ],
+        });
     }
     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,
+        node_assert_1.default.ok(asyncOptions.useFactory, 'useFactory is required');
+        return this._createDynamicModule(asyncOptions, {
+            global: asyncOptions.global,
             providers: [
                 {
-                    provide: redis_constants_js_1.IOREDIS_MODULE_OPTIONS,
-                    useFactory: asyncOptions.useFactory,
-                    inject: asyncOptions.inject || [],
+                    provide: constants_js_1.IOREDIS_CONNECTION_OPTIONS,
+                    inject: asyncOptions.inject,
+                    useFactory: async (...args) => {
+                        const opts = await asyncOptions.useFactory(...args);
+                        return this._readConnectionOptions(opts, asyncOptions.envPrefix);
+                    },
                 },
+            ],
+        });
+    }
+    static _createDynamicModule(opts, metadata) {
+        const token = opts.token ?? redis_client_js_1.RedisClient;
+        const providers = [
+            {
+                provide: token,
+                inject: [constants_js_1.IOREDIS_CONNECTION_OPTIONS],
+                useFactory: async (connectionOptions) => {
+                    return this._createClient(connectionOptions);
+                },
+            },
+            {
+                provide: CLIENT_TOKEN,
+                useExisting: token,
+            },
+            {
+                provide: common_1.Logger,
+                useValue: typeof opts.logger === 'string' ? new common_1.Logger(opts.logger) : opts.logger,
+            },
+        ];
+        return {
+            module: RedisCoreModule_1,
+            ...metadata,
+            providers: [
+                ...(metadata.providers ?? []),
+                ...providers,
                 {
-                    provide: redis_constants_js_1.IOREDIS_MODULE_TOKEN,
+                    provide: constants_js_1.IOREDIS_MODULE_TOKEN,
                     useValue: crypto.randomUUID(),
                 },
-                connectionProvider,
             ],
-            exports: [connectionProvider],
+            exports: [constants_js_1.IOREDIS_CONNECTION_OPTIONS, token, ...(metadata.exports ?? [])],
         };
     }
-    static async _createClient(options) {
-        if (options.host && options.nodes) {
-            throw new TypeError(`You should set either "host" or "nodes", not both`);
+    static _readConnectionOptions(options, prefix = 'REDIS_') {
+        const env = node_process_1.default.env;
+        const out = (0, objects_1.clone)(options || {});
+        let redisOptions;
+        if ((0, utils_js_1.isClusterOptions)(out)) {
+            redisOptions = out.redisOptions = out.redisOptions || {};
+            out.nodes = out.nodes ?? (env[prefix + 'NODES'] || 'localhost:6379').split(/\s*,\s*/);
         }
+        else {
+            redisOptions = out;
+            out.host = out.host ?? env[prefix + 'HOST'] ?? 'localhost';
+            out.port = out.port ?? (0, putil_varhelpers_1.toIntDef)(env[prefix + 'PORT'], 6379);
+        }
+        redisOptions.db = redisOptions.db ?? (0, putil_varhelpers_1.toIntDef)(env[prefix + 'DB'], 0);
+        redisOptions.username = redisOptions.username ?? env[prefix + 'USERNAME'];
+        redisOptions.password = redisOptions.password ?? env[prefix + 'PASSWORD'];
+        redisOptions.autoResubscribe = redisOptions.autoResubscribe ?? (0, putil_varhelpers_1.toBoolean)(env[prefix + 'AUTO_RESUBSCRIBE']);
+        if (!redisOptions.reconnectOnError) {
+            let n = env[prefix + 'RECONNECT_ON_ERROR'];
+            if (n === 'true' || n === 'false') {
+                n = (0, putil_varhelpers_1.toBoolean)(n);
+            }
+            else
+                n = (0, putil_varhelpers_1.toInt)(n);
+            redisOptions.reconnectOnError = () => n;
+        }
+        redisOptions.connectTimeout = redisOptions.connectTimeout ?? (0, putil_varhelpers_1.toInt)(env[prefix + 'CONNECT_TIMEOUT']);
+        redisOptions.socketTimeout = redisOptions.socketTimeout ?? (0, putil_varhelpers_1.toInt)(env[prefix + 'SOCKET_TIMEOUT']);
+        redisOptions.keepAlive = redisOptions.keepAlive ?? (0, putil_varhelpers_1.toInt)(env[prefix + 'KEEP_ALIVE']);
+        redisOptions.noDelay = redisOptions.noDelay ?? (0, putil_varhelpers_1.toBoolean)(env[prefix + 'NO_DELAY']);
+        redisOptions.connectionName = redisOptions.connectionName ?? env[prefix + 'CONNECTION_NAME'];
+        redisOptions.maxRetriesPerRequest =
+            redisOptions.maxRetriesPerRequest ?? (0, putil_varhelpers_1.toInt)(env[prefix + 'MAX_RETRIES_PER_REQUEST']);
+        return out;
+    }
+    static _createClient(options) {
         const opts = { ...options };
-        const isCluster = (0, utils_js_1.isClusterOptions)(opts);
         let client;
-        if (isCluster) {
+        if ((0, utils_js_1.isClusterOptions)(opts)) {
             delete opts.name;
             delete opts.nodes;
+            opts.lazyConnect = true;
             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;
+        else if ((0, utils_js_1.isStandaloneOptions)(opts)) {
+            if (opts.host && opts.host.includes('://')) {
+                const url = new URL(opts.host);
+                opts.host = url.hostname;
                 if (url.port)
-                    options.port = parseInt(url.port, 10);
+                    opts.port = parseInt(url.port, 10);
                 if (url.username)
-                    options.username = url.username;
+                    opts.username = url.username;
                 if (url.password)
-                    options.password = url.password;
+                    opts.password = url.password;
                 if (url.protocol === 'rediss:') {
                     // @ts-ignore
-                    options.tls = true;
+                    opts.tls = true;
                 }
                 const db = parseInt(url.pathname.substring(1), 10);
                 if (db > 0)
-                    options.db = db;
+                    opts.db = db;
             }
             const standalone = new ioredis_1.default({
-                ...options,
+                ...opts,
                 lazyConnect: true,
             });
             client = new redis_client_js_1.RedisClient({ standalone });
         }
+        else
+            throw new TypeError(`Invalid connection options`);
         return client;
     }
+    /**
+     *
+     * @constructor
+     */
+    constructor(client, connectionOptions, logger) {
+        this.client = client;
+        this.connectionOptions = connectionOptions;
+        this.logger = logger;
+    }
     async onApplicationBootstrap() {
-        const opts = this.options;
-        const logger = node_process_1.default.env.NODE_ENV === 'test' ? undefined : opts.logger;
+        const opts = this.connectionOptions;
         if (!opts.lazyConnect) {
             const isCluster = (0, utils_js_1.isClusterOptions)(opts);
             const hosts = isCluster
@@ -110,15 +169,14 @@ let RedisCoreModule = RedisCoreModule_1 = class RedisCoreModule {
                     .join(', ')
                 : opts.host;
             if (hosts) {
-                logger?.log('Connecting to redis at ' + ansi_colors_1.default.blue(hosts));
+                this.logger?.log('Connecting to redis at ' + ansi_colors_1.default.blue(hosts));
                 common_1.Logger.flush();
-                const client = this.moduleRef.get(this.options.token || redis_client_js_1.RedisClient);
                 try {
-                    await client.redis.connect();
-                    await client.redis.ping();
+                    await this.client.redis.connect();
+                    await this.client.redis.ping();
                 }
                 catch (e) {
-                    logger?.error('Redis connection failed: ' + e.message);
+                    this.logger?.error('Redis connection failed: ' + e.message);
                     throw e;
                 }
             }
@@ -126,8 +184,7 @@ let RedisCoreModule = RedisCoreModule_1 = class RedisCoreModule {
     }
     async onApplicationShutdown() {
         try {
-            const client = this.moduleRef.get(this.options.token || redis_client_js_1.RedisClient);
-            await client.quit();
+            await this.client.quit();
         }
         catch {
             //
@@ -136,8 +193,7 @@ let RedisCoreModule = RedisCoreModule_1 = class RedisCoreModule {
 };
 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])
+    tslib_1.__param(0, (0, common_1.Inject)(CLIENT_TOKEN)),
+    tslib_1.__param(1, (0, common_1.Inject)(constants_js_1.IOREDIS_CONNECTION_OPTIONS)),
+    tslib_1.__metadata("design:paramtypes", [redis_client_js_1.RedisClient, Object, common_1.Logger])
 ], RedisCoreModule);

package/cjs/utils.js

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

package/esm/constants.js

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

package/esm/index.js

@@ -1,4 +1,3 @@
-export * from './redis.interface.js';
 export * from './redis.module.js';
 export * from './redis-client.js';
 export * from './shared-lock.js';

package/esm/redis-core.module.js

@@ -1,104 +1,163 @@
 var RedisCoreModule_1;
 import { __decorate, __metadata, __param } from "tslib";
+import assert from 'node:assert';
 import process from 'node:process';
-import { Global, Inject, Logger, Module, } from '@nestjs/common';
-import { ModuleRef } from '@nestjs/core';
+import { clone } from '@jsopen/objects';
+import { Inject, Logger } from '@nestjs/common';
 import colors from 'ansi-colors';
 import * as crypto from 'crypto';
 import Redis, { Cluster } from 'ioredis';
-import { IOREDIS_MODULE_OPTIONS, IOREDIS_MODULE_TOKEN } from './redis.constants.js';
+import { toBoolean, toInt, toIntDef } from 'putil-varhelpers';
+import { IOREDIS_CONNECTION_OPTIONS, IOREDIS_MODULE_TOKEN } from './constants.js';
 import { RedisClient } from './redis-client.js';
-import { isClusterOptions } from './utils.js';
+import { isClusterOptions, isStandaloneOptions } from './utils.js';
+const CLIENT_TOKEN = Symbol('CLIENT_TOKEN');
 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 forRoot(moduleOptions) {
+        const connectionOptions = this._readConnectionOptions(moduleOptions.useValue, moduleOptions.envPrefix);
+        return this._createDynamicModule(moduleOptions, {
+            global: moduleOptions.global,
+            providers: [
+                {
+                    provide: IOREDIS_CONNECTION_OPTIONS,
+                    useValue: connectionOptions,
+                },
+            ],
+        });
     }
     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,
+        assert.ok(asyncOptions.useFactory, 'useFactory is required');
+        return this._createDynamicModule(asyncOptions, {
+            global: asyncOptions.global,
             providers: [
                 {
-                    provide: IOREDIS_MODULE_OPTIONS,
-                    useFactory: asyncOptions.useFactory,
-                    inject: asyncOptions.inject || [],
+                    provide: IOREDIS_CONNECTION_OPTIONS,
+                    inject: asyncOptions.inject,
+                    useFactory: async (...args) => {
+                        const opts = await asyncOptions.useFactory(...args);
+                        return this._readConnectionOptions(opts, asyncOptions.envPrefix);
+                    },
                 },
+            ],
+        });
+    }
+    static _createDynamicModule(opts, metadata) {
+        const token = opts.token ?? RedisClient;
+        const providers = [
+            {
+                provide: token,
+                inject: [IOREDIS_CONNECTION_OPTIONS],
+                useFactory: async (connectionOptions) => {
+                    return this._createClient(connectionOptions);
+                },
+            },
+            {
+                provide: CLIENT_TOKEN,
+                useExisting: token,
+            },
+            {
+                provide: Logger,
+                useValue: typeof opts.logger === 'string' ? new Logger(opts.logger) : opts.logger,
+            },
+        ];
+        return {
+            module: RedisCoreModule_1,
+            ...metadata,
+            providers: [
+                ...(metadata.providers ?? []),
+                ...providers,
                 {
                     provide: IOREDIS_MODULE_TOKEN,
                     useValue: crypto.randomUUID(),
                 },
-                connectionProvider,
             ],
-            exports: [connectionProvider],
+            exports: [IOREDIS_CONNECTION_OPTIONS, token, ...(metadata.exports ?? [])],
         };
     }
-    static async _createClient(options) {
-        if (options.host && options.nodes) {
-            throw new TypeError(`You should set either "host" or "nodes", not both`);
+    static _readConnectionOptions(options, prefix = 'REDIS_') {
+        const env = process.env;
+        const out = clone(options || {});
+        let redisOptions;
+        if (isClusterOptions(out)) {
+            redisOptions = out.redisOptions = out.redisOptions || {};
+            out.nodes = out.nodes ?? (env[prefix + 'NODES'] || 'localhost:6379').split(/\s*,\s*/);
         }
+        else {
+            redisOptions = out;
+            out.host = out.host ?? env[prefix + 'HOST'] ?? 'localhost';
+            out.port = out.port ?? toIntDef(env[prefix + 'PORT'], 6379);
+        }
+        redisOptions.db = redisOptions.db ?? toIntDef(env[prefix + 'DB'], 0);
+        redisOptions.username = redisOptions.username ?? env[prefix + 'USERNAME'];
+        redisOptions.password = redisOptions.password ?? env[prefix + 'PASSWORD'];
+        redisOptions.autoResubscribe = redisOptions.autoResubscribe ?? toBoolean(env[prefix + 'AUTO_RESUBSCRIBE']);
+        if (!redisOptions.reconnectOnError) {
+            let n = env[prefix + 'RECONNECT_ON_ERROR'];
+            if (n === 'true' || n === 'false') {
+                n = toBoolean(n);
+            }
+            else
+                n = toInt(n);
+            redisOptions.reconnectOnError = () => n;
+        }
+        redisOptions.connectTimeout = redisOptions.connectTimeout ?? toInt(env[prefix + 'CONNECT_TIMEOUT']);
+        redisOptions.socketTimeout = redisOptions.socketTimeout ?? toInt(env[prefix + 'SOCKET_TIMEOUT']);
+        redisOptions.keepAlive = redisOptions.keepAlive ?? toInt(env[prefix + 'KEEP_ALIVE']);
+        redisOptions.noDelay = redisOptions.noDelay ?? toBoolean(env[prefix + 'NO_DELAY']);
+        redisOptions.connectionName = redisOptions.connectionName ?? env[prefix + 'CONNECTION_NAME'];
+        redisOptions.maxRetriesPerRequest =
+            redisOptions.maxRetriesPerRequest ?? toInt(env[prefix + 'MAX_RETRIES_PER_REQUEST']);
+        return out;
+    }
+    static _createClient(options) {
         const opts = { ...options };
-        const isCluster = isClusterOptions(opts);
         let client;
-        if (isCluster) {
+        if (isClusterOptions(opts)) {
             delete opts.name;
             delete opts.nodes;
+            opts.lazyConnect = true;
             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;
+        else if (isStandaloneOptions(opts)) {
+            if (opts.host && opts.host.includes('://')) {
+                const url = new URL(opts.host);
+                opts.host = url.hostname;
                 if (url.port)
-                    options.port = parseInt(url.port, 10);
+                    opts.port = parseInt(url.port, 10);
                 if (url.username)
-                    options.username = url.username;
+                    opts.username = url.username;
                 if (url.password)
-                    options.password = url.password;
+                    opts.password = url.password;
                 if (url.protocol === 'rediss:') {
                     // @ts-ignore
-                    options.tls = true;
+                    opts.tls = true;
                 }
                 const db = parseInt(url.pathname.substring(1), 10);
                 if (db > 0)
-                    options.db = db;
+                    opts.db = db;
             }
             const standalone = new Redis({
-                ...options,
+                ...opts,
                 lazyConnect: true,
             });
             client = new RedisClient({ standalone });
         }
+        else
+            throw new TypeError(`Invalid connection options`);
         return client;
     }
+    /**
+     *
+     * @constructor
+     */
+    constructor(client, connectionOptions, logger) {
+        this.client = client;
+        this.connectionOptions = connectionOptions;
+        this.logger = logger;
+    }
     async onApplicationBootstrap() {
-        const opts = this.options;
-        const logger = process.env.NODE_ENV === 'test' ? undefined : opts.logger;
+        const opts = this.connectionOptions;
         if (!opts.lazyConnect) {
             const isCluster = isClusterOptions(opts);
             const hosts = isCluster
@@ -107,15 +166,14 @@ let RedisCoreModule = RedisCoreModule_1 = class RedisCoreModule {
                     .join(', ')
                 : opts.host;
             if (hosts) {
-                logger?.log('Connecting to redis at ' + colors.blue(hosts));
+                this.logger?.log('Connecting to redis at ' + colors.blue(hosts));
                 Logger.flush();
-                const client = this.moduleRef.get(this.options.token || RedisClient);
                 try {
-                    await client.redis.connect();
-                    await client.redis.ping();
+                    await this.client.redis.connect();
+                    await this.client.redis.ping();
                 }
                 catch (e) {
-                    logger?.error('Redis connection failed: ' + e.message);
+                    this.logger?.error('Redis connection failed: ' + e.message);
                     throw e;
                 }
             }
@@ -123,8 +181,7 @@ let RedisCoreModule = RedisCoreModule_1 = class RedisCoreModule {
     }
     async onApplicationShutdown() {
         try {
-            const client = this.moduleRef.get(this.options.token || RedisClient);
-            await client.quit();
+            await this.client.quit();
         }
         catch {
             //
@@ -132,9 +189,8 @@ let RedisCoreModule = RedisCoreModule_1 = class RedisCoreModule {
     }
 };
 RedisCoreModule = RedisCoreModule_1 = __decorate([
-    Global(),
-    Module({}),
-    __param(0, Inject(IOREDIS_MODULE_OPTIONS)),
-    __metadata("design:paramtypes", [Object, ModuleRef])
+    __param(0, Inject(CLIENT_TOKEN)),
+    __param(1, Inject(IOREDIS_CONNECTION_OPTIONS)),
+    __metadata("design:paramtypes", [RedisClient, Object, Logger])
 ], RedisCoreModule);
 export { RedisCoreModule };

package/esm/utils.js

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

package/package.json

@@ -1,11 +1,13 @@
 {
   "name": "@xnestjs/ioredis",
-  "version": "1.2.5",
+  "version": "1.3.1",
   "description": "NestJS extension library for ioredis",
   "author": "Panates",
   "license": "MIT",
   "dependencies": {
+    "@jsopen/objects": "^1.5.2",
     "ansi-colors": "^4.1.3",
+    "putil-varhelpers": "^1.6.5",
     "tslib": "^2.8.1"
   },
   "peerDependencies": {

package/types/constants.d.ts

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

package/types/index.d.cts

@@ -1,4 +1,3 @@
-export * from './redis.interface.js';
 export * from './redis.module.js';
 export * from './redis-client.js';
 export * from './shared-lock.js';

package/types/index.d.ts

@@ -1,4 +1,3 @@
-export * from './redis.interface.js';
 export * from './redis.module.js';
 export * from './redis-client.js';
 export * from './shared-lock.js';

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

@@ -1,13 +1,20 @@
-import { DynamicModule, OnApplicationBootstrap, OnApplicationShutdown } from '@nestjs/common';
-import { ModuleRef } from '@nestjs/core';
-import { RedisClientAsyncOptions, RedisClientOptions, RedisClusterAsyncOptions, RedisClusterOptions } from './redis.interface.js';
+import { DynamicModule, Logger, OnApplicationBootstrap, OnApplicationShutdown } from '@nestjs/common';
+import { RedisClient } from './redis-client.js';
+import type { RedisAsyncModuleOptions, RedisConnectionOptions, RedisModuleOptions } from './types.js';
 export declare class RedisCoreModule implements OnApplicationBootstrap, 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;
+    protected client: RedisClient;
+    private readonly connectionOptions;
+    private logger?;
+    static forRoot(moduleOptions: RedisModuleOptions): DynamicModule;
+    static forRootAsync(asyncOptions: RedisAsyncModuleOptions): DynamicModule;
+    private static _createDynamicModule;
+    private static _readConnectionOptions;
     private static _createClient;
+    /**
+     *
+     * @constructor
+     */
+    constructor(client: RedisClient, connectionOptions: RedisConnectionOptions, logger?: Logger | undefined);
     onApplicationBootstrap(): Promise<void>;
     onApplicationShutdown(): Promise<void>;
 }

package/types/redis.module.d.ts

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

package/types/types.d.ts

@@ -1,4 +1,38 @@
+import type { Logger } from '@nestjs/common';
+import type { ModuleMetadata } from '@nestjs/common/interfaces';
+import type { InjectionToken } from '@nestjs/common/interfaces/modules/injection-token.interface';
+import type { RedisOptions } from 'ioredis';
+import type { ClusterOptions } from 'ioredis/built/cluster/ClusterOptions';
+import type { ClusterNode } from 'ioredis/built/cluster/index.js';
 import type { Lock } from 'redis-semaphore/lib/Lock';
+export interface RedisStandaloneConnectionOptions extends RedisOptions {
+}
+export interface RedisClusterConnectionOptions extends ClusterOptions {
+    nodes: ClusterNode[];
+}
+export type RedisConnectionOptions = RedisStandaloneConnectionOptions | RedisClusterConnectionOptions;
+export interface RedisStandaloneModuleOptions extends BaseRedisModuleOptions {
+    useValue?: RedisStandaloneConnectionOptions;
+}
+export interface RedisStandaloneAsyncModuleOptions extends BaseRedisModuleOptions, Pick<ModuleMetadata, 'imports'> {
+    inject?: InjectionToken[];
+    useFactory: (...args: any[]) => Promise<RedisStandaloneConnectionOptions> | RedisStandaloneConnectionOptions;
+}
+export interface RedisClusterModuleOptions extends BaseRedisModuleOptions {
+    useValue?: RedisClusterConnectionOptions;
+}
+export interface RedisClusterAsyncModuleOptions extends BaseRedisModuleOptions, Pick<ModuleMetadata, 'imports'> {
+    inject?: InjectionToken[];
+    useFactory: (...args: any[]) => Promise<RedisClusterConnectionOptions> | RedisClusterConnectionOptions;
+}
+export type RedisModuleOptions = RedisStandaloneModuleOptions | RedisClusterModuleOptions;
+export type RedisAsyncModuleOptions = RedisStandaloneAsyncModuleOptions | RedisClusterAsyncModuleOptions;
+export interface BaseRedisModuleOptions {
+    token?: InjectionToken;
+    envPrefix?: string;
+    logger?: Logger | string;
+    global?: boolean;
+}
 export interface SharedLock extends Lock {
     readonly refCount: number;
     acquire(): Promise<void>;

package/types/utils.d.ts

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

package/cjs/redis.constants.js

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

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

package/esm/redis.constants.js

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

package/esm/redis.interface.js

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

package/types/redis.constants.d.ts

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

package/types/redis.interface.d.ts

@@ -1,50 +0,0 @@
-import { Logger } from '@nestjs/common';
-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;
-    logger?: Logger;
-}
-export interface RedisClusterOptions extends ClusterOptions {
-    /**
-     * Injection token
-     */
-    token?: any;
-    logger?: Logger;
-    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;
-}