How rahuldadige/pastebox works
PasteBox is a full-stack web application: a React (Vite) SPA client + a Node/Express REST API server, backed by MongoDB (Mongoose) and Cloudinary for blob/file storage. It supports two primary user journeys:
• Registered users (JWT auth): dashboard, manage uploads, aliasing, expiry/password updates, delete, etc.
• Guest users: upload/share without account (still supports password/expiry).
Client (React SPA)
Root: client/
Key architectural signals:
• Vite entry: client/index.html, client/src/main.jsx
• App + routing: client/src/App.jsx (likely routes/layout composition)
• Auth gating: client/src/components/Auth/RequireAuth.jsx, NotRequireAuth.jsx
• State management: Redux Toolkit in client/src/redux/**
• authSlice.js, authThunk.js
• fileSlice.js, fileThunk.js
• HTTP layer: client/src/config/axiosInstance.js (central API base URL, interceptors likely)
• Pages/sections: Home, Dashboard/*, Guest/*, Download*, AliasDownloadPage.jsx, etc.
• Router / Pages
• Auth guard layer
• Redux store + async thunks (API calls)
• Axios API client
Server (Express API)
Root: server/
Key architectural signals:
• Entrypoints: server/src/index.js (server start), server/src/app.js (Express app wiring)
• DB: server/src/db/index.js
• Config: server/src/config/cloudinary.js, server/src/constant.js
• Routes: server/src/routes/*.routes.js
• Controllers: server/src/controllers/*.controller.js
• Models: server/src/models/*.models.js for user, file, guestFile, alias
• Middlewares:
• auth.middlewares.js (JWT verification, probably role/user attach)
• upload.middlewares.js (Multer pipeline, file validation, etc.)
Routes → Middleware → Controllers → Models → DB/Cloudinary.
External dependencies worth explicit nodes
• MongoDB Atlas (per README prerequisites)
• Cloudinary (file storage + retrieval)
• JWT signing/verification (auth boundary)
• BCrypt (password-protect links / hashing)
• Helmet / Rate Limiting / Compression (cross-cutting concerns)
React SPA (Vite)
• Auth/Guest UI
• Redux store + thunks
• Axios client
Express API (Node.js)
• Route modules: user.routes, file.routes, alias.routes
• Middlewares: auth, upload, security/perf (helmet/rate-limit/compression)
MongoDB (Mongoose)
• Collections: users, files, guestFiles, aliases
Cloudinary
• Blob storage for uploaded files
Frontend ↔ Backend
• HTTPS/REST JSON calls from SPA to API:
• POST /api/users/register
• POST /api/users/login → returns JWT
• POST /api/files/upload (auth required) → multipart/form-data
• GET /api/files/f/:code (download metadata / access flow)
• POST /api/alias/upload (alias creation)
• That Axios instance uses VITE_API_BASE_URL.
Backend ↔ MongoDB
• Controllers use Mongoose models:
• user.models.js for auth/user profile
• file.models.js for user uploads
• guestFile.models.js for guest uploads
• alias.models.js for mapping aliases → file groups / codes
Backend ↔ Cloudinary
• Upload flow uses upload.middlewares.js (Multer) and config/cloudinary.js.
• Store Cloudinary public_id/URL in MongoDB.
• Download flow likely:
• validate code/alias + password/expiry in MongoDB
• fetch Cloudinary URL / stream / redirect, then client downloads as blob (README mentions blob downloads)
Cross-cutting security/performance
• Helmet: headers hardening
• Rate limiting: anti-abuse
• Compression: response compression
• JWT middleware: protects authenticated endpoints
• BCrypt: password hashing for protected file links
• SPA + REST API separation (client-only rendering, server is JSON API)
• Layered backend (Routes → Middlewares → Controllers → Models)
• Externalized blob storage (Cloudinary) + metadata in MongoDB
• Stateless auth (JWT): frontend stores token; backend verifies per request
Registered Upload + Share
• SPA → POST /login → JWT
• SPA → POST /files/upload (multipart + Authorization: Bearer)
• API: auth middleware → upload middleware → Cloudinary upload → MongoDB save metadata (ownerId, cloudinaryUrl, expiry, passwordHash, code)
• API → SPA: returns code/link/metadata
• SPA: show QR code / share link
Guest Upload + Download
• SPA → POST guest upload (may hit same /files/upload with different handling or a guest endpoint; model guestFile.models.js strongly suggests different persistence)
• API → Cloudinary + MongoDB(guestFiles)
• Downloader SPA → GET /files/f/:code → validate expiry/password → return download URL/stream → blob download in browser
Connect
• Axios → Routes (label endpoints)
• Controllers → MongoDB (metadata)
• Controllers → Cloudinary (file blob)
• Endpoints requiring JWT (e.g., /api/files/upload auth required per README)