vantiv.io 1.0.0

package/src/classes/Handlers/EventHandlers.js

@@ -0,0 +1,259 @@
+const ModelPool = require("highrise-core/src/utils/ModelPool");
+const { User, Position, Message, AnchorPosition, SessionMetadata, Voice, Direct, HiddenChannel, Tip, RoomModerate } = require('highrise-core/src/utils/Models')
+
+const modelPool = new ModelPool()
+
+modelPool.registerModel('Tip', (data) => new Tip(data))
+modelPool.registerModel('User', (data) => new User(data));
+modelPool.registerModel('Voice', (data) => new Voice(data))
+modelPool.registerModel('Direct', (data) => new Direct(data));
+modelPool.registerModel('Message', (data) => new Message(data));
+modelPool.registerModel('Position', (data) => new Position(data));
+modelPool.registerModel('RoomModerate', (data) => new RoomModerate(data))
+modelPool.registerModel('HiddenChannel', (data) => new HiddenChannel(data))
+modelPool.registerModel('AnchorPosition', (data) => new AnchorPosition(data));
+modelPool.registerModel('SessionMetadata', (data) => new SessionMetadata(data));
+
+function safeEmit(server, eventName, ...args) {
+    try {
+        server.emit(eventName, ...args);
+    } catch (error) {
+        console.error(`[PlayerHandlers] Error emitting ${eventName}:`, error);
+        server.emit('handlerError', error, eventName);
+    }
+}
+
+function releaseModels(modelMap) {
+    if (!modelMap) return;
+
+    for (const [type, models] of Object.entries(modelMap)) {
+        if (Array.isArray(models)) {
+            modelPool.releaseBatch(type, models);
+        } else if (models) {
+            modelPool.release(type, models);
+        }
+    }
+}
+
+function HiddenChannelHandler(server, data) {
+    let hiddenChannel = null
+
+    try {
+        hiddenChannel = modelPool.get('HiddenChannel', data)
+
+        if (server._channelManager) {
+            server._channelManager.storeIncomingMessage(
+                hiddenChannel.sender_id,
+                hiddenChannel.message,
+                hiddenChannel.tags
+            );
+        }
+
+
+        safeEmit(server, 'Channel', hiddenChannel.sender_id, hiddenChannel.message, hiddenChannel.tags)
+    } catch (error) {
+        console.error('[HiddenChannelHandler] Error:', error);
+        server.emit('error', error);
+    } finally {
+        if (hiddenChannel) {
+            modelPool.release('HiddenChannel', hiddenChannel);
+        }
+    }
+}
+
+function SessionMetadataHandler(server, data) {
+    let sessionMetadata = null;
+
+    try {
+        server._info.user.id = data.user_id
+        server._info.room.owner_id = data.room_info.owner_id
+        server._info.room.name = data.room_info.room_name
+
+        server.logger.info('Highrise', `Bot is now Online in ${data.room_info.room_name}!\n`);
+
+        sessionMetadata = modelPool.get('SessionMetadata', data);
+        safeEmit(server, 'Ready', sessionMetadata);
+    } catch (error) {
+        console.error('[SessionMetadataHandler] Error:', error);
+        server.emit('error', error);
+    } finally {
+        if (sessionMetadata) {
+            modelPool.release('SessionMetadata', sessionMetadata);
+        }
+    }
+}
+
+function UserJoinedHandler(server, data) {
+    let user = null, position = null;
+
+    try {
+        user = modelPool.get('User', data);
+        position = modelPool.get('Position', data);
+
+        server._movementCache._update(user.id, user.username, position);
+        safeEmit(server, 'UserJoined', user, position);
+    } catch (error) {
+        console.error('[UserJoinHandler] Error:', error);
+        server.emit('error', error);
+    } finally {
+        releaseModels({
+            'User': [user],
+            'Position': [position]
+        });
+    }
+}
+
+function UserLeftHandler(server, data) {
+    let user = null;
+
+    try {
+        user = modelPool.get('User', data);
+        server._movementCache._remove(user.id);
+        safeEmit(server, 'UserLeft', user);
+    } catch (error) {
+        console.error('[UserLeftHandler] Error:', error);
+        server.emit('error', error);
+    } finally {
+        if (user) {
+            modelPool.release('User', user);
+        }
+    }
+}
+
+function MessageEventHandler(server, data) {
+    let message = null;
+    if (data.user?.id === server._info?.user?.id) return;
+
+    try {
+        message = modelPool.get('Message', data);
+        const eventName = data.whisper ? 'Whisper' : 'Chat';
+        safeEmit(server, eventName, message.user, message.message);
+    } catch (error) {
+        console.error('[MessageEventHandler] Error:', error);
+        server.emit('error', error);
+    } finally {
+        if (message) {
+            modelPool.release('Message', message);
+        }
+    }
+}
+
+async function VoiceEventHandler(server, data) {
+    let voice = null
+
+    try {
+        voice = modelPool.get('Voice', data)
+        if (voice.users.length === 0) voice.ended = true
+
+        safeEmit(server, 'Voice', voice.users, voice.seconds_left, voice.ended)
+    } catch (error) {
+        console.error('[VoiceEventHandler] Error:', error);
+        server.emit('error', error);
+    } finally {
+        modelPool.release('Voice', voice);
+    }
+}
+
+async function DirectEventHandler(server, data) {
+    let direct = null
+
+    if (data.user_id === server._info?.user?.id) return;
+
+    const response = await server._direct.messages.get(data.conversation_id)
+
+    try {
+        if (!response || !Array.isArray(response) || response.length === 0) {
+            server.logger.warn('DirectEventHandler', 'No messages in response', {
+                conversationId: data.conversation_id
+            });
+            return;
+        }
+
+        const message = response[0].content || '';
+        data.message = message;
+
+        direct = modelPool.get('Direct', data)
+        server.await._processEvent('direct',
+            { id: data.user_id, username: null },
+            data.message,
+            { id: data.conversation_id, is_new_conversation: data.is_new_conversation }
+        );
+        safeEmit(server, 'Direct', direct.user, direct.message, direct.conversation);
+    } catch (error) {
+        console.error('[DirectEventHandler] Error:', error);
+        server.emit('error', error);
+    } finally {
+        modelPool.release('Direct', direct);
+    }
+}
+
+function UserMovementHandler(server, data) {
+    let user = null, position = null, anchor = null;
+
+    try {
+        user = modelPool.get('User', data);
+        position = modelPool.get('Position', data);
+
+        const isAnchor = data.position?.entity_id;
+        if (isAnchor) {
+            anchor = modelPool.get('AnchorPosition', data);
+        }
+
+        const changed = server._movementCache._update(user.id, user.username, position, anchor);
+
+        if (changed) {
+            safeEmit(server, 'Movement', user, position, anchor);
+        }
+
+    } catch (error) {
+        console.error('[UserMovementHandler] Error:', error);
+        server.emit('error', error);
+    } finally {
+        releaseModels({
+            'User': [user],
+            'Position': [position],
+            'AnchorPosition': [anchor]
+        });
+    }
+}
+
+function TipReactionHandler(server, data) {
+    let tip = null
+
+    try {
+        tip = modelPool.get('Tip', data)
+        safeEmit(server, 'Tip', tip.sender, tip.receiver, tip.item)
+    } catch (error) {
+        console.error('[TipReactionHandler] Error:', error);
+        server.emit('error', error);
+    } finally {
+        modelPool.release('Tip', tip);
+    }
+}
+
+function RoomModerateHandler(server, data) {
+    let roomModerate = null
+
+    try {
+        roomModerate = modelPool.get('RoomModerate', data)
+        safeEmit(server, 'Moderation', roomModerate.moderator, roomModerate.target, roomModerate.action)
+    } catch (error) {
+        console.error('[RoomModerateHandler] Error:', error);
+        server.emit('error', error);
+    } finally {
+        modelPool.release('RoomModerate', roomModerate);
+    }
+}
+
+module.exports = {
+    UserLeftHandler,
+    VoiceEventHandler,
+    UserJoinedHandler,
+    TipReactionHandler,
+    DirectEventHandler,
+    MessageEventHandler,
+    UserMovementHandler,
+    RoomModerateHandler,
+    HiddenChannelHandler,
+    SessionMetadataHandler,
+}

package/src/classes/Handlers/WebSocketHandlers.js

@@ -0,0 +1,54 @@
+const WebSocketConstants = require('highrise-core/src/constants/WebSocketConstants');
+
+class WebSocketHandlers {
+    constructor(server) {
+        this.server = server;
+        this.logger = server.logger;
+    }
+    
+    setupErrorHandlers() {
+        const handlers = {
+            uncaughtException: this._handleUncaughtException.bind(this),
+            unhandledRejection: this._handleUnhandledRejection.bind(this),
+            SIGINT: this._handleSIGINT.bind(this),
+            SIGTERM: this._handleSIGTERM.bind(this)
+        };
+        
+        process.on('uncaughtException', handlers.uncaughtException);
+        process.on('unhandledRejection', handlers.unhandledRejection);
+        process.on('SIGINT', handlers.SIGINT);
+        process.on('SIGTERM', handlers.SIGTERM);
+        
+        return handlers;
+    }
+    
+    _handleUncaughtException(error) {
+        this.logger.error('WebSocketHandlers', `Uncaught exception: ${error.message}`);
+    }
+    
+    _handleUnhandledRejection(reason, promise) {
+        this.logger.error('WebSocketHandlers', `Unhandled promise rejection: ${reason}`);
+    }
+    
+    _handleSIGINT() {
+        this.logger.info('WebSocketHandlers', 'Received SIGINT, shutting down gracefully');
+        this.server.disconnect();
+        setTimeout(() => process.exit(0), 1000);
+    }
+    
+    _handleSIGTERM() {
+        this.logger.info('WebSocketHandlers', 'Received SIGTERM, shutting down gracefully');
+        this.server.disconnect();
+        setTimeout(() => process.exit(0), 1000);
+    }
+    
+    removeErrorHandlers(handlers) {
+        if (!handlers) return;
+        
+        Object.entries(handlers).forEach(([event, handler]) => {
+            process.removeListener(event, handler);
+        });
+    }
+}
+
+module.exports = WebSocketHandlers;

package/src/classes/Managers/ChannelManager.js

@@ -0,0 +1,303 @@
+const crypto = require('crypto');
+
+class ChannelManager {
+    constructor(server) {
+        this.server = server;
+        this.logger = server.logger;
+
+        this._messageHistory = [];
+        this._maxHistory = 500;
+        this._listeners = new Map();
+        this._tagIndex = new Map();
+    }
+
+    async send(message, tags = []) {
+        const method = 'bot.channel.send';
+
+        try {
+            if (typeof message !== 'string' || message.length === 0) {
+                throw new TypeError('Message must be a non-empty string');
+            }
+
+            if (!Array.isArray(tags)) {
+                throw new TypeError('Tags must be an array');
+            }
+
+            const normalizedTags = this._normalizeTags(tags);
+
+            const payload = {
+                _type: 'ChannelRequest',
+                message: message,
+                tags: normalizedTags,
+                rid: crypto.randomUUID()
+            };
+
+            const response = await this.server._fireAndForget.send(payload);
+
+            if (response.success) {
+                this._storeMessage({
+                    id: crypto.randomUUID(),
+                    message,
+                    tags: normalizedTags,
+                    timestamp: Date.now(),
+                    senderId: this.server.info.user?.id || 'unknown',
+                    sent: true
+                });
+
+                this.logger.debug(method, 'Channel message sent', {
+                    tags: normalizedTags,
+                    messageLength: message.length
+                });
+
+                return true;
+            }
+
+            return false;
+
+        } catch (error) {
+            if (error instanceof TypeError) {
+                this.logger.error(method, `TypeError: ${error.message}`, { message, tags }, error);
+            } else {
+                this.logger.error(method, `Failed to send channel message: ${error.message}`,
+                    { message, tags }, error);
+            }
+            return false;
+        }
+    }
+
+    on(tags, callback, options = {}) {
+        const method = 'bot.channel.on';
+
+        try {
+            if (!callback || typeof callback !== 'function') {
+                throw new TypeError('Callback must be a function');
+            }
+
+            const normalizedTags = this._normalizeTags(Array.isArray(tags) ? tags : [tags]);
+
+            const listenerId = crypto.randomUUID();
+            const listener = {
+                id: listenerId,
+                callback,
+                tags: normalizedTags,
+                options: {
+                    once: options.once || false,
+                    ...options
+                }
+            };
+
+            this._listeners.set(listenerId, listener);
+
+            normalizedTags.forEach(tag => {
+                if (!this._tagIndex.has(tag)) {
+                    this._tagIndex.set(tag, new Set());
+                }
+                this._tagIndex.get(tag).add(listenerId);
+            });
+
+            this.logger.debug(method, 'Listener registered', {
+                listenerId,
+                tags: normalizedTags
+            });
+
+            return listenerId;
+
+        } catch (error) {
+            if (error instanceof TypeError) {
+                this.logger.error(method, `TypeError: ${error.message}`, { tags }, error);
+            } else {
+                this.logger.error(method, `Failed to register listener: ${error.message}`, { tags }, error);
+            }
+            return null;
+        }
+    }
+
+    once(tags, callback) {
+        return this.on(tags, callback, { once: true });
+    }
+
+    off(listenerId) {
+        const method = 'bot.channel.off';
+
+        try {
+            const listener = this._listeners.get(listenerId);
+            if (!listener) {
+                this.logger.warn(method, 'Listener not found', { listenerId });
+                return false;
+            }
+
+            listener.tags.forEach(tag => {
+                const set = this._tagIndex.get(tag);
+                if (set) {
+                    set.delete(listenerId);
+                    if (set.size === 0) {
+                        this._tagIndex.delete(tag);
+                    }
+                }
+            });
+
+            this._listeners.delete(listenerId);
+
+            this.logger.debug(method, 'Listener removed', { listenerId });
+            return true;
+
+        } catch (error) {
+            this.logger.error(method, `Failed to remove listener: ${error.message}`, { listenerId }, error);
+            return false;
+        }
+    }
+
+    offAll(tags) {
+        const normalizedTags = this._normalizeTags(Array.isArray(tags) ? tags : [tags]);
+
+        const listenersToRemove = new Set();
+
+        normalizedTags.forEach(tag => {
+            const listeners = this._tagIndex.get(tag);
+            if (listeners) {
+                listeners.forEach(listenerId => listenersToRemove.add(listenerId));
+            }
+        });
+
+        let removed = 0;
+        listenersToRemove.forEach(listenerId => {
+            if (this.off(listenerId)) {
+                removed++;
+            }
+        });
+
+        return removed;
+    }
+
+    query(filter = {}) {
+        const {
+            tags = [],
+            since = 0,
+            until = Date.now(),
+            limit = 50
+        } = filter;
+
+        const normalizedTags = this._normalizeTags(Array.isArray(tags) ? tags : [tags]);
+
+        const results = [];
+
+        for (const msg of this._messageHistory) {
+            if (this._matchesFilter(msg, { tags: normalizedTags, since, until })) {
+                results.push(msg);
+                if (results.length >= limit) break;
+            }
+        }
+
+        return results;
+    }
+
+    getStats() {
+        return {
+            totalMessages: this._messageHistory.length,
+            listeners: this._listeners.size
+        };
+    }
+
+    storeIncomingMessage(senderId, message, tags) {
+        try {
+            const normalizedTags = this._normalizeTags(tags);
+
+            const storedMsg = {
+                id: crypto.randomUUID(),
+                message,
+                tags: normalizedTags,
+                timestamp: Date.now(),
+                senderId,
+                sent: false
+            };
+
+            this._storeMessage(storedMsg);
+
+            this._triggerListeners(storedMsg);
+
+        } catch (error) {
+            this.logger.error('ChannelManager', 'Failed to store incoming message', { error: error.message });
+        }
+    }
+
+    _triggerListeners(message) {
+        const matchedListeners = new Map();
+
+        message.tags.forEach(tag => {
+            const listeners = this._tagIndex.get(tag);
+            if (listeners) {
+                listeners.forEach(listenerId => {
+                    const listener = this._listeners.get(listenerId);
+                    if (listener && !matchedListeners.has(listenerId)) {
+                        const hasAllTags = listener.tags.every(t => message.tags.includes(t));
+                        if (hasAllTags) {
+                            matchedListeners.set(listenerId, listener);
+                        }
+                    }
+                });
+            }
+        });
+
+        matchedListeners.forEach((listener, listenerId) => {
+            try {
+                listener.callback(message);
+
+                if (listener.options.once) {
+                    this.off(listenerId);
+                }
+
+            } catch (error) {
+                this.logger.error('ChannelManager', 'Listener callback error', { listenerId, error: error.message });
+            }
+        });
+    }
+
+    _normalizeTags(tags) {
+        const normalized = tags
+            .map(tag => {
+                if (typeof tag !== 'string') return '';
+                return tag.toLowerCase()
+                    .trim()
+                    .replace(/[^a-z0-9_:.-]/g, '-')
+                    .replace(/-+/g, '-')
+                    .substring(0, 50);
+            })
+            .filter(tag => tag.length > 0)
+            .filter((tag, index, self) => self.indexOf(tag) === index)
+            .sort();
+
+        return normalized.length > 0 ? normalized : ['global'];
+    }
+
+    _storeMessage(message) {
+        this._messageHistory.unshift(message);
+
+        if (this._messageHistory.length > this._maxHistory) {
+            this._messageHistory.splice(this._maxHistory);
+        }
+    }
+
+    _matchesFilter(message, filter) {
+        const { tags = [], since = 0, until = Date.now() } = filter;
+
+        if (message.timestamp < since || message.timestamp > until) {
+            return false;
+        }
+
+        if (tags.length > 0) {
+            const hasAllTags = tags.every(tag => message.tags.includes(tag));
+            if (!hasAllTags) return false;
+        }
+
+        return true;
+    }
+
+    clear() {
+        this._messageHistory = [];
+        this._listeners.clear();
+        this._tagIndex.clear();
+        this.logger.info('ChannelManager', 'Cleared channel history and listeners');
+    }
+}
+
+module.exports = ChannelManager;