How rvkisme/quickmeet works
What this project is (type + purpose)
QuickMeet is a minimal real-time “room” meeting app with no login and no data persistence (“meet your friends in a room without any data saving or login”).
From the tree, it’s a small client–server web application:
• Client: static frontend (client/index.html, client/style.css, client/client.js)
• Server: Node.js backend (server/server.js + server/package.json), likely serving the client and handling “room” coordination (commonly via HTTP + WebSocket).
• No database: there’s no db/, migrations, ORM config, or persistence layer.
• what server/server.js actually does (HTTP only vs WebSocket vs WebRTC signaling),
• what client/client.js actually does (polling vs WebSocket vs WebRTC peer connections).
Top-level
• client/ → purely frontend assets. This suggests a single-page-ish flow (even if not a SPA framework).
• server/ → self-contained Node service with NPM dependencies (package.json, node_modules/).
Important implications
• Monolith, not microservices: only one backend service exists.
• Likely ephemeral state: rooms probably exist in server memory; “no data saving” implies no durable storage.
• Network boundary: browser ↔ node server is the primary boundary; if meetings are truly peer-to-peer, there may be browser ↔ browser media paths.
What to extract from README (and what’s missing)
README only states product intent:
• “room” concept (implies room IDs, join/leave, member list)
• “no data saving or login” (implies no auth provider, no DB)
• No persistent storage
• No authentication / identity provider
• Room state is transient (most likely in-memory)
Browser Client
• index.html (UI shell)
• style.css (presentation)
• client.js (room join logic, event handling, real-time messaging/media setup)
Node.js Server
• server.js (HTTP routing + real-time room coordination)
• NPM dependencies (from package.json) — label major frameworks once confirmed (e.g., Express, ws, Socket.IO)
In-memory Room State (within server process)
• rooms map, participants list, ephemeral session/connection tracking
(Conditional) Peer-to-peer Media/Data Plane
• If client.js uses WebRTC: add Browser ↔ Browser media streams (audio/video/data channels)
• Server then becomes signaling/coordination only (SDP/ICE exchange), not media relay.
Static asset delivery
• Browser → Node Server: HTTP GET / (serves index.html)
• Browser → Node Server: HTTP GET /client.js, HTTP GET /style.css (static assets)
Room join + real-time coordination
One of these will be true—confirm by inspecting server.js/client.js:
• Browser ↔ Node Server: WebSocket (or Socket.IO) for:
• create/join room
• broadcast presence (join/leave)
• exchange meeting metadata
(If WebRTC) Signaling vs media
• Browser A ↔ Node Server ↔ Browser B: signaling messages (offer/answer/ICE)
• Browser A ↔ Browser B: media streams (SRTP)
• Control plane (via server)
• Media plane (P2P between browsers)
Architectural patterns/design principles used
• Stateless persistence: “No DB; rooms are ephemeral”
• Single backend process: Node server handles all coordination
• Client-heavy behavior: core UX and meeting logic lives in client.js
• Real-time communication: WebSocket/Socket.IO (if present) and/or WebRTC (if present)
Relevant technologies/frameworks/libraries
• If express is used: label backend as “Node.js + Express”
• If socket.io is used: label realtime as “Socket.IO”
• If ws is used: label realtime as “WebSocket (ws)”
• If WebRTC APIs appear in client.js: label “WebRTC (RTCPeerConnection)”
Practical advice: “separate into as many components as possible” (without overthinking)
• Client UI shell vs client logic (index.html vs client.js)
• Server HTTP/static hosting vs realtime room coordinator
• In-memory state as an explicit subcomponent
• Control plane vs media plane (if WebRTC)
Use this as your initial structure, then refine after checking server.js/client.js:
• [Browser Client]
• UI (index.html/css)
• Room/RTC logic (client.js)
• ↔ (WebSocket/Socket.IO) ↔ [Node Server]
• [Node Server]
• Static file serving (client/)
• Room coordinator (join/leave/broadcast)
• In-memory room registry (no persistence)
• (Optional if WebRTC):
• Browser A ⇄ Browser B (P2P media/data)
• Node server only for signaling messages