feat(equipments): ⚡ added route endpoint to get exercises by specific…

… equipment

src/modules/bodyparts/controllers/bodyPart.controller.ts

@@ -134,7 +134,7 @@ export class BodyPartController implements Routes {
         method: 'get',
         path: '/bodyparts/{bodyPartName}/exercises',
         tags: ['BodyParts'],
-        summary: 'Retrive all exercises by bodyPart',
+        summary: 'Retrive exercises by bodyPart',
         description: 'Retrive list of all bodyparts.',
         operationId: 'getExercisesByBodyPart',
         request: {

src/modules/equipments/controllers/equipment.controller.ts

@@ -5,13 +5,15 @@ import { EquipmentModel } from '../models/equipment.model'
 import { EquipmentService } from '../services'
 import Equipment from '#infra/mongodb/models/equipments/equipment.schema.js'
 import { HTTPException } from 'hono/http-exception'
+import { ExerciseModel } from '#modules/exercises/models/exercise.model.js'
+import Exercise from '#infra/mongodb/models/exercises/exercise.schema.js'
 
 export class EquipmentController implements Routes {
   public controller: OpenAPIHono
   private readonly equipmentService: EquipmentService
   constructor() {
     this.controller = new OpenAPIHono()
-    this.equipmentService = new EquipmentService(Equipment)
+    this.equipmentService = new EquipmentService(Equipment, Exercise)
   }
 
   public initRoutes() {
@@ -127,5 +129,87 @@ export class EquipmentController implements Routes {
         return ctx.json({ success: true, data: response })
       }
     )
+    this.controller.openapi(
+      createRoute({
+        method: 'get',
+        path: '/equipments/{equipmentName}/exercises',
+        tags: ['Equipments'],
+        summary: 'Retrive exercises by equipments',
+        description: 'Retrive list of all equipments.',
+        operationId: 'getExercisesByEquipment',
+        request: {
+          params: z.object({
+            equipmentName: z.string().openapi({
+              description: 'equipments name',
+              type: 'string',
+              example: 'body weight',
+              default: 'body weight'
+            })
+          }),
+          query: z.object({
+            offset: z.coerce.number().nonnegative().optional().openapi({
+              title: 'Offset',
+              description:
+                'The number of exercises to skip from the start of the list. Useful for pagination to fetch subsequent pages of results.',
+              type: 'number',
+              example: 10,
+              default: 0
+            }),
+            limit: z.coerce.number().positive().max(100).optional().openapi({
+              title: 'Limit',
+              description:
+                'The maximum number of exercises to return in the response. Limits the number of results for pagination purposes.',
+              maximum: 100,
+              minimum: 1,
+              type: 'number',
+              example: 10,
+              default: 10
+            })
+          })
+        },
+        responses: {
+          200: {
+            description: 'Successful response with list of all exercises.',
+            content: {
+              'application/json': {
+                schema: z.object({
+                  success: z.boolean().openapi({
+                    description: 'Indicates whether the request was successful',
+                    type: 'boolean',
+                    example: true
+                  }),
+                  data: z.array(ExerciseModel).openapi({
+                    description: 'Array of Exercises.'
+                  })
+                })
+              }
+            }
+          },
+          500: {
+            description: 'Internal server error'
+          }
+        }
+      }),
+      async (ctx) => {
+        const { offset, limit = 10 } = ctx.req.valid('query')
+        const search = ctx.req.param('equipmentName')
+        const { origin, pathname } = new URL(ctx.req.url)
+        const response = await this.equipmentService.getExercisesByEquipment({ offset, limit, search })
+        return ctx.json({
+          success: true,
+          data: {
+            previousPage:
+              response.currentPage > 1
+                ? `${origin}${pathname}?offset=${(response.currentPage - 1) * limit}&limit=${limit}`
+                : null,
+            nextPage:
+              response.currentPage < response.totalPages
+                ? `${origin}${pathname}?offset=${response.currentPage * limit}&limit=${limit}`
+                : null,
+            ...response
+          }
+        })
+      }
+    )
   }
 }

src/modules/equipments/services/equipment.service.ts

@@ -1,14 +1,25 @@
 import { IEquipmentModel } from '#infra/mongodb/models/equipments/equipment.entity.js'
+import { IExerciseModel } from '#infra/mongodb/models/exercises/exercise.entity.js'
+import { GetExerciseSerivceArgs } from '#modules/exercises/services/exercise.service.js'
+import {
+  GetExercisesArgs,
+  GetExercisesUseCase
+} from '#modules/exercises/use-cases/get-exercises/get-exercise.usecase.js'
 import { CreateEquipmentArgs, CreateEquipmentUseCase } from '../use-cases/create-equipment'
 import { GetEquipmentsUseCase } from '../use-cases/get-equipments'
 
 export class EquipmentService {
   private readonly createEquipmentUseCase: CreateEquipmentUseCase
   private readonly getEquipmentUseCase: GetEquipmentsUseCase
+  private readonly getExercisesUseCase: GetExercisesUseCase
 
-  constructor(private readonly equipmentModel: IEquipmentModel) {
+  constructor(
+    private readonly equipmentModel: IEquipmentModel,
+    private readonly exerciseModel: IExerciseModel
+  ) {
     this.createEquipmentUseCase = new CreateEquipmentUseCase(equipmentModel)
     this.getEquipmentUseCase = new GetEquipmentsUseCase(equipmentModel)
+    this.getExercisesUseCase = new GetExercisesUseCase(exerciseModel)
   }
 
   createEquipment = (args: CreateEquipmentArgs) => {
@@ -18,4 +29,17 @@ export class EquipmentService {
   getEquipments = () => {
     return this.getEquipmentUseCase.execute()
   }
+  getExercisesByEquipment = (params: GetExerciseSerivceArgs) => {
+    const query: GetExercisesArgs = {
+      offset: params.offset,
+      limit: params.limit,
+      query: {
+        equipments: {
+          $all: [params.search]
+        }
+      }
+    }
+
+    return this.getExercisesUseCase.execute(query)
+  }
 }