Getting Started with WebSockets in Hapi.js

import Hapi from '@hapi/hapi';
import { fileURLToPath } from 'url';
import { dirname, join } from 'path';

const __dirname = dirname(fileURLToPath(import.meta.url));

const init = async () => {
    const server = Hapi.server({
        port: process.env.PORT || 3000,
        host: 'localhost'
    });

    // Register static file plugin
    await server.register(Inert);

    await server.start();
    console.log('Server running on %s', server.info.uri);
};

process.on('unhandledRejection', (err) => {
    console.log(err);
    process.exit(1);
});

init();

import Hapi from '@hapi/hapi';
import Inert from '@hapi/inert';
import { fileURLToPath } from 'url';
import { dirname, join } from 'path';

const __dirname = dirname(fileURLToPath(import.meta.url));

const init = async () => {
    const server = Hapi.server({
        port: process.env.PORT || 3000,
        host: 'localhost'
    });

    await server.register(Inert);

    // Serve static files
    server.route({
        method: 'GET',
        path: '/{param*}',
        handler: {
            directory: {
                path: join(__dirname, 'public'),
                index: ['index.html']
            }
        }
    });

    await server.start();
    console.log('Server running on %s', server.info.uri);
};

process.on('unhandledRejection', (err) => {
    console.log(err);
    process.exit(1);
});

init();

import Hapi from '@hapi/hapi';
import Inert from '@hapi/inert';
import Nes from '@hapi/nes';
import { fileURLToPath } from 'url';
import { dirname, join } from 'path';

const __dirname = dirname(fileURLToPath(import.meta.url));

const init = async () => {
    const server = Hapi.server({
        ...
    });
    await server.register([Inert, Nes]);
    // Serve static files
    server.route({
        ...
    });

    // WebSocket subscription endpoint
    server.subscription('/websocket');

    // Handle WebSocket connections
    server.route({
        method: 'POST',
        path: '/message',
        handler: (request, h) => {
            const { message } = request.payload;
            console.log('Received message:', message);

            // Echo message back to all subscribers
            server.publish('/websocket', `Echo from Hapi: ${message}`);

            return { success: true };
        }
    });

    await server.start();
    console.log('Server running on %s', server.info.uri);
};

process.on('unhandledRejection', (err) => {
    console.log(err);
    process.exit(1);
});

init();

import Hapi from '@hapi/hapi';
import Inert from '@hapi/inert';
import Nes from '@hapi/nes';
import { fileURLToPath } from 'url';
import { dirname, join } from 'path';

const __dirname = dirname(fileURLToPath(import.meta.url));

// Connection tracking
const connections = new Map();
let connectionCounter = 0;

function trackConnection(socket) {
    const id = ++connectionCounter;
    const connectionInfo = {
        id,
        connectedAt: new Date(),
        lastActivity: new Date(),
        isActive: true
    };

    connections.set(socket, connectionInfo);
    console.log(`Client ${id} connected. Total connections: ${connections.size}`);
    return connectionInfo;
}

function removeConnection(socket) {
    const info = connections.get(socket);
    if (info) {
        connections.delete(socket);
        console.log(`Client ${info.id} disconnected. Remaining: ${connections.size}`);
    }
}

const init = async () => {
    const server = Hapi.server({
        port: process.env.PORT || 3000,
        host: 'localhost'
    });

    await server.register([
        Inert,
        {
            plugin: Nes,
            options: {
                onConnection: (socket) => {
                    trackConnection(socket);

                    // Send personalized welcome
                    const info = connections.get(socket);
                    server.publish('/websocket', `Welcome! You are user #${info.id}. ${connections.size} users online.`);
                },
                onDisconnection: (socket) => {
                    const info = connections.get(socket);
                    removeConnection(socket);
                    if (info) {
                        server.publish('/websocket', `User #${info.id} left. ${connections.size} users remaining.`);
                    }
                },
                onMessage: (socket, message) => {
                    const info = connections.get(socket);
                    if (info) {
                        info.lastActivity = new Date();
                        console.log(`Message from user #${info.id}:`, message);
                    }
                }
            }
        }
    ]);

    // Serve static files
    server.route({
        ...
    });

    // WebSocket subscription endpoint
    server.subscription('/websocket');

    // Handle WebSocket messages
    server.route({
        method: 'POST',
        path: '/message',
        handler: (request, h) => {
            try {
                const { message } = request.payload;

                if (!message || message.trim().length === 0) {
                    return { success: false, error: 'Message cannot be empty' };
                }

                if (message.length > 500) {
                    return { success: false, error: 'Message too long (max 500 characters)' };
                }

                console.log('Broadcasting message:', message);
                server.publish('/websocket', `User message: ${message}`);

                return { success: true };
            } catch (error) {
                console.error('Message handling error:', error);
                return { success: false, error: 'Server error processing message' };
            }
        }
    });

    await server.start();
    console.log('Server running on %s', server.info.uri);
};

process.on('unhandledRejection', (err) => {
    console.log(err);
    process.exit(1);
});

init();

import Hapi from '@hapi/hapi';
import Inert from '@hapi/inert';
import Nes from '@hapi/nes';
import { fileURLToPath } from 'url';
import { dirname, join } from 'path';

const __dirname = dirname(fileURLToPath(import.meta.url));

// Enhanced connection and broadcasting management
class ConnectionManager {
    constructor() {
        this.connections = new Map();
        this.userCounter = 0;
        this.messageHistory = [];
        this.maxHistorySize = 20;
    }

    addConnection(socket) {
        const userData = {
            id: ++this.userCounter,
            nickname: `User${this.userCounter}`,
            connectedAt: new Date(),
            lastSeen: new Date(),
            messagesSent: 0
        };

        this.connections.set(socket, userData);
        console.log(`${userData.nickname} joined. Total users: ${this.connections.size}`);
        return userData;
    }

    removeConnection(socket) {
        const userData = this.connections.get(socket);
        if (userData) {
            this.connections.delete(socket);
            console.log(`${userData.nickname} left. Remaining users: ${this.connections.size}`);
            return userData;
        }
    }

    updateActivity(socket) {
        const userData = this.connections.get(socket);
        if (userData) {
            userData.lastSeen = new Date();
            userData.messagesSent++;
        }
    }

    addToHistory(message) {
        this.messageHistory.push({
            text: message,
            timestamp: new Date().toISOString()
        });

        if (this.messageHistory.length > this.maxHistorySize) {
            this.messageHistory.shift();
        }
    }

    getStats() {
        return {
            totalUsers: this.connections.size,
            totalMessages: this.messageHistory.length
        };
    }
}

const connectionManager = new ConnectionManager();

const init = async () => {
    const server = Hapi.server({
        port: process.env.PORT || 3000,
        host: 'localhost'
    });

    await server.register([
        Inert,
        {
            plugin: Nes,
            options: {
                onConnection: (socket) => {
                    const userData = connectionManager.addConnection(socket);
                    const stats = connectionManager.getStats();

                    // Send personalized welcome with stats
                    setTimeout(() => {
                        server.publish('/websocket',
                            `Welcome ${userData.nickname}! ${stats.totalUsers} users online, ${stats.totalMessages} messages today.`
                        );

                        // Notify others about new user
                        server.publish('/websocket',
                            `${userData.nickname} joined the chat! Say hello!`
                        );
                    }, 100);
                },
                onDisconnection: (socket) => {
                    const userData = connectionManager.removeConnection(socket);
                    if (userData) {
                        server.publish('/websocket',
                            `${userData.nickname} left the chat. ${connectionManager.getStats().totalUsers} users remain.`
                        );
                    }
                },
                onMessage: (socket, message) => {
                    connectionManager.updateActivity(socket);
                }
            }
        }
    ]);

    // Serve static files
    server.route({
        ...
    });

    // WebSocket subscription endpoint
    server.subscription('/websocket');

    // Enhanced message handling
    server.route({
        method: 'POST',
        path: '/message',
        handler: (request, h) => {
            try {
                ...
                if (message.length > 500) {
                    return { success: false, error: 'Message too long (max 500 characters)' };
                }

                // Add to message history
                connectionManager.addToHistory(message);

                // Broadcast with timestamp and formatting
                const timestamp = new Date().toLocaleTimeString();
                const formattedMessage = `[${timestamp}] ${message}`;

                console.log('Broadcasting:', formattedMessage);
                server.publish('/websocket', formattedMessage);

                return { success: true };
            } catch (error) {
                console.error('Message handling error:', error);
                return { success: false, error: 'Server error processing message' };
            }
        }
    });

    // Add stats endpoint
    server.route({
        method: 'GET',
        path: '/stats',
        handler: (request, h) => {
            return connectionManager.getStats();
        }
    });

    await server.start();
    console.log('Server running on %s', server.info.uri);
};

process.on('unhandledRejection', (err) => {
    console.log(err);
    process.exit(1);
});

init();