@xnestjs/ioredis 0.0.1

package/LICENSE

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

package/README.md

@@ -0,0 +1,3 @@
+# @xnestjs/ioredis
+
+NestJS extension library for ioredis

package/cjs/index.js

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

package/cjs/package.json

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

package/cjs/redis-client.js

@@ -0,0 +1,73 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RedisClient = void 0;
+const tslib_1 = require("tslib");
+const ioredis_1 = tslib_1.__importDefault(require("ioredis"));
+const putil_varhelpers_1 = require("putil-varhelpers");
+class RedisClient extends ioredis_1.default {
+    lockPrefix;
+    /**
+     * Try to lock once
+     * @param {string} name redis-lock name
+     * @param {number} [expire] milliseconds, TTL for the redis key
+     * @returns {boolean} true: success, false: failed
+     */
+    async tryLock(name, expire) {
+        const result = await this.set(this._getLockKey(name), '_lock_', 'PX', expire, 'NX');
+        return result !== null;
+    }
+    /**
+     * lock, automatically retrying if failed
+     * @param {string} name redis-lock name
+     * @param {object} [options] Options
+     * @param {number} [options.expire=60000] TTL
+     * @param {number} [options.retryInterval=100] milliseconds, the interval to retry if failed
+     * @param {number} [options.maxRetries=10] max times to retry
+     */
+    async lock(name, options) {
+        const expire = (0, putil_varhelpers_1.toNumberDef)(options?.expire, 60000);
+        const retryInterval = (0, putil_varhelpers_1.toNumberDef)(options?.retryInterval, 100);
+        const maxRetries = (0, putil_varhelpers_1.toNumberDef)(options?.maxRetries, 10);
+        let retryTimes = 0;
+        // eslint-disable-next-line no-constant-condition
+        while (1) {
+            if (await this.tryLock(name, expire)) {
+                break;
+            }
+            else {
+                await this._sleep(retryInterval);
+                if (retryTimes >= maxRetries) {
+                    throw new Error(`Redis lock "${name}" timed out`);
+                }
+                retryTimes++;
+            }
+        }
+    }
+    /**
+     * Unlock a redis-lock by name
+     * @param {string} name redis-lock name
+     */
+    async unlock(name) {
+        const s = 'if redis.call(\'get\', KEYS[1]) == ARGV[1] then return redis.call(\'del\', KEYS[1]) else return 0 end';
+        await this.eval(s, 1, this._getLockKey(name), '_lock_');
+    }
+    /**
+     * Set TTL for a redis-lock
+     * @param {string} name redis-lock name
+     * @param {number} milliseconds TTL
+     */
+    async setLockTTL(name, milliseconds) {
+        const result = await this.pexpire(this._getLockKey(name), milliseconds);
+        return !!result;
+    }
+    _getLockKey(name) {
+        return (this.lockPrefix || 'lock:') + name;
+    }
+    /**
+     * @param {number} ms milliseconds, the sleep interval
+     */
+    _sleep(ms) {
+        return new Promise(resolve => setTimeout(resolve, Number(ms)));
+    }
+}
+exports.RedisClient = RedisClient;

package/cjs/redis-core.module.js

@@ -0,0 +1,118 @@
+"use strict";
+var RedisCoreModule_1;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RedisCoreModule = void 0;
+const tslib_1 = require("tslib");
+const crypto = tslib_1.__importStar(require("crypto"));
+const common_1 = require("@nestjs/common");
+const core_1 = require("@nestjs/core");
+const redis_constants_js_1 = require("./redis.constants.js");
+const redis_utils_js_1 = require("./redis.utils.js");
+const redis_client_js_1 = require("./redis-client.js");
+let RedisCoreModule = RedisCoreModule_1 = class RedisCoreModule {
+    options;
+    moduleRef;
+    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 connectionProvider = {
+            provide: (0, redis_utils_js_1.getRedisClientToken)(options.name),
+            useFactory: () => this.createClient(options)
+        };
+        return {
+            module: RedisCoreModule_1,
+            providers: [connectionProvider, optionsProvider],
+            exports: [connectionProvider]
+        };
+    }
+    static forRootAsync(asyncOptions) {
+        const connectionProvider = {
+            provide: (0, redis_utils_js_1.getRedisClientToken)(asyncOptions.name),
+            inject: [redis_constants_js_1.IOREDIS_MODULE_OPTIONS],
+            useFactory: async (moduleOptions) => {
+                const name = asyncOptions.name || moduleOptions.name;
+                return this.createClient({
+                    ...moduleOptions,
+                    name
+                });
+            }
+        };
+        const asyncProviders = this.createAsyncProviders(asyncOptions);
+        return {
+            module: RedisCoreModule_1,
+            imports: asyncOptions.imports,
+            providers: [
+                ...asyncProviders,
+                connectionProvider,
+                {
+                    provide: redis_constants_js_1.IOREDIS_MODULE_TOKEN,
+                    useValue: crypto.randomUUID()
+                }
+            ],
+            exports: [connectionProvider]
+        };
+    }
+    async onApplicationShutdown() {
+        const client = this.moduleRef.get((0, redis_utils_js_1.getRedisClientToken)(this.options.name));
+        if (client)
+            await client.quit();
+    }
+    static createAsyncProviders(asyncOptions) {
+        if (asyncOptions.useExisting || asyncOptions.useFactory)
+            return [this.createAsyncOptionsProvider(asyncOptions)];
+        if (asyncOptions.useClass)
+            return [
+                this.createAsyncOptionsProvider(asyncOptions),
+                {
+                    provide: asyncOptions.useClass,
+                    useClass: asyncOptions.useClass
+                }
+            ];
+        throw new Error('Invalid configuration. Must provide useFactory, useClass or useExisting');
+    }
+    static createAsyncOptionsProvider(asyncOptions) {
+        if (asyncOptions.useFactory) {
+            return {
+                provide: redis_constants_js_1.IOREDIS_MODULE_OPTIONS,
+                useFactory: asyncOptions.useFactory,
+                inject: asyncOptions.inject || []
+            };
+        }
+        const useClass = asyncOptions.useClass || asyncOptions.useExisting;
+        if (useClass) {
+            return {
+                provide: redis_constants_js_1.IOREDIS_MODULE_OPTIONS,
+                useFactory: (optionsFactory) => optionsFactory.createOptions(asyncOptions.name),
+                inject: [useClass]
+            };
+        }
+        throw new Error('Invalid configuration. Must provide useFactory, useClass or useExisting');
+    }
+    static async createClient(options) {
+        const client = new redis_client_js_1.RedisClient(options);
+        await new Promise((resolve, reject) => {
+            client.once('ready', () => {
+                client.removeListener('error', reject);
+                resolve();
+            });
+            client.once('error', (e) => {
+                client.removeListener('ready', resolve);
+                reject(e);
+            });
+        });
+        return client;
+    }
+};
+RedisCoreModule = RedisCoreModule_1 = tslib_1.__decorate([
+    (0, common_1.Global)(),
+    (0, common_1.Module)({}),
+    tslib_1.__param(0, (0, common_1.Inject)(redis_constants_js_1.IOREDIS_MODULE_OPTIONS)),
+    tslib_1.__metadata("design:paramtypes", [Object, core_1.ModuleRef])
+], RedisCoreModule);
+exports.RedisCoreModule = RedisCoreModule;

package/cjs/redis.constants.js

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

package/cjs/redis.decorators.js

@@ -0,0 +1,7 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.InjectIORedis = void 0;
+const common_1 = require("@nestjs/common");
+const redis_utils_js_1 = require("./redis.utils.js");
+const InjectIORedis = (name) => (0, common_1.Inject)((0, redis_utils_js_1.getRedisClientToken)(name));
+exports.InjectIORedis = InjectIORedis;

package/cjs/redis.interface.js

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

package/cjs/redis.module.js

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

package/cjs/redis.utils.js

@@ -0,0 +1,12 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getRedisClientToken = void 0;
+const redis_client_js_1 = require("./redis-client.js");
+function getRedisClientToken(name) {
+    if (!name)
+        return redis_client_js_1.RedisClient;
+    if (typeof name === 'symbol' || typeof name === 'function')
+        return name;
+    return `${name}_RedisClient`;
+}
+exports.getRedisClientToken = getRedisClientToken;

package/esm/index.d.ts

@@ -0,0 +1,5 @@
+export * from './redis.decorators.js';
+export * from './redis.interface.js';
+export * from './redis.module.js';
+export * from './redis.utils.js';
+export * from './redis-client.js';

package/esm/index.js

@@ -0,0 +1,5 @@
+export * from './redis.decorators.js';
+export * from './redis.interface.js';
+export * from './redis.module.js';
+export * from './redis.utils.js';
+export * from './redis-client.js';

package/esm/redis-client.d.ts

@@ -0,0 +1,41 @@
+import Redis from 'ioredis';
+export interface LockOptions {
+    expire?: number;
+    retryInterval?: number;
+    maxRetries?: number;
+}
+export declare class RedisClient extends Redis {
+    lockPrefix?: string;
+    /**
+     * Try to lock once
+     * @param {string} name redis-lock name
+     * @param {number} [expire] milliseconds, TTL for the redis key
+     * @returns {boolean} true: success, false: failed
+     */
+    tryLock(name: any, expire: any): Promise<boolean>;
+    /**
+     * lock, automatically retrying if failed
+     * @param {string} name redis-lock name
+     * @param {object} [options] Options
+     * @param {number} [options.expire=60000] TTL
+     * @param {number} [options.retryInterval=100] milliseconds, the interval to retry if failed
+     * @param {number} [options.maxRetries=10] max times to retry
+     */
+    lock(name: string, options?: LockOptions): Promise<void>;
+    /**
+     * Unlock a redis-lock by name
+     * @param {string} name redis-lock name
+     */
+    unlock(name: any): Promise<void>;
+    /**
+     * Set TTL for a redis-lock
+     * @param {string} name redis-lock name
+     * @param {number} milliseconds TTL
+     */
+    setLockTTL(name: any, milliseconds: any): Promise<boolean>;
+    private _getLockKey;
+    /**
+     * @param {number} ms milliseconds, the sleep interval
+     */
+    private _sleep;
+}

package/esm/redis-client.js

@@ -0,0 +1,68 @@
+import Redis from 'ioredis';
+import { toNumberDef } from 'putil-varhelpers';
+export class RedisClient extends Redis {
+    lockPrefix;
+    /**
+     * Try to lock once
+     * @param {string} name redis-lock name
+     * @param {number} [expire] milliseconds, TTL for the redis key
+     * @returns {boolean} true: success, false: failed
+     */
+    async tryLock(name, expire) {
+        const result = await this.set(this._getLockKey(name), '_lock_', 'PX', expire, 'NX');
+        return result !== null;
+    }
+    /**
+     * lock, automatically retrying if failed
+     * @param {string} name redis-lock name
+     * @param {object} [options] Options
+     * @param {number} [options.expire=60000] TTL
+     * @param {number} [options.retryInterval=100] milliseconds, the interval to retry if failed
+     * @param {number} [options.maxRetries=10] max times to retry
+     */
+    async lock(name, options) {
+        const expire = toNumberDef(options?.expire, 60000);
+        const retryInterval = toNumberDef(options?.retryInterval, 100);
+        const maxRetries = toNumberDef(options?.maxRetries, 10);
+        let retryTimes = 0;
+        // eslint-disable-next-line no-constant-condition
+        while (1) {
+            if (await this.tryLock(name, expire)) {
+                break;
+            }
+            else {
+                await this._sleep(retryInterval);
+                if (retryTimes >= maxRetries) {
+                    throw new Error(`Redis lock "${name}" timed out`);
+                }
+                retryTimes++;
+            }
+        }
+    }
+    /**
+     * Unlock a redis-lock by name
+     * @param {string} name redis-lock name
+     */
+    async unlock(name) {
+        const s = 'if redis.call(\'get\', KEYS[1]) == ARGV[1] then return redis.call(\'del\', KEYS[1]) else return 0 end';
+        await this.eval(s, 1, this._getLockKey(name), '_lock_');
+    }
+    /**
+     * Set TTL for a redis-lock
+     * @param {string} name redis-lock name
+     * @param {number} milliseconds TTL
+     */
+    async setLockTTL(name, milliseconds) {
+        const result = await this.pexpire(this._getLockKey(name), milliseconds);
+        return !!result;
+    }
+    _getLockKey(name) {
+        return (this.lockPrefix || 'lock:') + name;
+    }
+    /**
+     * @param {number} ms milliseconds, the sleep interval
+     */
+    _sleep(ms) {
+        return new Promise(resolve => setTimeout(resolve, Number(ms)));
+    }
+}

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

@@ -0,0 +1,14 @@
+import { DynamicModule, OnApplicationShutdown } from '@nestjs/common';
+import { ModuleRef } from '@nestjs/core';
+import { RedisModuleAsyncOptions, RedisModuleOptions } from './redis.interface.js';
+export declare class RedisCoreModule implements OnApplicationShutdown {
+    private readonly options;
+    private readonly moduleRef;
+    constructor(options: RedisModuleOptions, moduleRef: ModuleRef);
+    static forRoot(options?: RedisModuleOptions): DynamicModule;
+    static forRootAsync(asyncOptions: RedisModuleAsyncOptions): DynamicModule;
+    onApplicationShutdown(): Promise<void>;
+    private static createAsyncProviders;
+    private static createAsyncOptionsProvider;
+    private static createClient;
+}

package/esm/redis-core.module.js

@@ -0,0 +1,115 @@
+var RedisCoreModule_1;
+import { __decorate, __metadata, __param } from "tslib";
+import * as crypto from 'crypto';
+import { Global, Inject, Module } from '@nestjs/common';
+import { ModuleRef } from '@nestjs/core';
+import { IOREDIS_MODULE_OPTIONS, IOREDIS_MODULE_TOKEN } from './redis.constants.js';
+import { getRedisClientToken } from './redis.utils.js';
+import { RedisClient } from './redis-client.js';
+let RedisCoreModule = RedisCoreModule_1 = class RedisCoreModule {
+    options;
+    moduleRef;
+    constructor(options, moduleRef) {
+        this.options = options;
+        this.moduleRef = moduleRef;
+    }
+    static forRoot(options = {}) {
+        const optionsProvider = {
+            provide: IOREDIS_MODULE_OPTIONS,
+            useValue: options
+        };
+        const connectionProvider = {
+            provide: getRedisClientToken(options.name),
+            useFactory: () => this.createClient(options)
+        };
+        return {
+            module: RedisCoreModule_1,
+            providers: [connectionProvider, optionsProvider],
+            exports: [connectionProvider]
+        };
+    }
+    static forRootAsync(asyncOptions) {
+        const connectionProvider = {
+            provide: getRedisClientToken(asyncOptions.name),
+            inject: [IOREDIS_MODULE_OPTIONS],
+            useFactory: async (moduleOptions) => {
+                const name = asyncOptions.name || moduleOptions.name;
+                return this.createClient({
+                    ...moduleOptions,
+                    name
+                });
+            }
+        };
+        const asyncProviders = this.createAsyncProviders(asyncOptions);
+        return {
+            module: RedisCoreModule_1,
+            imports: asyncOptions.imports,
+            providers: [
+                ...asyncProviders,
+                connectionProvider,
+                {
+                    provide: IOREDIS_MODULE_TOKEN,
+                    useValue: crypto.randomUUID()
+                }
+            ],
+            exports: [connectionProvider]
+        };
+    }
+    async onApplicationShutdown() {
+        const client = this.moduleRef.get(getRedisClientToken(this.options.name));
+        if (client)
+            await client.quit();
+    }
+    static createAsyncProviders(asyncOptions) {
+        if (asyncOptions.useExisting || asyncOptions.useFactory)
+            return [this.createAsyncOptionsProvider(asyncOptions)];
+        if (asyncOptions.useClass)
+            return [
+                this.createAsyncOptionsProvider(asyncOptions),
+                {
+                    provide: asyncOptions.useClass,
+                    useClass: asyncOptions.useClass
+                }
+            ];
+        throw new Error('Invalid configuration. Must provide useFactory, useClass or useExisting');
+    }
+    static createAsyncOptionsProvider(asyncOptions) {
+        if (asyncOptions.useFactory) {
+            return {
+                provide: IOREDIS_MODULE_OPTIONS,
+                useFactory: asyncOptions.useFactory,
+                inject: asyncOptions.inject || []
+            };
+        }
+        const useClass = asyncOptions.useClass || asyncOptions.useExisting;
+        if (useClass) {
+            return {
+                provide: IOREDIS_MODULE_OPTIONS,
+                useFactory: (optionsFactory) => optionsFactory.createOptions(asyncOptions.name),
+                inject: [useClass]
+            };
+        }
+        throw new Error('Invalid configuration. Must provide useFactory, useClass or useExisting');
+    }
+    static async createClient(options) {
+        const client = new RedisClient(options);
+        await new Promise((resolve, reject) => {
+            client.once('ready', () => {
+                client.removeListener('error', reject);
+                resolve();
+            });
+            client.once('error', (e) => {
+                client.removeListener('ready', resolve);
+                reject(e);
+            });
+        });
+        return client;
+    }
+};
+RedisCoreModule = RedisCoreModule_1 = __decorate([
+    Global(),
+    Module({}),
+    __param(0, Inject(IOREDIS_MODULE_OPTIONS)),
+    __metadata("design:paramtypes", [Object, ModuleRef])
+], RedisCoreModule);
+export { RedisCoreModule };

package/esm/redis.constants.d.ts

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

package/esm/redis.constants.js

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

package/esm/redis.decorators.d.ts

@@ -0,0 +1 @@
+export declare const InjectIORedis: (name?: string) => ParameterDecorator;

package/esm/redis.decorators.js

@@ -0,0 +1,3 @@
+import { Inject } from '@nestjs/common';
+import { getRedisClientToken } from './redis.utils.js';
+export const InjectIORedis = (name) => Inject(getRedisClientToken(name));

package/esm/redis.interface.d.ts

@@ -0,0 +1,19 @@
+import { RedisOptions } from 'ioredis';
+import { Type } from '@nestjs/common';
+import { ModuleMetadata } from '@nestjs/common/interfaces';
+export interface RedisModuleOptions extends RedisOptions {
+    /**
+     * Connection name
+     */
+    name?: string;
+}
+export interface RedisModuleOptionsFactory {
+    createOptions(connectionName?: string): Promise<RedisModuleOptions> | RedisModuleOptions;
+}
+export interface RedisModuleAsyncOptions extends Pick<ModuleMetadata, 'imports'> {
+    name?: string;
+    useExisting?: Type<RedisModuleOptionsFactory>;
+    useClass?: Type<RedisModuleOptionsFactory>;
+    useFactory?: (...args: any[]) => Promise<RedisModuleOptions> | RedisModuleOptions;
+    inject?: any[];
+}

package/esm/redis.interface.js

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

package/esm/redis.module.d.ts

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

package/esm/redis.module.js

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

package/esm/redis.utils.d.ts

@@ -0,0 +1,3 @@
+import { Type } from '@nestjs/common';
+import { RedisClient } from './redis-client.js';
+export declare function getRedisClientToken(name?: string | symbol | Type<RedisClient>): string | symbol | Type<RedisClient>;

package/esm/redis.utils.js

@@ -0,0 +1,8 @@
+import { RedisClient } from './redis-client.js';
+export function getRedisClientToken(name) {
+    if (!name)
+        return RedisClient;
+    if (typeof name === 'symbol' || typeof name === 'function')
+        return name;
+    return `${name}_RedisClient`;
+}

package/package.json

@@ -0,0 +1,62 @@
+{
+  "name": "@xnestjs/ioredis",
+  "version": "0.0.1",
+  "description": "NestJS extension library for ioredis",
+  "author": "Panates",
+  "license": "MIT",
+  "scripts": {
+    "compile": "tsc",
+    "prebuild": "npm run lint && npm run clean",
+    "build": "npm run build:cjs && npm run build:esm",
+    "build:cjs": "tsc -b tsconfig-build-cjs.json",
+    "build:esm": "tsc -b tsconfig-build-esm.json",
+    "postbuild": "cp README.md package.json ../../LICENSE ../../build/ioredis && cp ../../package.cjs.json ../../build/ioredis/cjs/package.json",
+    "lint": "eslint .",
+    "test": "jest",
+    "cover": "jest --collect-coverage",
+    "clean": "npm run clean:src && npm run clean:dist && npm run clean:cover",
+    "clean:src": "ts-cleanup -s src --all",
+    "clean:dist": "rimraf ../../build/ioredis",
+    "clean:cover": "rimraf ../../coverage/ioredis"
+  },
+  "dependencies": {
+  },
+  "devDependencies": {
+    "@nestjs/common": "^9.0.11",
+    "@nestjs/core": "^9.0.11",
+    "@nestjs/testing": "^9.0.11",
+    "@types/ioredis": "^4.28.10"
+  },
+  "peerDependencies": {
+    "@nestjs/common": ">= 7.4.0",
+    "ioredis": ">= 5.x.x"
+  },
+  "type": "module",
+  "main": "cjs/index.js",
+  "module": "esm/index.js",
+  "types": "esm/index.d.ts",
+  "exports": {
+    ".": {
+      "require": "./cjs/index.js",
+      "default": "./esm/index.js"
+    },
+    "./cjs": "./cjs/index.js",
+    "./esm": "./esm/index.js"
+  },
+  "engines": {
+    "node": ">=16.0",
+    "npm": ">=7.0.0"
+  },
+  "files": [
+    "bin/",
+    "cjs/",
+    "esm/",
+    "LICENSE",
+    "README.md"
+  ],
+  "keywords": [
+    "nestjs",
+    "ioredis",
+    "redis"
+  ]
+}