Archivos de la Carpeta `routes`

La carpeta src/routes es el corazón del enrutamiento de la API, donde se definen las rutas HTTP y se asocian a las funciones controladoras (controllers) que manejan la lógica de negocio. Estos archivos actúan como el mapa de tu API, indicando qué URL (endpoint) responde a cada tipo de solicitud (GET, POST, PUT, DELETE) y qué lógica debe ejecutarse, incluyendo la aplicación de middlewares para tareas como la autenticación o el manejo de subidas de archivos.

`auth.routes.ts`

Este archivo define las rutas para las operaciones de autenticación de usuarios, como el inicio de sesión y el registro.

Descripción: Configura dos rutas POST principales: una para el inicio de sesión (/) y otra para el registro de nuevos usuarios (/register). La ruta de registro incluye el middleware verifyToken para asegurar que solo un usuario autenticado (por ejemplo, un administrador) pueda registrar a otros.
Propósito: Proporcionar los endpoints API para que los usuarios puedan autenticarse y registrarse en el sistema, sirviendo como la puerta de entrada inicial a la aplicación.
Funcionalidad:
- router.post("/", authController.handleLogin): Define la ruta para iniciar sesión. Una solicitud POST a la raíz de la ruta de autenticación (/api/v1/auth/ si se monta así) será manejada por authController.handleLogin.
- router.post("/register", verifyToken, authController.handleRegister): Define la ruta para el registro de usuarios. Esta ruta es protegida por el middleware verifyToken, lo que significa que solo se puede acceder si la solicitud incluye un token JWT válido. Después de la verificación, authController.handleRegister procesará la solicitud.
Rol en la aplicación: Es fundamental para la seguridad y el acceso inicial a la aplicación. Controla cómo los usuarios se identifican y obtienen autorización para interactuar con los recursos protegidos.

import { Router } from "express"; // Importa la clase Router de Express para crear enrutadores
import { authController } from "../controllers/auth.controller"; // Importa el controlador de autenticación
import { verifyToken } from "../middlewares/jwt.middlewares"; // Importa el middleware para verificar tokens JWT

const router = Router(); // Crea una nueva instancia de Router

// Define una ruta POST para el inicio de sesión (ruta base, ej. /api/v1/auth/)
// Esta ruta es pública y no requiere autenticación previa.
router.post("/", authController.handleLogin);

// Define una ruta POST para el registro de nuevos usuarios (ej. /api/v1/auth/register)
// Esta ruta está protegida por el middleware 'verifyToken', lo que significa que
// solo usuarios con un token JWT válido (ej. un administrador) pueden registrar a otros.
router.post("/register", verifyToken, authController.handleRegister);

export default router; // Exporta el enrutador configurado

`student.route.ts`

Este archivo define las rutas para las operaciones CRUD (Crear, Leer, Actualizar, Eliminar) de la entidad Estudiante.

Descripción: Configura múltiples rutas para interactuar con los datos de estudiantes (obtener todos, obtener por ID, crear, actualizar, eliminar). Todas las rutas definidas en este enrutador están protegidas por el middleware verifyToken. Las operaciones de creación y actualización incluyen middleware de Multer para manejar la subida de múltiples archivos (studentImage, birthCertificate, etc.) asociados a los estudiantes.
Propósito: Proporcionar una API completa para la gestión de los registros de estudiantes, incluyendo la capacidad de adjuntar y actualizar documentos y fotos directamente a través de las operaciones de la API.
Funcionalidad:
- router.use(verifyToken): Aplica el middleware verifyToken a todas las rutas definidas después de esta línea en este enrutador. Esto significa que todas las operaciones de estudiantes requieren un usuario autenticado.
- router.get("/", studentController.getAllStudentsHandler): Ruta GET para obtener una lista de todos los estudiantes.
- router.post("/", upload.fields([...]), async (req: Request, res: Response, next: NextFunction) => {...}): Ruta POST para crear un nuevo estudiante. Antes de llegar al controlador, pasa por upload.fields, que procesa la subida de los archivos especificados. La solicitud (req) se castea a MulterRequest para acceder a la propiedad files de forma segura.
- router.get("/:id", studentController.getStudentByIdHandler): Ruta GET para obtener un estudiante específico por su ID.
- router.put("/:id", upload.fields([...]), async (req: Request, res: Response, next: NextFunction) => {...}): Ruta PUT para actualizar un estudiante existente. Similar a la creación, maneja la subida de archivos para la actualización.
- router.delete("/:id", studentController.deleteStudentHandler): Ruta DELETE para eliminar un estudiante por su ID.
Rol en la aplicación: Es el centro de la interacción para la administración de estudiantes. Define cómo se manipulan los datos de los estudiantes, asegurando que solo usuarios autenticados puedan realizar estas operaciones y gestionando la complejidad de las subidas de archivos directamente en el flujo de la ruta.

// student.route.ts
import { Router, Request, Response, NextFunction } from "express"; // Importa los tipos y la clase Router de Express
import { studentController } from "../controllers/student.controller"; // Importa el controlador de estudiantes
import { verifyToken } from "../middlewares/jwt.middlewares"; // Importa el middleware para verificar tokens JWT
import { upload } from "../middlewares/multer.middleware"; // Importa el middleware de Multer para manejo de archivos
import { MulterRequest } from "../interfaces/express.interface"; // Importa la interfaz personalizada para solicitudes con Multer

const router = Router(); // Crea una nueva instancia de Router

// Aplica el middleware 'verifyToken' a todas las rutas definidas en este enrutador.
// Esto significa que todas las operaciones relacionadas con estudiantes requieren autenticación JWT.
router.use(verifyToken);

// Define una ruta GET para obtener todos los estudiantes (ej. /api/v1/students/)
router.get("/", studentController.getAllStudentsHandler);

// Define una ruta POST para crear un nuevo estudiante (ej. /api/v1/students/)
router.post(
  "/",
  // Middleware de Multer para manejar la subida de múltiples campos de archivo.
  // Cada objeto define el nombre del campo en el formulario y la cantidad máxima de archivos.
  upload.fields([
    { name: "studentImage", maxCount: 1 }, // Imagen del estudiante
    { name: "birthCertificate", maxCount: 1 }, // Certificado de nacimiento
    { name: "studyCertificate", maxCount: 1 }, // Certificado de estudio
    { name: "linkDni", maxCount: 1 }, // Enlace/documento del DNI
  ]),
  // Función asíncrona que maneja la solicitud después de que Multer haya procesado los archivos.
  async (req: Request, res: Response, next: NextFunction) => {
    // Se castea 'req' a 'MulterRequest' para asegurar que TypeScript reconozca
    // la propiedad 'files' añadida por Multer.
    await studentController.createStudentHandler(
      req as MulterRequest,
      res,
      next
    );
  }
);

// Define una ruta GET para obtener un estudiante por su ID (ej. /api/v1/students/:id)
router.get("/:id", studentController.getStudentByIdHandler);

// Define una ruta PUT para actualizar un estudiante existente por su ID (ej. /api/v1/students/:id)
router.put(
  "/:id",
  // Similar a la ruta POST, Multer maneja la subida de archivos para la actualización.
  upload.fields([
    { name: "studentImage", maxCount: 1 },
    { name: "birthCertificate", maxCount: 1 },
    { name: "studyCertificate", maxCount: 1 },
    { name: "linkDni", maxCount: 1 },
  ]),
  // Función asíncrona que maneja la solicitud después de la subida de archivos.
  async (req: Request, res: Response, next: NextFunction) => {
    // Se castea 'req' a 'MulterRequest' para acceder a 'files'.
    await studentController.updateStudentHandler(
      req as MulterRequest,
      res,
      next
    );
  }
);

// Define una ruta DELETE para eliminar un estudiante por su ID (ej. /api/v1/students/:id)
router.delete("/:id", studentController.deleteStudentHandler);

export default router; // Exporta el enrutador configurado

`user.route.ts`

Este archivo define las rutas para las operaciones CRUD (Crear, Leer, Actualizar, Eliminar) de la entidad Usuario.

Descripción: Configura múltiples rutas para interactuar con los datos de usuarios (obtener todos, obtener por ID, crear, actualizar, eliminar). Todas las rutas definidas en este enrutador están protegidas por el middleware verifyToken.
Propósito: Proporcionar una API completa para la gestión de los registros de usuarios, permitiendo la administración de las cuentas de usuario una vez que el usuario que realiza la solicitud ha sido autenticado.
Funcionalidad:
- router.use(verifyToken): Aplica el middleware verifyToken a todas las rutas definidas después de esta línea en este enrutador. Esto significa que todas las operaciones de usuarios requieren un usuario autenticado.
- router.get("/", userController.getAllUsersHandler): Ruta GET para obtener una lista de todos los usuarios.
- router.post("/", userController.createUserHandler): Ruta POST para crear un nuevo usuario.
- router.get("/:id", userController.getUserByIdHandler): Ruta GET para obtener un usuario específico por su ID.
- router.put("/:id", userController.updateUserHandler): Ruta PUT para actualizar un usuario existente por su ID.
- router.delete("/:id", userController.deleteUserHandler): Ruta DELETE para eliminar un usuario por su ID.
Rol en la aplicación: Es el punto de interacción para la administración de usuarios. Facilita la gestión de las cuentas de usuario, asegurando que solo los usuarios con los permisos adecuados (otorgados por el verifyToken y la lógica del controlador) puedan realizar estas operaciones críticas.

import { Router } from "express"; // Importa la clase Router de Express
import { userController } from "../controllers/user.controller"; // Importa el controlador de usuarios
import { verifyToken } from "../middlewares/jwt.middlewares"; // Importa el middleware para verificar tokens JWT

// Comentario indicando la ruta base esperada para este enrutador si se monta en el archivo principal de la app.
// Path: http://localhost:3000/api/v1/users

const router = Router(); // Crea una nueva instancia de Router

// Aplica el middleware 'verifyToken' a todas las rutas definidas en este enrutador.
// Esto significa que todas las operaciones relacionadas con usuarios requieren autenticación JWT.
router.use(verifyToken);

// Define una ruta GET para obtener todos los usuarios (ej. /api/v1/users/)
router.get("/", userController.getAllUsersHandler);

// Define una ruta POST para crear un nuevo usuario (ej. /api/v1/users/)
router.post("/", userController.createUserHandler);

// Define una ruta GET para obtener un usuario por su ID (ej. /api/v1/users/:id)
router.get("/:id", userController.getUserByIdHandler);

// Define una ruta PUT para actualizar un usuario existente por su ID (ej. /api/v1/users/:id)
router.put("/:id", userController.updateUserHandler);

// Define una ruta DELETE para eliminar un usuario por su ID (ej. /api/v1/users/:id)
router.delete("/:id", userController.deleteUserHandler);

export default router; // Exporta el enrutador configurado

Archivos de la Carpeta routes #

auth.routes.ts #

student.route.ts #

user.route.ts #

Archivos de la Carpeta `routes`

`auth.routes.ts`

`student.route.ts`

`user.route.ts`