feat: added new endpoints to save workout exercise and exercise enum

Author: gare-dev

package.json

@@ -9,7 +9,8 @@
     "server"
   ],
   "scripts": {
-    "dev:server": "npm --workspace server run dev"
+    "dev:server": "npm --workspace server run dev",
+    "dev:server:prisma-studio": "npm --workspace server run prisma-studio"
   },
   "keywords": [],
   "author": "",

server/package.json

@@ -4,7 +4,8 @@
   "description": "",
   "main": "index.js",
   "scripts": {
-    "dev": "ts-node-dev --respawn --transpile-only --env-file .env src/index.ts"
+    "dev": "ts-node-dev --respawn --transpile-only --env-file .env src/index.ts",
+    "prisma-studio": "npx prisma studio"
   },
   "keywords": [],
   "author": "",
@@ -32,4 +33,4 @@
     "ts-node-dev": "^2.0.0",
     "typescript": "^5.8.3"
   }
-}
+}

server/src/db/models/ExerciseEnumModel.ts

@@ -0,0 +1,12 @@
+import z from "zod"
+
+export const fullExerciseEnumSchema = z.object({
+    idExercise: z.number().int().optional(),
+    idUser: z.number().int("MISSING_IDUSER"),
+    exerciseName: z.string("MISSING_EXERCISENAME"),
+    muscle: z.string("MISSING_MUSCLE"),
+    description: z.string("MISSING_DESCRIPTION"),
+})
+
+export type ExerciseEnumDTO = z.infer<typeof fullExerciseEnumSchema>
+export type CreateExerciseEnumDTO = Omit<ExerciseEnumDTO, "idExercise">

server/src/db/models/WorkoutExerciseModel.ts

@@ -0,0 +1,10 @@
+import z from "zod"
+
+export const fullWorkoutExerciseSchema = z.object({
+    idWorkoutExercise: z.number().int().optional(),
+    idWorkout: z.number().int("MISSING_IDWORKOUT"),
+    idExercise: z.number().int("MISSING_IDEXERCISE")
+})
+
+export type WorkoutExerciseDTO = z.infer<typeof fullWorkoutExerciseSchema>
+export type CreateWorkoutExerciseDTO = Omit<WorkoutExerciseDTO, "idWorkoutExercise">

server/src/http/server.ts

@@ -3,17 +3,27 @@ import cors from "cors"
 import { errorHandler } from '../middleware/errorHandler'
 import UserRoutes from '../routes/UserRoutes'
 import WorkoutRoutes from "../routes/WorkoutRoutes"
+import ExerciseEnumRoutes from "../routes/ExerciseEnumRoutes"
+import WorkoutExerciseRoutes from "../routes/WorkoutExerciseRoutes"
 import cookieParser from "cookie-parser"
+import { unauthenticatedMiddleware } from '../middleware/unauthenticated'
+import { Redis } from '../../utils/redis'
+import { JWTClass } from '../../utils/jwt'
 
 
 const app = express()
+const redis = new Redis()
+const jwt = new JWTClass(process.env.JWT_TOKEN!)
 
 app.use(cors())
 app.use(express.json())
 app.use(cookieParser())
 
 app.use(UserRoutes)
-app.use(WorkoutRoutes)
+app.use(unauthenticatedMiddleware(jwt, redis), WorkoutRoutes)
+app.use(unauthenticatedMiddleware(jwt, redis), ExerciseEnumRoutes)
+app.use(unauthenticatedMiddleware(jwt, redis), WorkoutExerciseRoutes)
+
 
 app.use(errorHandler)
 

server/src/middleware/errorHandler.ts

@@ -1,5 +1,6 @@
 import { Request, Response, NextFunction } from "express";
 import { HttpError } from "../errors/HttpError";
+import { PrismaClientKnownRequestError } from "../generated/prisma/runtime/library";
 
 
 export function errorHandler(err: unknown, req: Request, res: Response, next: NextFunction) {
@@ -9,7 +10,13 @@ export function errorHandler(err: unknown, req: Request, res: Response, next: Ne
             code: err.errorCode
         })
     }
+    if (err instanceof PrismaClientKnownRequestError) {
+        return res.status(500).json({
+            error: "Error while trying to create resource!",
+            code: "P_ERROR"
+        })
+    }
 
-    console.error("Unexpected error. " + err)
+    console.log("Unexpected error. " + err)
     return res.status(500).json({ error: "Server error.", code: (err as string).toString() })
 }

server/src/middleware/unauthenticated.ts

@@ -0,0 +1,24 @@
+import { NextFunction, Request, Response } from "express";
+import { CustomError } from "../errors/HttpError";
+import { JWTClass } from "../../utils/jwt";
+import { Redis } from "../../utils/redis";
+
+
+export function unauthenticatedMiddleware(jwt: JWTClass, redis: Redis) {
+    return async (req: Request, res: Response, next: NextFunction) => {
+        try {
+            const token = req.cookies.token
+            if (!token) return next(new CustomError("Unauthenticated.", 401, "UNAUTHENTICATED"))
+
+            const decoded = jwt.verifyJWT(token)
+            if (!decoded?.email) return next(new CustomError("Unauthenticated.", 401, "UNAUTHENTICATED"))
+
+            const user = await redis.getRedis(decoded.email)
+            if (!user) return next(new CustomError("Unauthenticated.", 401, "UNAUTHENTICATED"))
+
+            next()
+        } catch (err) {
+            next(err)
+        }
+    }
+}

server/src/repositories/ExerciseEnumRepository.ts

@@ -0,0 +1,19 @@
+import prisma from "../db/connect";
+import { CreateExerciseEnumDTO, ExerciseEnumDTO } from "../db/models/ExerciseEnumModel";
+
+
+export class ExerciseEnumRepository {
+    async create(exercise: CreateExerciseEnumDTO): Promise<ExerciseEnumDTO> {
+        return await prisma.exercisesEnum.create({
+            data: exercise
+        })
+    }
+
+    async getExercisesEnum(idUser: number): Promise<ExerciseEnumDTO[]> {
+        return await prisma.exercisesEnum.findMany({
+            where: {
+                idUser: idUser
+            }
+        })
+    }
+}

server/src/repositories/WorkoutExerciseRepository.ts

@@ -0,0 +1,22 @@
+import prisma from "../db/connect";
+import { CreateWorkoutExerciseDTO, WorkoutExerciseDTO } from "../db/models/WorkoutExerciseModel";
+
+
+export class WorkoutExerciseRepository {
+    async create(workoutExercise: CreateWorkoutExerciseDTO): Promise<WorkoutExerciseDTO> {
+        return await prisma.workoutExercises.create({
+            data: workoutExercise,
+        })
+    }
+
+    async getUserWorkout(idUser: number, idWorkout: number): Promise<boolean> {
+        const workout = await prisma.workouts.findFirst({
+            where: {
+                idWorkout,
+                idUser
+            }
+        })
+
+        return !!workout
+    }
+}

server/src/routes/ExerciseEnumRoutes.ts

@@ -0,0 +1,35 @@
+import express, { Response, Request } from "express"
+import { ExerciseEnumService } from "../services/ExerciseEnumService"
+import { ExerciseEnumRepository } from "../repositories/ExerciseEnumRepository"
+import { JWTClass } from "../../utils/jwt"
+import { Redis } from "../../utils/redis"
+
+const router = express.Router()
+const service = new ExerciseEnumService(new ExerciseEnumRepository(), new JWTClass(process.env.JWT_TOKEN!), new Redis())
+
+router.post("/exercise/enum", async (req: Request, res: Response) => {
+    const { exerciseName, muscle, description } = req.body
+    const token = req.cookies.token
+
+    const newExerciseEnum = await service.createExerciseEnum({ exerciseName, muscle, description }, token)
+
+    return res.status(201).json({
+        message: "Exercise enum created successfully!",
+        code: "ENUM_CREATED",
+        data: newExerciseEnum
+    })
+})
+
+router.get("/exercise/enum", async (req: Request, res: Response) => {
+    const token = req.cookies.token
+
+    const exerciseEnum = await service.getExerciseEnum(token)
+
+    return res.status(201).json({
+        message: "Exercise enum found.",
+        code: "ENUM_SUCCESS",
+        data: exerciseEnum
+    })
+})
+
+export default router