How fran-laz/proyecto-sceci-postulacion works
1. This repository is split into two clear applications:
- study-match: a Spring Boot backend.
- frontend-study-match: a Vite + React frontend.
Together they form a classic client/server architecture with the frontend consuming backend APIs.
2. The backend is the core application. It exposes REST controllers for the main domain areas:
- authentication
- study groups
- subjects/materias
- projects
- requests/solicitudes
The package structure is organized in the usual layered style: controllers → services → repositories → models.
3. Security is a first-class boundary in the backend. The presence of JwtAuthenticationFilter, JwtUtil, and SecurityConfig indicates JWT-based authentication with filter-driven request protection. This means some endpoints are public, while others require a valid token sent from the frontend.
4. The backend domain model is centered on academic collaboration. The main entities are:
- Usuario
- Perfil
- Carrera
- Materia
- GrupoMateria
- GrupoEstudio
- Proyecto
- Solicitud
These names suggest the system manages user profiles, academic programs, study subjects, study groups, and participation/request workflows.
5. Data access is repository-based. Each main entity has a repository interface, which implies persistence is handled through Spring Data-style data stores. The application.properties file likely contains the database and runtime configuration, making persistence an infrastructure concern isolated from controllers and services.
6. Service classes hold the business logic and orchestration:
- UsuarioService
- MateriaService
- GrupoEstudioService
- ProyectoService
- SolicitudService
Controllers depend on these services rather than repositories directly, keeping HTTP concerns separated from domain rules.
7. DTOs are used throughout the backend for API contracts. Separate request/response DTOs exist for auth, group studies, projects, and solicitudes. This means the API does not expose entities directly, which is an important architectural boundary between persistence models and external JSON payloads.
8. The frontend is a small single-page application with route-based screens:
- Inicio
- Login
- Registro
- Dashboard
The presence of ProtectedRoute.jsx shows that authenticated access is enforced on the client as well, likely gating the dashboard or private features based on login state/token presence.
9. The frontend role is presentation and session handling, not domain logic. It likely sends credentials to the backend auth endpoint, stores the returned JWT, and uses that token for subsequent API requests. The routing structure suggests a public entry flow into login/registration and then a protected area for the app’s main functionality.
10. Build and deployment tooling is intentionally separated per app:
- Frontend: Vite, ESLint, npm lockfiles.
- Backend: Maven Wrapper, pom.xml, Spring Boot, Dockerfile.
This indicates the backend can be built and containerized independently, while the frontend is developed and served as a separate web client.
11. Operationally, there are API testing artifacts in the backend (postman and .postman folders), which suggests the REST contract is intended to be exercised directly and verified outside the UI. That reinforces the backend as the stable service boundary.
12. For an architecture diagram, the key flow is:
browser/user → React routes/components → authenticated API calls → Spring Security/JWT filter → controller → service → repository → database,
with DTOs translating at the API boundary and protected routes enforcing the same access model on the client side.
Main entry points: AuthController.java AuthController · controllers Domain APIs · services Services · App.jsx Router
Components 17
Frontend
Vite + React client
- Main · Bootstraps the React app
frontend-study-match/src/main.jsx - Router · Top-level client routing and app composition
frontend-study-match/src/App.jsx - ProtectedRoute · Client-side auth gate for private screens
frontend-study-match/src/components/ProtectedRoute.jsx - Pages · Inicio, Login, Registro, Dashboard
frontend-study-match/src/pages
Backend
Spring Boot API
- App · Backend application entrypoint
study-match/src/main/java/com/flazarte/study_match/StudyMatchApplication.java - Config · Application properties and runtime setup
study-match/src/main/resources/application.properties - SecurityConfig · HTTP security and protected endpoint rules
study-match/src/main/java/com/flazarte/study_match/config/SecurityConfig.java - JwtFilter · JWT-bearing request filter
study-match/src/main/java/com/flazarte/study_match/config/JwtAuthenticationFilter.java - JwtUtil · JWT creation and validation helper
study-match/src/main/java/com/flazarte/study_match/config/JwtUtil.java - AuthController · Login and registration endpoints
study-match/src/main/java/com/flazarte/study_match/controllers/AuthController.java - Domain APIs · Study group, subject, project, and request endpoints
study-match/src/main/java/com/flazarte/study_match/controllers - Services · Business rules and orchestration
study-match/src/main/java/com/flazarte/study_match/services - DTOs · Request and response payloads
study-match/src/main/java/com/flazarte/study_match/dtos - Models · Usuario, Perfil, Carrera, Materia, GrupoMateria, GrupoEstudio, Proyecto, Solicitud
study-match/src/main/java/com/flazarte/study_match/models - Repositories · Persistence interfaces for domain entities
study-match/src/main/java/com/flazarte/study_match/repositories - Database · Underlying data store accessed through repositories
- Postman · REST contract collections and globals
study-match/postman
Connections 21
- Main → Router: mounts · React entrypoint renders the app shell
- Router → Pages: routes to · App composes the public and private screens
- Router → ProtectedRoute: guards · Route protection is applied at the client boundary
- Pages → AuthController: login/register · Public screens call authentication endpoints
- Pages → Domain APIs: api requests · Protected screens consume the main REST API
- ProtectedRoute → AuthController: token check · Private navigation depends on authenticated session state
- App → Config: loads · Application bootstrap uses runtime configuration
- App → SecurityConfig: starts with · Security rules are part of backend startup
- SecurityConfig → JwtFilter: registers · Security config inserts the JWT filter into the chain
- JwtFilter → JwtUtil: validates · Filter relies on JWT parsing and verification
- JwtFilter → AuthController: protects · Authenticated requests are routed through the security boundary
- AuthController → DTOs: exchanges · Auth endpoints use request/response DTOs
- Domain APIs → DTOs: exchanges · REST controllers map JSON through DTOs
- AuthController → Services: delegates · Controllers hand off business work to services
- Domain APIs → Services: delegates · Domain controllers call the service layer
- Services → Models: operates on · Services coordinate domain entities
- Services → Repositories: persists via · Business logic uses repositories for storage
- Repositories → Database: reads/writes · Repository interfaces back onto the persistent store
- Models → Repositories: mapped by · Entities are the persistence shape used by repositories
- Postman → AuthController: tests · Collections exercise the public auth contract
- Postman → Domain APIs: tests · Collections exercise the main REST resources