seventh commit

Author: andersoncgiusti

README.md

@@ -30,14 +30,22 @@ src/
 │       └── Validation.ts
 └── useCases/
     └── user/
-        ├── createUser/
+        ├── create/
         │   ├── CreateUserController.ts
         │   ├── CreateUserUseCase.ts
         │   └── ICreateUserRepository.ts
-        └── getUser/
-            ├── GetUserController.ts
-            ├── GetUserUseCase.ts
-            └── IGetUserRepository.ts
+        ├── delete/
+        │   ├── DeleteUserController.ts
+        │   ├── DeleteUserUseCase.ts
+        │   └── IDeleteUserRepository.ts
+        ├── get/
+        │   ├── GetUserController.ts
+        │   ├── GetUserUseCase.ts
+        │   └── IGetUserRepository.ts       │
+        └── put/
+            ├── PutUserController.ts
+            ├── PutUserUseCase.ts
+            └── IPutUserRepository.ts
 └── index.ts
 
 ```

package-lock.json

@@ -35,6 +35,7 @@
     "nodemon": "^3.1.1",
     "prettier": "^3.2.5",
     "ts-node": "^10.9.2",
+    "tsconfig-paths": "^4.2.0",
     "typescript": "^5.4.5"
   },
   "volta": {

package.json

@@ -1,8 +1,72 @@
 import { Application, Request, Response } from 'express'
-import { UserService } from '../../services/UserService'
+import { UserService } from '@/services/UserService'
 import { UserPresenter } from '../presenters/UserPresenter'
 
 export default (app: Application, userService: UserService) => {
+  /**
+   * @swagger
+   * /api/users:
+   *   post:
+   *     summary: Cria um novo usuário
+   *     requestBody:
+   *       required: true
+   *       content:
+   *         application/json:
+   *           schema:
+   *             type: object
+   *             properties:
+   *               name:
+   *                 type: string
+   *     responses:
+   *       '201':
+   *         description: Mensagem de sucesso
+   */
+  app.post('/api/users', async (req: Request, res: Response) => {
+    try {
+      const user = await userService.createUser(req.body)
+      res.status(201).json(UserPresenter.toResponse(user))
+    } catch (error) {
+      res.status(500).json({ error: 'Internal Server Error' })
+    }
+  })
+
+  /**
+   * @swagger
+   * /api/users:
+   *   get:
+   *     summary: Busca todos os usuários cadastrados
+   *     responses:
+   *       '200':
+   *         description: Mensagem de sucesso
+   */
+  app.get('/api/users', async (req: Request, res: Response) => {
+    try {
+      const users = await userService.getUsers()
+      if (!users || users.length === 0) {
+        return res.status(404).json({ error: 'No users found' })
+      }
+      res.json(UserPresenter.toResponseArray(users))
+    } catch (error) {
+      res.status(500).json({ error: 'Internal Server Error' })
+    }
+  })
+
+  /**
+   * @swagger
+   * /api/users/{id}:
+   *   get:
+   *     summary: Verifica se existe usuário com o ID informado
+   *     parameters:
+   *       - in: path
+   *         name: id
+   *         required: true
+   *         description: ID do usuário a ser consultado
+   *         schema:
+   *           type: string
+   *     responses:
+   *       '200':
+   *         description: Mensagem de sucesso
+   */
   app.get('/api/users/:id', async (req: Request, res: Response) => {
     const { id } = req.params
     try {
@@ -16,22 +80,68 @@ export default (app: Application, userService: UserService) => {
     }
   })
 
-  app.get('/api/users', async (req: Request, res: Response) => {
+  /**
+   * @swagger
+   * /api/users/{id}:
+   *   put:
+   *     summary: Atualiza informações do usuário com o ID informado
+   *     parameters:
+   *       - in: path
+   *         name: id
+   *         required: true
+   *         description: ID do usuário a ser atualizado
+   *         schema:
+   *           type: string
+   *     requestBody:
+   *       required: true
+   *       content:
+   *         application/json:
+   *           schema:
+   *             type: object
+   *             properties:
+   *               name:
+   *                 type: string
+   *     responses:
+   *       '200':
+   *         description: Mensagem de sucesso
+   */
+  app.put('/api/users/:id', async (req: Request, res: Response) => {
+    const { id } = req.params
     try {
-      const users = await userService.getUsers()
-      if (!users || users.length === 0) {
-        return res.status(404).json({ error: 'No users found' })
+      const user = await userService.putUserById(id, req.body)
+      if (!user) {
+        return res.status(404).json({ error: 'User not found' })
       }
-      res.json(UserPresenter.toResponseArray(users))
+      res.json(UserPresenter.toResponse(req.body))
     } catch (error) {
       res.status(500).json({ error: 'Internal Server Error' })
     }
   })
 
-  app.post('/api/users', async (req: Request, res: Response) => {
+  /**
+   * @swagger
+   * /api/users/{id}:
+   *   delete:
+   *     summary: Deleta usuário com o ID informado
+   *     parameters:
+   *       - in: path
+   *         name: id
+   *         required: true
+   *         description: ID do usuário a ser deletado
+   *         schema:
+   *           type: string
+   *     responses:
+   *       '200':
+   *         description: Mensagem de sucesso
+   */
+  app.delete('/api/users/:id', async (req: Request, res: Response) => {
+    const { id } = req.params
     try {
-      const user = await userService.createUser(req.body)
-      res.status(201).json(UserPresenter.toResponse(user))
+      const user = await userService.deleteUserById(id)
+      if (!user) {
+        return res.status(404).json({ error: 'User not found' })
+      }
+      res.json(UserPresenter.toResponse(user))
     } catch (error) {
       res.status(500).json({ error: 'Internal Server Error' })
     }

src/adapters/controllers/UserController.ts

@@ -1,4 +1,4 @@
-import { User } from '../../entities/User'
+import { User } from '@/entities/User'
 
 export class UserPresenter {
   static toResponse(user: User): User {

src/adapters/presenters/UserPresenter.ts

@@ -1,12 +1,19 @@
 import User, { IUser } from '../../frameworks/typeorm/entities/UserEntity'
 
 export interface IUserRepository {
+  createUser(userData: Partial<IUser>): Promise<IUser>
   getUsers(): Promise<IUser[]>
   getUserById(userId: string): Promise<IUser | null>
-  createUser(userData: Partial<IUser>): Promise<IUser>
+  putUserById(userId: string, userData: Partial<IUser>): Promise<IUser | null>
+  deleteUserById(userId: string): Promise<IUser | null>
 }
 
 export class UserRepository implements IUserRepository {
+  async createUser(userData: Partial<IUser>): Promise<IUser> {
+    const user = new User(userData)
+    return user.save()
+  }
+
   async getUsers(): Promise<IUser[]> {
     return User.find().exec()
   }
@@ -15,8 +22,14 @@ export class UserRepository implements IUserRepository {
     return User.findById(userId).exec()
   }
 
-  async createUser(userData: Partial<IUser>): Promise<IUser> {
-    const user = new User(userData)
-    return user.save()
+  async putUserById(
+    userId: string,
+    userData: Partial<IUser>
+  ): Promise<IUser | null> {
+    return User.findByIdAndUpdate(userId, userData).exec()
+  }
+
+  async deleteUserById(userId: string): Promise<IUser | null> {
+    return User.findByIdAndDelete(userId).exec()
   }
 }

src/adapters/repositories/UserRepository.ts

@@ -1,22 +1,37 @@
-import { User } from '../entities/User'
-import { GetUserUseCase } from '../useCases/User/get/GetUserUseCase'
-import { CreateUserUseCase } from '../useCases/User/create/CreateUserUseCase'
-import { UserRepository } from '../adapters/repositories/UserRepository'
+import { User } from '@/entities/User'
+import { CreateUserUseCase } from '@/useCases/User/create/CreateUserUseCase'
+import { GetUserUseCase } from '@/useCases/User/get/GetUserUseCase'
+import { PutUserUseCase } from '@/useCases/User/put/PutUserUseCase'
+import { DeleteUserUseCase } from '@/useCases/User/delete/DeleteUserUseCase'
+import { UserRepository } from '@/adapters/repositories/UserRepository'
 
 export class UserService {
   constructor(private readonly userRepository: UserRepository) {}
 
-  async getUserById(userId: string): Promise<User | null> {
-    const getUserUseCase = new GetUserUseCase(this.userRepository)
-    return getUserUseCase.execute(userId)
+  async createUser(userData: Partial<User>): Promise<User> {
+    const createUserUseCase = new CreateUserUseCase(this.userRepository)
+    return createUserUseCase.execute(userData)
   }
 
   async getUsers(): Promise<User[]> {
     return this.userRepository.getUsers()
   }
 
-  async createUser(userData: Partial<User>): Promise<User> {
-    const createUserUseCase = new CreateUserUseCase(this.userRepository)
-    return createUserUseCase.execute(userData)
+  async getUserById(userId: string): Promise<User | null> {
+    const getUserUseCaseId = new GetUserUseCase(this.userRepository)
+    return getUserUseCaseId.execute(userId)
+  }
+
+  async putUserById(
+    userId: string,
+    userData: Partial<User>
+  ): Promise<User | null> {
+    const putUserUseCase = new PutUserUseCase(this.userRepository)
+    return putUserUseCase.execute(userId, userData)
+  }
+
+  async deleteUserById(userId: string): Promise<User | null> {
+    const deleteUserUseCase = new DeleteUserUseCase(this.userRepository)
+    return deleteUserUseCase.execute(userId)
   }
 }

src/services/UserService.ts

@@ -9,7 +9,10 @@ const options = {
       description: 'Documentation for the Clean Architecture API'
     }
   },
-  apis: ['./src/frameworks/express/server.ts']
+  apis: [
+    './src/frameworks/express/server.ts', 
+    './src/adapters/controllers/*.ts'
+  ],
 }
 
 const specs = swaggerJsdoc(options)