sixth commit

Author: andersoncgiusti

src/adapters/controllers/UserController.ts

@@ -6,7 +6,7 @@ export default (app: Application, userService: UserService) => {
   app.get('/api/users/:id', async (req: Request, res: Response) => {
     const { id } = req.params
     try {
-      const user = await userService.getUserById(Number(id))
+      const user = await userService.getUserById(id)
       if (!user) {
         return res.status(404).json({ error: 'User not found' })
       }
@@ -27,4 +27,13 @@ export default (app: Application, userService: UserService) => {
       res.status(500).json({ error: 'Internal Server Error' })
     }
   })
+
+  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' })
+    }
+  })
 }

src/adapters/repositories/UserRepository.ts

@@ -1,20 +1,22 @@
-import { User } from '../../entities/User'
-
-const users: User[] = [
-  { id: 1, name: 'John Doe' },
-  { id: 2, name: 'Jane Smith' }
-]
+import User, { IUser } from '../../frameworks/typeorm/entities/UserEntity'
 
 export interface IUserRepository {
-  getUsers(): User[]
+  getUsers(): Promise<IUser[]>
+  getUserById(userId: string): Promise<IUser | null>
+  createUser(userData: Partial<IUser>): Promise<IUser>
 }
 
 export class UserRepository implements IUserRepository {
-  getUsers(): User[] {
-    return users
+  async getUsers(): Promise<IUser[]> {
+    return User.find().exec()
+  }
+
+  async getUserById(userId: string): Promise<IUser | null> {
+    return User.findById(userId).exec()
   }
 
-  getUserById(userId: number): User | null {
-    return users.find((user) => user.id === userId) || null
+  async createUser(userData: Partial<IUser>): Promise<IUser> {
+    const user = new User(userData)
+    return user.save()
   }
 }

src/entities/User.ts

@@ -1,4 +1,4 @@
 export interface User {
-  id: number
+  id?: string
   name: string
 }

src/frameworks/typeorm/entities/UserEntity.ts

@@ -0,0 +1,11 @@
+import mongoose, { Schema, Document } from 'mongoose'
+
+export interface IUser extends Document {
+  name: string
+}
+
+const UserSchema: Schema = new Schema({
+  name: { type: String, required: true }
+})
+
+export default mongoose.model<IUser>('User', UserSchema)

src/services/UserService.ts

@@ -1,16 +1,22 @@
 import { User } from '../entities/User'
 import { GetUserUseCase } from '../useCases/User/get/GetUserUseCase'
-import { IGetUserRepository } from '../useCases/User/get/IGetUserRepository'
+import { CreateUserUseCase } from '../useCases/User/create/CreateUserUseCase'
+import { UserRepository } from '../adapters/repositories/UserRepository'
 
 export class UserService {
-  constructor(private readonly getUserRepository: IGetUserRepository) {}
+  constructor(private readonly userRepository: UserRepository) {}
 
-  async getUserById(userId: number): Promise<User | null> {
-    const getUserUseCase = new GetUserUseCase(this.getUserRepository)
+  async getUserById(userId: string): Promise<User | null> {
+    const getUserUseCase = new GetUserUseCase(this.userRepository)
     return getUserUseCase.execute(userId)
   }
 
-  async getUsers(): Promise<User[] | null> {
-    return this.getUserRepository.getUsers()
+  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)
   }
 }

src/useCases/User/create/CreateUserController.ts

@@ -1,10 +1,16 @@
-import { User } from '../../../entities/User'
-import { IGetUserRepository } from './IGetUserRepository'
+import { Request, Response } from 'express'
+import { UserService } from '../../../services/UserService'
+import { UserPresenter } from '../../../adapters/presenters/UserPresenter'
 
-export class GetUserController {
-  constructor(private readonly userRepository: IGetUserRepository) {}
+export class CreateUserController {
+  constructor(private readonly userService: UserService) {}
 
-  async execute(): Promise<User[]> {
-    return this.userRepository.getUsers()
+  async handle(req: Request, res: Response): Promise<void> {
+    try {
+      const user = await this.userService.createUser(req.body)
+      res.status(201).json(UserPresenter.toResponse(user))
+    } catch (error) {
+      res.status(500).json({ error: 'Internal Server Error' })
+    }
   }
 }

src/useCases/User/create/CreateUserUseCase.ts

@@ -0,0 +1,10 @@
+import { IUser } from '../../../frameworks/typeorm/entities/UserEntity'
+import { UserRepository } from '../../../adapters/repositories/UserRepository'
+
+export class CreateUserUseCase {
+  constructor(private userRepository: UserRepository) {}
+
+  async execute(userData: Partial<IUser>): Promise<IUser> {
+    return this.userRepository.createUser(userData)
+  }
+}

src/useCases/User/create/ICreateUserRepository.ts

@@ -0,0 +1,5 @@
+import { IUser } from '../../../frameworks/typeorm/entities/UserEntity'
+
+export interface ICreateUserRepository {
+  createUser(userData: Partial<IUser>): Promise<IUser>
+}

src/useCases/User/get/GetUserController.ts

@@ -1,27 +1,20 @@
-import { Application, Request, Response } from 'express'
-import { UserRepository } from '../../../adapters/repositories/UserRepository'
+import { Request, Response } from 'express'
+import { UserService } from '../../../services/UserService'
 import { UserPresenter } from '../../../adapters/presenters/UserPresenter'
 
-export default (app: Application, userRepository: UserRepository) => {
-  app.get('/api/users/:id', async (req: Request, res: Response) => {
+export class GetUserController {
+  constructor(private readonly userService: UserService) {}
+
+  async handle(req: Request, res: Response): Promise<void> {
     const { id } = req.params
     try {
-      const user = await userRepository.getUserById(Number(id))
+      const user = await this.userService.getUserById(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' })
     }
-  })
-
-  app.get('/api/users', async (req: Request, res: Response) => {
-    try {
-      const users = userRepository.getUsers()
-      res.json(UserPresenter.toResponseArray(users))
-    } catch (error) {
-      res.status(500).json({ error: 'Internal Server Error' })
-    }
-  })
+  }
 }

src/useCases/User/get/GetUserUseCase.ts

@@ -1,10 +1,10 @@
-import { User } from '../../../entities/User'
-import { IGetUserRepository } from './IGetUserRepository'
+import { IUser } from '../../../frameworks/typeorm/entities/UserEntity'
+import { UserRepository } from '../../../adapters/repositories/UserRepository'
 
 export class GetUserUseCase {
-  constructor(private readonly userRepository: IGetUserRepository) {}
+  constructor(private readonly userRepository: UserRepository) {}
 
-  async execute(userId: number): Promise<User | null> {
+  async execute(userId: string): Promise<IUser | null> {
     return this.userRepository.getUserById(userId)
   }
 }