api: add full blown mood endpoint

Holy shit, this was a wild ride. I've refactored to address a couple of
bunch of lying issues:

- No auth middleware being used
- Weird ass models that weren't models at all
- Basically ignoring types everywhere
- Weird shape of parameters being tossed around
- Controllers doing validations + models doing validations

These need to be ported now to the auth and user endpoints as well. Then
it'll probably be easier to just keep it tidy.

Now, Prisma can keep working as our repository layer, our services actually
behave as services instead of "models", validation happens with Zod at
the controller level, and schemas are there to keep track of what needs
to be validated. A problem is that now it lacks good i18n translation,
so we gotta patch that sometime

Pedro Lucas Porcellis porcellis@eletrotupi.com 1 month ago 4831e19b7a0b1f141e9b8ba7372f931fb909d5f4

Parents: bc4e3ca

6 file(s) changed

api/src/controllers/moods.ts +42 -0
api/src/createApp.ts +2 -0
api/src/routes/moods.ts +10 -0
api/src/schemas/index.ts +8 -0
api/src/schemas/mood.schema.ts +23 -0
api/src/services/mood.service.ts +27 -0

api/src/controllers/moods.ts

@@ -0,0 +1,42 @@
  + import { Request, Response, NextFunction } from 'express';
  + import { AuthenticatedRequest } from '@app/middleware/auth';
  + import {
  +   createMood,
  +   getMoodsByUserId
  + } from '@app/services/mood.service';
  + 
  + import {
  +   CreateMoodSchema
  + } from '@app/schemas'
  + 
  + export const MoodsController = {
  +   create: async (req: AuthenticatedRequest, res: Response, next: NextFunction) => {
  +     try {
  +       const parsed = CreateMoodSchema.safeParse(req.body.mood);
  + 
  +       if (!parsed.success) {
  +         return res.status(400).json({
  +           errors: parsed.error!.issues
  +         });
  +       }
  + 
  +       const mood = await createMood(req.userId!, parsed.data);
  + 
  +       return res.status(201).json({ mood });
  +     } catch (err) {
  +       next(err);
  +     }
  +   },
  + 
  +   index: async (req: Request, res: Response, next: NextFunction) => {
  +     try {
  +       const moods = await getMoodsByUserId(Number(req.params.id));
  + 
  +       return res.status(200).json({
  +         moods
  +       })
  +     } catch (err) {
  +       next(err);
  +     }
  +   },
  + };

api/src/createApp.ts

@@ -5,6 +5,7 @@ import morgan from 'morgan';
    import mainRouter from '@app/routes/main';
    import userRouter from '@app/routes/users';
    import authRouter from '@app/routes/auth';
  + import moodRouter from '@app/routes/moods';
    import { errorHandler } from '@app/middleware/errorHandler';
    import { PrismaClient } from '@prisma/client';
    import { bootWorkers, closeAllWorkers, closeAllQueues } from '@app/lib/queue';

@@ -29,6 +30,7 @@
      app.get('/', mainRouter);
      app.use("/users", userRouter);
      app.use("/auth", authRouter);
  +   app.use("/moods", moodRouter);
    
      app.use(errorHandler); // always last
    

api/src/routes/moods.ts

@@ -0,0 +1,10 @@
  + import { Router } from "express";
  + import { MoodsController } from '@app/controllers/moods'
  + import { requireAuth } from '@app/middleware/auth';
  + 
  + const router = Router();
  + 
  + router.get('/', MoodsController.index);
  + router.post('/', requireAuth, MoodsController.create);
  + 
  + export default router;

api/src/schemas/index.ts

@@ -0,0 +1,8 @@
  + export {
  +   CreateMoodSchema,
  +   MoodComponentSchema
  + } from '@app/schemas/mood.schema';
  + 
  + export type {
  +   CreateMoodInput
  + } from '@app/schemas/mood.schema';

api/src/schemas/mood.schema.ts

@@ -0,0 +1,23 @@
  + import { z } from 'zod';
  + import {
  +   BaseMoodOption,
  +   MoodComponentOption,
  +   IntensityLevel
  + } from '@prisma/client';
  + 
  + export const MoodComponentSchema = z.object({
  +   component: z.nativeEnum(MoodComponentOption),
  +   intensity: z.nativeEnum(IntensityLevel)
  + });
  + 
  + export const CreateMoodSchema = z.object({
  +   annotation: z.string().optional(),
  +   moment: z.coerce.date(),
  +   selectedMood: z.nativeEnum(BaseMoodOption),
  +   anxietyLevel: z.number().int().min(0).max(10),
  +   stressLevel: z.number().int().min(0).max(10),
  +   energyLevel: z.number().int().min(0).max(10),
  +   moodComponents: z.array(MoodComponentSchema).min(1)
  + });
  + 
  + export type CreateMoodInput = z.infer<typeof CreateMoodSchema>;

api/src/services/mood.service.ts

@@ -0,0 +1,27 @@
  + import { prisma } from '@app/lib/prisma';
  + import { Mood } from '@prisma/client';
  + 
  + import { CreateMoodInput } from '@app/schemas';
  + 
  + export const createMood = async (userId: number, input: CreateMoodInput): Promise<Mood> => {
  +   const { moodComponents, ...moodData } = input;
  + 
  +   return prisma.mood.create({
  +     data: {
  +       ...moodData,
  +       userId,
  +       moodComponents: {
  +         create: moodComponents
  +       }
  +     },
  +     include: { moodComponents: true }
  +   });
  + };
  + 
  + export const getMoodsByUserId = async (userId: number): Promise<Mood[]> => {
  +   return prisma.mood.findMany({
  +     where: { userId },
  +     include: { moodComponents: true },
  +     orderBy: { moment: 'desc' }
  +   });
  + };