Merge pull request #13 from DevAnseSenior/feat-gyms

Feat gyms

Author: DevAnseSenior

src/app.ts

@@ -2,15 +2,19 @@ import fastifyJwt from '@fastify/jwt'
 import fastify from 'fastify'
 import { ZodError } from 'zod'
 import { env } from './env'
-import { appRoutes } from './http/routes'
+import { checkInsRoutes } from './http/controllers/check-ins/routes'
+import { gymsRoutes } from './http/controllers/gyms/routes'
+import { usersRoutes } from './http/controllers/users/routes'
 
 export const app = fastify()
 
 app.register(fastifyJwt, {
   secret: env.JWT_SECRET,
 })
 
-app.register(appRoutes)
+app.register(usersRoutes)
+app.register(gymsRoutes)
+app.register(checkInsRoutes)
 
 app.setErrorHandler((error, _, reply) => {
   if (error instanceof ZodError) {

src/http/controllers/check-ins/create.spec.ts

@@ -0,0 +1,37 @@
+import { app } from '@/app'
+import { prisma } from '@/lib/prisma'
+import { createAndAuthenticateUser } from '@/utils/test/create-and-authenticate-user'
+import request from 'supertest'
+import { afterAll, beforeAll, describe, expect, it } from 'vitest'
+
+describe('Create Check-In (e2e)', () => {
+  beforeAll(async () => {
+    await app.ready()
+  })
+
+  afterAll(async () => {
+    await app.close()
+  })
+
+  it('should be able to create a check-in', async () => {
+    const { token } = await createAndAuthenticateUser(app)
+
+    const gym = await prisma.gym.create({
+      data: {
+        title: 'JS Gym',
+        latitude: -3.07446,
+        longitude: -59.9450322,
+      },
+    })
+
+    const response = await request(app.server)
+      .post(`/gyms/${gym.id}/check-ins`)
+      .set('Authorization', `Bearer ${token}`)
+      .send({
+        latitude: -3.07446,
+        longitude: -59.9450322,
+      })
+
+    expect(response.statusCode).toEqual(201)
+  })
+})

src/http/controllers/check-ins/create.ts

@@ -0,0 +1,32 @@
+import { makeGCheckInUseCase } from '@/use-cases/factories/make-check-in-use-case'
+import { FastifyReply, FastifyRequest } from 'fastify'
+import { z } from 'zod'
+
+export async function create(request: FastifyRequest, reply: FastifyReply) {
+  const createCheckInParamsSchema = z.object({
+    gymId: z.string().uuid(),
+  })
+
+  const createCheckInBodySchema = z.object({
+    latitude: z.number().refine((value) => {
+      return Math.abs(value) <= 90
+    }),
+    longitude: z.number().refine((value) => {
+      return Math.abs(value) <= 180
+    }),
+  })
+
+  const { gymId } = createCheckInParamsSchema.parse(request.params)
+  const { latitude, longitude } = createCheckInBodySchema.parse(request.body)
+
+  const createGymUseCase = makeGCheckInUseCase()
+
+  await createGymUseCase.execute({
+    gymId,
+    userId: request.user.sub,
+    userLatitude: latitude,
+    userLongitude: longitude,
+  })
+
+  return reply.status(201).send()
+}

src/http/controllers/check-ins/history.spec.ts

@@ -0,0 +1,59 @@
+import { app } from '@/app'
+import { prisma } from '@/lib/prisma'
+import { createAndAuthenticateUser } from '@/utils/test/create-and-authenticate-user'
+import request from 'supertest'
+import { afterAll, beforeAll, describe, expect, it } from 'vitest'
+
+describe('Check-In History (e2e)', () => {
+  beforeAll(async () => {
+    await app.ready()
+  })
+
+  afterAll(async () => {
+    await app.close()
+  })
+
+  it('should be able to list the history of a check-ins', async () => {
+    const { token } = await createAndAuthenticateUser(app)
+
+    const user = await prisma.user.findFirstOrThrow()
+
+    const gym = await prisma.gym.create({
+      data: {
+        title: 'JS Gym',
+        latitude: -3.07446,
+        longitude: -59.9450322,
+      },
+    })
+
+    await prisma.checkIn.createMany({
+      data: [
+        {
+          gym_id: gym.id,
+          user_id: user.id,
+        },
+        {
+          gym_id: gym.id,
+          user_id: user.id,
+        },
+      ],
+    })
+
+    const response = await request(app.server)
+      .get('/check-ins/history')
+      .set('Authorization', `Bearer ${token}`)
+      .send()
+
+    expect(response.statusCode).toEqual(200)
+    expect(response.body.checkIns).toEqual([
+      expect.objectContaining({
+        gym_id: gym.id,
+        user_id: user.id,
+      }),
+      expect.objectContaining({
+        gym_id: gym.id,
+        user_id: user.id,
+      }),
+    ])
+  })
+})

src/http/controllers/check-ins/history.ts

@@ -0,0 +1,22 @@
+import { makeFetchUserCheckInsHistoryUseCase } from '@/use-cases/factories/make-fetch-user-check-ins-history-use-case'
+import { FastifyReply, FastifyRequest } from 'fastify'
+import { z } from 'zod'
+
+export async function history(request: FastifyRequest, reply: FastifyReply) {
+  const checkInHistoryQuerySchema = z.object({
+    page: z.coerce.number().min(1).default(1),
+  })
+
+  const { page } = checkInHistoryQuerySchema.parse(request.query)
+
+  const fetchUserCheckInsUseCase = makeFetchUserCheckInsHistoryUseCase()
+
+  const { checkIns } = await fetchUserCheckInsUseCase.execute({
+    userId: request.user.sub,
+    page,
+  })
+
+  return reply.status(200).send({
+    checkIns,
+  })
+}

src/http/controllers/check-ins/metrics.spec.ts

@@ -0,0 +1,50 @@
+import { app } from '@/app'
+import { prisma } from '@/lib/prisma'
+import { createAndAuthenticateUser } from '@/utils/test/create-and-authenticate-user'
+import request from 'supertest'
+import { afterAll, beforeAll, describe, expect, it } from 'vitest'
+
+describe('Check-In Metrics (e2e)', () => {
+  beforeAll(async () => {
+    await app.ready()
+  })
+
+  afterAll(async () => {
+    await app.close()
+  })
+
+  it('should be able to get the count of check-ins', async () => {
+    const { token } = await createAndAuthenticateUser(app)
+
+    const user = await prisma.user.findFirstOrThrow()
+
+    const gym = await prisma.gym.create({
+      data: {
+        title: 'JS Gym',
+        latitude: -3.07446,
+        longitude: -59.9450322,
+      },
+    })
+
+    await prisma.checkIn.createMany({
+      data: [
+        {
+          gym_id: gym.id,
+          user_id: user.id,
+        },
+        {
+          gym_id: gym.id,
+          user_id: user.id,
+        },
+      ],
+    })
+
+    const response = await request(app.server)
+      .get('/check-ins/metrics')
+      .set('Authorization', `Bearer ${token}`)
+      .send()
+
+    expect(response.statusCode).toEqual(200)
+    expect(response.body.checkInsCount).toEqual(2)
+  })
+})

src/http/controllers/check-ins/metrics.ts

@@ -0,0 +1,14 @@
+import { makeGetUserMetricsUseCase } from '@/use-cases/factories/make-get-user-metrics-use-case'
+import { FastifyReply, FastifyRequest } from 'fastify'
+
+export async function metrics(request: FastifyRequest, reply: FastifyReply) {
+  const getUserMetricsUseCase = makeGetUserMetricsUseCase()
+
+  const { checkInsCount } = await getUserMetricsUseCase.execute({
+    userId: request.user.sub,
+  })
+
+  return reply.status(200).send({
+    checkInsCount,
+  })
+}

src/http/controllers/check-ins/routes.ts

@@ -0,0 +1,17 @@
+import { verifyJwt } from '@/http/middlewares/verify-jwt'
+import { FastifyInstance } from 'fastify'
+
+import { create } from './create'
+import { history } from './history'
+import { metrics } from './metrics'
+import { validate } from './validate'
+
+export async function checkInsRoutes(app: FastifyInstance) {
+  app.addHook('onRequest', verifyJwt)
+
+  app.get('/check-ins/history', history)
+  app.get('/check-ins/metrics', metrics)
+
+  app.post('/gyms/:gymId/check-ins', create)
+  app.patch('/check-ins/:checkInId/validate', validate)
+}

src/http/controllers/check-ins/validate.spec.ts

@@ -0,0 +1,51 @@
+import { app } from '@/app'
+import { prisma } from '@/lib/prisma'
+import { createAndAuthenticateUser } from '@/utils/test/create-and-authenticate-user'
+import request from 'supertest'
+import { afterAll, beforeAll, describe, expect, it } from 'vitest'
+
+describe('Validate Check-In (e2e)', () => {
+  beforeAll(async () => {
+    await app.ready()
+  })
+
+  afterAll(async () => {
+    await app.close()
+  })
+
+  it('should be able to validate a check-in', async () => {
+    const { token } = await createAndAuthenticateUser(app)
+
+    const user = await prisma.user.findFirstOrThrow()
+
+    const gym = await prisma.gym.create({
+      data: {
+        title: 'JS Gym',
+        latitude: -3.07446,
+        longitude: -59.9450322,
+      },
+    })
+
+    let checkIn = await prisma.checkIn.create({
+      data: {
+        gym_id: gym.id,
+        user_id: user.id,
+      },
+    })
+
+    const response = await request(app.server)
+      .patch(`/check-ins/${checkIn.id}/validate`)
+      .set('Authorization', `Bearer ${token}`)
+      .send()
+
+    expect(response.statusCode).toEqual(204)
+
+    checkIn = await prisma.checkIn.findUniqueOrThrow({
+      where: {
+        id: checkIn.id,
+      },
+    })
+
+    expect(checkIn.validated_at).toEqual(expect.any(Date))
+  })
+})

src/http/controllers/check-ins/validate.ts

@@ -0,0 +1,19 @@
+import { makeValidateCheckInUseCase } from '@/use-cases/factories/make-validate-check-in-use-case'
+import { FastifyReply, FastifyRequest } from 'fastify'
+import { z } from 'zod'
+
+export async function validate(request: FastifyRequest, reply: FastifyReply) {
+  const validateCheckInParamsSchema = z.object({
+    checkInId: z.string().uuid(),
+  })
+
+  const { checkInId } = validateCheckInParamsSchema.parse(request.params)
+
+  const validateCheckInUseCase = makeValidateCheckInUseCase()
+
+  await validateCheckInUseCase.execute({
+    checkInId,
+  })
+
+  return reply.status(204).send()
+}