NodeServer - Code Quality Report¶

server.js
├── Total Lines: 2,968
├── Code Lines: 2,450 (82.5%)
├── Comment Lines: 120 (4.0%)
├── Blank Lines: 398 (13.4%)
├── Functions: 142
├── Average Function Length: 17.3 lines
├── Longest Function: 156 lines (CSendFile)
└── Global Variables: 47

Total Duplicate Blocks: 34
Duplicate Lines: 442 (18.0% of codebase)
Largest Duplicate: 38 lines

Common Duplicate Patterns:
1. Database connection setup (12 instances)
2. Error handling blocks (24 instances)
3. User list iteration (15 instances)
4. WebSocket send patterns (18 instances)

{
  "dependencies": 9,
  "outdatedDependencies": 6,
  "vulnerabilities": {
    "critical": 0,
    "high": 2,
    "moderate": 4,
    "low": 3
  },
  "unusedDependencies": 0
}

// server.js contains EVERYTHING:
// - WebSocket server setup
// - Database connections (12 tenants)
// - Authentication logic
// - Presence management
// - Collaboration (WebRTC signaling)
// - Messaging persistence
// - File transfer
// - Push notifications
// - Logging
// - Heartbeat monitoring

// Proposed structure:
src/
├── server.js                    // Entry point (50 lines)
├── config/
│   ├── database.js             // DB config per tenant
│   ├── firebase.js             // FCM config
│   └── constants.js            // All enums
├── middleware/
│   ├── authentication.js       // Auth logic
│   ├── rateLimit.js           // Rate limiting
│   └── validation.js          // Input validation
├── services/
│   ├── PresenceService.js     // Presence mode
│   ├── CollaborationService.js // Collaboration mode
│   ├── MessagingService.js    // Messaging mode
│   ├── DatabaseService.js     // DB operations
│   └── PushNotificationService.js
├── models/
│   ├── User.js
│   ├── Message.js
│   └── CollaborationSession.js
└── utils/
    ├── logger.js
    └── helpers.js

function PSendMessage(client, command, message, fromUser, toUserList, clientInitiationTime) {
    try {
        var requestData = JSON.parse(message);

        sql.connect(dbConfig, function (err) {  // Level 1
            if (err) { /* ... */ }

            var request = new sql.Request();
            request
                .input('SenderId', sql.BigInt, fromUser.Id)
                .execute('Message_InsertMessage', function (err, result) {  // Level 2
                    if (err) { /* ... */ }

                    sql.connect(dbConfig, function (err) {  // Level 3
                        if (err) { /* ... */ }

                        var request2 = new sql.Request();
                        request2
                            .input('MessageId', sql.BigInt, lMessageId)
                            .execute('Message_Insert_MessageUsers', function (err, result) {  // Level 4
                                if (err) { /* ... */ }

                                toUserList.forEach(function (toUser) {  // Level 5
                                    for (var i = 0; i < userList.length; i++) {  // Level 6
                                        if (userList[i].UserId == toUser.Id) {
                                            userList[i].client.send(JSON.stringify({...}));  // Level 7
                                        }
                                    }
                                });
                            });
                    });
                });
        });
    } catch (e) { /* ... */ }
}

async function PSendMessage(client, command, message, fromUser, toUserList, clientInitiationTime) {
    try {
        const requestData = JSON.parse(message);

        // Insert message
        const pool = await sql.connect(dbConfig);
        const result = await pool.request()
            .input('SenderId', sql.BigInt, fromUser.Id)
            .input('Text', sql.NVarChar, requestData.Text)
            .execute('Message_InsertMessage');

        const messageId = result.recordset[0].MessageId;

        // Insert message recipients
        await pool.request()
            .input('MessageId', sql.BigInt, messageId)
            .execute('Message_Insert_MessageUsers');

        // Notify recipients
        await notifyRecipients(toUserList, messageId, requestData);

        // Send success response
        PSendCommand(client, '', command, cReason.SUCCESS, messageId);

    } catch (error) {
        logError('PSendMessage failed', error);
        PSendInvalidRequestCommand(client, '', command, cReason.ERROR);
    }
}

async function notifyRecipients(toUserList, messageId, messageData) {
    const onlineUsers = userList.filter(u => 
        toUserList.some(recipient => recipient.Id === u.UserId)
    );

    for (const user of onlineUsers) {
        user.client.send(JSON.stringify({
            Command: cCommand.P_CHAT,
            MessageId: messageId,
            Text: messageData.Text,
            Timestamp: new Date().toISOString()
        }));
    }
}

// What does 3333 mean?
var sslSrv = https.createServer(options).listen(3333);

// What are these client modes?
if (currentClientMode == 0) { /* ... */ }
if (currentClientMode == 4) { /* ... */ }

// Magic timeout values
setTimeout(() => { /* ... */ }, 1800000);  // What's 1800000ms?

// Hardcoded strings
if (pUser.ConnectionMode == "1") { /* ... */ }  // Should be enum

// Random numbers
var UniqueToken = Math.floor(Math.random() * 100000000);  // Why 100M?

// config/constants.js
const CONFIG = {
    SERVER: {
        WSS_PORT: 3333,
        HEARTBEAT_INTERVAL_MS: 30 * 60 * 1000,  // 30 minutes
        SESSION_TIMEOUT_MS: 24 * 60 * 60 * 1000  // 24 hours
    },
    CLIENT_MODES: {
        PSYTER_DEV: 0,
        PSYTER_LIVE: 4,
        TAHOON_DEV: 1,
        TAHOON_LIVE: 5
    },
    TOKEN: {
        MAX_VALUE: 100000000,
        LENGTH: 8
    }
};

// Usage
var sslSrv = https.createServer(options).listen(CONFIG.SERVER.WSS_PORT);

if (currentClientMode === CONFIG.CLIENT_MODES.PSYTER_LIVE) { /* ... */ }

setTimeout(() => { /* ... */ }, CONFIG.SERVER.HEARTBEAT_INTERVAL_MS);

var userList = [];                    // Global mutable state
var pUserConnectionList = [];         // Global mutable state
var collaborationList = [];           // Global mutable state
var messageList = [];                 // Global mutable state
var enableLog = true;                 // Global config
var currentClientMode = -1;           // Global mode
var dbConfig = null;                  // Global DB connection
var fcmAPISettings = null;            // Global FCM config
var logger = null;                    // Global logger
// ... 38 more globals

// Use dependency injection and classes
class NodeServer {
    constructor(config) {
        this.config = config;
        this.userList = [];
        this.collaborationList = [];
        this.messageList = [];
        this.dbService = new DatabaseService(config.database);
        this.fcmService = new PushNotificationService(config.firebase);
        this.logger = new Logger(config.logging);
    }

    async start() {
        this.wss = new WebSocket.Server({ port: this.config.port });
        this.wss.on('connection', (client, req) => this.handleConnection(client, req));
    }

    handleConnection(client, request) {
        // Instance methods have access to this.userList, etc.
        // No global variables needed
    }
}

// Usage
const config = loadConfig();
const server = new NodeServer(config);
await server.start();

// Inconsistent prefixes
function PAuthenticate() {}        // P prefix = Presence?
function CProcessCommand() {}       // C prefix = Collaboration?
function MSendMessage() {}          // M prefix = Messaging?

// Mixed casing
var cCommand = {};                  // lowercase 'c'
var cClient = {};                   // lowercase 'c'
var lMessageId;                     // lowercase 'l' (local?)
var requestData;                    // camelCase
var ToUserList;                     // PascalCase

// Unclear abbreviations
var pUser;                          // Presence user?
var cUser;                          // Collaboration user?
var objUser;                        // Object user?
var lUserId;                        // Local user ID?

// Inconsistent parameter names
function foo(client, command, message) {}
function bar(command, client, data) {}     // Different order!

// Consistent conventions:
// - Classes: PascalCase
// - Functions: camelCase
// - Constants: UPPER_SNAKE_CASE
// - Variables: camelCase
// - Private methods: _camelCase

// Clear, descriptive names
class PresenceService {
    async authenticateUser(client, credentials) {}
    async sendMessage(sender, recipients, message) {}
    async updateUserStatus(userId, status) {}
}

class CollaborationService {
    async createSession(initiator, participant) {}
    async sendSignal(sessionId, signalData) {}
}

// Constants
const COMMAND_TYPES = {
    AUTHENTICATE: 1,
    SEND_MESSAGE: 5,
    UPDATE_STATUS: 7
};

// Variables
const messageId = result.recordset[0].MessageId;
const onlineUsers = this.userList.filter(u => u.isOnline);

CSendFile()              // 156 lines ❌
PProcessCommand()        // 142 lines ❌
CProcessCommand()        // 138 lines ❌
PSendMessage()           // 89 lines ❌
CCallUser()              // 76 lines ❌

function CSendFile(client, command, message, fromUser, toUser, clientInitiationTime) {
    try {
        var requestData = JSON.parse(message);

        // Lines 1-20: Parse request data
        var fileUniqueToken = requestData.FileUniqueToken;
        var fileName = requestData.FileName;
        var fileSize = requestData.FileSize;
        // ... more parsing

        // Lines 21-45: Database insert
        sql.connect(dbConfig, function (err) {
            var request = new sql.Request();
            request
                .input('CollaborationId', sql.BigInt, fromUser.CollaborationId)
                .input('FileName', sql.NVarChar, fileName)
                // ... 15 more inputs
                .execute('COB_FileTransfer_InsertFileTransfer', function (err, result) {
                    // ... error handling
                });
        });

        // Lines 46-80: Notify recipient
        for (var i = 0; i < collaborationList.length; i++) {
            // ... complex logic
        }

        // Lines 81-120: Update collaboration state
        sql.connect(dbConfig, function (err) {
            // ... more database calls
        });

        // Lines 121-156: Send push notification
        // ... FCM logic

    } catch (e) {
        logInfo('CSendFile Error : ' + e, logType.ERROR);
    }
}

async function handleFileTransfer(client, command, message, fromUser, toUser) {
    try {
        const fileData = parseFileTransferRequest(message);
        const fileTransferId = await saveFileTransfer(fromUser, fileData);
        await notifyRecipient(toUser, fileData, fileTransferId);
        await updateCollaborationState(fromUser.CollaborationId, 'file_transfer');
        await sendFileTransferNotification(toUser, fileData);

        sendSuccessResponse(client, command, fileTransferId);
    } catch (error) {
        handleFileTransferError(client, command, error);
    }
}

function parseFileTransferRequest(message) {
    const data = JSON.parse(message);
    return {
        token: data.FileUniqueToken,
        name: data.FileName,
        size: data.FileSize,
        type: data.CatFileTypeId
    };
}

async function saveFileTransfer(fromUser, fileData) {
    const pool = await sql.connect(dbConfig);
    const result = await pool.request()
        .input('CollaborationId', sql.BigInt, fromUser.CollaborationId)
        .input('FileName', sql.NVarChar, fileData.name)
        .input('FileSize', sql.BigInt, fileData.size)
        .execute('COB_FileTransfer_InsertFileTransfer');

    return result.recordset[0].FileTransferId;
}

async function notifyRecipient(toUser, fileData, fileTransferId) {
    const recipientClient = findUserClient(toUser.Id);
    if (recipientClient) {
        recipientClient.send(JSON.stringify({
            Command: cCommand.C_SEND_FILE,
            FileTransferId: fileTransferId,
            FileName: fileData.name,
            FileSize: fileData.size
        }));
    }
}

// Each function now < 20 lines, single responsibility

// Repeated 12 times throughout file
sql.connect(dbConfig, function (err) {
    if (err) {
        logInfo('SERVER  -->  ' + err, logType.ERROR);
        PSendInvalidRequestCommand(client, '', command, cReason.ERROR);
        return;
    }

    var request = new sql.Request();
    // ... specific query
});

async function executeQuery(queryName, params) {
    try {
        const pool = await sql.connect(dbConfig);
        const request = pool.request();

        // Add parameters
        for (const [key, value] of Object.entries(params)) {
            request.input(key, value.type, value.value);
        }

        const result = await request.execute(queryName);
        return result.recordset;
    } catch (error) {
        logError(`Query ${queryName} failed`, error);
        throw error;
    }
}

// Usage
const users = await executeQuery('COB_Authenticate_Get_User_List', {
    CommunicationKey: { type: sql.NVarChar, value: communicationKey }
});

// Repeated everywhere:
for (var i = 0; i < userList.length; i++) {
    if (userList[i].UserId == userId) {
        // Do something with userList[i]
    }
}

// Better:
function findUser(userId) {
    return userList.find(u => u.UserId === userId);
}

function findUsersByIds(userIds) {
    return userList.filter(u => userIds.includes(u.UserId));
}

// Repeated pattern:
client.send(JSON.stringify({
    Command: command,
    Reason: reason,
    Message: message
}));

// Better:
function sendToClient(client, command, data) {
    const payload = {
        Command: command,
        Timestamp: new Date().toISOString(),
        ...data
    };
    client.send(JSON.stringify(payload));
}

// 1. Silent failures
function PUpdateStatus(command, status, userId) {
    sql.connect(dbConfig, function (err) {
        // ❌ Error logged but not handled
        if (err) {
            logInfo('SERVER  -->  ' + err, logType.ERROR);
            return;  // Client never notified!
        }
        // ...
    });
}

// 2. Unhandled promise rejections
async function someAsyncFunction() {
    await doSomething();  // ❌ No try-catch
}

// 3. Generic error messages
catch (e) {
    logInfo('Error: ' + e, logType.ERROR);  // ❌ Too vague
}

// 4. No error propagation
function foo() {
    try {
        bar();  // May throw
    } catch (e) {
        // ❌ Error swallowed
    }
}

class DatabaseError extends Error {
    constructor(message, query, params) {
        super(message);
        this.name = 'DatabaseError';
        this.query = query;
        this.params = params;
    }
}

class ValidationError extends Error {
    constructor(message, field) {
        super(message);
        this.name = 'ValidationError';
        this.field = field;
    }
}

async function updateUserStatus(command, client, status, userId) {
    try {
        // Validate input
        if (!isValidStatus(status)) {
            throw new ValidationError('Invalid status', 'status');
        }

        // Execute query
        const pool = await sql.connect(dbConfig);
        const result = await pool.request()
            .input('UserId', sql.BigInt, userId)
            .input('Status', sql.TinyInt, status)
            .execute('COB_Update_Status');

        // Send success response
        sendToClient(client, command, {
            Reason: cReason.SUCCESS,
            Status: status
        });

        // Notify other users
        await broadcastStatusUpdate(userId, status);

    } catch (error) {
        // Specific error handling
        if (error instanceof ValidationError) {
            logError(`Validation failed for ${error.field}`, error);
            sendToClient(client, command, {
                Reason: cReason.INVALID_REQUEST,
                Message: error.message
            });
        } else if (error instanceof DatabaseError) {
            logError(`Database query failed: ${error.query}`, error);
            sendToClient(client, command, {
                Reason: cReason.ERROR,
                Message: 'Database error occurred'
            });
        } else {
            // Unexpected error
            logError('Unexpected error in updateUserStatus', error);
            sendToClient(client, command, {
                Reason: cReason.ERROR,
                Message: 'Internal server error'
            });
        }
    }
}

// Everything depends on everything
function PSendMessage(client, command, message, fromUser, toUserList, ...) {
    // ❌ Directly accesses global userList
    for (var i = 0; i < userList.length; i++) {
        // ❌ Directly calls database
        sql.connect(dbConfig, function (err) {
            // ❌ Directly calls FCM
            admin.messaging().send({...});

            // ❌ Directly manipulates client
            client.send(JSON.stringify({...}));
        });
    }
}

class MessagingService {
    constructor(dbService, userService, pushService, wsService) {
        this.dbService = dbService;
        this.userService = userService;
        this.pushService = pushService;
        this.wsService = wsService;
    }

    async sendMessage(senderId, recipientIds, messageData) {
        // Save to database
        const messageId = await this.dbService.saveMessage({
            senderId,
            text: messageData.text,
            timestamp: new Date()
        });

        // Find online recipients
        const onlineRecipients = await this.userService.findOnlineUsers(recipientIds);

        // Send via WebSocket
        await this.wsService.broadcast(onlineRecipients, {
            type: 'NEW_MESSAGE',
            messageId,
            text: messageData.text
        });

        // Find offline recipients
        const offlineRecipients = recipientIds.filter(
            id => !onlineRecipients.some(u => u.id === id)
        );

        // Send push notifications
        if (offlineRecipients.length > 0) {
            await this.pushService.sendNotifications(offlineRecipients, {
                title: 'New Message',
                body: messageData.text
            });
        }

        return messageId;
    }
}

// No type checking - runtime errors likely
function PSendMessage(client, command, message, fromUser, toUserList) {
    // What types are these? Unknown until runtime
    // toUserList could be undefined, null, not an array, etc.
}

// Property access errors
var userId = user.Id;  // Crashes if user is undefined

// Silent type coercion
if (user.Id == "123") {}  // String vs number comparison

interface User {
    Id: number;
    Name: string;
    Status: UserStatus;
    ConnectionMode: ConnectionMode;
}

interface Message {
    Text: string;
    FilePath?: string;
    FileTypeId?: number;
}

class MessagingService {
    async sendMessage(
        client: WebSocket,
        command: Command,
        message: Message,
        fromUser: User,
        toUserList: User[]
    ): Promise<number> {
        // TypeScript ensures:
        // - toUserList is an array of User objects
        // - message has required Text property
        // - Return type is number (messageId)

        const messageId = await this.dbService.saveMessage({
            senderId: fromUser.Id,  // TypeScript knows Id is a number
            text: message.Text,
            timestamp: new Date()
        });

        return messageId;
    }
}

// PProcessCommand - 142 lines
function PProcessCommand(client, data, command, fromUser, toUser, toUserList, collaborationId, clientInitiationTime) {
    switch (command) {
        case cCommand.P_AUTHENTICATE:
            PAuthenticate(command, client, data, clientInitiationTime);
            break;
        case cCommand.P_CHAT:
            PSendMessage(client, command, data, fromUser, toUserList, clientInitiationTime);
            break;
        // ... 40 more cases
    }
}

// CProcessCommand - 138 lines (almost identical structure!)
function CProcessCommand(client, data, command, fromUser, toUser, collaborationId, clientInitiationTime) {
    switch (command) {
        case cCommand.C_AUTHENTICATE:
            CAuthenticate(command, client, data, clientInitiationTime);
            break;
        case cCommand.C_CALL_USER:
            CCallUser(client, command, data, fromUser, toUser, clientInitiationTime);
            break;
        // ... 20 more cases
    }
}

class CommandDispatcher {
    constructor() {
        this.handlers = new Map();
    }

    register(command, handler) {
        this.handlers.set(command, handler);
    }

    async dispatch(client, message) {
        const { command, data } = message;
        const handler = this.handlers.get(command);

        if (!handler) {
            throw new Error(`Unknown command: ${command}`);
        }

        return await handler(client, data);
    }
}

// Register handlers
const presenceDispatcher = new CommandDispatcher();
presenceDispatcher.register(cCommand.P_AUTHENTICATE, presenceService.authenticate);
presenceDispatcher.register(cCommand.P_CHAT, presenceService.sendMessage);
// ...

const collaborationDispatcher = new CommandDispatcher();
collaborationDispatcher.register(cCommand.C_AUTHENTICATE, collaborationService.authenticate);
collaborationDispatcher.register(cCommand.C_CALL_USER, collaborationService.callUser);
// ...

// Usage
await presenceDispatcher.dispatch(client, message);

// ❌ Commented-out code left in production
// function OldAuthentication() {
//     // This was the old way
//     // var user = getUser();
//     // if (user) { return true; }
// }

// ❌ Unused variables
var unusedVar = 123;

// ❌ APN (Apple Push Notifications) code - disabled but not removed
if (currentClientMode == cClient.PSYTER_LIVE || currentClientMode == cClient.PSYTER_DEV) {
    // apnProvider.send(...).then(...);  // Commented out
}

# Remove all commented code
# Remove unused imports
# Remove unused functions
# Use Git history instead of commented code

class User {
    constructor(data) {
        this.id = data.Id;
        this.name = data.Name;
        this.status = data.Status;
        // ... all fields in one place
    }

    toJSON() {
        return {
            Id: this.id,
            Name: this.name,
            Status: this.status
        };
    }

    static fromDatabaseRow(row) {
        return new User(row);
    }
}

// Now adding a field only requires changes in User class

Technical Debt Ratio = 42.9%

sql.connect(dbConfig, function (err) {
    if (err) {
        logInfo('SERVER  -->  ' + err, logType.ERROR);
        return;
    }
    var request = new sql.Request();
    // ...
});

for (var i = 0; i < userList.length; i++) {
    if (userList[i].UserId == userId) {
        // ...
    }
}

client.send(JSON.stringify({
    Command: command,
    Reason: reason,
    Message: message
}));

Test Files: 0
Test Coverage: 0%
Unit Tests: 0
Integration Tests: 0
E2E Tests: 0

tests/
├── unit/
│   ├── services/
│   │   ├── PresenceService.test.js
│   │   ├── MessagingService.test.js
│   │   └── CollaborationService.test.js
│   ├── models/
│   │   ├── User.test.js
│   │   └── Message.test.js
│   └── utils/
│       └── helpers.test.js
├── integration/
│   ├── database.test.js
│   ├── websocket.test.js
│   └── fcm.test.js
└── e2e/
    ├── authentication.test.js
    ├── messaging.test.js
    └── collaboration.test.js

// tests/unit/services/MessagingService.test.js
const MessagingService = require('../../../src/services/MessagingService');

describe('MessagingService', () => {
    let messagingService;
    let mockDbService;
    let mockUserService;
    let mockPushService;

    beforeEach(() => {
        mockDbService = {
            saveMessage: jest.fn().mockResolvedValue(123)
        };
        mockUserService = {
            findOnlineUsers: jest.fn().mockResolvedValue([])
        };
        mockPushService = {
            sendNotifications: jest.fn().mockResolvedValue(true)
        };

        messagingService = new MessagingService(
            mockDbService,
            mockUserService,
            mockPushService
        );
    });

    describe('sendMessage', () => {
        it('should save message to database', async () => {
            await messagingService.sendMessage(1, [2, 3], { text: 'Hello' });

            expect(mockDbService.saveMessage).toHaveBeenCalledWith({
                senderId: 1,
                text: 'Hello',
                timestamp: expect.any(Date)
            });
        });

        it('should send push notifications to offline users', async () => {
            mockUserService.findOnlineUsers.mockResolvedValue([{ id: 2 }]);

            await messagingService.sendMessage(1, [2, 3], { text: 'Hello' });

            expect(mockPushService.sendNotifications).toHaveBeenCalledWith(
                [3],  // Only user 3 is offline
                expect.objectContaining({ body: 'Hello' })
            );
        });
    });
});

// ❌ Vague
function PAuthenticate(command, client, data, clientInitiationTime) {
    // Authenticate user
    // ...
}

// ❌ Outdated
// This function handles user login (actually does more than that)

// ❌ Obvious
var userId = user.Id;  // Get user ID (duh!)

/**
 * Authenticates a user in Presence mode via WebSocket connection.
 * 
 * Validates the communication key against the database, checks user
 * credentials, and establishes a session. Sends success or failure
 * response to the client.
 * 
 * @param {number} command - Command type (should be P_AUTHENTICATE)
 * @param {WebSocket} client - Active WebSocket connection
 * @param {Object} data - Authentication payload
 * @param {string} data.communicationKey - One-time verification code
 * @param {number} clientInitiationTime - Client timestamp for latency calc
 * 
 * @returns {Promise<void>}
 * 
 * @throws {ValidationError} If communication key is invalid
 * @throws {DatabaseError} If database query fails
 * 
 * @example
 * await authenticateUser(
 *     cCommand.P_AUTHENTICATE,
 *     clientWebSocket,
 *     { communicationKey: 'ABC123' },
 *     Date.now()
 * );
 */
async function authenticateUser(command, client, data, clientInitiationTime) {
    // Implementation
}

// Before (callbacks)
function PSendMessage(client, command, message, fromUser, toUserList, clientInitiationTime) {
    sql.connect(dbConfig, function (err) {
        if (err) { return; }
        var request = new sql.Request();
        request.execute('Message_InsertMessage', function (err, result) {
            if (err) { return; }
            // ...
        });
    });
}

// After (async/await)
async function sendMessage(client, command, message, fromUser, toUserList) {
    try {
        const pool = await sql.connect(dbConfig);
        const result = await pool.request().execute('Message_InsertMessage');
        // ...
    } catch (error) {
        handleError(error);
    }
}

src/
├── server.js (entry point - 50 lines)
├── config/
│   ├── constants.js
│   ├── database.js
│   └── firebase.js
├── models/
│   ├── User.js
│   ├── Message.js
│   └── CollaborationSession.js
├── services/
│   ├── PresenceService.js (300 lines)
│   ├── CollaborationService.js (250 lines)
│   ├── MessagingService.js (200 lines)
│   ├── DatabaseService.js (150 lines)
│   └── PushNotificationService.js (100 lines)
├── middleware/
│   ├── authentication.js
│   ├── rateLimit.js
│   └── validation.js
└── utils/
    ├── logger.js
    └── helpers.js

class NodeServer {
    constructor(config) {
        // Instance variables instead of globals
        this.userList = [];
        this.collaborationList = [];
        this.config = config;
    }
}

{
  "devDependencies": {
    "eslint": "^8.0.0",
    "eslint-plugin-security": "^1.7.0",
    "eslint-plugin-node": "^11.1.0",
    "prettier": "^2.8.0",
    "husky": "^8.0.0",
    "lint-staged": "^13.0.0",
    "jest": "^29.0.0",
    "supertest": "^6.3.0",
    "@typescript-eslint/eslint-plugin": "^5.0.0",
    "@typescript-eslint/parser": "^5.0.0"
  }
}

// .eslintrc.js
module.exports = {
    extends: [
        'eslint:recommended',
        'plugin:node/recommended',
        'plugin:security/recommended'
    ],
    rules: {
        'complexity': ['error', 10],
        'max-depth': ['error', 3],
        'max-lines-per-function': ['warn', 50],
        'max-params': ['warn', 4],
        'no-var': 'error',
        'prefer-const': 'error',
        'prefer-arrow-callback': 'error',
        'no-eval': 'error',
        'no-implied-eval': 'error'
    }
};

// package.json
{
  "husky": {
    "hooks": {
      "pre-commit": "lint-staged",
      "pre-push": "npm test"
    }
  },
  "lint-staged": {
    "*.js": [
      "eslint --fix",
      "prettier --write",
      "git add"
    ]
  }
}