@anthonylzq/simba.js 1.9.1 → 2.0.2

package/lib/src/functions/express.js

@@ -5,30 +5,39 @@ const writeFile = require('../utils/writeFile')
 /*
  * src
  * |- @types:
- * |  |- global: content, file
- * |- controllers:
- * |  |- utils:
- * |  |  |- messages:
- * |  |  |  |- user: content, file
- * |  |  |  |- index: content, file
- * |  |  |- index: content, file
- * |  |- user: content, file
+ * |- |- dto:
+ * |- |- |- user: content, file
+ * |- |- models:
+ * |- |- |- user: content, file
  * |  |- index: content, file
- * |- dto-interfaces:
- * |  |- user: content, file
- * |  |- index: content, file
- * |- models:
- * |  |- user: content, file
+ * |- database:
+ * |  |- mongo:
+ * |  |- |- models:
+ * |  |- |- |- index: content, file
+ * |  |- |- |- user: content, file
+ * |  |- |- queries:
+ * |  |- |- |- index: content, file
+ * |  |- |- |- user: content, file
+ * |  |- |- index: content, file
  * |  |- index: content, file
  * |- network:
+ * |  |- routes:
+ * |  |  |- schemas:
+ * |  |  |  |- user: content, file
+ * |  |  |  |- index: content, file
+ * |  |  |- home: content, file
+ * |  |  |- user: content, file
+ * |  |  |- index: content, file
+ * |  |  |- response: content, file
+ * |  |- router: content, file
  * |  |- server: content, file
- * |  |- routes: content, file
  * |  |- index: content, file
- * |- routes:
- * |  |- home: content, file
- * |  |- user: content, file
- * |  |- index: content, file
- * |- schemas:
+ * |- services:
+ * |  |- utils:
+ * |  |  |- messages:
+ * |  |  |  |- user: content, file
+ * |  |  |  |- index: content, file
+ * |  |  |- index: content, file
  * |  |- user: content, file
  * |  |- index: content, file
  * |- test:
@@ -50,265 +59,86 @@ module.exports = async (projectName, projectVersion, email) => {
     '@types': {
       index: {
         content: `/* eslint-disable no-var */
-import { IncomingHttpHeaders } from 'http'
-import { Request, Response } from 'express'
-
-import { DtoUser } from 'dto-interfaces'
-
-declare global {
-  // This variable is global, so it will be available everywhere in the code
-  var response = (
-    error: boolean,
-    message: unknown,
-    res: Response,
-    status: number
-  ): void => {
-    res.status(status).send({ error, message })
-  }
-
-  // We can personalize the response and request objects in case we need it by
-  // adding new optional attributes to this interface
-  interface CustomResponse extends Response {
-    newValue?: string
-  }
-
-  interface CustomRequest extends Request {
-    body: {
-      args?: DtoUser
-    }
-    // We can add custom headers via intersection, remember that for some reason
-    // headers must be in Snake-Pascal-Case
-    headers: IncomingHttpHeaders & {
-      'Custom-Header'?: string
-    }
-  }
-}
+declare global {}
 
 export {}
 `,
         file: `${projectName}/src/@types/index.d.ts`
       }
     },
-    controllers: {
-      index: {
-        content: `import { User } from './user'
-
-export { User }
-`,
-        file: `${projectName}/src/controllers/index.ts`
-      },
+    '@types/dto': {
       user: {
-        content: `import httpErrors from 'http-errors'
-
-import { DtoUser } from 'dto-interfaces'
-import { IUser, UserModel } from 'models'
-import { EFU, MFU, GE, errorHandling } from './utils'
-
-type Process = {
-  type: 'store' | 'getAll' | 'deleteAll' | 'getOne' | 'update' | 'delete'
+        content: `interface DtoUser {
+  id?: string
+  lastName?: string
+  name?: string
 }
+`,
+        file: `${projectName}/src/@types/dto/user.d.ts`
+      }
+    },
+    '@types/custom': {
+      request: {
+        content: `type ExpressRequest = import('express').Request
 
-class User {
-  private _args: DtoUser | null
-
-  constructor(args: DtoUser | null = null) {
-    this._args = args
-  }
-
-  public process({
-    type
-  }: Process): Promise<string> | Promise<IUser[]> | Promise<IUser> {
-    switch (type) {
-      case 'store':
-        return this._store()
-      case 'getAll':
-        return this._getAll()
-      case 'deleteAll':
-        return this._deleteAll()
-      case 'getOne':
-        return this._getOne()
-      case 'update':
-        return this._update()
-      case 'delete':
-        return this._delete()
-      default:
-        throw new httpErrors.InternalServerError(GE.INTERNAL_SERVER_ERROR)
-    }
-  }
-
-  private async _store(): Promise<IUser> {
-    const { lastName, name } = this._args as DtoUser
-
-    try {
-      const newUser = new UserModel({ lastName, name })
-      const result = await newUser.save()
-
-      return result
-    } catch (e) {
-      return errorHandling(e, GE.INTERNAL_SERVER_ERROR)
-    }
-  }
-
-  private async _getAll(): Promise<IUser[]> {
-    try {
-      const users = await UserModel.find({})
-
-      return users
-    } catch (e) {
-      return errorHandling(e, GE.INTERNAL_SERVER_ERROR)
-    }
-  }
-
-  private async _deleteAll(): Promise<string> {
-    try {
-      const usersDeleted = await UserModel.deleteMany({})
-
-      if (usersDeleted.acknowledged) return MFU.ALL_USERS_DELETED
-
-      throw new httpErrors.InternalServerError(GE.INTERNAL_SERVER_ERROR)
-    } catch (e) {
-      return errorHandling(e, GE.INTERNAL_SERVER_ERROR)
-    }
-  }
-
-  private async _getOne(): Promise<IUser> {
-    const { id } = this._args as DtoUser
-
-    try {
-      const user = await UserModel.findById(id)
-
-      if (!user) throw new httpErrors.NotFound(EFU.NOT_FOUND)
-
-      return user
-    } catch (e) {
-      return errorHandling(e, GE.INTERNAL_SERVER_ERROR)
-    }
-  }
-
-  private async _update(): Promise<IUser> {
-    const { id, lastName, name } = this._args as DtoUser
-
-    try {
-      const updatedUser = await UserModel.findByIdAndUpdate(
-        id,
-        { lastName, name },
-        { new: true }
-      )
-
-      if (!updatedUser) throw new httpErrors.NotFound(EFU.NOT_FOUND)
-
-      return updatedUser
-    } catch (e) {
-      return errorHandling(e, GE.INTERNAL_SERVER_ERROR)
-    }
+interface CustomRequest extends ExpressRequest {
+  body: {
+    args?: DtoUser
   }
-
-  private async _delete(): Promise<string> {
-    const { id } = this._args as DtoUser
-
-    try {
-      const deletedUser = await UserModel.findByIdAndRemove(id)
-
-      if (!deletedUser) throw new httpErrors.NotFound(EFU.NOT_FOUND)
-
-      return MFU.USER_DELETED
-    } catch (e) {
-      return errorHandling(e, GE.INTERNAL_SERVER_ERROR)
-    }
+  // 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
   }
 }
-
-export { User }
 `,
-        file: `${projectName}/src/controllers/user.ts`
-      }
-    },
-    'controllers/utils': {
-      index: {
-        content: `import httpErrors from 'http-errors'
-
-import { EFU, MFU, GE } from './messages'
-
-// eslint-disable-next-line @typescript-eslint/no-explicit-any
-const errorHandling = (e: any, message?: string): never => {
-  console.error(e)
-
-  if (e instanceof httpErrors.HttpError) throw e
+        file: `${projectName}/src/@types/custom/request.d.ts`
+      },
+      response: {
+        content: `type ExpressResponse = import('express').Response
 
-  throw new httpErrors.InternalServerError(message ?? e.message)
+interface CustomResponse extends ExpressResponse {
+  newValue?: string
 }
-
-export { EFU, MFU, GE, errorHandling }
 `,
-        file: `${projectName}/src/controllers/utils/index.ts`
+        file: `${projectName}/src/@types/custom/response.d.ts`
       }
     },
-    'controllers/utils/messages': {
-      index: {
-        content: `import { EFU, MFU } from './user'
-
-enum GenericErrors {
-  INTERNAL_SERVER_ERROR = 'Something went wrong'
-}
-
-export { EFU, MFU, GenericErrors as GE }
-`,
-        file: `${projectName}/src/controllers/utils/messages/index.ts`
-      },
+    '@types/models': {
       user: {
-        content: `enum ErrorForUser {
-  NOT_FOUND = 'The requested user does not exists'
-}
-
-enum MessageForUser {
-  ALL_USERS_DELETED = 'All the users were deleted successfully',
-  USER_DELETED = 'The requested user was successfully deleted'
+        content: `interface IUser {
+  _id: import('mongoose').Types.ObjectId
+  name: string
+  lastName: string
+  updatedAt: Date
 }
-
-export { ErrorForUser as EFU, MessageForUser as MFU }
 `,
-        file: `${projectName}/src/controllers/utils/messages/user.ts`
+        file: `${projectName}/src/@types/models/user.d.ts`
       }
     },
-    'dto-interfaces': {
+    database: {
       index: {
-        content: `import { DtoUser } from './user'
-
-export { DtoUser }
-`,
-        file: `${projectName}/src/dto-interfaces/index.ts`
-      },
-      user: {
-        content: `interface DtoUser {
-  id: string
-  lastName?: string
-  name?: string
-}
-
-export { DtoUser }
-`,
-        file: `${projectName}/src/dto-interfaces/user.ts`
+        content: "export * from './mongo'\n",
+        file: `${projectName}/src/database/index.ts`
       }
     },
-    models: {
+    'database/mongo': {
       index: {
-        content: `import { IUser, UserModel } from './user'
-
-export { IUser, UserModel }
+        content: `export * from './models'
+export * from './queries'
 `,
-        file: `${projectName}/src/models/index.ts`
+        file: `${projectName}/src/database/mongo/index.ts`
+      }
+    },
+    'database/mongo/models': {
+      index: {
+        content: "export * from './user'\n",
+        file: `${projectName}/src/database/mongo/models/index.ts`
       },
       user: {
-        content: `/* eslint-disable no-underscore-dangle */
-import { Document, model, Schema } from 'mongoose'
+        content: `import { model, Schema } from 'mongoose'
 
-interface IUser extends Document {
-  lastName: string
-  name: string
-  updatedAt: Date
-}
-
-const User = new Schema(
+const User = new Schema<IUser>(
   {
     lastName: {
       required: true,
@@ -323,36 +153,98 @@ const User = new Schema(
     timestamps: {
       createdAt: false,
       updatedAt: true
+    },
+    toJSON: {
+      transform(_, ret) {
+        ret.id = ret._id
+        delete ret._id
+        delete ret.__v
+        delete ret.updatedAt
+      },
+      versionKey: false,
+      virtuals: true
     }
   }
 )
 
-User.set('toJSON', {
-  // eslint-disable-next-line @typescript-eslint/no-explicit-any
-  transform: function (_: any, ret: any) {
-    ret.id = ret._id
-    delete ret._id
-    delete ret.__v
-    delete ret.updatedAt
-  },
-  versionKey: false,
-  virtuals: true
-})
-
 const UserModel = model<IUser>('users', User)
 
-export { IUser, UserModel }
+export { UserModel }
 `,
-        file: `${projectName}/src/models/user.ts`
+        file: `${projectName}/src/database/mongo/models/user.ts`
+      }
+    },
+    'database/mongo/queries': {
+      index: {
+        content: "export * from './user'\n",
+        file: `${projectName}/src/database/mongo/queries/index.ts`
+      },
+      user: {
+        content: `import { UserModel } from '../models'
+
+const store = async (userData: DtoUser): Promise<IUser> => {
+  const user = new UserModel(userData)
+
+  return await user.save()
+}
+
+const remove = async (
+  id: string | null = null
+): Promise<IUser | number | null> => {
+  if (id) return await UserModel.findByIdAndRemove(id)
+
+  return (await UserModel.deleteMany({})).deletedCount
+}
+
+const get = async (
+  id: string | null = null
+): Promise<IUser[] | IUser | null> => {
+  if (id) return await UserModel.findById(id)
+
+  return await UserModel.find({})
+}
+
+const update = async (userData: DtoUser): Promise<IUser | null> => {
+  const { id, ...rest } = userData
+
+  return await UserModel.findByIdAndUpdate(id, rest, { new: true })
+}
+
+export { store, remove, get, update }
+`,
+        file: `${projectName}/src/database/mongo/queries/user.ts`
       }
     },
     network: {
-      routes: {
+      index: {
+        content: `export * from './routes'
+export * from './server'
+`,
+        file: `${projectName}/src/network/index.ts`
+      },
+      response: {
+        content: `interface ResponseProps {
+  error: boolean
+  message: unknown
+  res: CustomResponse
+  status: number
+}
+
+const response = ({ error, message, res, status }: ResponseProps): void => {
+  res.status(status).send({ error, message })
+}
+
+export { response }
+`,
+        file: `${projectName}/src/network/response.ts`
+      },
+      router: {
         content: `import { Application, Response, Request, Router, NextFunction } from 'express'
 import swaggerUi from 'swagger-ui-express'
 import httpErrors from 'http-errors'
 
-import { Home, User } from 'routes'
+import { response } from './response'
+import { Home, User } from './routes'
 import { docs } from 'utils'
 
 const routers = [User]
@@ -373,7 +265,12 @@ const applyRoutes = (app: Application): void => {
       res: Response,
       next: NextFunction
     ) => {
-      response(true, error.message, res, error.status)
+      response({
+        error: true,
+        message: error.message,
+        res,
+        status: error.status
+      })
       next()
     }
   )
@@ -381,14 +278,14 @@ const applyRoutes = (app: Application): void => {
 
 export { applyRoutes }
 `,
-        file: `${projectName}/src/network/routes.ts`
+        file: `${projectName}/src/network/router.ts`
       },
       server: {
         content: `import express from 'express'
 import mongoose from 'mongoose'
 import morgan from 'morgan'
 
-import { applyRoutes } from './routes'
+import { applyRoutes } from './router'
 
 const PORT = (process.env.PORT as string) || '1996'
 
@@ -421,6 +318,7 @@ class Server {
         next()
       }
     )
+
     applyRoutes(this._app)
   }
 
@@ -476,46 +374,43 @@ const server = new Server()
 export { server as Server }
 `,
         file: `${projectName}/src/network/server.ts`
-      },
-      index: {
-        content: `import { applyRoutes } from './routes'
-import { Server } from './server'
-
-export { applyRoutes, Server }
-`,
-        file: `${projectName}/src/network/index.ts`
       }
     },
-    routes: {
+    'network/routes': {
       home: {
         content: `import { Response, Request, Router } from 'express'
 
+import { response } from 'network/response'
+
 const Home = Router()
 
 Home.route('').get((req: Request, res: Response) => {
-  response(false, 'Welcome to your Express Backend!', res, 200)
+  response({
+    error: false,
+    message: 'Welcome to your Express Backend!',
+    res,
+    status: 200
+  })
 })
 
 export { Home }
 `,
-        file: `${projectName}/src/routes/home.ts`
+        file: `${projectName}/src/network/routes/home.ts`
       },
       index: {
-        content: `import { Home } from './home'
-import { User } from './user'
-
-export { Home, User }
+        content: `export * from './home'
+export * from './user'
 `,
-        file: `${projectName}/src/routes/index.ts`
+        file: `${projectName}/src/network/routes/index.ts`
       },
       user: {
         content: `import { Router, NextFunction } from 'express'
 import httpErrors from 'http-errors'
 import { ValidationError } from 'joi'
 
-import { User as UserC } from 'controllers/user'
-import { DtoUser } from 'dto-interfaces'
-import { idSchema, userSchema } from 'schemas'
+import { response } from 'network/response'
+import { UserService } from 'services/user'
+import { idSchema, userSchema } from './schemas'
 
 const User = Router()
 
@@ -529,11 +424,11 @@ User.route('/users')
       const {
         body: { args }
       } = req
-      const u = new UserC(args as DtoUser)
+      const us = new UserService(args as DtoUser)
 
       try {
-        const result = await u.process({ type: 'store' })
-        response(false, result, res, 201)
+        const result = await us.process({ type: 'store' })
+        response({ error: false, message: result, res, status: 201 })
       } catch (e) {
         next(e)
       }
@@ -545,11 +440,11 @@ User.route('/users')
       res: CustomResponse,
       next: NextFunction
     ): Promise<void> => {
-      const u = new UserC()
+      const us = new UserService()
 
       try {
-        const result = await u.process({ type: 'getAll' })
-        response(false, result, res, 200)
+        const result = await us.process({ type: 'getAll' })
+        response({ error: false, message: result, res, status: 200 })
       } catch (e) {
         next(e)
       }
@@ -561,11 +456,11 @@ User.route('/users')
       res: CustomResponse,
       next: NextFunction
     ): Promise<void> => {
-      const u = new UserC()
+      const us = new UserService()
 
       try {
-        const result = await u.process({ type: 'deleteAll' })
-        response(false, result, res, 200)
+        const result = await us.process({ type: 'deleteAll' })
+        response({ error: false, message: result, res, status: 200 })
       } catch (e) {
         next(e)
       }
@@ -585,9 +480,9 @@ User.route('/user/:id')
 
       try {
         await idSchema.validateAsync(id)
-        const u = new UserC({ id } as DtoUser)
-        const result = await u.process({ type: 'getOne' })
-        response(false, result, res, 200)
+        const us = new UserService({ id } as DtoUser)
+        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))
@@ -613,9 +508,9 @@ User.route('/user/:id')
 
       try {
         await userSchema.validateAsync(user)
-        const u = new UserC(user)
-        const result = await u.process({ type: 'update' })
-        response(false, result, res, 200)
+        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))
@@ -636,9 +531,9 @@ User.route('/user/:id')
 
       try {
         await idSchema.validateAsync(id)
-        const u = new UserC({ id } as DtoUser)
-        const result = await u.process({ type: 'delete' })
-        response(false, result, res, 200)
+        const us = new UserService({ id } as DtoUser)
+        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))
@@ -650,20 +545,19 @@ User.route('/user/:id')
 
 export { User }
 `,
-        file: `${projectName}/src/routes/user.ts`
+        file: `${projectName}/src/network/routes/user.ts`
       }
     },
-    schemas: {
+    'network/routes/schemas': {
       index: {
         content: `import Joi from 'joi'
 
-import { userSchema } from './user'
-
 const idSchema = Joi.string().length(24).required()
 
-export { idSchema, userSchema }
+export { idSchema }
+export * from './user'
 `,
-        file: `${projectName}/src/schemas/index.ts`
+        file: `${projectName}/src/network/routes/schemas/index.ts`
       },
       user: {
         content: `import Joi from 'joi'
@@ -676,7 +570,175 @@ const userSchema = Joi.object().keys({
 
 export { userSchema }
 `,
-        file: `${projectName}/src/schemas/user.ts`
+        file: `${projectName}/src/network/routes/schemas/user.ts`
+      }
+    },
+    services: {
+      index: {
+        content: "export * from './user'\n",
+        file: `${projectName}/src/services/index.ts`
+      },
+      user: {
+        content: `import httpErrors from 'http-errors'
+
+import { store, remove, get, update } from 'database'
+import { EFU, MFU, GE, errorHandling } from './utils'
+
+type Process = {
+  type: 'store' | 'getAll' | 'deleteAll' | 'getOne' | 'update' | 'delete'
+}
+
+class UserService {
+  private _args: DtoUser | null
+
+  constructor(args: DtoUser | null = null) {
+    this._args = args
+  }
+
+  public process({ type }: Process): Promise<string | IUser[] | IUser> {
+    switch (type) {
+      case 'store':
+        return this._store()
+      case 'getAll':
+        return this._getAll()
+      case 'deleteAll':
+        return this._deleteAll()
+      case 'getOne':
+        return this._getOne()
+      case 'update':
+        return this._update()
+      case 'delete':
+        return this._delete()
+      default:
+        throw new httpErrors.InternalServerError(GE.INTERNAL_SERVER_ERROR)
+    }
+  }
+
+  private async _store(): Promise<IUser> {
+    try {
+      const result = await store(this._args as DtoUser)
+
+      return result
+    } catch (e) {
+      return errorHandling(e, GE.INTERNAL_SERVER_ERROR)
+    }
+  }
+
+  private async _getAll(): Promise<IUser[]> {
+    try {
+      const users = (await get()) as IUser[]
+
+      return users
+    } catch (e) {
+      return errorHandling(e, GE.INTERNAL_SERVER_ERROR)
+    }
+  }
+
+  private async _deleteAll(): Promise<string> {
+    try {
+      const usersDeleted = (await remove()) as number
+
+      if (usersDeleted >= 1) return MFU.ALL_USERS_DELETED
+
+      if (usersDeleted === 0)
+        throw new httpErrors.Conflict(EFU.NOTHING_TO_DELETE)
+
+      throw new httpErrors.InternalServerError(GE.INTERNAL_SERVER_ERROR)
+    } catch (e) {
+      return errorHandling(e, GE.INTERNAL_SERVER_ERROR)
+    }
+  }
+
+  private async _getOne(): Promise<IUser> {
+    const { id } = this._args as DtoUser
+
+    try {
+      const user = (await get(id as string)) as IUser | null
+
+      if (!user) throw new httpErrors.NotFound(EFU.NOT_FOUND)
+
+      return user
+    } catch (e) {
+      return errorHandling(e, GE.INTERNAL_SERVER_ERROR)
+    }
+  }
+
+  private async _update(): Promise<IUser> {
+    try {
+      const updatedUser = await update(this._args as DtoUser)
+
+      if (!updatedUser) throw new httpErrors.NotFound(EFU.NOT_FOUND)
+
+      return updatedUser
+    } catch (e) {
+      return errorHandling(e, GE.INTERNAL_SERVER_ERROR)
+    }
+  }
+
+  private async _delete(): Promise<string> {
+    const { id } = this._args as DtoUser
+
+    try {
+      const deletedUser = await remove(id)
+
+      if (!deletedUser) throw new httpErrors.NotFound(EFU.NOT_FOUND)
+
+      return MFU.USER_DELETED
+    } catch (e) {
+      return errorHandling(e, GE.INTERNAL_SERVER_ERROR)
+    }
+  }
+}
+
+export { UserService }
+`,
+        file: `${projectName}/src/services/user.ts`
+      }
+    },
+    'services/utils': {
+      index: {
+        content: `import httpErrors from 'http-errors'
+
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+const errorHandling = (e: any, message?: string): never => {
+  console.error(e)
+
+  if (e instanceof httpErrors.HttpError) throw e
+
+  throw new httpErrors.InternalServerError(message ?? e.message)
+}
+
+export { errorHandling }
+export * from './messages'
+`,
+        file: `${projectName}/src/services/utils/index.ts`
+      }
+    },
+    'services/utils/messages': {
+      index: {
+        content: `enum GenericErrors {
+  INTERNAL_SERVER_ERROR = 'Something went wrong'
+}
+
+export { GenericErrors as GE }
+export * from './user'
+`,
+        file: `${projectName}/src/services/utils/messages/index.ts`
+      },
+      user: {
+        content: `enum ErrorForUser {
+  NOT_FOUND = 'The requested user does not exists',
+  NOTHING_TO_DELETE = 'There is no user to be deleted'
+}
+
+enum MessageForUser {
+  ALL_USERS_DELETED = 'All the users were deleted successfully',
+  USER_DELETED = 'The requested user was successfully deleted'
+}
+
+export { ErrorForUser as EFU, MessageForUser as MFU }
+`,
+        file: `${projectName}/src/services/utils/messages/user.ts`
       }
     },
     test: {
@@ -1140,10 +1202,7 @@ DELETE http://localhost:1996/api/user/60e7e3b93b01c1a7aa74cd6b
         file: `${projectName}/src/utils/docs.json`
       },
       index: {
-        content: `import docs from './docs.json'
-
-export { docs }
-`,
+        content: "export { default as docs } from './docs.json'\n",
         file: `${projectName}/src/utils/index.ts`
       }
     },
@@ -1162,14 +1221,19 @@ Server.start()
 
   await exec(`mkdir ${projectName}/src \
 ${projectName}/src/@types \
-${projectName}/src/controllers \
-${projectName}/src/controllers/utils \
-${projectName}/src/controllers/utils/messages \
-${projectName}/src/dto-interfaces \
-${projectName}/src/models \
+${projectName}/src/@types/dto \
+${projectName}/src/@types/custom \
+${projectName}/src/@types/models \
+${projectName}/src/services \
+${projectName}/src/services/utils \
+${projectName}/src/services/utils/messages \
+${projectName}/src/database \
+${projectName}/src/database/mongo \
+${projectName}/src/database/mongo/models \
+${projectName}/src/database/mongo/queries \
 ${projectName}/src/network \
-${projectName}/src/routes \
-${projectName}/src/schemas \
+${projectName}/src/network/routes \
+${projectName}/src/network/routes/schemas \
 ${projectName}/src/test \
 ${projectName}/src/utils
 `)
@@ -1177,53 +1241,97 @@ ${projectName}/src/utils
   // /@types
   await writeFile(data['@types'].index.file, data['@types'].index.content)
 
-  // /controllers
-  await writeFile(data.controllers.user.file, data.controllers.user.content)
-  await writeFile(data.controllers.index.file, data.controllers.index.content)
+  // /@types/custom
+  await writeFile(
+    data['@types/custom'].request.file,
+    data['@types/custom'].request.content
+  )
+  await writeFile(
+    data['@types/custom'].response.file,
+    data['@types/custom'].response.content
+  )
 
-  // /controllers/utils
+  // /@types/dto
+  await writeFile(data['@types/dto'].user.file, data['@types/dto'].user.content)
+
+  // /@types/models
   await writeFile(
-    data['controllers/utils'].index.file,
-    data['controllers/utils'].index.content
+    data['@types/models'].user.file,
+    data['@types/models'].user.content
   )
 
-  // /controllers/utils/messages
+  // /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(
-    data['controllers/utils/messages'].user.file,
-    data['controllers/utils/messages'].user.content
+    data['database/mongo'].index.file,
+    data['database/mongo'].index.content
   )
   await writeFile(
-    data['controllers/utils/messages'].index.file,
-    data['controllers/utils/messages'].index.content
+    data['database/mongo/models'].index.file,
+    data['database/mongo/models'].index.content
+  )
+  await writeFile(
+    data['database/mongo/models'].user.file,
+    data['database/mongo/models'].user.content
+  )
+  await writeFile(
+    data['database/mongo/queries'].index.file,
+    data['database/mongo/queries'].index.content
   )
-
-  // /dto-interfaces
   await writeFile(
-    data['dto-interfaces'].user.file,
-    data['dto-interfaces'].user.content
+    data['database/mongo/queries'].user.file,
+    data['database/mongo/queries'].user.content
   )
+
+  // /services/utils
   await writeFile(
-    data['dto-interfaces'].index.file,
-    data['dto-interfaces'].index.content
+    data['services/utils'].index.file,
+    data['services/utils'].index.content
   )
 
-  // /models
-  await writeFile(data.models.user.file, data.models.user.content)
-  await writeFile(data.models.index.file, data.models.index.content)
+  // /services/utils/messages
+  await writeFile(
+    data['services/utils/messages'].user.file,
+    data['services/utils/messages'].user.content
+  )
+  await writeFile(
+    data['services/utils/messages'].index.file,
+    data['services/utils/messages'].index.content
+  )
 
   // /network
-  await writeFile(data.network.routes.file, data.network.routes.content)
-  await writeFile(data.network.server.file, data.network.server.content)
   await writeFile(data.network.index.file, data.network.index.content)
+  await writeFile(data.network.response.file, data.network.response.content)
+  await writeFile(data.network.router.file, data.network.router.content)
+  await writeFile(data.network.server.file, data.network.server.content)
 
-  // /routes
-  await writeFile(data.routes.home.file, data.routes.home.content)
-  await writeFile(data.routes.user.file, data.routes.user.content)
-  await writeFile(data.routes.index.file, data.routes.index.content)
+  // /network/routes
+  await writeFile(
+    data['network/routes'].home.file,
+    data['network/routes'].home.content
+  )
+  await writeFile(
+    data['network/routes'].user.file,
+    data['network/routes'].user.content
+  )
+  await writeFile(
+    data['network/routes'].index.file,
+    data['network/routes'].index.content
+  )
 
-  // /schemas
-  await writeFile(data.schemas.index.file, data.schemas.index.content)
-  await writeFile(data.schemas.user.file, data.schemas.user.content)
+  // /network/routes/schemas
+  await writeFile(
+    data['network/routes/schemas'].index.file,
+    data['network/routes/schemas'].index.content
+  )
+  await writeFile(
+    data['network/routes/schemas'].user.file,
+    data['network/routes/schemas'].user.content
+  )
 
   // /test
   await writeFile(data.test.index.file, data.test.index.content)