@midwayjs/redis 4.0.0-alpha.1 → 4.0.0-beta.10

package/README.md

@@ -9,4 +9,4 @@ Document: [https://midwayjs.org](https://midwayjs.org)
 
 ## License
 
-[MIT]((http://github.com/midwayjs/midway/blob/master/LICENSE))
+[MIT](https://github.com/midwayjs/midway/blob/master/LICENSE)

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,323 @@
+"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 {
+    client;
+    pubsub;
+    options;
+    logger;
+    unsubscribe = null;
+    // 新增：定时刷新 TTL
+    ttlTimeout = null;
+    instance = null;
+    instanceKey = null;
+    serviceName;
+    constructor(serviceName, client, pubsub, options, logger) {
+        super();
+        this.client = client;
+        this.pubsub = pubsub;
+        this.options = options;
+        this.logger = logger;
+        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 {
+    redis;
+    serviceDiscoveryOptions;
+    logger;
+    getListener;
+    registeredInstance = null;
+    onlineInstanceData = null;
+    constructor(redis, serviceDiscoveryOptions, logger, getListener) {
+        super(redis, serviceDiscoveryOptions);
+        this.redis = redis;
+        this.serviceDiscoveryOptions = serviceDiscoveryOptions;
+        this.logger = logger;
+        this.getListener = getListener;
+    }
+    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 {
+    redisServiceFactory;
+    configService;
+    coreLogger;
+    redisServiceDiscoveryOptions;
+    listenerStore = new Map();
+    pubsub;
+    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

@@ -14,39 +14,43 @@ const core_1 = require("@midwayjs/core");
 const ioredis_1 = require("ioredis");
 const assert = require("assert");
 let RedisServiceFactory = class RedisServiceFactory extends core_1.ServiceFactory {
+    redisConfig;
     async init() {
-        await this.initClients(this.redisConfig);
+        await this.initClients(this.redisConfig, {
+            concurrent: true,
+        });
     }
-    async createClient(config) {
+    logger;
+    async createClient(config, name) {
         let client;
         if (config.cluster === true) {
-            assert.ok(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.ok(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`);
             });
             client = new ioredis_1.default.Cluster(config.nodes, config);
             this.logger.info('[midway:redis] cluster is connecting');
         }
         else if (config.sentinels) {
-            assert.ok(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.ok(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`);
             });
             client = new ioredis_1.default(config);
-            this.logger.info('[midway:redis] sentinel is connecting');
+            this.logger.info(`[midway:redis] client(${name}) sentinel is connecting`);
         }
         else {
-            assert.ok(config.host && config.port, `[midway:redis] 'host: ${config.host}', 'port: ${config.port}' are required on config`);
+            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] server is connecting redis://:***@%s:%s', config.host, config.port);
+            this.logger.info(`[midway:redis] client(${name}) server is connecting redis://:***@${config.host}:${config.port}`);
         }
         await new Promise((resolve, reject) => {
             client.on('ready', () => {
-                this.logger.info('[midway:redis] client connect success');
+                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,17 +59,18 @@ 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);
         }
     }
 };
@@ -89,6 +94,8 @@ exports.RedisServiceFactory = RedisServiceFactory = __decorate([
     (0, core_1.Scope)(core_1.ScopeEnum.Singleton)
 ], RedisServiceFactory);
 let RedisService = class RedisService {
+    serviceFactory;
+    instance;
     async init() {
         this.instance = this.serviceFactory.get(this.serviceFactory.getDefaultClientName?.() || 'default');
         if (!this.instance) {

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": "4.0.0-alpha.1",
+  "version": "4.0.0-beta.10",
   "main": "dist/index.js",
   "typings": "index.d.ts",
   "files": [
@@ -10,11 +10,11 @@
     "index.d.ts"
   ],
   "devDependencies": {
-    "@midwayjs/core": "^4.0.0-alpha.1",
-    "@midwayjs/mock": "^4.0.0-alpha.1"
+    "@midwayjs/core": "^4.0.0-beta.10",
+    "@midwayjs/mock": "^4.0.0-beta.10"
   },
   "dependencies": {
-    "ioredis": "5.4.1"
+    "ioredis": "5.4.2"
   },
   "keywords": [
     "redis"
@@ -29,11 +29,11 @@
     "lint": "mwts check"
   },
   "engines": {
-    "node": ">=12"
+    "node": ">=20"
   },
   "repository": {
     "type": "git",
     "url": "https://github.com/midwayjs/midway.git"
   },
-  "gitHead": "14bb4da91805a1cf52f190c0d37a74b395dd6372"
+  "gitHead": "1b1856629913703f67304155aaf611ec936a81ac"
 }