qq-official-bot
Version:
262 lines (261 loc) • 8.35 kB
JavaScript
;
/**
* 事件分发器 - 统一管理事件的分发和处理
*/
Object.defineProperty(exports, "__esModule", { value: true });
exports.EventDispatcher = void 0;
const events_1 = require("events");
/**
* 事件分发器
* 提供统一的事件处理、中间件支持和错误处理
*/
class EventDispatcher extends events_1.EventEmitter {
constructor(bot) {
super();
this.bot = bot;
this.middlewares = new Map();
this.eventStats = new Map();
this.errorHandlers = new Map();
this.setupErrorHandling();
}
/**
* 分发事件
*/
async dispatch(eventName, packet) {
try {
// 更新事件统计
this.updateEventStats(eventName);
// 创建事件元数据
const metadata = {
eventType: eventName,
source: String(packet.s || 'unknown'),
timestamp: Date.now(),
processed: false
};
// 预处理事件数据
const processedEvent = await this.preprocessEvent(eventName, packet);
// 执行中间件链
await this.executeMiddlewares(eventName, processedEvent, metadata);
// 分发给具体的事件处理器
await this.emitEvent(eventName, processedEvent, metadata);
// 标记为已处理
metadata.processed = true;
this.bot.logger.debug(`[EVENT] 事件分发完成: ${eventName}`, {
eventId: packet.id,
timestamp: metadata.timestamp
});
}
catch (error) {
this.bot.logger.error(`[EVENT] 事件分发失败: ${eventName}`, error);
await this.handleEventError(eventName, error, packet);
}
}
/**
* 添加事件中间件
*/
use(eventName, middleware) {
if (!this.middlewares.has(eventName)) {
this.middlewares.set(eventName, []);
}
this.middlewares.get(eventName).push(middleware);
this.bot.logger.debug(`[EVENT] 中间件已添加: ${eventName}`);
}
/**
* 添加全局中间件（对所有事件生效）
*/
useGlobal(middleware) {
this.use('*', middleware);
}
/**
* 添加错误处理器
*/
onError(eventName, handler) {
if (!this.errorHandlers.has(eventName)) {
this.errorHandlers.set(eventName, []);
}
this.errorHandlers.get(eventName).push(handler);
}
/**
* 添加全局错误处理器
*/
onGlobalError(handler) {
this.onError('*', handler);
}
/**
* 获取事件统计信息
*/
getEventStats() {
return new Map(this.eventStats);
}
/**
* 重置事件统计
*/
resetEventStats() {
this.eventStats.clear();
}
/**
* 预处理事件数据
*/
async preprocessEvent(eventName, packet) {
// 根据事件类型进行特定的预处理
switch (eventName) {
case 'message.guild':
case 'message.direct':
case 'message.group':
case 'message.c2c':
return this.bot.processPayload(packet.id, eventName, packet.d);
default:
return packet.d;
}
}
/**
* 执行中间件链
*/
async executeMiddlewares(eventName, event, metadata) {
// 获取全局中间件和特定事件的中间件
const globalMiddlewares = this.middlewares.get('*') || [];
const eventMiddlewares = this.middlewares.get(eventName) || [];
const allMiddlewares = [...globalMiddlewares, ...eventMiddlewares];
if (allMiddlewares.length === 0)
return;
// 创建中间件执行链
let index = 0;
const next = async () => {
if (index >= allMiddlewares.length)
return;
const middleware = allMiddlewares[index++];
await middleware(event, next);
};
await next();
}
/**
* 发出事件
*/
async emitEvent(eventName, event, metadata) {
// 同步触发事件
this.emit(eventName, event, metadata);
// 异步触发事件（如果有async监听器）
const asyncEventName = `async:${eventName}`;
if (this.listenerCount(asyncEventName) > 0) {
setImmediate(() => {
this.emit(asyncEventName, event, metadata);
});
}
}
/**
* 更新事件统计
*/
updateEventStats(eventName) {
const current = this.eventStats.get(eventName) || 0;
this.eventStats.set(eventName, current + 1);
}
/**
* 处理事件错误
*/
async handleEventError(eventName, error, packet) {
// 触发特定事件的错误处理器
const eventErrorHandlers = this.errorHandlers.get(eventName) || [];
const globalErrorHandlers = this.errorHandlers.get('*') || [];
const allErrorHandlers = [...eventErrorHandlers, ...globalErrorHandlers];
for (const handler of allErrorHandlers) {
try {
await handler(error);
}
catch (handlerError) {
this.bot.logger.error(`[EVENT] 错误处理器执行失败:`, handlerError);
}
}
// 发出错误事件
this.emit('error', {
eventName,
error,
packet,
timestamp: Date.now()
});
}
/**
* 设置基础错误处理
*/
setupErrorHandling() {
// 处理未捕获的异常
this.on('error', (errorInfo) => {
this.bot.logger.error(`[EVENT] 未处理的事件错误:`, errorInfo);
});
// 添加默认的全局错误处理器
this.onGlobalError((error) => {
this.bot.logger.error(`[EVENT] 全局事件错误:`, error);
});
}
/**
* 创建事件过滤中间件
*/
static createFilterMiddleware(predicate, onFilter) {
return async (event, next) => {
if (predicate(event)) {
await next();
}
else if (onFilter) {
onFilter(event);
}
};
}
/**
* 创建事件转换中间件
*/
static createTransformMiddleware(transformer) {
return async (event, next) => {
const transformedEvent = await transformer(event);
Object.assign(event, transformedEvent);
await next();
};
}
/**
* 创建事件日志中间件
*/
static createLoggingMiddleware(logger, options = {}) {
const { level = 'debug', includeData = false } = options;
return async (event, next) => {
const start = Date.now();
logger[level](`[EVENT] 开始处理事件`, {
eventType: event.constructor?.name || 'unknown',
data: includeData ? event : undefined
});
await next();
const duration = Date.now() - start;
logger[level](`[EVENT] 事件处理完成`, {
duration: `${duration}ms`
});
};
}
/**
* 创建速率限制中间件
*/
static createRateLimitMiddleware(maxEvents, windowMs) {
const eventCounts = new Map();
return async (event, next) => {
const now = Date.now();
const eventKey = event.user_id || event.guild_id || 'global';
let eventData = eventCounts.get(eventKey);
if (!eventData || now > eventData.resetTime) {
eventData = { count: 0, resetTime: now + windowMs };
eventCounts.set(eventKey, eventData);
}
if (eventData.count >= maxEvents) {
throw new Error(`事件频率限制: ${eventKey} 超过 ${maxEvents} 次/${windowMs}ms`);
}
eventData.count++;
await next();
};
}
/**
* 销毁事件分发器
*/
destroy() {
this.middlewares.clear();
this.eventStats.clear();
this.errorHandlers.clear();
this.removeAllListeners();
this.bot.logger.debug("[EVENT] 事件分发器已销毁");
}
}
exports.EventDispatcher = EventDispatcher;