@midwayjs/redis 3.20.4 → 4.0.0-beta.1

package/dist/configuration.js

@@ -34,7 +34,8 @@ let RedisConfiguration = class RedisConfiguration {
         };
     }
 };
-RedisConfiguration = __decorate([
+exports.RedisConfiguration = RedisConfiguration;
+exports.RedisConfiguration = RedisConfiguration = __decorate([
     (0, core_1.Configuration)({
         namespace: 'redis',
         importConfigs: [
@@ -46,5 +47,4 @@ RedisConfiguration = __decorate([
         ],
     })
 ], RedisConfiguration);
-exports.RedisConfiguration = RedisConfiguration;
 //# sourceMappingURL=configuration.js.map

package/dist/extension/serviceDiscovery.d.ts

@@ -0,0 +1,68 @@
+import { ServiceDiscovery, ServiceDiscoveryClient, DataListener, ILogger } from '@midwayjs/core';
+import { RedisServiceDiscoveryOptions, RedisInstanceMetadata } from '../interface';
+import Redis from 'ioredis';
+declare class RedisDataListener extends DataListener<RedisInstanceMetadata[]> {
+    protected readonly client: Redis;
+    protected readonly pubsub: Redis;
+    protected readonly options: RedisServiceDiscoveryOptions;
+    protected readonly logger: ILogger;
+    private unsubscribe;
+    private ttlTimeout;
+    private instance;
+    private instanceKey;
+    private serviceName;
+    constructor(serviceName: string, client: Redis, pubsub: Redis, options: RedisServiceDiscoveryOptions, logger: ILogger);
+    init(): Promise<void>;
+    initData(): Promise<RedisInstanceMetadata[]>;
+    onData(setData: any): void;
+    destroyListener(): Promise<void>;
+    onlineInstance(instance?: RedisInstanceMetadata): Promise<void>;
+    offlineInstance(instance?: RedisInstanceMetadata): Promise<void>;
+    /**
+     * 生成实例唯一 key
+     * 格式: <prefix><serviceName>:instance:<instanceId>
+     * 例:   services:order:instance:abc123
+     */
+    private getInstanceKey;
+    private startTTLRefresh;
+    private clearTTLRefresh;
+    /**
+     * 使用 SCAN 替代 KEYS，游标式遍历所有匹配的 key
+     */
+    private scanKeys;
+    /**
+     * 批量获取实例 key 并反序列化为对象数组
+     */
+    private fetchInstancesByKeys;
+}
+export declare class RedisServiceDiscoverClient extends ServiceDiscoveryClient<Redis, RedisServiceDiscoveryOptions, RedisInstanceMetadata> {
+    protected redis: Redis;
+    protected serviceDiscoveryOptions: RedisServiceDiscoveryOptions;
+    protected logger: ILogger;
+    protected getListener: (serviceName: string) => Promise<RedisDataListener>;
+    private registeredInstance;
+    private onlineInstanceData;
+    constructor(redis: Redis, serviceDiscoveryOptions: RedisServiceDiscoveryOptions, logger: ILogger, getListener: (serviceName: string) => Promise<RedisDataListener>);
+    register(instance: RedisInstanceMetadata): Promise<void>;
+    deregister(): Promise<void>;
+    online(): Promise<void>;
+    offline(): Promise<void>;
+    beforeStop(): Promise<void>;
+}
+export declare class RedisServiceDiscovery extends ServiceDiscovery<Redis, RedisServiceDiscoveryOptions, RedisInstanceMetadata, RedisInstanceMetadata, string> {
+    private redisServiceFactory;
+    private configService;
+    private coreLogger;
+    private redisServiceDiscoveryOptions;
+    private listenerStore;
+    private pubsub;
+    init(): Promise<void>;
+    getServiceClient(): Redis;
+    protected createServiceDiscoverClientImpl(options: RedisServiceDiscoveryOptions): RedisServiceDiscoverClient;
+    protected getDefaultServiceDiscoveryOptions(): RedisServiceDiscoveryOptions;
+    private getListener;
+    getInstances(serviceName: string): Promise<RedisInstanceMetadata[]>;
+    beforeStop(): Promise<void>;
+}
+export {};
+//# sourceMappingURL=serviceDiscovery.d.ts.map

package/dist/extension/serviceDiscovery.js

@@ -0,0 +1,312 @@
+"use strict";
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RedisServiceDiscovery = exports.RedisServiceDiscoverClient = void 0;
+const core_1 = require("@midwayjs/core");
+const manager_1 = require("../manager");
+class RedisDataListener extends core_1.DataListener {
+    constructor(serviceName, client, pubsub, options, logger) {
+        super();
+        this.client = client;
+        this.pubsub = pubsub;
+        this.options = options;
+        this.logger = logger;
+        this.unsubscribe = null;
+        // 新增：定时刷新 TTL
+        this.ttlTimeout = null;
+        this.instance = null;
+        this.instanceKey = null;
+        this.serviceName = serviceName;
+    }
+    async init() {
+        await super.init();
+    }
+    async initData() {
+        // 1. 用 SCAN 替代 KEYS 获取所有实例 key
+        const keys = await this.scanKeys(`${this.options.prefix}${this.serviceName}:instance:*`);
+        return this.fetchInstancesByKeys(keys);
+    }
+    onData(setData) {
+        // 订阅当前 serviceName 的变更消息
+        const channel = `service:change:${this.serviceName}`;
+        const handler = async (channelName, message) => {
+            this.logger.debug(`[midway:redis] pubsub event received: channel=${channelName}, message=${message}`);
+            if (channelName !== channel)
+                return;
+            try {
+                // 变更时重新拉取全量数据
+                const keys = await this.scanKeys(`${this.options.prefix}${this.serviceName}:instance:*`);
+                setData(await this.fetchInstancesByKeys(keys));
+            }
+            catch (err) {
+                this.logger.error('[midway:redis] Error on service change:', err);
+            }
+        };
+        this.pubsub.subscribe(channel);
+        this.pubsub.on('message', handler);
+        // 提供取消订阅方法
+        this.unsubscribe = () => {
+            this.pubsub.off('message', handler);
+            this.pubsub.unsubscribe(channel);
+        };
+    }
+    async destroyListener() {
+        this.clearTTLRefresh();
+        if (this.unsubscribe) {
+            this.unsubscribe();
+            this.unsubscribe = null;
+        }
+    }
+    // 新增：上线时启动 TTL 刷新
+    async onlineInstance(instance) {
+        instance = this.instance = instance || this.instance;
+        this.instanceKey = this.getInstanceKey(instance.serviceName, instance.id);
+        const data = { ...instance, status: 'UP' };
+        const ttl = instance.ttl || this.options.ttl || 30;
+        this.logger.debug(`[midway:redis] set key: ${this.instanceKey}, value: ${JSON.stringify(data)}, ttl: ${ttl}`);
+        await this.client.set(this.instanceKey, JSON.stringify(data), 'EX', ttl);
+        this.startTTLRefresh();
+        const testKeys = await this.client.scan('0', 'MATCH', `${this.options.prefix}${instance.serviceName}:instance:*`, 'COUNT', 100);
+        this.logger.debug(`[midway:redis] after set, scan test: ${JSON.stringify(testKeys)}`);
+    }
+    // 新增：下线时清理 TTL 刷新
+    async offlineInstance(instance) {
+        instance = instance || this.instance;
+        this.clearTTLRefresh();
+        const instanceKey = this.getInstanceKey(instance.serviceName, instance.id);
+        await this.client.del(instanceKey);
+    }
+    /**
+     * 生成实例唯一 key
+     * 格式: <prefix><serviceName>:instance:<instanceId>
+     * 例:   services:order:instance:abc123
+     */
+    getInstanceKey(serviceName, instanceId) {
+        return `${this.options.prefix}${serviceName}:instance:${instanceId}`;
+    }
+    startTTLRefresh() {
+        this.clearTTLRefresh();
+        if (!this.instance)
+            return;
+        const ttl = this.instance.ttl || this.options.ttl || 30;
+        const interval = Math.max(ttl * 500, 1000);
+        const refresh = async () => {
+            try {
+                if (this.instanceKey && this.instance) {
+                    const data = { ...this.instance, status: 'UP' };
+                    await this.client.set(this.instanceKey, JSON.stringify(data), 'EX', ttl);
+                }
+            }
+            catch (err) {
+                this.logger.error('[midway:redis] TTL refresh failed:', err);
+            }
+            this.ttlTimeout = setTimeout(refresh, interval);
+        };
+        refresh();
+    }
+    clearTTLRefresh() {
+        if (this.ttlTimeout) {
+            clearTimeout(this.ttlTimeout);
+            this.ttlTimeout = null;
+        }
+    }
+    /**
+     * 使用 SCAN 替代 KEYS，游标式遍历所有匹配的 key
+     */
+    async scanKeys(pattern, count) {
+        let cursor = '0';
+        let keys = [];
+        const scanCount = count || this.options.scanCount || 100;
+        do {
+            const [nextCursor, foundKeys] = await this.client.scan(cursor, 'MATCH', pattern, 'COUNT', scanCount);
+            cursor = nextCursor;
+            keys = keys.concat(foundKeys);
+        } while (cursor !== '0');
+        this.logger.debug(`[midway:redis] scanKeys pattern=${pattern}, found keys=${JSON.stringify(keys)}`);
+        return keys;
+    }
+    /**
+     * 批量获取实例 key 并反序列化为对象数组
+     */
+    async fetchInstancesByKeys(keys) {
+        if (keys.length === 0)
+            return [];
+        const values = await this.client.mget(keys);
+        return values
+            .map(value => {
+            try {
+                return JSON.parse(value);
+            }
+            catch {
+                return null;
+            }
+        })
+            .filter(Boolean);
+    }
+}
+class RedisServiceDiscoverClient extends core_1.ServiceDiscoveryClient {
+    constructor(redis, serviceDiscoveryOptions, logger, getListener) {
+        super(redis, serviceDiscoveryOptions);
+        this.redis = redis;
+        this.serviceDiscoveryOptions = serviceDiscoveryOptions;
+        this.logger = logger;
+        this.getListener = getListener;
+        this.registeredInstance = null;
+        this.onlineInstanceData = null;
+    }
+    async register(instance) {
+        this.registeredInstance = instance;
+        if (!instance.serviceName) {
+            throw new core_1.MidwayConfigMissingError('instance.serviceName is required when register service in redis');
+        }
+        // 注册时默认上线
+        await this.online();
+        this.logger.info(`[midway:redis] register instance: ${instance.id} for service: ${instance.serviceName}`);
+    }
+    async deregister() {
+        if (this.onlineInstanceData) {
+            await this.offline();
+        }
+        if (this.registeredInstance) {
+            // 发布服务变更消息
+            await this.client.publish(`service:change:${this.registeredInstance.serviceName}`, JSON.stringify({
+                type: 'deregister',
+                service: this.registeredInstance.serviceName,
+                instance: this.registeredInstance,
+            }));
+            this.logger.info(`[midway:redis] deregister instance: ${this.registeredInstance.id} for service: ${this.registeredInstance.serviceName}`);
+            this.registeredInstance = null;
+        }
+    }
+    async online() {
+        this.logger.debug('[midway:redis] online() called');
+        this.logger.debug(`[midway:redis] registeredInstance: ${JSON.stringify(this.registeredInstance)}`);
+        if (!this.registeredInstance) {
+            this.logger.error('[midway:redis] online() failed: No instance registered.');
+            throw new Error('No instance registered, cannot online.');
+        }
+        // 已经上线则忽略
+        if (this.onlineInstanceData) {
+            this.logger.debug('[midway:redis] online() ignored: already online.');
+            return;
+        }
+        const listener = await this.getListener(this.registeredInstance.serviceName);
+        await listener.onlineInstance(this.registeredInstance);
+        this.onlineInstanceData = this.registeredInstance;
+        this.logger.info(`[midway:redis] online() success: instance ${this.registeredInstance.id} for service ${this.registeredInstance.serviceName}`);
+        // 发布上线消息
+        await this.client.publish(`service:change:${this.registeredInstance.serviceName}`, JSON.stringify({
+            type: 'online',
+            service: this.registeredInstance.serviceName,
+            instance: this.registeredInstance,
+        }));
+    }
+    async offline() {
+        this.logger.debug('[midway:redis] offline() called');
+        this.logger.debug(`[midway:redis] onlineInstanceData: ${JSON.stringify(this.onlineInstanceData)}`);
+        // 已经下线则忽略
+        if (!this.onlineInstanceData) {
+            this.logger.info('[midway:redis] offline() ignored: already offline.');
+            return;
+        }
+        const listener = await this.getListener(this.onlineInstanceData.serviceName);
+        await listener.offlineInstance(this.onlineInstanceData);
+        this.logger.info(`[midway:redis] offline() success: instance ${this.onlineInstanceData.id} for service ${this.onlineInstanceData.serviceName}`);
+        // 发布下线消息
+        await this.client.publish(`service:change:${this.onlineInstanceData.serviceName}`, JSON.stringify({
+            type: 'offline',
+            service: this.onlineInstanceData.serviceName,
+            instance: this.onlineInstanceData,
+        }));
+        this.onlineInstanceData = null;
+    }
+    async beforeStop() { }
+}
+exports.RedisServiceDiscoverClient = RedisServiceDiscoverClient;
+let RedisServiceDiscovery = class RedisServiceDiscovery extends core_1.ServiceDiscovery {
+    constructor() {
+        super(...arguments);
+        this.listenerStore = new Map();
+    }
+    async init() {
+        this.redisServiceDiscoveryOptions = this.configService.getConfiguration('redis.serviceDiscovery', {});
+        this.redisServiceDiscoveryOptions.prefix =
+            this.redisServiceDiscoveryOptions.prefix || 'services:';
+    }
+    getServiceClient() {
+        return this.redisServiceFactory.get(this.redisServiceDiscoveryOptions.serviceDiscoveryClient ||
+            this.redisServiceFactory.getDefaultClientName() ||
+            'default');
+    }
+    createServiceDiscoverClientImpl(options) {
+        return new RedisServiceDiscoverClient(this.getServiceClient(), options, this.coreLogger, serviceName => this.getListener(serviceName));
+    }
+    getDefaultServiceDiscoveryOptions() {
+        return this.redisServiceDiscoveryOptions;
+    }
+    async getListener(serviceName) {
+        if (!this.pubsub) {
+            this.pubsub = this.getServiceClient().duplicate();
+        }
+        // 日志：打印当前请求的 serviceName
+        this.coreLogger.debug(`[midway:redis] getListener called for serviceName: ${serviceName}`);
+        // 日志：打印当前 listenerStore keys
+        this.coreLogger.debug(`[midway:redis] listenerStore keys: ${Array.from(this.listenerStore.keys()).join(',')}`);
+        if (!this.listenerStore.has(serviceName)) {
+            this.coreLogger.debug(`[midway:redis] listener for ${serviceName} not found, creating new listener.`);
+            const listener = new RedisDataListener(serviceName, this.getServiceClient(), this.pubsub, this.redisServiceDiscoveryOptions, this.coreLogger);
+            this.listenerStore.set(serviceName, listener);
+            await listener.init();
+            this.coreLogger.debug(`[midway:redis] listener for ${serviceName} initialized.`);
+        }
+        else {
+            this.coreLogger.debug(`[midway:redis] listener for ${serviceName} found in cache.`);
+        }
+        return this.listenerStore.get(serviceName);
+    }
+    async getInstances(serviceName) {
+        // 优先从 listener 的缓存获取数据
+        const listener = await this.getListener(serviceName);
+        return listener.getData();
+    }
+    async beforeStop() {
+        await Promise.all(Array.from(this.listenerStore.values()).map(listener => listener.destroyListener()));
+        this.listenerStore.clear();
+        if (this.pubsub) {
+            await this.pubsub.unsubscribe();
+            await this.pubsub.quit();
+            this.pubsub = null;
+        }
+    }
+};
+exports.RedisServiceDiscovery = RedisServiceDiscovery;
+__decorate([
+    (0, core_1.Inject)(),
+    __metadata("design:type", manager_1.RedisServiceFactory)
+], RedisServiceDiscovery.prototype, "redisServiceFactory", void 0);
+__decorate([
+    (0, core_1.Inject)(),
+    __metadata("design:type", core_1.MidwayConfigService)
+], RedisServiceDiscovery.prototype, "configService", void 0);
+__decorate([
+    (0, core_1.Logger)(),
+    __metadata("design:type", Object)
+], RedisServiceDiscovery.prototype, "coreLogger", void 0);
+__decorate([
+    (0, core_1.Init)(),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", []),
+    __metadata("design:returntype", Promise)
+], RedisServiceDiscovery.prototype, "init", null);
+exports.RedisServiceDiscovery = RedisServiceDiscovery = __decorate([
+    (0, core_1.Singleton)()
+], RedisServiceDiscovery);
+//# sourceMappingURL=serviceDiscovery.js.map

package/dist/index.d.ts

@@ -2,5 +2,6 @@ import Redis from 'ioredis';
 export { RedisConfiguration as Configuration } from './configuration';
 export * from './manager';
 export * from './interface';
+export * from './extension/serviceDiscovery';
 export { Redis };
 //# sourceMappingURL=index.d.ts.map

package/dist/index.js

@@ -21,4 +21,5 @@ var configuration_1 = require("./configuration");
 Object.defineProperty(exports, "Configuration", { enumerable: true, get: function () { return configuration_1.RedisConfiguration; } });
 __exportStar(require("./manager"), exports);
 __exportStar(require("./interface"), exports);
+__exportStar(require("./extension/serviceDiscovery"), exports);
 //# sourceMappingURL=index.js.map

package/dist/interface.d.ts

@@ -1,7 +1,69 @@
 import * as Redis from 'ioredis';
 import { ClusterNode, ClusterOptions } from 'ioredis';
+import { DefaultInstanceMetadata, ServiceDiscoveryBaseInstance, ServiceDiscoveryOptions, ServiceFactoryConfigOption } from '@midwayjs/core';
 export type RedisConfigOptions = Redis.RedisOptions | ({
-    cluster?: boolean;
     nodes?: ClusterNode[];
 } & ClusterOptions);
+export interface RedisInstanceMetadata extends ServiceDiscoveryBaseInstance {
+    /**
+     * 服务名称
+     */
+    serviceName: string;
+    /**
+     * 服务实例 ID
+     */
+    id: string;
+    /**
+     * 服务实例的地址
+     */
+    host: string;
+    /**
+     * 服务实例的端口
+     */
+    port: number;
+    /**
+     * 服务实例的过期时间（秒）
+     */
+    ttl?: number;
+    /**
+     * 服务实例的标签
+     */
+    tags?: string[];
+    /**
+     * 服务实例的元数据
+     */
+    meta?: Record<string, string>;
+    /**
+     * 服务实例的状态
+     */
+    status?: 'UP' | 'DOWN';
+}
+export interface RedisServiceDiscoveryOptions extends ServiceDiscoveryOptions<RedisInstanceMetadata> {
+    /**
+     * 服务信息的过期时间（秒）
+     */
+    ttl?: number;
+    /**
+     * 服务信息的 key 前缀
+     */
+    prefix?: string;
+    /**
+     * 服务实例配置
+     */
+    serviceOptions?: RedisInstanceMetadata | ((meta: DefaultInstanceMetadata) => RedisInstanceMetadata);
+    /**
+     * 下线状态的 TTL（秒）
+     */
+    downTTL?: number;
+    /**
+     * SCAN 命令每次遍历的数量，默认 100
+     */
+    scanCount?: number;
+}
+export type MidwayRedisConfigOptions = ServiceFactoryConfigOption<RedisConfigOptions> & {
+    /**
+     * Redis 服务发现配置
+     */
+    serviceDiscovery?: RedisServiceDiscoveryOptions;
+};
 //# sourceMappingURL=interface.d.ts.map

package/dist/manager.d.ts

@@ -5,9 +5,9 @@ export declare class RedisServiceFactory extends ServiceFactory<Redis> {
     protected redisConfig: ServiceFactoryConfigOption<RedisConfigOptions>;
     protected init(): Promise<void>;
     protected logger: ILogger;
-    protected createClient(config: any): Promise<Redis>;
+    protected createClient(config: any, name: string): Promise<Redis>;
     getName(): string;
-    protected destroyClient(redisInstance: any): Promise<void>;
+    protected destroyClient(redisInstance: Redis, name: string): Promise<void>;
 }
 export declare class RedisService implements Redis {
     private serviceFactory;

package/dist/manager.js

@@ -15,38 +15,40 @@ const ioredis_1 = require("ioredis");
 const assert = require("assert");
 let RedisServiceFactory = class RedisServiceFactory extends core_1.ServiceFactory {
     async init() {
-        await this.initClients(this.redisConfig);
+        await this.initClients(this.redisConfig, {
+            concurrent: true,
+        });
     }
-    async createClient(config) {
+    async createClient(config, name) {
         let client;
         if (config.cluster === true) {
-            assert(config.nodes && config.nodes.length !== 0, '[midway:redis] cluster nodes configuration is required when use cluster redis');
+            assert.ok(config.nodes && config.nodes.length !== 0, `[midway:redis] client(${name}) cluster nodes configuration is required when use cluster redis`);
             config.nodes.forEach(client => {
-                assert(client.host && client.port, `[midway:redis] 'host: ${client.host}', 'port: ${client.port}' are required on config`);
+                assert.ok(client.host && client.port, `[midway:redis] client(${name}) 'host: ${client.host}', 'port: ${client.port}' are required on config`);
             });
-            this.logger.info('[midway:redis] cluster connecting');
             client = new ioredis_1.default.Cluster(config.nodes, config);
+            this.logger.info('[midway:redis] cluster is connecting');
         }
         else if (config.sentinels) {
-            assert(config.sentinels && config.sentinels.length !== 0, '[midway:redis] sentinels configuration is required when use redis sentinel');
+            assert.ok(config.sentinels && config.sentinels.length !== 0, `[midway:redis] client(${name}) sentinels configuration is required when use redis sentinel`);
             config.sentinels.forEach(sentinel => {
-                assert(sentinel.host && sentinel.port, `[midway:redis] 'host: ${sentinel.host}', 'port: ${sentinel.port}' are required on config`);
+                assert.ok(sentinel.host && sentinel.port, `[midway:redis] client(${name}) 'host: ${sentinel.host}', 'port: ${sentinel.port}' are required on config`);
             });
-            this.logger.info('[midway:redis] sentinel connecting start');
             client = new ioredis_1.default(config);
+            this.logger.info(`[midway:redis] client(${name}) sentinel is connecting`);
         }
         else {
-            assert(config.host && config.port, `[midway:redis] 'host: ${config.host}', 'port: ${config.port}' are required on config`);
-            this.logger.info('[midway:redis] server connecting redis://:***@%s:%s', config.host, config.port);
+            assert.ok(config.host && config.port, `[midway:redis] client(${name}) 'host: ${config.host}', 'port: ${config.port}' are required on config`);
             client = new ioredis_1.default(config);
+            this.logger.info(`[midway:redis] client(${name}) server is connecting redis://:***@${config.host}:${config.port}`);
         }
         await new Promise((resolve, reject) => {
-            client.on('connect', () => {
-                this.logger.info('[midway:redis] client connect success');
+            client.on('ready', () => {
+                this.logger.info(`[midway:redis] client(${name}) connect success`);
                 resolve();
             });
             client.on('error', err => {
-                this.logger.error('[midway:redis] client error: %s', err);
+                this.logger.error(`[midway:redis] client(${name}) error: ${err}`);
                 reject(err);
             });
         });
@@ -55,20 +57,22 @@ let RedisServiceFactory = class RedisServiceFactory extends core_1.ServiceFactor
     getName() {
         return 'redis';
     }
-    async destroyClient(redisInstance) {
+    async destroyClient(redisInstance, name) {
         try {
             if (redisInstance) {
                 const canQuit = !['end', 'close'].includes(redisInstance.status);
                 if (canQuit) {
                     await redisInstance.quit();
+                    this.logger.info(`[midway:redis] client(${name}) quit success`);
                 }
             }
         }
         catch (error) {
-            this.logger.error('[midway:redis] Redis quit failed.', error);
+            this.logger.error(`[midway:redis] client(${name}) Redis quit failed.`, error);
         }
     }
 };
+exports.RedisServiceFactory = RedisServiceFactory;
 __decorate([
     (0, core_1.Config)('redis'),
     __metadata("design:type", Object)
@@ -83,20 +87,19 @@ __decorate([
     (0, core_1.Logger)('coreLogger'),
     __metadata("design:type", Object)
 ], RedisServiceFactory.prototype, "logger", void 0);
-RedisServiceFactory = __decorate([
+exports.RedisServiceFactory = RedisServiceFactory = __decorate([
     (0, core_1.Provide)(),
     (0, core_1.Scope)(core_1.ScopeEnum.Singleton)
 ], RedisServiceFactory);
-exports.RedisServiceFactory = RedisServiceFactory;
 let RedisService = class RedisService {
     async init() {
-        var _a, _b;
-        this.instance = this.serviceFactory.get(((_b = (_a = this.serviceFactory).getDefaultClientName) === null || _b === void 0 ? void 0 : _b.call(_a)) || 'default');
+        this.instance = this.serviceFactory.get(this.serviceFactory.getDefaultClientName?.() || 'default');
         if (!this.instance) {
             throw new core_1.MidwayCommonError('redis default instance not found.');
         }
     }
 };
+exports.RedisService = RedisService;
 __decorate([
     (0, core_1.Inject)(),
     __metadata("design:type", RedisServiceFactory)
@@ -107,11 +110,10 @@ __decorate([
     __metadata("design:paramtypes", []),
     __metadata("design:returntype", Promise)
 ], RedisService.prototype, "init", null);
-RedisService = __decorate([
+exports.RedisService = RedisService = __decorate([
     (0, core_1.Provide)(),
     (0, core_1.Scope)(core_1.ScopeEnum.Singleton)
 ], RedisService);
-exports.RedisService = RedisService;
 (0, core_1.delegateTargetAllPrototypeMethod)(RedisService, ioredis_1.default);
 RedisService.prototype.defineCommand = function (name, definition) {
     this.instance.defineCommand(name, definition);

package/index.d.ts

@@ -1,4 +1,4 @@
-import { RedisConfigOptions } from './dist';
+import { MidwayRedisConfigOptions } from './dist';
 export * from './dist/index';
 
 // Single Redis
@@ -48,6 +48,6 @@ export * from './dist/index';
 
 declare module '@midwayjs/core/dist/interface' {
   interface MidwayConfig {
-    redis?: ServiceFactoryConfigOption<RedisConfigOptions>;
+    redis?: MidwayRedisConfigOptions;
   }
 }

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@midwayjs/redis",
   "description": "midway redis component",
-  "version": "3.20.4",
+  "version": "4.0.0-beta.1",
   "main": "dist/index.js",
   "typings": "index.d.ts",
   "files": [
@@ -10,8 +10,8 @@
     "index.d.ts"
   ],
   "devDependencies": {
-    "@midwayjs/core": "^3.20.4",
-    "@midwayjs/mock": "^3.20.4"
+    "@midwayjs/core": "^4.0.0-beta.1",
+    "@midwayjs/mock": "^4.0.0-beta.1"
   },
   "dependencies": {
     "ioredis": "5.4.2"
@@ -23,8 +23,8 @@
   "license": "MIT",
   "scripts": {
     "build": "tsc",
-    "test": "node --require=ts-node/register ../../node_modules/.bin/jest --runInBand",
-    "cov": "node --require=ts-node/register ../../node_modules/.bin/jest --runInBand --coverage --forceExit",
+    "test": "node -r ts-node/register ../../node_modules/jest/bin/jest.js --runInBand",
+    "cov": "node -r ts-node/register ../../node_modules/jest/bin/jest.js --runInBand --coverage --forceExit",
     "ci": "npm run test",
     "lint": "mwts check"
   },
@@ -35,5 +35,5 @@
     "type": "git",
     "url": "https://github.com/midwayjs/midway.git"
   },
-  "gitHead": "c3fb65a7ada8829635f3c6af5ef83c65c3a43d79"
+  "gitHead": "832961ec3aff123c033197d8c00cb2bc9bad7ff8"
 }