How krishacodes30/video-chatapp works
This is a full-stack MERN real-time communication app:
• Frontend (React + Vite + Tailwind) in zoom/
• Backend (Node/Express) in backend/
• Database (MongoDB via Mongoose models) in backend/src/models/
• Real-time layer (Socket.IO) in backend/socket.js + backend/src/controllers/socketManager.js
• Peer-to-peer media (WebRTC) implied by zoom/src/pages/socketio/VideoCallSocket.jsx (frontend does signaling via Socket.IO; media flows P2P)
• Authentication via backend/src/middleware/authMiddleware.js and zoom/src/pages/Auth/*
• HTTP REST is used for auth/users/chat endpoints.
• Socket.IO is used for real-time chat + WebRTC signaling.
• WebRTC media goes directly between browsers (not through your backend).
Backend structure (backend/)
Key files that imply architectural boundaries:
• backend/app.js → Express app composition (middleware, routes, server bootstrap)
• backend/socket.js → Socket.IO server setup / binding to HTTP server
• backend/src/routes/* → REST API surface
• chat.routes.js
• user.routes.js
• backend/src/controllers/* → business logic & orchestration
• chat.controller.js (chat/message operations)
• user.controller.js (auth/user operations)
• socketManager.js (real-time event handling; likely join/leave rooms, relay signaling, broadcast messages)
• backend/src/models/* → persistence layer (MongoDB/Mongoose)
• user.model.js
• message.model.js
• backend/src/middleware/authMiddleware.js → auth boundary (JWT/session/headers)
This is a classic Express layered structure:
Routes → Controllers → Models → MongoDB, with Middleware applied cross-cutting.
Frontend structure (zoom/)
Key indicators:
• zoom/src/main.jsx, zoom/src/App.jsx → app bootstrap + routing composition
• zoom/src/context/UserContextApi.jsx → global auth/user state (token, current user, login status)
• zoom/src/pages/Auth/* → login/logout/isLogin flows
• zoom/src/pages/Dashboard/Dashboard.jsx → post-auth landing, likely user list / start call / chat UI
• zoom/src/pages/socketio/VideoCallSocket.jsx → Socket.IO client + WebRTC signaling integration
This implies frontend layers:
UI Pages/Components → Context (auth state) → API client (REST) + Socket.IO client → Backend
REST Routes Layer
• /users routes (user.routes.js)
• /chat routes (chat.routes.js)
Controllers
• User Controller (user.controller.js)
• Chat Controller (chat.controller.js)
10. Auth Middleware (authMiddleware.js) (explicitly drawn as a gate in front of protected endpoints)
Socket.IO Server (socket.js)
12. Socket Event Manager (socketManager.js) (the event routing / room management / signaling relay)
Data Models
• User model (user.model.js)
• Message model (message.model.js)
Signaling path (through your backend)
Browser A ↔ Socket.IO ↔ Browser B
Events typically: join room, offer, answer, ice-candidate, leave
Media path (peer-to-peer)
Browser A ⇄ Browser B (WebRTC SRTP media)
Backend is *not* in the media plane.
Architectural patterns to highlight (derived from structure)
• Layered backend: Routes → Controllers → Models (MVC-like separation)
• Cross-cutting middleware: authMiddleware as a security boundary
• Dual-channel communication:
• REST for CRUD/auth/history
• WebSockets (Socket.IO) for presence, live chat, and signaling
• Signaling vs media separation (WebRTC best practice)
What “detailed enough” means for this repo
At minimum, include:
• REST vs Socket.IO split
• Controllers/Routes/Models layers
• Auth middleware boundary
• WebRTC signaling vs media plane separation
• Message persistence (Message model) and User persistence (User model)