redai-automation-web-sdk
Version:
TypeScript SDK for RedAI Automation Web API - Zalo Personal automation, messaging, advanced sticker search, and bulk operations. 100% compatible with automation-web backend. v1.8.0: Added SessionProxyService for managing proxy assignments to sessions with
310 lines • 9.45 kB
JavaScript
;
/**
* Event handling utility functions
*/
Object.defineProperty(exports, "__esModule", { value: true });
exports.EventUtils = exports.EventManager = void 0;
const eventemitter3_1 = require("eventemitter3");
/**
* Event manager class for handling webhook events
*/
class EventManager extends eventemitter3_1.EventEmitter {
constructor() {
super(...arguments);
this.handlers = new Map();
}
/**
* Register event handler
*/
addHandler(eventType, handler) {
super.on(eventType, handler);
if (!this.handlers.has(eventType)) {
this.handlers.set(eventType, new Set());
}
this.handlers.get(eventType).add(handler);
return this;
}
/**
* Register one-time event handler
*/
addOnceHandler(eventType, handler) {
super.once(eventType, handler);
return this;
}
/**
* Remove event handler
*/
removeHandler(eventType, handler) {
super.off(eventType, handler);
const handlers = this.handlers.get(eventType);
if (handlers) {
handlers.delete(handler);
if (handlers.size === 0) {
this.handlers.delete(eventType);
}
}
return this;
}
/**
* Remove all handlers for event type
*/
removeAllListeners(eventType) {
if (eventType) {
super.removeAllListeners(eventType);
this.handlers.delete(eventType);
}
else {
super.removeAllListeners();
this.handlers.clear();
}
return this;
}
/**
* Emit event to all handlers
*/
async emitAsync(eventType, event) {
const handlers = this.handlers.get(eventType);
if (!handlers || handlers.size === 0) {
return;
}
const promises = Array.from(handlers).map(async (handler) => {
try {
await handler(event);
}
catch (error) {
console.error(`Error in event handler for ${eventType}:`, error);
this.emit('error', error, eventType, event);
}
});
await Promise.all(promises);
}
/**
* Get registered event types
*/
getEventTypes() {
return Array.from(this.handlers.keys());
}
/**
* Get handler count for event type
*/
getHandlerCount(eventType) {
return this.handlers.get(eventType)?.size || 0;
}
/**
* Check if event type has handlers
*/
hasHandlers(eventType) {
return this.getHandlerCount(eventType) > 0;
}
}
exports.EventManager = EventManager;
/**
* Event utilities class
*/
class EventUtils {
/**
* Check if event is a message event
*/
static isMessageEvent(eventType) {
return eventType.includes('message') && !eventType.includes('reaction');
}
/**
* Check if event is a group event
*/
static isGroupEvent(eventType) {
return (eventType.includes('group') ||
eventType.includes('from-group') ||
eventType.includes('to-group'));
}
/**
* Check if event is a friend event
*/
static isFriendEvent(eventType) {
return (eventType.includes('friend') ||
eventType.includes('user-online') ||
eventType.includes('user-offline'));
}
/**
* Check if event is a connection event
*/
static isConnectionEvent(eventType) {
return eventType.includes('connection') || eventType.includes('session');
}
/**
* Check if event is an error event
*/
static isErrorEvent(eventType) {
return eventType.includes('error') || eventType.includes('rate-limit');
}
/**
* Extract message type from event type
*/
static extractMessageType(eventType) {
const match = eventType.match(/^(text|image|video|voice|file|sticker|location|link|gif|doodle)-message/);
return match ? match[1] : null;
}
/**
* Extract direction from event type (sent/received)
*/
static extractDirection(eventType) {
if (eventType.includes('sent-to'))
return 'sent';
if (eventType.includes('received-from'))
return 'received';
return null;
}
/**
* Extract target type from event type (user/group)
*/
static extractTargetType(eventType) {
if (eventType.includes('to-user') || eventType.includes('from-user'))
return 'user';
if (eventType.includes('to-group') || eventType.includes('from-group'))
return 'group';
return null;
}
/**
* Normalize event type
*/
static normalizeEventType(eventType) {
return eventType.toLowerCase().replace(/[_\s]+/g, '-');
}
/**
* Create event filter function
*/
static createEventFilter(criteria) {
return (event) => {
// Filter by message type
if (criteria.messageTypes && criteria.messageTypes.length > 0) {
const messageType = this.extractMessageType(event.eventType);
if (!messageType || !criteria.messageTypes.includes(messageType)) {
return false;
}
}
// Filter by direction
if (criteria.directions && criteria.directions.length > 0) {
const direction = this.extractDirection(event.eventType);
if (!direction || !criteria.directions.includes(direction)) {
return false;
}
}
// Filter by target type
if (criteria.targetTypes && criteria.targetTypes.length > 0) {
const targetType = this.extractTargetType(event.eventType);
if (!targetType || !criteria.targetTypes.includes(targetType)) {
return false;
}
}
// Filter by session ID
if (criteria.sessionIds && criteria.sessionIds.length > 0) {
if (!criteria.sessionIds.includes(event.sessionId)) {
return false;
}
}
// Filter by user UUID
if (criteria.userUuids && criteria.userUuids.length > 0) {
if (!criteria.userUuids.includes(event.userUuid)) {
return false;
}
}
return true;
};
}
/**
* Debounce function for event handling
*/
static debounce(func, delay) {
let timeoutId;
return (...args) => {
clearTimeout(timeoutId);
timeoutId = setTimeout(() => func(...args), delay);
};
}
/**
* Throttle function for event handling
*/
static throttle(func, delay) {
let lastCall = 0;
return (...args) => {
const now = Date.now();
if (now - lastCall >= delay) {
lastCall = now;
func(...args);
}
};
}
/**
* Create rate limiter for events
*/
static createRateLimiter(maxEvents, windowMs) {
const events = [];
return {
canProcess() {
const now = Date.now();
const windowStart = now - windowMs;
// Remove old events outside the window
while (events.length > 0 && events[0] < windowStart) {
events.shift();
}
// Check if we can add another event
if (events.length < maxEvents) {
events.push(now);
return true;
}
return false;
},
getRemainingEvents() {
const now = Date.now();
const windowStart = now - windowMs;
// Remove old events
while (events.length > 0 && events[0] < windowStart) {
events.shift();
}
return Math.max(0, maxEvents - events.length);
},
getResetTime() {
if (events.length === 0) {
return 0;
}
return events[0] + windowMs;
},
};
}
/**
* Create event aggregator
*/
static createEventAggregator(windowMs, processor) {
const events = [];
let timeoutId = null;
return {
add(event) {
events.push(event);
if (timeoutId) {
clearTimeout(timeoutId);
}
timeoutId = setTimeout(() => {
if (events.length > 0) {
processor([...events]);
events.length = 0;
}
timeoutId = null;
}, windowMs);
},
flush() {
if (timeoutId) {
clearTimeout(timeoutId);
timeoutId = null;
}
if (events.length > 0) {
processor([...events]);
events.length = 0;
}
},
getQueuedCount() {
return events.length;
},
};
}
}
exports.EventUtils = EventUtils;
//# sourceMappingURL=event.utils.js.map