api: introduce routes and error handling middleware

Pedro Lucas Porcellis porcellis@eletrotupi.com 3 months ago 3bcf802a5ee2d0a9efe349a6250e92f62e9f27ee

Parents: a6b6444

5 file(s) changed

api/src/index.ts +17 -0
api/src/middleware/errorHandler.ts +29 -0
api/src/routes/mood.js +0 -509
api/src/routes/users.js +0 -219
api/src/routes/users.ts +8 -0

api/src/index.ts

@@ -0,0 +1,17 @@
  + import express from 'express';
  + import userRouter from '@app/routes/users'
  + import { errorHandler } from '@app/middleware/errorHandler';
  + 
  + const port = process.env.PORT || 3000;
  + 
  + const app = express();
  + app.use(express.json())
  + 
  + app.use("/users", userRouter);
  + 
  + app.use(errorHandler); // always last
  + 
  + app.listen(port, () => {
  +   console.log(`Server booted on port ${port}`)
  + })
  + 

api/src/middleware/errorHandler.ts

@@ -0,0 +1,29 @@
  + import { Request, Response, NextFunction } from 'express';
  + import { Prisma } from '@prisma/client' // Bleh
  + import { isDomainError } from "@app/lib/errors/base";
  + 
  + export const errorHandler = (
  +   err: unknown,
  +   _req: Request,
  +   res: Response,
  +   _next: NextFunction
  + ) => {
  +   // TODO: Rig some improved, centralized error logging here
  +   console.error(`[ErrorHandler]: ${err}`);
  + 
  +   if (isDomainError(err)) {
  +     return res.status(err.status)
  +       .json({ error: err.message });
  +   }
  + 
  +   // Prisma errors as a fallback (or map these to domain errors in the repo)
  +   if (err instanceof Prisma.PrismaClientKnownRequestError) {
  +     if (err.code === "P2025") return res.status(404)
  +       .json({ error: "Record not found" });
  + 
  +     if (err.code === "P2002") return res.status(409)
  +       .json({ error: "Unique constraint violation" });
  +   }
  +   
  +   res.status(500).json({ error: "Internal server error" });
  + }

@@ -1,509 +0,0 @@
  - 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();
  - 
  - router.get('/', (req, res) => {
  -   
  - });
  - 
  - // Create new mood entry with components
  - router.post("/", (req, res) => {
  -   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
  -     );
  - 
  -     const moodId = moodResult.lastInsertRowid;
  - 
  -     // 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
  -         );
  -       }
  -     }
  - 
  -     // Commit transaction
  -     db.prepare("COMMIT").run();
  - 
  -     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" });
  -   }
  - });
  - 
  - // 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;
  - 
  -   // Calculate emotion stats
  -   if (components.length > 0) {
  -     mood.emotion_stats = calculateEmotionStats(components);
  -   }
  - 
  -   res.json(mood);
  - });
  - 
  - // 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;

@@ -1,219 +0,0 @@
  - import express from "express";
  - import bcrypt from "bcryptjs";
  - 
  - import {
  -   isValidEmail,
  -   isValidPassword,
  -   sanitizeString,
  -   validateRequiredFields
  - } from "../utils/validators.js";
  - 
  - const router = express.Router();
  - 
  - // Create user
  - router.post("/", (req, res) => {
  -   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 = 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'
  -     );
  - 
  -     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" });
  -     }
  - 
  -     // 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) {
  -     console.error('Error updating user:', err);
  -     res.status(500).json({ error: "Erro ao atualizar usuário" });
  -   }
  - });
  - 
  - // 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;

api/src/routes/users.ts

@@ -0,0 +1,8 @@
  + import { Router } from "express";
  + import { UsersController } from '@app/controllers/users'
  + 
  + const router = Router();
  + 
  + router.post('/', UsersController.create);
  + 
  + export default router;