NodeServer - Structure Analysis¶

npm audit fix              # Fix known vulnerabilities
npm update winston         # Update logging
npm install firebase-admin@latest  # Update Firebase SDK
npm install mssql@latest   # Update SQL driver

server.js (2968 lines)
├── Constants & Enums
├── Configuration
├── Server Initialization
├── Connection Handling
├── Presence Mode Functions (800+ lines)
├── Collaboration Mode Functions (600+ lines)
├── Messaging Functions (400+ lines)
└── Utility Functions

src/
├── index.js (entry point)
├── config/
│   ├── constants.js (cCommand, cReason, etc.)
│   ├── database.js (per-tenant DB configs)
│   ├── firebase.js (FCM settings)
│   └── ssl.js (SSL cert loading)
├── handlers/
│   ├── presenceHandler.js (P_* commands)
│   ├── collaborationHandler.js (C_* commands)
│   └── messagingHandler.js (messaging functions)
├── services/
│   ├── authService.js (authentication logic)
│   ├── notificationService.js (FCM/APN)
│   └── dbService.js (SQL query wrappers)
├── models/
│   ├── User.js
│   ├── Collaboration.js
│   └── Message.js
└── utils/
    ├── logger.js
    ├── tokenGenerator.js
    └── validators.js

Client Connection
    ↓
wss.on('connection')
    ↓
Parse Query Params
    ↓
Route to Authentication
    ↓
client.on('message')
    ↓
Parse JSON Command
    ↓
Route to P/C Handler
    ↓
Process Command
    ↓
Send Response
    ↓
client.on('close')
    ↓
Cleanup Resources

wss.on('connection', (client, request) => {
    // Initial connection setup
    client.on('message', (data) => {
        // Message routing
    });
    client.on('close', (code, data) => {
        // Cleanup
    });
    client.on('error', (error) => {
        // Error handling
    });
    client.on('pong', heartbeat);
});

// Convert to async/await
async function handleMessage(client, data) {
    const message = JSON.parse(data);

    try {
        switch(message.Command) {
            case cCommand.P_AUTHENTICATE:
                await handleAuthentication(client, message);
                break;
            // ...
        }
    } catch (error) {
        await handleError(client, error);
    }
}

// Use Promise-based SQL queries
async function authenticateUser(communicationKey) {
    const request = new sql.Request(connection);
    const result = await request
        .input('verificationCode', sql.NVarChar(100), communicationKey)
        .execute('COB_Authenticate_Get_User_List');
    return result.recordsets[0];
}

var userList = [];                  // All authenticated users
var pUserConnectionList = [];       // Presence connections
var cUserConnectionList = [];       // Collaboration connections
var collaborationList = [];         // Active sessions
var connection = null;              // SQL connection (singleton)

{
    Id: 42,
    UserInfo: {
        Id: 42,
        Fullname: "John Doe",
        Email: "john@example.com",
        Status: 2,  // ONLINE
        CollaborationStatus: 1,  // AVAILABLE
        NetworkStatus: 7,  // NETWORK_OK
        // Tenant-specific fields
        PatientId?: 123,
        ServiceProviderId?: 456,
        IsPatient?: true
    },
    UserList: [/* Friend list */]
}

{
    Id: 1636540800000,  // Timestamp-based ID
    deviceId: "android_device_123",
    clientPlatform: 2,   // MOBILE_ANDROID
    wsClient: WebSocket  // ws library object
}

{
    Id: 42,  // User ID
    wsClientList: [
        { Id: 123, deviceId: "android_1", wsClient: WebSocket },
        { Id: 456, deviceId: "web_1", wsClient: WebSocket }
    ]
}

{
    Key: "uuid-1234-5678",
    Initiator: { /* User object */ },
    ParticipantList: [{ /* User objects */ }],
    BookingId: 789,
    IsScheduled: 1,
    StartTime: "2025-11-10 12:00:00",
    TimeLimit: 60,  // seconds
    CountdownTimer: setTimeout()  // Node.js timer reference
}

// Use Redis for shared state
const Redis = require('ioredis');
const redis = new Redis();

// Store user presence in Redis
async function setUserOnline(userId, deviceId) {
    await redis.hset(`user:${userId}`, 'status', 'ONLINE');
    await redis.sadd(`user:${userId}:devices`, deviceId);
    await redis.expire(`user:${userId}`, 3600);  // 1 hour TTL
}

// Pub/Sub for multi-server communication
redis.subscribe('collaboration:events');
redis.on('message', (channel, message) => {
    broadcastToLocalClients(JSON.parse(message));
});

NodeServer/
├── server.js                   # Main server (2968 lines)
│   ├── Lines 1-150:    Constants & Enums
│   ├── Lines 150-250:  Configuration & Init
│   ├── Lines 250-400:  Connection Handling
│   ├── Lines 400-2200: Presence Functions
│   ├── Lines 2200-2800: Collaboration Functions
│   └── Lines 2800-2968: Messaging Functions
│
├── package.json                # Dependencies
├── package-lock.json           # Dependency lock
├── config.json                 # Runtime config
│   └── { "enableLog": "true" }
│
├── restart.sh                  # Linux restart script
│
├── ssl/                        # SSL certificates
│   ├── PSYTER_DEV/
│   │   ├── key_live.pem
│   │   └── cert_live.pem
│   ├── PSYTER_LIVE/
│   ├── QURAN_DEV/
│   ├── QURAN_LMS/
│   ├── ASSESSMENTSYSTEM_*/
│   └── ...
│
└── node_modules/               # Installed packages

function PAuthenticate(command, client, data) {
    // Directly accesses global:
    // - connection (SQL)
    // - userList
    // - pUserConnectionList

    var request = new sql.Request(connection);  // Global
    // ...
    userList.push(userObject);  // Global
    pUserConnectionList.push(pUserConnectionObject);  // Global
}

class PresenceHandler {
    constructor(dbConnection, userStore, logger) {
        this.db = dbConnection;
        this.users = userStore;
        this.logger = logger;
    }

    async authenticate(client, data) {
        const request = new sql.Request(this.db);
        // ...
        await this.users.addUser(userObject);
        this.logger.info('User authenticated');
    }
}

┌─────────────────────────────────────────────────────────┐
│                  Client Connection                       │
└─────────────────────────────────────────────────────────┘
                          │
                          ▼
┌─────────────────────────────────────────────────────────┐
│   wss.on('connection', (client, request))               │
│   - Parse URL query parameters                          │
│   - Validate connectionMode                             │
└─────────────────────────────────────────────────────────┘
                          │
           ┌──────────────┴──────────────┐
           │                             │
           ▼                             ▼
┌─────────────────────┐       ┌─────────────────────┐
│  Presence Mode (1)  │       │ Collaboration (2)   │
│  - Authentication   │       │  - Join session     │
│  - Status updates   │       │  - WebRTC signals   │
│  - Messaging        │       │  - Call controls    │
└─────────────────────┘       └─────────────────────┘
           │                             │
           └──────────────┬──────────────┘
                          │
                          ▼
┌─────────────────────────────────────────────────────────┐
│            client.on('message', (data))                 │
│   - Parse JSON                                          │
│   - Extract Command, Message, FromUser, ToUserList      │
└─────────────────────────────────────────────────────────┘
                          │
           ┌──────────────┴──────────────┐
           │                             │
           ▼                             ▼
┌─────────────────────┐       ┌─────────────────────┐
│  PProcessCommand()  │       │  CProcessCommand()  │
│  - P_* commands     │       │  - C_* commands     │
└─────────────────────┘       └─────────────────────┘
           │                             │
           └──────────────┬──────────────┘
                          │
                          ▼
┌─────────────────────────────────────────────────────────┐
│                Business Logic Layer                      │
│  - Database queries (SQL Server)                        │
│  - State updates (userList, collaborationList)          │
│  - Push notifications (FCM/APN)                         │
└─────────────────────────────────────────────────────────┘
                          │
                          ▼
┌─────────────────────────────────────────────────────────┐
│              PSendCommand() / CSendCommand()            │
│   - Serialize to JSON                                   │
│   - ws.send() to client(s)                              │
└─────────────────────────────────────────────────────────┘
                          │
                          ▼
┌─────────────────────────────────────────────────────────┐
│            client.on('close', (code, data))             │
│   - Cleanup connections                                 │
│   - Broadcast sign-out                                  │
│   - Clear collaboration                                 │
└─────────────────────────────────────────────────────────┘

Client → P_AUTHENTICATE
    ↓
Server queries DB (COB_Authenticate_Get_User_List)
    ↓
Server adds to userList, pUserConnectionList
    ↓
Server broadcasts P_SIGNIN to user's friends
    ↓
Server sends P_AUTHENTICATE response to client

Initiator → C_CREATE_COLLABORATION
    ↓
Server generates collaborationKey
    ↓
Server adds to collaborationList
    ↓
Server sends P_ACCEPT_COLLABORATION to participants (via FCM if offline)
    ↓
Participants connect with connectionMode=2&collaborationKey=...
    ↓
Server routes C_SDP, C_ICECANDIDATE between peers
    ↓
Initiator/Participant → C_END_COLLABORATION
    ↓
Server calls CConsumptionInsert() to log duration
    ↓
Server broadcasts C_END_COLLABORATION
    ↓
Server clears collaborationList entry

Sender → P_SEND_MESSAGE
    ↓
Server calls Message_InsertMessage stored procedure
    ↓
Server sends P_RECIEVE_MESSAGE to recipient (if online)
    ↓
Server sends PSendFCMNotification (if offline)
    ↓
Server sends P_SEND_MESSAGE response to sender

// Tier 1: User-level aggregation
pUserConnectionList = [
    {
        Id: 42,  // User ID
        wsClientList: [/* Tier 2 */]
    }
];

// Tier 2: Device-level connections
wsClientList = [
    {
        Id: 1636540800000,  // Client ID (timestamp)
        deviceId: "android_123",
        clientPlatform: 2,  // MOBILE_ANDROID
        wsClient: WebSocket
    }
];

// User 42 has 3 devices connected
pUserConnectionList = [
    {
        Id: 42,
        wsClientList: [
            { deviceId: "android_phone", wsClient: WebSocket1 },
            { deviceId: "web_browser", wsClient: WebSocket2 },
            { deviceId: "android_tablet", wsClient: WebSocket3 }
        ]
    }
];

// Broadcast to all 3 devices
PSendCommand(pUserConnection[0].wsClientList, message, command, reason);

setInterval(function ping() {
    wss.clients.forEach(function each(ws) {
        if (ws.isAlive === false) {
            OnUnExpectedConnectionClose(ws);
            return ws.terminate();
        }
        ws.isAlive = false;
        ws.ping(noop);
    });
}, (30 * 60 * 1000));  // Every 30 minutes

client.on('close', function (code, data) {
    // Removes from pUserConnectionList/cUserConnectionList
    // Broadcasts P_SIGNOUT if last device
    CleanSocketConnectionList();
    CleanOtherUserList();
});

function CleanSocketConnectionList() {
    // Filter out closed connections
    pUserConnectionList.forEach(pUserConnection => {
        pUserConnection.wsClientList = pUserConnection.wsClientList.filter(
            p => p.wsClient.readyState === ws.OPEN
        );
    });

    // Remove users with no active connections
    pUserConnectionList = pUserConnectionList.filter(
        p => p.wsClientList.length > 0
    );
}

cCommand = {
    // Presence Commands (P_*)
    P_AUTHENTICATE: 1,
    P_SIGNIN: 2,
    P_SIGNOUT: 3,
    P_CLOSE: 4,
    P_CHAT: 5,
    // ... 20 more presence commands

    // Collaboration Commands (C_*)
    C_INITIATE: 12,
    C_CREATE_COLLABORATION: 13,
    C_SDP: 16,
    C_ICECANDIDATE: 17,
    // ... 15 more collaboration commands

    // Shared/Special
    COMMAND_RECEIVED_ACK: 40,
    P_FILE_START: 47,
    P_FILE_DATA: 48,
    P_FILE_END: 49,
    // ...
};

function PProcessCommand(client, data, command, fromUser, toUserList, ...) {
    switch (command) {
        case cCommand.P_AUTHENTICATE:
            PAuthenticate(command, client, data);
            break;
        case cCommand.P_SIGNOUT:
            PSignOut(client, fromUser.Id);
            break;
        case cCommand.P_CHAT:
            PSendToUser(command, data, fromUser, toUserList);
            break;
        case cCommand.P_SEND_MESSAGE:
            PSendMessage(client, command, data, fromUser, toUserList, clientInitiationTime);
            break;
        // ... 20+ more cases
        default:
            // No default handler! Silently ignored.
    }
}

function CProcessCommand(client, data, command, collaborationKey, ...) {
    switch (command) {
        case cCommand.C_INITIATE:
            CInitiate(client, data, collaborationKey);
            break;
        case cCommand.C_CREATE_COLLABORATION:
            CCreateCollaboration(client, command, fromUser, toUserList, ...);
            break;
        case cCommand.C_SDP:
        case cCommand.C_ICECANDIDATE:
            CBroadCast(command, data, fromUser, collaborationKey, cReason.SUCCESS);
            break;
        // ... 15+ more cases
    }
}

function PProcessCommand(client, data, command, ...) {
    // Validate command
    if (!isValidPresenceCommand(command)) {
        logInfo(`Invalid command: ${command}`, logType.ERROR);
        PClose(client, 'Invalid command', cReason.INVALID_REQUEST);
        return;
    }

    // Rate limiting
    if (!checkRateLimit(client, command)) {
        logInfo(`Rate limit exceeded for user ${client.UserId}`, logType.ERROR);
        return;
    }

    // Permission check
    if (!hasPermission(client, command)) {
        PClose(client, 'Permission denied', cReason.NO_PERMISSION);
        return;
    }

    // Route to handler
    const handler = presenceHandlers[command];
    if (handler) {
        handler(client, data, ...);
    } else {
        logInfo(`No handler for command ${command}`, logType.ERROR);
    }
}

var connection = null;  // SQL connection object

function sqlConnect() {
    connection = sql.connect(dbConfig, function (err) {
        if (err) {
            logInfo("sql.connect  -->  err = " + err, logType.ERROR);
        } else {
            logInfo("Sql connection is established");
            loadFCMAPISettings();
        }
    });
}

sql.on('error', err => {
    logInfo("sql  -->  on(error)  -->  err = " + err, logType.ERROR);
});

const sql = require('mssql');

const pool = new sql.ConnectionPool({
    ...dbConfig,
    pool: {
        max: 10,
        min: 2,
        idleTimeoutMillis: 30000
    },
    options: {
        connectTimeout: 30000,
        requestTimeout: 30000
    }
});

async function connectDB() {
    try {
        await pool.connect();
        logInfo("Database pool connected");
    } catch (err) {
        logInfo(`DB connection failed: ${err}`, logType.ERROR);
        setTimeout(connectDB, 5000);  // Retry after 5s
    }
}

pool.on('error', err => {
    logInfo(`Pool error: ${err}`, logType.ERROR);
});

var request = new sql.Request(connection);
request
    .input('verificationCode', sql.NVarChar(100), data.communicationKey)
    .input('authenticateOnly', sql.Int, data.authenticateOnly)
    .execute('COB_Authenticate_Get_User_List', (err, result) => {
        if (err != null) {
            logInfo("Error: " + err, logType.ERROR);
            PClose(client, err.message, cReason.DATABASE_NOT_AVAILABLE);
            return;
        }

        if (result !== undefined && result.recordsets.length > 1) {
            var objUser = result.recordsets[0];
            // Process result
        }
    });

admin.initializeApp({
    credential: admin.credential.cert({
        projectId: fcmAPISettings.ProjectId,
        clientEmail: fcmAPISettings.ClientEmail,
        privateKey: fcmAPISettings.PrivateKey
    }),
    databaseURL: fcmAPISettings.DatabaseURL
});

function SendFCMNotification(topic, title, body, fromUser, toUser, collaborationKey, retryNotify, isPresenceNotification) {
    var message = {
        topic: topic,  // Or condition with multiple topics
        data: {
            title: title,
            body: body
        },
        android: {
            priority: "high"
        },
        apns: {
            payload: {
                aps: {
                    alert: {
                        title: "Incoming call",
                        body: fromUser.Fullname
                    },
                    sound: "ringtone.mp3"
                },
                collaborationData: body
            }
        }
    };

    admin.messaging().send(message)
        .then(response => { /* Success */ })
        .catch(error => { /* Retry or mark unreachable */ });
}

// Psyter
if (toUser.IsPatient) {
    topic = 'patient_' + toUser.PatientId + '~';
} else {
    topic = 'doctor_' + toUser.ServiceProviderId + '~';
}

// Assessment Systems
if (toUser.IsStudent) {
    topic = 'student_' + toUser.StudentId + '~';
} else {
    topic = 'staff_' + toUser.StaffId + '~';
}

// Generic
topic = 'user_' + toUser.Id + '~';

var apnOptions = {
    token: {
        key: "ssl/AuthKey_L7XHN784FM.p8",
        keyId: "L7XHN784FM",
        teamId: "EV53AQE262"
    },
    production: false
};

apnProvider = new apn.Provider(apnOptions);

var note = new apn.Notification();
note.expiry = Math.floor(Date.now() / 1000) + 3600;
note.payload = {
    aps: {
        alert: {
            title: "Incoming call",
            body: fromUser.Fullname
        },
        sound: "ringtone.mp3"
    },
    collaborationData: body
};
note.topic = "com.innotech-sa.Quran-University.voip";

apnProvider.send(note, deviceToken).then(result => {
    // Handle result
});

cClient = {
    QURAN_DEV: 1,
    QURAN_LMS: 2,
    PSYTER_DEV: 3,
    PSYTER_LIVE: 4,
    ONE2ONE: 5,
    ASSESSMENTSYSTEM_DEV: 6,
    ASSESSMENTSYSTEM_AFU: 7,
    ASSESSMENTSYSTEM_PSU: 8,
    ASSESSMENTSYSTEM_KSU: 9,
    ASSESSMENTSYSTEM_MBRU: 10,
    ASSESSMENTSYSTEM_TAIF: 11,
    NARAAKUM_DEV: 12
};

switch (currentClientMode) {
    case cClient.PSYTER_DEV:
        dbConfig = {
            server: 'db.innotech-sa.com',
            database: 'Psyter_v1'
        };
        break;
    case cClient.PSYTER_LIVE:
        dbConfig = {
            server: '51.89.234.59',
            database: 'Psyter'
        };
        break;
    // ... 10 more cases
}

switch (currentClientMode) {
    case cClient.PSYTER_DEV:
        fcmAPISettings = {
            ProjectId: "psyterdev",
            ClientEmail: "firebase-adminsdk-uh0r6@psyterdev.iam.gserviceaccount.com",
            // ...
        };
        break;
    // ... other tenants
}

var pkey = fs.readFileSync(`ssl/${getKeyByValue(cClient, currentClientMode)}/key_live.pem`);
var pcert = fs.readFileSync(`ssl/${getKeyByValue(cClient, currentClientMode)}/cert_live.pem`);

if ((currentClientMode == cClient.ASSESSMENTSYSTEM_DEV || 
     currentClientMode == cClient.ASSESSMENTSYSTEM_AFU ||
     /* ... other assessment modes */) && 
    objUser[0].IsStudent) {

    PClose(client, '', cReason.ALREADY_LOGGED_IN);  // Deny duplicate login
    return;
}

if (currentClientMode == cClient.PSYTER_LIVE || 
    currentClientMode == cClient.PSYTER_DEV) {

    request.execute('SP_ManageCareProvidersServiceCount', ...);
}

// Externalize to JSON config file
const tenants = require('./tenants.json');

{
    "PSYTER_DEV": {
        "id": 3,
        "port": 3333,
        "database": {
            "server": "db.innotech-sa.com",
            "database": "Psyter_v1",
            "user": "PsyterUser"
        },
        "firebase": {
            "projectId": "psyterdev",
            "credentialsFile": "firebase/psyter-dev.json"
        },
        "ssl": {
            "keyFile": "ssl/PSYTER_DEV/key.pem",
            "certFile": "ssl/PSYTER_DEV/cert.pem"
        }
    },
    // ... other tenants
}

var userList = [];                  // All authenticated users
var pUserConnectionList = [];       // Presence WebSocket connections
var cUserConnectionList = [];       // Collaboration WebSocket connections
var collaborationList = [];         // Active collaboration sessions

const Redis = require('ioredis');
const redis = new Redis();

// Store user presence
async function addUserPresence(userId, userInfo) {
    await redis.hset(`user:${userId}`, {
        fullname: userInfo.Fullname,
        status: userInfo.Status,
        collaborationStatus: userInfo.CollaborationStatus
    });
    await redis.expire(`user:${userId}`, 3600);
}

// Store collaboration
async function createCollaboration(key, initiator, participants) {
    await redis.hset(`collab:${key}`, {
        initiator: JSON.stringify(initiator),
        participants: JSON.stringify(participants),
        startTime: Date.now()
    });
}

// Pub/Sub for multi-server sync
redis.subscribe('user:status:*');
redis.on('message', (channel, message) => {
    const [, , userId] = channel.split(':');
    broadcastStatusChange(userId, JSON.parse(message));
});

Event Loop (Single Thread)
    ↓
┌────────────────────────────┐
│  Incoming WebSocket Event  │
├────────────────────────────┤
│  Parse Message             │
│  Route to Handler          │
│  Execute Business Logic    │
│  Database I/O (async)      │ ← Non-blocking
│  Push Notification (async) │ ← Non-blocking
│  Send Response             │
└────────────────────────────┘
    ↓
Next Event in Queue

// Thread 1: User A sends collaboration request to User B
CCreateCollaboration(userA, [userB], ...);
    ↓
collaborationList.push(collaboration);  // Step 1

// Thread 2: User B simultaneously creates collaboration to User A
CCreateCollaboration(userB, [userA], ...);
    ↓
collaborationList.push(collaboration);  // Step 2

// Result: Two separate collaborations instead of one

// Use Redis for distributed locking
const Redlock = require('redlock');
const redlock = new Redlock([redis]);

async function createCollaboration(fromUser, toUserList) {
    const participants = [fromUser, ...toUserList].sort((a, b) => a.Id - b.Id);
    const lockKey = `collab:${participants.map(u => u.Id).join(':')}`;

    const lock = await redlock.lock(lockKey, 1000);  // 1s lock

    try {
        // Check if collaboration already exists
        const existing = await redis.get(lockKey);
        if (existing) {
            return JSON.parse(existing);
        }

        // Create new collaboration
        const collab = { Key: UniqueToken(), Initiator: fromUser, ... };
        await redis.set(lockKey, JSON.stringify(collab), 'EX', 3600);

        return collab;
    } finally {
        await lock.unlock();
    }
}

┌─────────────────┐
│  Load Balancer  │ (NGINX with ip_hash for sticky sessions)
└────────┬────────┘
         │
    ┌────┴────┬────────────┬─────────────┐
    │         │            │             │
┌───▼───┐ ┌──▼────┐  ┌───▼────┐  ┌────▼────┐
│Node 1 │ │Node 2 │  │ Node 3 │  │ Node 4  │
└───┬───┘ └───┬───┘  └───┬────┘  └────┬────┘
    │         │            │            │
    └─────────┴────────────┴────────────┘
                     │
              ┌──────▼───────┐
              │ Redis Cluster│ (Shared state + Pub/Sub)
              └──────────────┘

// Node 1 publishes user status change
redis.publish('user:status:42', JSON.stringify({
    userId: 42,
    status: 'ONLINE',
    timestamp: Date.now()
}));

// All nodes subscribe and update local state
redis.subscribe('user:status:*');
redis.on('message', (channel, message) => {
    const data = JSON.parse(message);
    updateLocalUserCache(data.userId, data.status);
    broadcastToLocalClients(data);
});

const EventLoopMonitor = require('event-loop-monitor');

EventLoopMonitor.on('data', (data) => {
    if (data.delay > 100) {  // >100ms lag
        logInfo(`Event loop lag: ${data.delay}ms`, logType.ERROR);
    }
});

setInterval(() => {
    const mem = process.memoryUsage();
    logInfo(`Memory: ${mem.heapUsed / 1024 / 1024}MB`, logType.INFO);
    logInfo(`Connections: ${ccCount}`, logType.INFO);
}, 60000);  // Every minute