api: rework mood and user routes to match improvements on model design

Pedro Lucas Porcellis porcellis@eletrotupi.com 6 months ago ba9ebeebe13950cdc2b168d63fe2ec5b3be67d11

Parents: 06314a5

2 file(s) changed

api/src/routes/mood.js +488 -18
api/src/routes/users.js +199 -13

api/src/routes/mood.js

@@ -1,33 +1,503 @@
    import express from "express";
  + import {
  +   validateMoodComponents,
  +   isValidLevel,
  +   isValidRating,
  +   calculateEmotionStats
  + } from "../utils/emotions.js";
  + import {
  +   validateRequiredFields,
  +   isValidDate,
  +   isNotFutureDate,
  +   isValidDateRange,
  +   sanitizeString,
  +   validatePagination
  + } from "../utils/validators.js";
    
    const router = express.Router();
    
  + // Create new mood entry with components
    router.post("/", (req, res) => {
  -   const { user_id, stress_level, anxiety_level, title, description } = req.body;
  +   const {
  +     user_id,
  +     rating,
  +     stress_level,
  +     anxiety_level,
  +     energy_level,
  +     title,
  +     description,
  +     recorded_at,
  +     mood_components
  +   } = req.body;
  + 
  +   // Validate required fields
  +   const requiredValidation = validateRequiredFields(req.body, [
  +     'user_id', 'stress_level', 'anxiety_level', 'energy_level', 'recorded_at'
  +   ]);
  + 
  +   if (!requiredValidation.valid) {
  +     return res.status(400).json({
  +       error: "Campos faltantes",
  +       missing: requiredValidation.missing
  +     });
  +   }
  + 
  +   // Validate levels
  +   if (!isValidLevel(stress_level)) {
  +     return res.status(400).json({ error: "stress_level deve ser entre 1 e 10" });
  +   }
  +   if (!isValidLevel(anxiety_level)) {
  +     return res.status(400).json({ error: "anxiety_level deve ser entre 1 e 10" });
  +   }
  +   if (!isValidLevel(energy_level)) {
  +     return res.status(400).json({ error: "energy_level deve ser entre 1 e 10" });
  +   }
  + 
  +   // Validate optional rating
  +   if (rating && !isValidRating(rating)) {
  +     return res.status(400).json({ error: "rating deve ser entre 1 e 10" });
  +   }
  + 
  +   // Validate date
  +   if (!isValidDate(recorded_at)) {
  +     return res.status(400).json({ error: "recorded_at deve ser uma data válida" });
  +   }
  + 
  +   if (!isNotFutureDate(recorded_at)) {
  +     return res.status(400).json({ error: "recorded_at não pode ser no futuro" });
  +   }
  + 
  +   // Validate mood components if provided
  +   if (mood_components) {
  +     const componentValidation = validateMoodComponents(mood_components);
  +     if (!componentValidation.valid) {
  +       return res.status(400).json({ error: componentValidation.error });
  +     }
  +   }
  + 
  +   const db = req.db;
  + 
  +   try {
  +     // Start transaction
  +     db.prepare("BEGIN").run();
  + 
  +     // Insert mood entry
  +     const moodStmt = db.prepare(`
  +       INSERT INTO mood (
  +         user_id, rating, stress_level, anxiety_level, energy_level,
  +         title, description, recorded_at
  +       ) VALUES (?, ?, ?, ?, ?, ?, ?, ?)
  +     `);
  + 
  +     const moodResult = moodStmt.run(
  +       user_id,
  +       rating || null,
  +       stress_level,
  +       anxiety_level,
  +       energy_level,
  +       sanitizeString(title) || null,
  +       sanitizeString(description) || null,
  +       recorded_at
  +     );
    
  -   if (!user_id || !stress_level || !anxiety_level)
  -     return res.status(400).json({ error: "Campos faltantes" });
  +     const moodId = moodResult.lastInsertRowid;
    
  -   const stmt = req.db.prepare(
  -     `
  -       INSERT INTO mood (user_id, stress_level, anxiety_level, title, description)
  -       VALUES (?, ?, ?, ?, ?)
  -     `
  -   );
  +     // Insert mood components if provided
  +     if (mood_components && mood_components.length > 0) {
  +       const componentStmt = db.prepare(`
  +         INSERT INTO mood_components (mood_id, emotion, intensity)
  +         VALUES (?, ?, ?)
  +       `);
  + 
  +       for (const component of mood_components) {
  +         componentStmt.run(
  +           moodId,
  +           component.emotion.toLowerCase(),
  +           component.intensity
  +         );
  +       }
  +     }
    
  -   const result = stmt.run(
  -     user_id, stress_level, anxiety_level, title || null, description || null
  -   );
  +     // Commit transaction
  +     db.prepare("COMMIT").run();
    
  -   res.status(201).json({ id: result.lastInsertRowid });
  +     res.status(201).json({ id: moodId });
  +   } catch (err) {
  +     // Rollback on error
  +     db.prepare("ROLLBACK").run();
  +     console.error('Error creating mood:', err);
  +     res.status(500).json({ error: "Erro ao criar registro de humor" });
  +   }
    });
    
  - router.get("/:user_id", (req, res) => {
  -   const stmt = req.db.prepare("SELECT * FROM mood WHERE user_id = ?");
  -   const rows = stmt.all(req.params.user_id);
  + // Get single mood entry with components
  + router.get("/:mood_id", (req, res) => {
  +   const moodId = req.params.mood_id;
  +   const db = req.db;
  + 
  +   const moodStmt = db.prepare(`
  +     SELECT m.*, u.first_name, u.last_name
  +     FROM mood m
  +     JOIN users u ON m.user_id = u.id
  +     WHERE m.id = ?
  +   `);
  + 
  +   const mood = moodStmt.get(moodId);
  + 
  +   if (!mood) {
  +     return res.status(404).json({ error: "Humor não encontrado" });
  +   }
  + 
  +   // Get mood components
  +   const componentsStmt = db.prepare(`
  +     SELECT emotion, intensity
  +     FROM mood_components
  +     WHERE mood_id = ?
  +   `);
  + 
  +   const components = componentsStmt.all(moodId);
  +   mood.mood_components = components;
    
  -   res.json(rows);
  +   // Calculate emotion stats
  +   if (components.length > 0) {
  +     mood.emotion_stats = calculateEmotionStats(components);
  +   }
  + 
  +   res.json(mood);
    });
    
  - export default router;
  + // Update mood entry
  + router.put("/:mood_id", (req, res) => {
  +   const moodId = req.params.mood_id;
  +   const {
  +     rating,
  +     stress_level,
  +     anxiety_level,
  +     energy_level,
  +     title,
  +     description,
  +     recorded_at,
  +     mood_components
  +   } = req.body;
  + 
  +   const db = req.db;
    
  +   // Check if mood exists
  +   const existingMood = db.prepare("SELECT id FROM mood WHERE id = ?").get(moodId);
  +   if (!existingMood) {
  +     return res.status(404).json({ error: "Humor não encontrado" });
  +   }
  + 
  +   // Build update query dynamically
  +   const updates = [];
  +   const values = [];
  + 
  +   if (rating !== undefined) {
  +     if (!isValidRating(rating)) {
  +       return res.status(400).json({ error: "rating deve ser entre 1 e 10" });
  +     }
  +     updates.push("rating = ?");
  +     values.push(rating);
  +   }
  + 
  +   if (stress_level !== undefined) {
  +     if (!isValidLevel(stress_level)) {
  +       return res.status(400).json({ error: "stress_level deve ser entre 1 e 10" });
  +     }
  +     updates.push("stress_level = ?");
  +     values.push(stress_level);
  +   }
  + 
  +   if (anxiety_level !== undefined) {
  +     if (!isValidLevel(anxiety_level)) {
  +       return res.status(400).json({ error: "anxiety_level deve ser entre 1 e 10" });
  +     }
  +     updates.push("anxiety_level = ?");
  +     values.push(anxiety_level);
  +   }
  + 
  +   if (energy_level !== undefined) {
  +     if (!isValidLevel(energy_level)) {
  +       return res.status(400).json({ error: "energy_level deve ser entre 1 e 10" });
  +     }
  +     updates.push("energy_level = ?");
  +     values.push(energy_level);
  +   }
  + 
  +   if (title !== undefined) {
  +     updates.push("title = ?");
  +     values.push(sanitizeString(title) || null);
  +   }
  + 
  +   if (description !== undefined) {
  +     updates.push("description = ?");
  +     values.push(sanitizeString(description) || null);
  +   }
  + 
  +   if (recorded_at !== undefined) {
  +     if (!isValidDate(recorded_at)) {
  +       return res.status(400).json({ error: "recorded_at deve ser uma data válida" });
  +     }
  +     if (!isNotFutureDate(recorded_at)) {
  +       return res.status(400).json({ error: "recorded_at não pode ser no futuro" });
  +     }
  +     updates.push("recorded_at = ?");
  +     values.push(recorded_at);
  +   }
  + 
  +   updates.push("updated_at = CURRENT_TIMESTAMP");
  + 
  +   try {
  +     db.prepare("BEGIN").run();
  + 
  +     // Update mood if there are changes
  +     if (updates.length > 0) {
  +       const updateQuery = `UPDATE mood SET ${updates.join(', ')} WHERE id = ?`;
  +       values.push(moodId);
  +       db.prepare(updateQuery).run(...values);
  +     }
  + 
  +     // Update mood components if provided
  +     if (mood_components !== undefined) {
  +       const componentValidation = validateMoodComponents(mood_components);
  +       if (!componentValidation.valid) {
  +         db.prepare("ROLLBACK").run();
  +         return res.status(400).json({ error: componentValidation.error });
  +       }
  + 
  +       // Delete existing components
  +       db.prepare("DELETE FROM mood_components WHERE mood_id = ?").run(moodId);
  + 
  +       // Insert new components
  +       if (mood_components.length > 0) {
  +         const componentStmt = db.prepare(`
  +           INSERT INTO mood_components (mood_id, emotion, intensity)
  +           VALUES (?, ?, ?)
  +         `);
  + 
  +         for (const component of mood_components) {
  +           componentStmt.run(
  +             moodId,
  +             component.emotion.toLowerCase(),
  +             component.intensity
  +           );
  +         }
  +       }
  +     }
  + 
  +     db.prepare("COMMIT").run();
  +     res.json({ success: true, id: moodId });
  +   } catch (err) {
  +     db.prepare("ROLLBACK").run();
  +     console.error('Error updating mood:', err);
  +     res.status(500).json({ error: "Erro ao atualizar humor" });
  +   }
  + });
  + 
  + // Delete mood entry
  + router.delete("/:mood_id", (req, res) => {
  +   const moodId = req.params.mood_id;
  +   const db = req.db;
  + 
  +   const result = db.prepare("DELETE FROM mood WHERE id = ?").run(moodId);
  + 
  +   if (result.changes === 0) {
  +     return res.status(404).json({ error: "Humor não encontrado" });
  +   }
  + 
  +   res.json({ success: true, deleted: moodId });
  + });
  + 
  + // Get user's moods with optional date range
  + router.get("/user/:user_id", (req, res) => {
  +   const userId = req.params.user_id;
  +   const { start_date, end_date, page, limit } = req.query;
  +   const db = req.db;
  + 
  +   // Validate pagination
  +   const { page: validPage, limit: validLimit, offset } = validatePagination(page, limit);
  + 
  +   let query = `
  +     SELECT m.*,
  +            COUNT(mc.id) as component_count
  +     FROM mood m
  +     LEFT JOIN mood_components mc ON m.id = mc.mood_id
  +     WHERE m.user_id = ?
  +   `;
  +   const params = [userId];
  + 
  +   // Add date range filtering
  +   if (start_date && end_date) {
  +     if (!isValidDateRange(start_date, end_date)) {
  +       return res.status(400).json({ error: "Intervalo de datas inválido" });
  +     }
  +     query += " AND m.recorded_at BETWEEN ? AND ?";
  +     params.push(start_date, end_date);
  +   } else if (start_date) {
  +     if (!isValidDate(start_date)) {
  +       return res.status(400).json({ error: "Data de início inválida" });
  +     }
  +     query += " AND m.recorded_at >= ?";
  +     params.push(start_date);
  +   } else if (end_date) {
  +     if (!isValidDate(end_date)) {
  +       return res.status(400).json({ error: "Data de fim inválida" });
  +     }
  +     query += " AND m.recorded_at <= ?";
  +     params.push(end_date);
  +   }
  + 
  +   query += " GROUP BY m.id ORDER BY m.recorded_at DESC LIMIT ? OFFSET ?";
  +   params.push(validLimit, offset);
  + 
  +   const moods = db.prepare(query).all(...params);
  + 
  +   // Get components for each mood
  +   const moodIds = moods.map(m => m.id);
  +   if (moodIds.length > 0) {
  +     const componentsQuery = `
  +       SELECT mood_id, emotion, intensity
  +       FROM mood_components
  +       WHERE mood_id IN (${moodIds.map(() => '?').join(',')})
  +     `;
  + 
  +     const components = db.prepare(componentsQuery).all(...moodIds);
  + 
  +     // Group components by mood_id
  +     const componentsByMood = {};
  +     components.forEach(c => {
  +       if (!componentsByMood[c.mood_id]) {
  +         componentsByMood[c.mood_id] = [];
  +       }
  +       componentsByMood[c.mood_id].push({
  +         emotion: c.emotion,
  +         intensity: c.intensity
  +       });
  +     });
  + 
  +     // Attach components to moods
  +     moods.forEach(mood => {
  +       mood.mood_components = componentsByMood[mood.id] || [];
  +       if (mood.mood_components.length > 0) {
  +         mood.emotion_stats = calculateEmotionStats(mood.mood_components);
  +       }
  +     });
  +   }
  + 
  +   // Get total count for pagination
  +   let countQuery = "SELECT COUNT(*) as total FROM mood WHERE user_id = ?";
  +   const countParams = [userId];
  + 
  +   if (start_date && end_date) {
  +     countQuery += " AND recorded_at BETWEEN ? AND ?";
  +     countParams.push(start_date, end_date);
  +   } else if (start_date) {
  +     countQuery += " AND recorded_at >= ?";
  +     countParams.push(start_date);
  +   } else if (end_date) {
  +     countQuery += " AND recorded_at <= ?";
  +     countParams.push(end_date);
  +   }
  + 
  +   const { total } = db.prepare(countQuery).get(...countParams);
  + 
  +   res.json({
  +     moods,
  +     pagination: {
  +       page: validPage,
  +       limit: validLimit,
  +       total,
  +       total_pages: Math.ceil(total / validLimit)
  +     }
  +   });
  + });
  + 
  + // Get mood statistics for a user
  + router.get("/user/:user_id/stats", (req, res) => {
  +   const userId = req.params.user_id;
  +   const { start_date, end_date } = req.query;
  +   const db = req.db;
  + 
  +   let baseQuery = "FROM mood WHERE user_id = ?";
  +   const params = [userId];
  + 
  +   if (start_date && end_date) {
  +     if (!isValidDateRange(start_date, end_date)) {
  +       return res.status(400).json({ error: "Intervalo de datas inválido" });
  +     }
  +     baseQuery += " AND recorded_at BETWEEN ? AND ?";
  +     params.push(start_date, end_date);
  +   }
  + 
  +   // Get aggregated stats
  +   const statsQuery = `
  +     SELECT
  +       COUNT(*) as total_entries,
  +       AVG(rating) as avg_rating,
  +       AVG(stress_level) as avg_stress,
  +       AVG(anxiety_level) as avg_anxiety,
  +       AVG(energy_level) as avg_energy,
  +       MIN(stress_level) as min_stress,
  +       MAX(stress_level) as max_stress,
  +       MIN(anxiety_level) as min_anxiety,
  +       MAX(anxiety_level) as max_anxiety,
  +       MIN(energy_level) as min_energy,
  +       MAX(energy_level) as max_energy
  +     ${baseQuery}
  +   `;
  + 
  +   const stats = db.prepare(statsQuery).get(...params);
  + 
  +   // Get emotion frequency
  +   const emotionQuery = `
  +     SELECT
  +       mc.emotion,
  +       COUNT(*) as frequency,
  +       AVG(mc.intensity) as avg_intensity
  +     FROM mood_components mc
  +     JOIN mood m ON mc.mood_id = m.id
  +     WHERE m.user_id = ?
  +     ${start_date && end_date ? 'AND m.recorded_at BETWEEN ? AND ?' : ''}
  +     GROUP BY mc.emotion
  +     ORDER BY frequency DESC
  +   `;
  + 
  +   const emotionParams = [...params];
  +   const emotions = db.prepare(emotionQuery).all(...emotionParams);
  + 
  +   // Get mood trends by day of week
  +   const dayTrendsQuery = `
  +     SELECT
  +       CASE CAST(strftime('%w', recorded_at) AS INTEGER)
  +         WHEN 0 THEN 'Sunday'
  +         WHEN 1 THEN 'Monday'
  +         WHEN 2 THEN 'Tuesday'
  +         WHEN 3 THEN 'Wednesday'
  +         WHEN 4 THEN 'Thursday'
  +         WHEN 5 THEN 'Friday'
  +         WHEN 6 THEN 'Saturday'
  +       END as day_of_week,
  +       AVG(stress_level) as avg_stress,
  +       AVG(anxiety_level) as avg_anxiety,
  +       AVG(energy_level) as avg_energy,
  +       COUNT(*) as entries
  +     ${baseQuery}
  +     GROUP BY strftime('%w', recorded_at)
  +   `;
  + 
  +   const dayTrends = db.prepare(dayTrendsQuery).all(...params);
  + 
  +   res.json({
  +     overall: stats,
  +     emotions: emotions,
  +     trends: {
  +       by_day_of_week: dayTrends
  +     },
  +     date_range: {
  +       start: start_date || 'all time',
  +       end: end_date || 'all time'
  +     }
  +   });
  + });
  + 
  + export default router;

api/src/routes/users.js

@@ -1,31 +1,218 @@
    import express from "express";
    import bcrypt from "bcryptjs";
  + import {
  +   isValidEmail,
  +   isValidPassword,
  +   sanitizeString,
  +   validateRequiredFields
  + } from "../utils/validators.js";
    
    const router = express.Router();
    
  - // XXX: Needs translations
  + // Create user
    router.post("/", (req, res) => {
  -   const { email, password, first_name, last_name } = req.body;
  -   if (!email || !password || !first_name || !last_name)
  -     return res.status(400).json({ error: "Campos faltantes" });
  +   const { email, password, first_name, last_name, timezone } = req.body;
  + 
  +   // Validate required fields
  +   const requiredValidation = validateRequiredFields(req.body, [
  +     'email', 'password', 'first_name', 'last_name'
  +   ]);
  + 
  +   if (!requiredValidation.valid) {
  +     return res.status(400).json({
  +       error: "Campos faltantes",
  +       missing: requiredValidation.missing
  +     });
  +   }
  + 
  +   // Validate email format
  +   if (!isValidEmail(email)) {
  +     return res.status(400).json({ error: "Email inválido" });
  +   }
  + 
  +   // Validate password strength
  +   if (!isValidPassword(password)) {
  +     return res.status(400).json({ error: "Senha deve ter pelo menos 6 caracteres" });
  +   }
    
      const hashed = bcrypt.hashSync(password, 10);
  +   const db = req.db;
    
      try {
  -     const stmt = req.db.prepare(
  -       `
  -         INSERT INTO users (email, password, first_name, last_name)
  -         VALUES (?, ?, ?, ?)
  -       `
  +     const stmt = db.prepare(`
  +       INSERT INTO users (email, password, first_name, last_name, timezone)
  +       VALUES (?, ?, ?, ?, ?)
  +     `);
  + 
  +     const result = stmt.run(
  +       email.toLowerCase(),
  +       hashed,
  +       sanitizeString(first_name),
  +       sanitizeString(last_name),
  +       timezone || 'UTC'
        );
    
  -     const result = stmt.run(email, hashed, first_name, last_name);
  +     res.status(201).json({ id: result.lastInsertRowid });
  +   } catch (err) {
  +     if (err.message.includes('UNIQUE')) {
  +       res.status(400).json({ error: "Email já cadastrado" });
  +     } else {
  +       console.error('Error creating user:', err);
  +       res.status(500).json({ error: "Erro ao criar usuário" });
  +     }
  +   }
  + });
  + 
  + // User login
  + router.post("/login", (req, res) => {
  +   const { email, password } = req.body;
  + 
  +   // Validate required fields
  +   if (!email || !password) {
  +     return res.status(400).json({ error: "Email e senha são obrigatórios" });
  +   }
  + 
  +   const db = req.db;
  + 
  +   const user = db.prepare(`
  +     SELECT id, email, password, first_name, last_name, timezone
  +     FROM users
  +     WHERE email = ?
  +   `).get(email.toLowerCase());
  + 
  +   if (!user) {
  +     return res.status(401).json({ error: "Credenciais inválidas" });
  +   }
  + 
  +   const passwordMatch = bcrypt.compareSync(password, user.password);
  + 
  +   if (!passwordMatch) {
  +     return res.status(401).json({ error: "Credenciais inválidas" });
  +   }
  + 
  +   // Don't send password in response
  +   delete user.password;
  + 
  +   res.json({
  +     success: true,
  +     user
  +   });
  + });
  + 
  + // Get user profile
  + router.get("/:user_id", (req, res) => {
  +   const userId = req.params.user_id;
  +   const db = req.db;
  + 
  +   const user = db.prepare(`
  +     SELECT id, email, first_name, last_name, timezone, created_at, updated_at
  +     FROM users
  +     WHERE id = ?
  +   `).get(userId);
  + 
  +   if (!user) {
  +     return res.status(404).json({ error: "Usuário não encontrado" });
  +   }
  + 
  +   // Get user's mood count
  +   const moodStats = db.prepare(`
  +     SELECT COUNT(*) as total_moods
  +     FROM mood
  +     WHERE user_id = ?
  +   `).get(userId);
  + 
  +   user.total_moods = moodStats.total_moods;
  + 
  +   res.json(user);
  + });
  + 
  + // Update user
  + router.put("/:user_id", (req, res) => {
  +   const userId = req.params.user_id;
  +   const { email, password, first_name, last_name, timezone } = req.body;
  +   const db = req.db;
  + 
  +   // Check if user exists
  +   const existingUser = db.prepare("SELECT id FROM users WHERE id = ?").get(userId);
  +   if (!existingUser) {
  +     return res.status(404).json({ error: "Usuário não encontrado" });
  +   }
  + 
  +   const updates = [];
  +   const values = [];
  + 
  +   if (email !== undefined) {
  +     if (!isValidEmail(email)) {
  +       return res.status(400).json({ error: "Email inválido" });
  +     }
    
  -     res.status(201).json({ id: result.lastInsertRowid });
  +     // Check if email is already taken by another user
  +     const emailCheck = db.prepare("SELECT id FROM users WHERE email = ? AND id != ?")
  +       .get(email.toLowerCase(), userId);
  + 
  +     if (emailCheck) {
  +       return res.status(400).json({ error: "Email já está em uso" });
  +     }
  + 
  +     updates.push("email = ?");
  +     values.push(email.toLowerCase());
  +   }
  + 
  +   if (password !== undefined) {
  +     if (!isValidPassword(password)) {
  +       return res.status(400).json({ error: "Senha deve ter pelo menos 6 caracteres" });
  +     }
  +     updates.push("password = ?");
  +     values.push(bcrypt.hashSync(password, 10));
  +   }
  + 
  +   if (first_name !== undefined) {
  +     updates.push("first_name = ?");
  +     values.push(sanitizeString(first_name));
  +   }
  + 
  +   if (last_name !== undefined) {
  +     updates.push("last_name = ?");
  +     values.push(sanitizeString(last_name));
  +   }
  + 
  +   if (timezone !== undefined) {
  +     updates.push("timezone = ?");
  +     values.push(timezone);
  +   }
  + 
  +   if (updates.length === 0) {
  +     return res.status(400).json({ error: "Nenhum campo para atualizar" });
  +   }
  + 
  +   updates.push("updated_at = CURRENT_TIMESTAMP");
  + 
  +   try {
  +     const updateQuery = `UPDATE users SET ${updates.join(', ')} WHERE id = ?`;
  +     values.push(userId);
  + 
  +     db.prepare(updateQuery).run(...values);
  + 
  +     res.json({ success: true, id: userId });
      } catch (err) {
  -     res.status(400).json({ error: "Email já cadastrado" });
  +     console.error('Error updating user:', err);
  +     res.status(500).json({ error: "Erro ao atualizar usuário" });
      }
    });
    
  - export default router;
  + // Delete user
  + router.delete("/:user_id", (req, res) => {
  +   const userId = req.params.user_id;
  +   const db = req.db;
    
  +   // This will cascade delete all moods and mood_components
  +   const result = db.prepare("DELETE FROM users WHERE id = ?").run(userId);
  + 
  +   if (result.changes === 0) {
  +     return res.status(404).json({ error: "Usuário não encontrado" });
  +   }
  + 
  +   res.json({ success: true, deleted: userId });
  + });
  + 
  + export default router;