How matiassio2774/soundcloud-downloader works
1. Overall shape
- This is a two-tier, Dockerized full-stack app: a React frontend and a Node.js/Express backend.
- The system’s purpose is to take a SoundCloud URL from the user and return an MP3 download.
2. Runtime boundaries
- The frontend runs as a browser-facing UI on port 3000.
- The backend exposes an HTTP API on port 5000.
- docker-compose.yml is the top-level orchestration point that connects both services in one local environment.
3. Frontend subsystem
- The frontend/ folder contains a standard React app with Material UI styling.
- src/App.js is the main composition point for the UI.
- src/components/ contains the visible pieces: Header, Logo, DownloaderForm, and Footer.
- src/theme.js and src/index.css define the look and feel.
4. Frontend data flow
- The user interacts with DownloaderForm, which is the core input boundary for the app.
- The form likely captures a SoundCloud track URL and triggers a download request.
- The frontend does not appear to handle downloading itself; it delegates network work to src/services/api.js.
5. Frontend API boundary
- src/services/api.js is the abstraction layer between UI and backend.
- This is the key boundary for architecture diagrams: UI components call a service module, and the service module talks to the backend over HTTP.
- In deployment, the frontend is wrapped with nginx.conf, suggesting the production container serves static assets through Nginx.
6. Backend subsystem
- The backend/ folder is a small Express server.
- src/index.js is the server entry point and likely wires middleware, route registration, and port startup.
- src/routes/download.js is the main backend endpoint and appears to be the only explicit route in the tree, so the backend is probably centered around one download API.
7. Backend responsibility
- The backend is the system boundary that handles the actual SoundCloud-to-MP3 workflow.
- Its job is likely to accept a URL, resolve or fetch the audio source, and return either the file or a download response to the client.
- This keeps external service interaction off the browser and centralizes the download logic server-side.
8. External dependency
- The only clear external system is SoundCloud itself.
- The backend is the integration point with that upstream service, which is important because the browser should not directly manage SoundCloud download logic.
9. Containerization
- Both backend/Dockerfile and frontend/Dockerfile indicate separate build/runtime images.
- The app is meant to be run as a coordinated multi-container stack rather than as a monolith.
- This separation also implies a clean deployment boundary between presentation and API layers.
10. Likely request path
- User enters URL in the React form.
- Frontend service module sends an HTTP request to the Express backend.
- Backend route processes the SoundCloud URL and returns the MP3 download response.
- Frontend then exposes that result to the user, likely as a browser download or a link.
11. Architecture diagram focus points
- Draw three main blocks: Browser/UI, Frontend container, Backend container.
- Show HTTP from browser to frontend, then HTTP from frontend to backend, then backend to SoundCloud.
- Emphasize that the frontend is presentation-only, while the backend owns the download logic.
12. Operational context
- The README describes a simple local startup flow via docker-compose up.
- Environment variables define the ports and NODE_ENV, which suggests a development-friendly setup but with containerized parity across services.
Main entry points: App.js App shell · docker-compose.yml Compose · DownloaderForm.js Downloader form · Header.js Header
Components 19
Orchestration
Top-level container composition and local startup
- Compose · Starts and connects the frontend and backend containers
docker-compose.yml
Frontend
React UI and static serving layer
- Frontend app · React application served through Nginx in the frontend container
- Frontend image · Builds and runs the frontend runtime image
frontend/Dockerfile - Nginx config · Production static asset serving configuration
frontend/nginx.conf - Entry · Bootstraps the React application
frontend/src/index.js - App shell · Main UI composition point
frontend/src/App.js - Downloader form · Captures the SoundCloud URL and starts the download request
frontend/src/components/DownloaderForm.js - Header · Top section of the interface
frontend/src/components/Header.js - Logo · Branding and visual identity
frontend/src/components/Logo.js - Footer · Bottom section of the interface
frontend/src/components/Footer.js - API client · Frontend boundary that talks to the backend over HTTP
frontend/src/services/api.js - Theme · Material UI theme configuration
frontend/src/theme.js - Styles · Global presentation styles
frontend/src/index.css
Backend
Express API and download workflow
- Backend API · Server-side download API container
- Backend image · Builds and runs the Express service image
backend/Dockerfile - Server entry · Wires middleware, routes, and port startup
backend/src/index.js - Download route · Main backend endpoint for processing SoundCloud URLs
backend/src/routes/download.js
External
Upstream service used by the download flow
- SoundCloud · Upstream source for track resolution and download workflow
Other components
- Browser · User-facing entry point for the app
Connections 19
- Browser → Frontend app: HTTP · User accesses the UI through the frontend service
- Compose → Frontend app: starts · Compose launches the frontend container
- Compose → Backend API: starts · Compose launches the backend container
- Frontend image → Frontend app: builds · Dockerfile defines the frontend runtime image
- Nginx config → Frontend app: serves · Nginx serves the built React assets
- Entry → App shell: mounts · React entry point renders the main app shell
- App shell → Header: renders · App composes the header
- Header → Logo: includes · Header includes the logo component
- App shell → Downloader form: renders · App composes the input form
- App shell → Footer: renders · App composes the footer
- App shell → Theme: uses · App styling is driven by the shared theme
- App shell → Styles: uses · Global CSS supports the UI presentation
- Downloader form → API client: calls · Form submits download requests through the API layer
- API client → Backend API: HTTP · Frontend API client sends requests to the backend
- Backend image → Backend API: builds · Dockerfile defines the backend runtime image
- Server entry → Download route: registers · Server entry wires the download route
- Download route → SoundCloud: integrates · Backend reaches out to SoundCloud for the download workflow
- Backend API → SoundCloud: HTTP · Backend is the system boundary for external SoundCloud interaction
- Frontend app → Backend API: HTTP · Browser-facing frontend delegates download work to the backend