@anthonylzq/simba.js 3.1.0 → 4.2.0

package/lib/src/functions/api.js

@@ -121,23 +121,13 @@ export {}
         file: `${projectName}/src/@types/index.d.ts`
       }
     },
-    '@types/dto': {
-      user: {
-        content: `interface DtoUser {
-  id: string
-  lastName: string
-  name: string
-}
-`,
-        file: `${projectName}/src/@types/dto/user.d.ts`
-      }
-    },
     '@types/models': {
       user: {
-        content: `interface IUser {
+        content: `interface UserDBO {
   id: string
   name: string
   lastName: string
+  createdAt: Date
   updatedAt: Date
 }
 `,
@@ -166,7 +156,7 @@ export * from './queries'
       user: {
         content: `import { model, Schema } from 'mongoose'
 
-const User = new Schema<IUser>(
+const UserSchema = new Schema<UserDBO>(
   {
     lastName: {
       required: true,
@@ -178,24 +168,18 @@ const User = new Schema<IUser>(
     }
   },
   {
-    timestamps: {
-      createdAt: false,
-      updatedAt: true
-    },
+    timestamps: true,
     versionKey: false,
-    toJSON: {
-      transform(_, ret) {
+    toObject: {
+      transform: (_, ret) => {
         ret.id = ret._id.toString()
-        ret.updatedAt = ret.updatedAt.toISOString()
         delete ret._id
-        delete ret.__v
-      },
-      virtuals: true
+      }
     }
   }
 )
 
-const UserModel = model<IUser>('users', User)
+const UserModel = model<UserDBO>('users', UserSchema)
 
 export { UserModel }
 `,
@@ -208,42 +192,63 @@ export { UserModel }
         file: `${projectName}/src/database/mongo/queries/index.ts`
       },
       user: {
-        content: `import { UserModel } from '..'
+        content: `import { Document, Types } from 'mongoose'
+
+import { UserModel } from '..'
+import { UserDTO } from 'schemas'
+
+const userDBOtoDTO = (
+  userDBO: Document<unknown, unknown, UserDBO> &
+    UserDBO & {
+      _id: Types.ObjectId
+    }
+): UserDTO => ({
+  ...userDBO.toObject(),
+  createdAt: userDBO.createdAt.toISOString(),
+  updatedAt: userDBO.updatedAt.toISOString()
+})
 
-const store = async (userData: DtoUser): Promise<IUser> => {
+const store = async (userData: UserDTO): Promise<UserDTO> => {
   const user = new UserModel(userData)
+
   await user.save()
 
-  return user.toJSON()
+  return userDBOtoDTO(user)
 }
 
 const remove = async (
   id: string | null = null
-): Promise<IUser | number | null> => {
-  if (id) return await UserModel.findByIdAndRemove(id)
+): Promise<UserDTO | number | null> => {
+  if (id) {
+    const removedUser = await UserModel.findByIdAndRemove(id)
+
+    if (!removedUser) return null
+
+    return userDBOtoDTO(removedUser)
+  }
 
   return (await UserModel.deleteMany({})).deletedCount
 }
 
 const get = async (
   id: string | null = null
-): Promise<IUser[] | IUser | null> => {
+): Promise<UserDTO[] | UserDTO | null> => {
   if (id) {
     const user = await UserModel.findById(id)
 
-    return user ? user.toJSON() : null
+    return user ? userDBOtoDTO(user) : null
   }
 
   const users = await UserModel.find({})
 
-  return users.map(u => u.toJSON())
+  return users.map(u => userDBOtoDTO(u))
 }
 
-const update = async (userData: DtoUser): Promise<IUser | null> => {
+const update = async (userData: UserDTO): Promise<UserDTO | null> => {
   const { id, ...rest } = userData
   const user = await UserModel.findByIdAndUpdate(id, rest, { new: true })
 
-  return user ? user.toJSON() : null
+  return user ? userDBOtoDTO(user) : null
 }
 
 export { store, remove, get, update }
@@ -259,6 +264,58 @@ export * from './server'
         file: `${projectName}/src/network/index.ts`
       }
     },
+    schemas: {
+      index: {
+        content: `import { Static, Type } from '@sinclair/typebox'
+
+const id = Type.String({
+  pattern: '^[a-zA-Z0-9]{24,}$'
+})
+
+type Id = Static<typeof id>
+
+const idSchema = Type.Object({ id })
+
+type IdSchema = Static<typeof idSchema>
+
+export { id, Id, idSchema, IdSchema }
+export * from './user'
+`,
+        file: `${projectName}/src/schemas/index.ts`
+      },
+      user: {
+        content: `import { Static, Type } from '@sinclair/typebox'
+
+import { id } from '.'
+
+const user = Type.Object({
+  lastName: Type.String(),
+  name: Type.String()
+})
+
+type User = Static<typeof user>
+
+const userDto = Type.Object({
+  id: Type.Optional(id),
+  lastName: Type.String(),
+  name: Type.String(),
+  createdAt: Type.Optional(Type.String()),
+  updatedAt: Type.Optional(Type.String())
+})
+
+type UserDTO = Static<typeof userDto>
+
+const storeUserSchema = Type.Object({
+  args: user
+})
+
+type StoreUser = Static<typeof storeUserSchema>
+
+export { userDto, UserDTO, user, User, storeUserSchema, StoreUser }
+`,
+        file: `${projectName}/src/schemas/user.ts`
+      }
+    },
     services: {
       index: {
         content: "export * from './user'\n",
@@ -268,41 +325,53 @@ export * from './server'
         content: `import httpErrors from 'http-errors'
 
 import { store, remove, get, update } from 'database'
+import { UserDTO } from 'schemas'
 import { EFU, MFU, GE, errorHandling } from './utils'
 
 type Process = {
   type: 'store' | 'getAll' | 'deleteAll' | 'getOne' | 'update' | 'delete'
 }
 
+type Arguments = {
+  id?: string
+  userDto?: UserDTO
+  userDtoWithoutId?: Omit<UserDTO, 'id'>
+}
+
 class UserService {
-  private _args: Partial<DtoUser> | null
+  #args: Arguments
 
-  constructor(args: Partial<DtoUser> | null = null) {
-    this._args = args
+  constructor(args: Arguments = {}) {
+    this.#args = args
   }
 
-  public process({ type }: Process): Promise<string | IUser[] | IUser> {
+  public process({ type }: Process): Promise<string | UserDTO | UserDTO[]> {
     switch (type) {
       case 'store':
-        return this._store()
+        return this.#store()
       case 'getAll':
-        return this._getAll()
+        return this.#getAll()
       case 'deleteAll':
-        return this._deleteAll()
+        return this.#deleteAll()
       case 'getOne':
-        return this._getOne()
+        return this.#getOne()
       case 'update':
-        return this._update()
+        return this.#update()
       case 'delete':
-        return this._delete()
+        return this.#delete()
       default:
         throw new httpErrors.InternalServerError(GE.INTERNAL_SERVER_ERROR)
     }
   }
 
-  private async _store(): Promise<IUser> {
+  async #store(): Promise<UserDTO> {
     try {
-      const result = await store(this._args as DtoUser)
+      if (!this.#args.userDtoWithoutId)
+        throw new httpErrors.UnprocessableEntity(GE.INTERNAL_SERVER_ERROR)
+
+      const result = await store({
+        ...this.#args.userDtoWithoutId
+      })
 
       return result
     } catch (e) {
@@ -310,9 +379,9 @@ class UserService {
     }
   }
 
-  private async _getAll(): Promise<IUser[]> {
+  async #getAll(): Promise<UserDTO[]> {
     try {
-      const users = (await get()) as IUser[]
+      const users = (await get()) as UserDTO[]
 
       return users
     } catch (e) {
@@ -320,7 +389,7 @@ class UserService {
     }
   }
 
-  private async _deleteAll(): Promise<string> {
+  async #deleteAll(): Promise<string> {
     try {
       const usersDeleted = (await remove()) as number
 
@@ -335,11 +404,13 @@ class UserService {
     }
   }
 
-  private async _getOne(): Promise<IUser> {
-    const { id } = this._args as DtoUser
-
+  async #getOne(): Promise<UserDTO> {
     try {
-      const user = (await get(id as string)) as IUser | null
+      if (!this.#args.id)
+        throw new httpErrors.UnprocessableEntity(GE.INTERNAL_SERVER_ERROR)
+
+      const { id } = this.#args
+      const user = (await get(id)) as UserDTO | null
 
       if (!user) throw new httpErrors.NotFound(EFU.NOT_FOUND)
 
@@ -349,9 +420,12 @@ class UserService {
     }
   }
 
-  private async _update(): Promise<IUser> {
+  async #update(): Promise<UserDTO> {
     try {
-      const updatedUser = await update(this._args as DtoUser)
+      if (!this.#args.userDto || !this.#args.userDto.id)
+        throw new httpErrors.UnprocessableEntity(GE.INTERNAL_SERVER_ERROR)
+
+      const updatedUser = await update(this.#args.userDto)
 
       if (!updatedUser) throw new httpErrors.NotFound(EFU.NOT_FOUND)
 
@@ -361,10 +435,12 @@ class UserService {
     }
   }
 
-  private async _delete(): Promise<string> {
-    const { id } = this._args as DtoUser
-
+  async #delete(): Promise<string> {
     try {
+      if (!this.#args.id)
+        throw new httpErrors.UnprocessableEntity(GE.INTERNAL_SERVER_ERROR)
+
+      const { id } = this.#args
       const deletedUser = await remove(id)
 
       if (!deletedUser) throw new httpErrors.NotFound(EFU.NOT_FOUND)
@@ -484,6 +560,33 @@ Server.start()
   }
 
   const expressData = {
+    '@types/custom': {
+      request: {
+        content: `type ExpressRequest = import('express').Request
+
+interface CustomRequest extends ExpressRequest {
+  body: {
+    args?: import('schemas').UserDTO
+  }
+  // We can add custom headers via intersection, remember that for some reason
+  // headers must be in Snake-Pascal-Case
+  headers: import('http').IncomingHttpHeaders & {
+    'Custom-Header'?: string
+  }
+}
+`,
+        file: `${projectName}/src/@types/custom/request.d.ts`
+      },
+      response: {
+        content: `type ExpressResponse = import('express').Response
+
+interface CustomResponse extends ExpressResponse {
+  newValue?: string
+}
+`,
+        file: `${projectName}/src/@types/custom/response.d.ts`
+      }
+    },
     network: {
       response: {
         content: `interface ResponseProps {
@@ -547,26 +650,27 @@ export { applyRoutes }
         content: `import express from 'express'
 import mongoose from 'mongoose'
 import morgan from 'morgan'
+import cors from 'cors'
 
 import { applyRoutes } from './router'
 
 const PORT = (process.env.PORT as string) || '1996'
 
 class Server {
-  private _app: express.Application
-  private _connection: mongoose.Connection | undefined
+  #app: express.Application
+  #connection: mongoose.Connection | undefined
 
   constructor() {
-    this._app = express()
-    this._config()
+    this.#app = express()
+    this.#config()
   }
 
-  private _config() {
-    this._app.set('port', PORT)
-    this._app.use(morgan('dev'))
-    this._app.use(express.json())
-    this._app.use(express.urlencoded({ extended: false }))
-    this._app.use(
+  #config() {
+    this.#app.use(cors())
+    this.#app.use(morgan('dev'))
+    this.#app.use(express.json())
+    this.#app.use(express.urlencoded({ extended: false }))
+    this.#app.use(
       (
         req: express.Request,
         res: express.Response,
@@ -582,23 +686,23 @@ class Server {
       }
     )
 
-    applyRoutes(this._app)
+    applyRoutes(this.#app)
   }
 
-  private async _mongo(): Promise<void> {
-    this._connection = mongoose.connection
+  async #mongo(): Promise<void> {
+    this.#connection = mongoose.connection
     const connection = {
       keepAlive: true,
       useNewUrlParser: true,
       useUnifiedTopology: true
     }
-    this._connection.on('connected', () => {
+    this.#connection.on('connected', () => {
       console.log('Mongo connection established.')
     })
-    this._connection.on('reconnected', () => {
+    this.#connection.on('reconnected', () => {
       console.log('Mongo connection reestablished')
     })
-    this._connection.on('disconnected', () => {
+    this.#connection.on('disconnected', () => {
       console.log('Mongo connection disconnected')
       console.log('Trying to reconnected to Mongo...')
       setTimeout(() => {
@@ -609,10 +713,10 @@ class Server {
         })
       }, 3000)
     })
-    this._connection.on('close', () => {
+    this.#connection.on('close', () => {
       console.log('Mongo connection closed')
     })
-    this._connection.on('error', (e: Error) => {
+    this.#connection.on('error', (e: Error) => {
       console.log('Mongo connection error:')
       console.error(e)
     })
@@ -620,12 +724,12 @@ class Server {
   }
 
   public start(): void {
-    this._app.listen(PORT, () => {
+    this.#app.listen(PORT, () => {
       console.log(\`Server running at port \${PORT}\`)
     })
 
     try {
-      this._mongo()
+      this.#mongo()
     } catch (e) {
       console.error(e)
     }
@@ -639,33 +743,6 @@ export { server as Server }
         file: `${projectName}/src/network/server.ts`
       }
     },
-    '@types/custom': {
-      request: {
-        content: `type ExpressRequest = import('express').Request
-
-interface CustomRequest extends ExpressRequest {
-  body: {
-    args?: DtoUser
-  }
-  // We can add custom headers via intersection, remember that for some reason
-  // headers must be in Snake-Pascal-Case
-  headers: import('http').IncomingHttpHeaders & {
-    'Custom-Header'?: string
-  }
-}
-`,
-        file: `${projectName}/src/@types/custom/request.d.ts`
-      },
-      response: {
-        content: `type ExpressResponse = import('express').Response
-
-interface CustomResponse extends ExpressResponse {
-  newValue?: string
-}
-`,
-        file: `${projectName}/src/@types/custom/response.d.ts`
-      }
-    },
     'network/routes': {
       home: {
         content: `import { Response, Request, Router } from 'express'
@@ -694,146 +771,82 @@ export * from './user'
         file: `${projectName}/src/network/routes/index.ts`
       },
       user: {
-        content: `import { Router, NextFunction } from 'express'
-import httpErrors from 'http-errors'
-import { ValidationError } from 'joi'
+        content: `import { Router } from 'express'
 
 import { response } from 'network/response'
-import { UserService } from 'services/user'
-import { idSchema, userSchema, storeUserSchema } from './schemas'
+import { UserService } from 'services'
+import { idSchema, storeUserSchema, UserDTO } from 'schemas'
+import { validatorCompiler } from './utils'
 
 const User = Router()
 
 User.route('/users')
   .post(
-    async (
-      req: CustomRequest,
-      res: CustomResponse,
-      next: NextFunction
-    ): Promise<void> => {
+    validatorCompiler(storeUserSchema, 'body'),
+    async (req: CustomRequest, res: CustomResponse): Promise<void> => {
       const {
         body: { args }
       } = req
+      const us = new UserService({ userDtoWithoutId: args })
+      const result = await us.process({ type: 'store' })
 
-      try {
-        await storeUserSchema.validateAsync(args)
-        const us = new UserService(args)
-        const result = await us.process({ type: 'store' })
-        response({ error: false, message: result, res, status: 201 })
-      } catch (e) {
-        if (e instanceof ValidationError)
-          return next(new httpErrors.UnprocessableEntity(e.message))
-
-        next(e)
-      }
-    }
-  )
-  .get(
-    async (
-      req: CustomRequest,
-      res: CustomResponse,
-      next: NextFunction
-    ): Promise<void> => {
-      const us = new UserService()
-
-      try {
-        const result = await us.process({ type: 'getAll' })
-        response({ error: false, message: result, res, status: 200 })
-      } catch (e) {
-        next(e)
-      }
+      response({ error: false, message: result, res, status: 201 })
     }
   )
-  .delete(
-    async (
-      req: CustomRequest,
-      res: CustomResponse,
-      next: NextFunction
-    ): Promise<void> => {
-      const us = new UserService()
+  .get(async (req: CustomRequest, res: CustomResponse): Promise<void> => {
+    const us = new UserService()
+    const result = await us.process({ type: 'getAll' })
 
-      try {
-        const result = await us.process({ type: 'deleteAll' })
-        response({ error: false, message: result, res, status: 200 })
-      } catch (e) {
-        next(e)
-      }
-    }
-  )
+    response({ error: false, message: result, res, status: 200 })
+  })
+  .delete(async (req: CustomRequest, res: CustomResponse): Promise<void> => {
+    const us = new UserService()
+    const result = await us.process({ type: 'deleteAll' })
+
+    response({ error: false, message: result, res, status: 200 })
+  })
 
 User.route('/user/:id')
   .get(
-    async (
-      req: CustomRequest,
-      res: CustomResponse,
-      next: NextFunction
-    ): Promise<void> => {
+    validatorCompiler(idSchema, 'params'),
+    async (req: CustomRequest, res: CustomResponse): Promise<void> => {
       const {
         params: { id }
       } = req
+      const us = new UserService({ id })
+      const result = await us.process({ type: 'getOne' })
 
-      try {
-        await idSchema.validateAsync(id)
-        const us = new UserService({ id })
-        const result = await us.process({ type: 'getOne' })
-        response({ error: false, message: result, res, status: 200 })
-      } catch (e) {
-        if (e instanceof ValidationError)
-          return next(new httpErrors.UnprocessableEntity(e.message))
-
-        next(e)
-      }
+      response({ error: false, message: result, res, status: 200 })
     }
   )
   .patch(
-    async (
-      req: CustomRequest,
-      res: CustomResponse,
-      next: NextFunction
-    ): Promise<void> => {
+    validatorCompiler(idSchema, 'params'),
+    validatorCompiler(storeUserSchema, 'body'),
+    async (req: CustomRequest, res: CustomResponse): Promise<void> => {
       const {
         body: { args },
         params: { id }
       } = req
-      const user = {
+      const userDto = {
         id,
         ...args
-      }
+      } as UserDTO
+      const us = new UserService({ userDto })
+      const result = await us.process({ type: 'update' })
 
-      try {
-        await userSchema.validateAsync(user)
-        const us = new UserService(user)
-        const result = await us.process({ type: 'update' })
-        response({ error: false, message: result, res, status: 200 })
-      } catch (e) {
-        if (e instanceof ValidationError)
-          return next(new httpErrors.UnprocessableEntity(e.message))
-
-        next(e)
-      }
+      response({ error: false, message: result, res, status: 200 })
     }
   )
   .delete(
-    async (
-      req: CustomRequest,
-      res: CustomResponse,
-      next: NextFunction
-    ): Promise<void> => {
+    validatorCompiler(idSchema, 'params'),
+    async (req: CustomRequest, res: CustomResponse): Promise<void> => {
       const {
         params: { id }
       } = req
+      const us = new UserService({ id })
+      const result = await us.process({ type: 'delete' })
 
-      try {
-        await idSchema.validateAsync(id)
-        const us = new UserService({ id })
-        const result = await us.process({ type: 'delete' })
-        response({ error: false, message: result, res, status: 200 })
-      } catch (e) {
-        if (e instanceof ValidationError)
-          return next(new httpErrors.UnprocessableEntity(e.message))
-
-        next(e)
-      }
+      response({ error: false, message: result, res, status: 200 })
     }
   )
 
@@ -842,34 +855,48 @@ export { User }
         file: `${projectName}/src/network/routes/user.ts`
       }
     },
-    'network/routes/schemas': {
+    'network/routes/utils': {
       index: {
-        content: `import Joi from 'joi'
-
-const idSchema = Joi.string().length(24).required()
-
-export { idSchema }
-export * from './user'
-`,
-        file: `${projectName}/src/network/routes/schemas/index.ts`
-      },
-      user: {
-        content: `import Joi from 'joi'
-
-const userSchema = Joi.object().keys({
-  id: Joi.string().length(24).required(),
-  lastName: Joi.string().required(),
-  name: Joi.string().required()
+        content: `import { NextFunction } from 'express'
+import httpErrors from 'http-errors'
+import { TObject, TProperties } from '@sinclair/typebox'
+import Ajv from 'ajv'
+
+const ajv = new Ajv({
+  removeAdditional: true,
+  useDefaults: true,
+  coerceTypes: true,
+  nullable: true
 })
 
-const storeUserSchema = Joi.object().keys({
-  lastName: Joi.string().required(),
-  name: Joi.string().required()
-})
+type Middleware = (
+  req: CustomRequest,
+  res: CustomResponse,
+  next: NextFunction
+) => void
+
+const validatorCompiler = <T extends TProperties>(
+  schema: TObject<T>,
+  value: 'body' | 'params'
+): Middleware => {
+  return (req: CustomRequest, res: CustomResponse, next: NextFunction) => {
+    const validate = ajv.compile(schema)
+    const ok = validate(req[value])
+
+    if (!ok && validate.errors) {
+      const [error] = validate.errors
+      const errorMessage = \`\${error.dataPath.replace('.', '')} \${error.message}\`
+
+      return next(new httpErrors.UnprocessableEntity(errorMessage))
+    }
 
-export { userSchema, storeUserSchema }
+    next()
+  }
+}
+
+export { validatorCompiler }
 `,
-        file: `${projectName}/src/network/routes/schemas/user.ts`
+        file: `${projectName}/src/network/routes/utils/index.ts`
       }
     },
     utils: {
@@ -909,7 +936,7 @@ export { userSchema, storeUserSchema }
         "summary": "Save a user in the database",
         "operationId": "store",
         "requestBody": {
-          "$ref": "#/components/requestBodies/DtoUser"
+          "$ref": "#/components/requestBodies/UserDTO"
         },
         "responses": {
           "201": {
@@ -1103,7 +1130,7 @@ export { userSchema, storeUserSchema }
           }
         ],
         "requestBody": {
-          "$ref": "#/components/requestBodies/DtoUser"
+          "$ref": "#/components/requestBodies/UserDTO"
         },
         "responses": {
           "200": {
@@ -1264,7 +1291,7 @@ export { userSchema, storeUserSchema }
       }
     },
     "requestBodies": {
-      "DtoUser": {
+      "UserDTO": {
         "description": "User name and last name",
         "content": {
           "application/json": {
@@ -1368,16 +1395,17 @@ import { applyRoutes } from './router'
 const PORT = process.env.PORT ?? '1996'
 
 class Server {
-  private _app: FastifyInstance
-  private _connection: mongoose.Connection | undefined
+  #app: FastifyInstance
+  #connection: mongoose.Connection | undefined
 
   constructor() {
-    this._app = Fastify({ logger: true })
-    this._config()
+    this.#app = Fastify({ logger: true })
+    this.#config()
   }
 
-  private _config() {
-    this._app.addHook('preHandler', (req, reply, done) => {
+  #config() {
+    this.#app.register(require('fastify-cors'), {})
+    this.#app.addHook('preHandler', (req, reply, done) => {
       reply.header('Access-Control-Allow-Methods', 'GET, POST, PATCH, DELETE')
       reply.header('Access-Control-Allow-Origin', '*')
       reply.header(
@@ -1386,25 +1414,25 @@ class Server {
       )
       done()
     })
-    applyRoutes(this._app)
+    applyRoutes(this.#app)
   }
 
-  private async _mongo(): Promise<void> {
-    this._connection = mongoose.connection
+  async #mongo(): Promise<void> {
+    this.#connection = mongoose.connection
     const connection = {
       keepAlive: true,
       useNewUrlParser: true,
       useUnifiedTopology: true
     }
-    this._connection.on('connected', () => {
-      this._app.log.info('Mongo connection established.')
+    this.#connection.on('connected', () => {
+      this.#app.log.info('Mongo connection established.')
     })
-    this._connection.on('reconnected', () => {
-      this._app.log.info('Mongo connection reestablished')
+    this.#connection.on('reconnected', () => {
+      this.#app.log.info('Mongo connection reestablished')
     })
-    this._connection.on('disconnected', () => {
-      this._app.log.info('Mongo connection disconnected')
-      this._app.log.info('Trying to reconnected to Mongo...')
+    this.#connection.on('disconnected', () => {
+      this.#app.log.info('Mongo connection disconnected')
+      this.#app.log.info('Trying to reconnected to Mongo...')
       setTimeout(() => {
         mongoose.connect(process.env.MONGO_URI as string, {
           ...connection,
@@ -1413,20 +1441,20 @@ class Server {
         })
       }, 3000)
     })
-    this._connection.on('close', () => {
-      this._app.log.info('Mongo connection closed')
+    this.#connection.on('close', () => {
+      this.#app.log.info('Mongo connection closed')
     })
-    this._connection.on('error', (e: Error) => {
-      this._app.log.info('Mongo connection error:')
-      this._app.log.error(e)
+    this.#connection.on('error', (e: Error) => {
+      this.#app.log.info('Mongo connection error:')
+      this.#app.log.error(e)
     })
     await mongoose.connect(process.env.MONGO_URI as string, connection)
   }
 
   public async start(): Promise<void> {
     try {
-      await this._app.listen(PORT)
-      this._mongo()
+      await this.#app.listen(PORT)
+      this.#mongo()
     } catch (e) {
       console.error(e)
     }
@@ -1479,7 +1507,7 @@ const Docs = (app: FastifyInstance, prefix = '/api'): void => {
 }
 
 export { Docs }
-        `,
+`,
         file: `${projectName}/src/network/routes/docs.ts`
       },
       home: {
@@ -1510,30 +1538,37 @@ export * from './docs'
       },
       user: {
         content: `import { FastifyInstance } from 'fastify'
+import { Type } from '@sinclair/typebox'
 
 import { response } from 'network/response'
-import { userSchema, idSchema, storeUserSchema } from './schemas'
+import {
+  userDto,
+  idSchema,
+  IdSchema,
+  storeUserSchema,
+  StoreUser
+} from 'schemas'
 import { UserService } from 'services'
+import { validatorCompiler } from './utils'
 
 const User = (app: FastifyInstance, prefix = '/api'): void => {
   app
-    .post<{ Body: { args: Omit<DtoUser, 'id'> } }>(
+    .post<{ Body: StoreUser }>(
       \`\${prefix}/users\`,
       {
         schema: {
-          body: {
-            args: storeUserSchema
-          },
+          body: storeUserSchema,
           response: {
             200: {
               error: {
                 type: 'boolean'
               },
-              message: userSchema
+              message: userDto
             }
           },
           tags: ['user']
-        }
+        },
+        validatorCompiler
       },
       async (request, reply) => {
         const {
@@ -1541,14 +1576,16 @@ const User = (app: FastifyInstance, prefix = '/api'): void => {
             args: { lastName, name }
           }
         } = request
-        const us = new UserService({ lastName, name })
+        const us = new UserService({
+          userDtoWithoutId: { lastName, name }
+        })
         const user = await us.process({ type: 'store' })
 
         response({
           error: false,
           message: user,
           reply,
-          status: 200
+          status: 201
         })
       }
     )
@@ -1561,10 +1598,7 @@ const User = (app: FastifyInstance, prefix = '/api'): void => {
               error: {
                 type: 'boolean'
               },
-              message: {
-                type: 'array',
-                items: userSchema
-              }
+              message: Type.Array(userDto)
             }
           },
           tags: ['user']
@@ -1611,23 +1645,22 @@ const User = (app: FastifyInstance, prefix = '/api'): void => {
         })
       }
     )
-    .get<{ Params: { id: string } }>(
+    .get<{ Params: IdSchema }>(
       \`\${prefix}/user/:id\`,
       {
         schema: {
-          params: {
-            id: idSchema
-          },
+          params: idSchema,
           response: {
             200: {
               error: {
                 type: 'boolean'
               },
-              message: userSchema
+              message: userDto
             }
           },
           tags: ['user']
-        }
+        },
+        validatorCompiler
       },
       async (request, reply) => {
         const {
@@ -1644,22 +1677,18 @@ const User = (app: FastifyInstance, prefix = '/api'): void => {
         })
       }
     )
-    .patch<{ Body: { args: Omit<DtoUser, 'id'> }; Params: { id: string } }>(
+    .patch<{ Body: StoreUser; Params: IdSchema }>(
       \`\${prefix}/user/:id\`,
       {
         schema: {
-          body: {
-            args: userSchema
-          },
-          params: {
-            id: idSchema
-          },
+          body: storeUserSchema,
+          params: idSchema,
           response: {
             200: {
               error: {
                 type: 'boolean'
               },
-              message: userSchema
+              message: userDto
             }
           },
           tags: ['user']
@@ -1672,7 +1701,9 @@ const User = (app: FastifyInstance, prefix = '/api'): void => {
           },
           params: { id }
         } = request
-        const us = new UserService({ name, lastName, id })
+        const us = new UserService({
+          userDto: { name, lastName, id }
+        })
         const user = await us.process({ type: 'update' })
 
         response({
@@ -1683,13 +1714,11 @@ const User = (app: FastifyInstance, prefix = '/api'): void => {
         })
       }
     )
-    .delete<{ Params: { id: string } }>(
+    .delete<{ Params: IdSchema }>(
       \`\${prefix}/user/:id\`,
       {
         schema: {
-          params: {
-            id: idSchema
-          },
+          params: idSchema,
           response: {
             200: {
               error: {
@@ -1725,45 +1754,54 @@ export { User }
         file: `${projectName}/src/network/routes/user.ts`
       }
     },
-    'network/routes/schemas': {
+    'network/routes/utils': {
       index: {
-        content: `import { Type } from '@sinclair/typebox'
+        content: `/* eslint-disable @typescript-eslint/no-explicit-any */
+import {
+  FastifyRouteSchemaDef,
+  FastifyValidationResult
+} from 'fastify/types/schema'
+import httpErrors from 'http-errors'
+import Ajv from 'ajv'
 
-const idSchema = Type.String({ minLength: 24, maxLength: 24 })
+const ajv = new Ajv({
+  removeAdditional: true,
+  useDefaults: true,
+  coerceTypes: true,
+  nullable: true
+})
 
-export { idSchema }
-export * from './user'
-`,
-        file: `${projectName}/src/network/routes/schemas/index.ts`
-      },
-      user: {
-        content: `import { Type } from '@sinclair/typebox'
+const validatorCompiler = ({
+  schema
+}: FastifyRouteSchemaDef<any>): FastifyValidationResult => {
+  const validate = ajv.compile(schema)
 
-const userSchema = Type.Object({
-  id: Type.Optional(Type.String({ minLength: 24, maxLength: 24 })),
-  lastName: Type.Optional(Type.String()),
-  name: Type.Optional(Type.String()),
-  updatedAt: Type.Optional(Type.String())
-})
+  return (data: unknown): boolean => {
+    const ok = validate(data)
 
-const storeUserSchema = Type.Object({
-  lastName: Type.String(),
-  name: Type.String()
-})
+    if (!ok && validate.errors) {
+      const [error] = validate.errors
+      const errorMessage = \`\${error.dataPath.replace('.', '')} \${error.message}\`
+
+      throw new httpErrors.UnprocessableEntity(errorMessage)
+    }
+
+    return true
+  }
+}
 
-export { userSchema, storeUserSchema }
+export { validatorCompiler }
 `,
-        file: `${projectName}/src/network/routes/schemas/user.ts`
+        file: `${projectName}/src/network/routes/utils/index.ts`
       }
     }
   }
 
-  const expressFolders = `${projectName}/src/utils`
+  const expressFolders = `${projectName}/src/utils \
+${projectName}/src/@types/custom`
 
   const createFoldersCommands = `mkdir ${projectName}/src \
 ${projectName}/src/@types \
-${projectName}/src/@types/dto \
-${projectName}/src/@types/custom \
 ${projectName}/src/@types/models \
 ${projectName}/src/database \
 ${projectName}/src/database/mongo \
@@ -1771,7 +1809,8 @@ ${projectName}/src/database/mongo/models \
 ${projectName}/src/database/mongo/queries \
 ${projectName}/src/network \
 ${projectName}/src/network/routes \
-${projectName}/src/network/routes/schemas \
+${projectName}/src/network/routes/utils \
+${projectName}/src/schemas \
 ${projectName}/src/services \
 ${projectName}/src/services/utils \
 ${projectName}/src/services/utils/messages \
@@ -1785,19 +1824,12 @@ ${fastify ? '' : `${expressFolders}`}
   // /@types
   await writeFile(data['@types'].index.file, data['@types'].index.content)
 
-  // /@types/dto
-  await writeFile(data['@types/dto'].user.file, data['@types/dto'].user.content)
-
   // /@types/models
   await writeFile(
     data['@types/models'].user.file,
     data['@types/models'].user.content
   )
 
-  // /services
-  await writeFile(data.services.user.file, data.services.user.content)
-  await writeFile(data.services.index.file, data.services.index.content)
-
   // /database
   await writeFile(data.database.index.file, data.database.index.content)
   await writeFile(
@@ -1821,6 +1853,14 @@ ${fastify ? '' : `${expressFolders}`}
     data['database/mongo/queries'].user.content
   )
 
+  // /schemas
+  await writeFile(data.schemas.user.file, data.schemas.user.content)
+  await writeFile(data.schemas.index.file, data.schemas.index.content)
+
+  // /services
+  await writeFile(data.services.user.file, data.services.user.content)
+  await writeFile(data.services.index.file, data.services.index.content)
+
   // /services/utils
   await writeFile(
     data['services/utils'].index.file,
@@ -1882,16 +1922,22 @@ ${fastify ? '' : `${expressFolders}`}
       fastifyData['network/routes'].index.content
     )
 
-    // /network/routes/schemas
+    // /network/routes/utils
+    await writeFile(
+      fastifyData['network/routes/utils'].index.file,
+      fastifyData['network/routes/utils'].index.content
+    )
+  } else {
+    // /@types/custom
     await writeFile(
-      fastifyData['network/routes/schemas'].index.file,
-      fastifyData['network/routes/schemas'].index.content
+      expressData['@types/custom'].request.file,
+      expressData['@types/custom'].request.content
     )
     await writeFile(
-      fastifyData['network/routes/schemas'].user.file,
-      fastifyData['network/routes/schemas'].user.content
+      expressData['@types/custom'].response.file,
+      expressData['@types/custom'].response.content
     )
-  } else {
+
     // /network
     await writeFile(
       expressData.network.response.file,
@@ -1920,14 +1966,10 @@ ${fastify ? '' : `${expressFolders}`}
       expressData['network/routes'].index.content
     )
 
-    // /network/routes/schemas
-    await writeFile(
-      expressData['network/routes/schemas'].index.file,
-      expressData['network/routes/schemas'].index.content
-    )
+    // /network/routes/utils
     await writeFile(
-      expressData['network/routes/schemas'].user.file,
-      expressData['network/routes/schemas'].user.content
+      expressData['network/routes/utils'].index.file,
+      expressData['network/routes/utils'].index.content
     )
 
     // /utils
@@ -1936,15 +1978,5 @@ ${fastify ? '' : `${expressFolders}`}
       expressData.utils.index.file,
       expressData.utils.index.content
     )
-
-    // /@types/custom
-    await writeFile(
-      expressData['@types/custom'].request.file,
-      expressData['@types/custom'].request.content
-    )
-    await writeFile(
-      expressData['@types/custom'].response.file,
-      expressData['@types/custom'].response.content
-    )
   }
 }