@anthonylzq/simba.js 7.2.0 → 8.0.0

package/lib/src/functions/api/express.js

@@ -1,7 +1,12 @@
 const { platform } = require('os')
 const { promisify } = require('util')
 const exec = promisify(require('child_process').exec)
+
+const db = require('./database')
+const schemas = require('./schemas')
+const services = require('./services')
 const writeFile = require('../../utils/writeFile')
+const utils = require('./utils')
 
 /**
  * @param {Object} args
@@ -29,47 +34,13 @@ export {}
       file: `${projectName}/src/@types/index.d.ts`
     },
     custom: {
-      request: {
-        content: `type ExpressRequest = import('express').Request
-
-interface CustomRequest extends ExpressRequest {
-  log: import('express-pino-logger').HttpLogger['logger']
-  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`
+      params: {
+        content: `type Params = {
+  [key: string]: string
+}\n`,
+        file: `${projectName}/src/@types/custom/params.d.ts`
       }
     },
-    ...(!dbIsSQL && {
-      models: {
-        user: {
-          content: `interface UserDBO {
-  name: string
-  lastName: string
-  createdAt: Date
-  updatedAt: Date
-}
-`,
-          file: `${projectName}/src/@types/models/user.d.ts`
-        }
-      }
-    }),
     ...(graphQL && {
       graphQL: {
         context: {
@@ -84,13 +55,9 @@ interface CustomResponse extends ExpressResponse {
   }
   const processes = [
     writeFile(types.index.file, types.index.content),
-    writeFile(types.custom.request.file, types.custom.request.content),
-    writeFile(types.custom.response.file, types.custom.response.content)
+    writeFile(types.custom.params.file, types.custom.params.content)
   ]
 
-  if (!dbIsSQL)
-    processes.push(writeFile(types.models.user.file, types.models.user.content))
-
   if (graphQL)
     processes.push(
       writeFile(types.graphQL.context.file, types.graphQL.context.content)
@@ -99,500 +66,6 @@ interface CustomResponse extends ExpressResponse {
   await Promise.all(processes)
 }
 
-/**
- * @param {Object} args
- * @param {String} args.projectName
- */
-const mongo = async ({ projectName }) => {
-  const createFoldersCommand = `mkdir ${projectName}/src/database \
-${projectName}/src/database/mongo ${projectName}/src/database/mongo/models \
-${projectName}/src/database/mongo/queries`
-
-  if (platform() === 'win32')
-    await exec(createFoldersCommand.replaceAll('/', '\\'))
-  else await exec(createFoldersCommand)
-
-  const database = {
-    index: {
-      content: "export * from './mongo'\n",
-      file: `${projectName}/src/database/index.ts`
-    },
-    mongo: {
-      connection: {
-        content: `import { connect, connection } from 'mongoose'
-import { HttpLogger } from 'express-pino-logger'
-
-const ENVIRONMENTS_WITHOUT_RECONNECTION = ['ci', 'local']
-const dbConnection = async (
-  logger?: HttpLogger['logger']
-): Promise<{
-  connect: () => Promise<typeof import('mongoose')>
-  disconnect: () => Promise<void>
-}> => {
-  const connectionConfig = {
-    keepAlive: true,
-    useNewUrlParser: true,
-    useUnifiedTopology: true
-  }
-
-  connection.on('connected', () => {
-    logger?.info('Mongo connection established.')
-  })
-  connection.on('reconnected', () => {
-    logger?.info('Mongo connection reestablished')
-  })
-  connection.on('disconnected', () => {
-    if (
-      !ENVIRONMENTS_WITHOUT_RECONNECTION.includes(
-        process.env.NODE_ENV as string
-      )
-    ) {
-      logger?.info(
-        'Mongo connection disconnected. Trying to reconnected to Mongo...'
-      )
-      setTimeout(() => {
-        connect(process.env.DB_URI as string, {
-          ...connection,
-          connectTimeoutMS: 3000,
-          socketTimeoutMS: 3000
-        })
-      }, 3000)
-    }
-  })
-  connection.on('close', () => {
-    logger?.info('Mongo connection closed')
-  })
-  connection.on('error', (e: Error) => {
-    logger?.info('Mongo connection error:')
-    logger?.error(e)
-  })
-
-  return {
-    connect: () => connect(process.env.DB_URI as string, connectionConfig),
-    disconnect: () => connection.close()
-  }
-}
-
-export { dbConnection }
-`,
-        file: `${projectName}/src/database/mongo/connection.ts`
-      },
-      index: {
-        content: `export * from './models'
-export * from './queries'
-export * from './connection'
-`,
-        file: `${projectName}/src/database/mongo/index.ts`
-      },
-      models: {
-        index: {
-          content: "export * from './user'\n",
-          file: `${projectName}/src/database/mongo/models/index.ts`
-        },
-        user: {
-          content: `import { model, Schema } from 'mongoose'
-
-const UserSchema = new Schema<UserDBO>(
-  {
-    lastName: {
-      required: true,
-      type: String
-    },
-    name: {
-      required: true,
-      type: String
-    }
-  },
-  {
-    timestamps: true,
-    versionKey: false,
-    toObject: {
-      transform: (_, ret) => {
-        ret.id = ret._id.toString()
-        delete ret._id
-      }
-    }
-  }
-)
-
-const UserModel = model<UserDBO>('users', UserSchema)
-
-export { UserModel }
-`,
-          file: `${projectName}/src/database/mongo/models/user.ts`
-        }
-      },
-      queries: {
-        index: {
-          content: "export * from './user'\n",
-          file: `${projectName}/src/database/mongo/queries/index.ts`
-        },
-        user: {
-          content: `import { Document, MergeType, Types } from 'mongoose'
-
-import { UserModel } from '..'
-import { User, UserDTO, UserWithId } from 'schemas'
-
-const userDBOtoDTO = (
-  userDBO: Document<unknown, unknown, MergeType<UserDBO, UserDBO>> &
-    Omit<UserDBO, keyof UserDBO> &
-    UserDBO & {
-      _id: Types.ObjectId
-    }
-): UserDTO => ({
-  ...userDBO.toObject(),
-  createdAt: userDBO.createdAt.toISOString(),
-  updatedAt: userDBO.updatedAt.toISOString()
-})
-
-const store = async (userData: User): Promise<UserDTO> => {
-  const user = new UserModel(userData)
-
-  await user.save()
-
-  return userDBOtoDTO(user)
-}
-
-const remove = async (
-  id: string | null = null
-): 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<UserDTO[] | UserDTO | null> => {
-  if (id) {
-    const user = await UserModel.findById(id)
-
-    return user ? userDBOtoDTO(user) : null
-  }
-
-  const users = await UserModel.find({})
-
-  return users.map(u => userDBOtoDTO(u))
-}
-
-const update = async (userData: UserWithId): Promise<UserDTO | null> => {
-  const { id, ...rest } = userData
-  const user = await UserModel.findByIdAndUpdate(id, rest, { new: true })
-
-  return user ? userDBOtoDTO(user) : null
-}
-
-export { store, remove, get, update }
-`,
-          file: `${projectName}/src/database/mongo/queries/user.ts`
-        }
-      }
-    }
-  }
-
-  await Promise.all([
-    writeFile(database.index.file, database.index.content),
-    writeFile(
-      database.mongo.connection.file,
-      database.mongo.connection.content
-    ),
-    writeFile(database.mongo.index.file, database.mongo.index.content),
-    writeFile(
-      database.mongo.models.index.file,
-      database.mongo.models.index.content
-    ),
-    writeFile(
-      database.mongo.models.user.file,
-      database.mongo.models.user.content
-    ),
-    writeFile(
-      database.mongo.queries.index.file,
-      database.mongo.queries.index.content
-    ),
-    writeFile(
-      database.mongo.queries.user.file,
-      database.mongo.queries.user.content
-    )
-  ])
-}
-
-/**
- * @param {Object} args
- * @param {String} args.projectName
- * @param {import('../../../../').Config['database']} args.db
- */
-const sql = async ({ projectName, db }) => {
-  const createFoldersCommand = `mkdir ${projectName}/src/scripts \
-${projectName}/src/database ${projectName}/src/database/${db} \
-${projectName}/src/database/${db}/models ${projectName}/src/database/${db}/queries \
-${projectName}/src/database/migrations`
-
-  if (platform() === 'win32')
-    await exec(createFoldersCommand.replaceAll('/', '\\'))
-  else await exec(createFoldersCommand)
-
-  const database = {
-    index: {
-      content: `export * from './${db}'\n`,
-      file: `${projectName}/src/database/index.ts`
-    },
-    [db]: {
-      config: {
-        content: `require('dotenv').config()
-
-module.exports = {
-  development: {
-    url: process.env.DB_URI,
-    dialect: 'postgres'
-  },
-  production: {
-    url: process.env.DB_URI,
-    dialect: 'postgres'
-  }
-}
-`,
-        file: `${projectName}/src/database/${db}/config.js`
-      },
-      connection: {
-        content: `import { join } from 'path'
-import { Sequelize } from 'sequelize-typescript'
-import { HttpLogger } from 'express-pino-logger'
-
-import * as models from './models'
-
-let sequelize: Sequelize
-
-const dbConnection = async (
-  logger?: HttpLogger['logger']
-): Promise<{
-  connect: () => Promise<Sequelize>
-  disconnect: () => Promise<void>
-  createMigration: (migrationName: string) => Promise<void>
-}> => {
-  return {
-    connect: async () => {
-      if (!sequelize) {
-        sequelize = new Sequelize(process.env.DB_URI as string, {
-          models: Object.values(models)
-        })
-        logger?.info('Postgres connection established.')
-      }
-
-      return sequelize
-    },
-    disconnect: () => {
-      logger?.info('Postgres connection closed.')
-
-      return sequelize?.close()
-    },
-    createMigration: async (migrationName: string) => {
-      const { SequelizeTypescriptMigration } = await import(
-        'sequelize-typescript-migration-lts'
-      )
-
-      await SequelizeTypescriptMigration.makeMigration(sequelize, {
-        outDir: join(__dirname, './migrations'),
-        migrationName,
-        preview: false
-      })
-    }
-  }
-}
-
-export { dbConnection }
-`,
-        file: `${projectName}/src/database/${db}/connection.ts`
-      },
-      index: {
-        content: `export * from './connection'
-export * from './models'
-export * from './queries'
-`,
-        file: `${projectName}/src/database/${db}/index.ts`
-      },
-      models: {
-        index: {
-          content: "export * from './user'\n",
-          file: `${projectName}/src/database/${db}/models/index.ts`
-        },
-        user: {
-          content: `import { Model, Column, Table, DataType } from 'sequelize-typescript'
-
-@Table({
-  paranoid: true,
-  tableName: 'users'
-})
-class User extends Model {
-  @Column({
-    type: DataType.STRING
-  })
-  name!: string
-
-  @Column({
-    type: DataType.STRING
-  })
-  lastName!: string
-
-  @Column({
-    type: DataType.STRING
-  })
-  email!: string
-}
-
-export { User }
-`,
-          file: `${projectName}/src/database/${db}/models/user.ts`
-        }
-      },
-      queries: {
-        index: {
-          content: "export * from './user'\n",
-          file: `${projectName}/src/database/${db}/queries/index.ts`
-        },
-        user: {
-          content: `import { User } from '..'
-import { User as UserSchema, UserDTO, UserWithId } from 'schemas'
-import { Transaction } from 'sequelize/types'
-
-const userDBOtoDTO = (userDBO: User): UserDTO => ({
-  ...userDBO.get(),
-  createdAt: userDBO.createdAt.toISOString(),
-  updatedAt: userDBO.updatedAt.toISOString()
-})
-
-const store = async (
-  userData: UserSchema,
-  transaction: Transaction | null = null
-): Promise<UserDTO> => {
-  const user = await User.create(userData, {
-    transaction
-  })
-
-  return userDBOtoDTO(user)
-}
-
-const remove = async (
-  id: number | null = null,
-  transaction: Transaction | null = null
-): Promise<number | null> => {
-  if (id) {
-    const removedUser = await User.destroy({
-      where: { id },
-      transaction
-    })
-
-    return removedUser
-  }
-
-  const w = await User.destroy({ truncate: true, transaction })
-
-  return w
-}
-
-const get = async (
-  id: number | null = null
-): Promise<UserDTO[] | UserDTO | null> => {
-  if (id) {
-    const user = await User.findByPk(id)
-
-    return user ? userDBOtoDTO(user) : null
-  }
-
-  const { rows: users } = await User.findAndCountAll()
-
-  return users.map(u => userDBOtoDTO(u))
-}
-
-const update = async (userData: UserWithId): Promise<UserDTO | null> => {
-  const { id, ...rest } = userData
-  const [, user] = await User.update(rest, {
-    where: { id },
-    returning: true,
-    limit: 1
-  })
-
-  return user[0] ? userDBOtoDTO(user[0]) : null
-}
-
-export { store, remove, get, update }
-`,
-          file: `${projectName}/src/database/${db}/queries/user.ts`
-        }
-      }
-    },
-    scripts: {
-      migration: {
-        content: `import { dbConnection } from 'database'
-import { promisify } from 'util'
-
-const exec = promisify(require('child_process').exec)
-
-const migration = async () => {
-  const connection = await dbConnection()
-
-  await connection.connect()
-
-  console.log('Creating migration')
-
-  if (process.env.MIGRATION)
-    await connection.createMigration(process.env.MIGRATION)
-
-  console.log('Executing migration')
-
-  await exec(
-    'yarn migrations:run:last && eslint src/database/* --ext .js --fix'
-  )
-
-  console.log('Migration complete')
-}
-
-migration()
-`,
-        file: `${projectName}/src/scripts/migration.ts`
-      }
-    },
-    sequelizerc: {
-      content: `module.exports = {
-  config: './src/database/postgres/config.js',
-  'migrations-path': './src/database/postgres/migrations/'
-}
-`,
-      file: `${projectName}/.sequelizerc`
-    }
-  }
-
-  await Promise.all([
-    writeFile(database.index.file, database.index.content),
-    writeFile(database[db].config.file, database[db].config.content),
-    writeFile(database[db].connection.file, database[db].connection.content),
-    writeFile(database[db].index.file, database[db].index.content),
-    writeFile(
-      database[db].models.index.file,
-      database[db].models.index.content
-    ),
-    writeFile(database[db].models.user.file, database[db].models.user.content),
-    writeFile(
-      database[db].queries.index.file,
-      database[db].queries.index.content
-    ),
-    writeFile(
-      database[db].queries.user.file,
-      database[db].queries.user.content
-    ),
-    writeFile(
-      database.scripts.migration.file,
-      database.scripts.migration.content
-    ),
-    writeFile(database.sequelizerc.file, database.sequelizerc.content)
-  ])
-}
-
 /**
  * @param {Object} args
  * @param {String} args.projectName
@@ -603,9 +76,7 @@ const network = async ({ projectName, graphQL, dbIsSQL }) => {
   const createFoldersCommand = `mkdir ${projectName}/src/network \
 ${projectName}/src/network/routes ${projectName}/src/network/routes/utils ${
     graphQL
-      ? ` ${projectName}/src/graphQL ${projectName}/src/graphQL/models \
-${projectName}/src/graphQL/models/User ${projectName}/src/graphQL/models/utils \
-${projectName}/src/graphQL/models/utils/messages`
+      ? ` ${projectName}/src/network/models ${projectName}/src/network/resolvers`
       : ''
   }`
 
@@ -615,25 +86,27 @@ ${projectName}/src/graphQL/models/utils/messages`
 
   const network = {
     index: {
-      content: `export * from './routes'
-export * from './server'
-`,
+      content: `export * from './routes'\nexport * from './server'\n`,
       file: `${projectName}/src/network/index.ts`
     },
     response: {
-      content: `interface ResponseProps {
+      content: `import { type Response } from 'express'
+
+const response = ({
+  error,
+  message,
+  res,
+  status
+}: {
   error: boolean
   message: unknown
-  res: CustomResponse
+  res: Response
   status: number
-}
-
-const response = ({ error, message, res, status }: ResponseProps): void => {
+}) => {
   res.status(status).send({ error, message })
 }
 
-export { response }
-`,
+export { response }\n`,
       file: `${projectName}/src/network/response.ts`
     },
     router: {
@@ -683,54 +156,38 @@ export { applyRoutes }
     },
     server: {
       content: graphQL
-        ? `import { createServer, Server as HttpServer } from 'http'
+        ? `import { Server as HttpServer } from 'http'
 import express from 'express'
 import cors from 'cors'
-import pino, { HttpLogger } from 'express-pino-logger'
-import { ApolloServer } from 'apollo-server-express'
-import {
-  ApolloServerPluginDrainHttpServer,
-  ApolloServerPluginLandingPageDisabled,
-  ApolloServerPluginLandingPageGraphQLPlayground
-} from 'apollo-server-core'
+import debug from 'debug'
+import { ApolloServer } from '@apollo/server'
+// eslint-disable-next-line import/extensions
+import { expressMiddleware } from '@apollo/server/express4'
 
 import { dbConnection } from 'database'
-import { mergedSchema as schema } from 'graphQL'
 import { applyRoutes } from './router'
+import { buildSchemas } from './resolvers'
+import { Log } from 'utils'
 
+const d = debug('App:Network:Server')
 const PORT = (process.env.PORT as string) || 1996
-const ENVIRONMENTS_WITHOUT_PRETTY_PRINT = ['production', 'ci']
 
-class Server {
+class Server implements Log {
   #app: express.Application
-  #log: HttpLogger
-  #server: HttpServer
-  #connection: Awaited<ReturnType<typeof dbConnection>> | undefined
+  #server: HttpServer | undefined
+  #connection: Awaited<ReturnType<typeof dbConnection>>
+  #apolloServer: ApolloServer | undefined
 
   constructor() {
     this.#app = express()
-    this.#server = createServer(this.#app)
-    this.#log = pino({
-      transport: !ENVIRONMENTS_WITHOUT_PRETTY_PRINT.includes(
-        process.env.NODE_ENV as string
-      )
-        ? {
-            target: 'pino-pretty',
-            options: {
-              translateTime: 'HH:MM:ss Z',
-              ignore: 'pid,hostname'
-            }
-          }
-        : undefined
-    })
-    this.#config()
+    this.#connection = dbConnection(d)
   }
 
-  #config() {
+  async #config() {
+    await this.#apolloConfig()
     this.#app.use(cors())
     this.#app.use(express.json())
     this.#app.use(express.urlencoded({ extended: false }))
-    this.#app.use(this.#log)
     this.#app.use(
       (
         req: express.Request,
@@ -747,100 +204,98 @@ class Server {
         next()
       }
     )
+    applyRoutes(this.#app)
   }
 
-  async #dbConnection() {
-    this.#connection = await dbConnection(this.#log.logger)
-  }
-
-  public async start(): Promise<void> {
-    const server = new ApolloServer({
-      schema,
-      plugins: [
-        ApolloServerPluginDrainHttpServer({ httpServer: this.#server }),
-        process.env.NODE_ENV === 'production'
-          ? ApolloServerPluginLandingPageDisabled()
-          : ApolloServerPluginLandingPageGraphQLPlayground()
-      ],
-      context: (): Context => ({
-        log: this.#log.logger
-      })
+  async #apolloConfig() {
+    this.#apolloServer = new ApolloServer({
+      schema: await buildSchemas()
     })
+    await this.#apolloServer.start()
+    this.#app.use(
+      '/graphql',
+      cors(),
+      express.json(),
+      expressMiddleware(this.#apolloServer)
+    )
+  }
 
+  async start() {
     try {
-      await server.start()
-      server.applyMiddleware({
-        app: this.#app,
-        path: '/api'
-      })
-      applyRoutes(this.#app)
-      await this.#dbConnection()
+      await this.#config()
       await this.#connection?.connect()
-      this.#server.listen(PORT, () => {
-        this.#log.logger.info(\`Server listening at port: \${PORT}\`)
-        this.#log.logger.info(
-          \`GraphQL server listening at: http://localhost:\${PORT}\${server.graphqlPath}\`
-        )
+      this.#server = this.#app.listen(PORT, () => {
+        d(\`HTTP server listening on port \${PORT}.\`)
       })
     } catch (e) {
-      console.error(e)
+      this.log({
+        method: this.start.name,
+        value: 'error',
+        content: e
+      })
     }
   }
 
-  public async stop(): Promise<void> {
+  async stop() {
     try {
       await this.#connection?.disconnect()
       this.#server?.close()
+      await this.#apolloServer?.stop()
     } catch (e) {
-      this.#log.logger.error(e)
+      this.log({
+        method: this.stop.name,
+        value: 'error',
+        content: e
+      })
     }
   }
+
+  log({
+    method,
+    value,
+    content
+  }: {
+    method: string
+    value: string
+    content: unknown
+  }) {
+    d(
+      \`Server invoked -> \${
+        this.constructor.name
+      } ~ \${method} ~ value: \${value} ~ content: \${content}\`
+    )
+  }
 }
 
 const server = new Server()
 
-export { server as Server }
-`
+export { server as Server }\n`
         : `import { Server as HttpServer } from 'http'
 import express from 'express'
 import cors from 'cors'
-import pino, { HttpLogger } from 'express-pino-logger'
+import debug from 'debug'
 
 import { dbConnection } from 'database'
 import { applyRoutes } from './router'
+import { Log } from 'utils'
 
+const d = debug('App:Network:Server')
 const PORT = (process.env.PORT as string) || 1996
-const ENVIRONMENTS_WITHOUT_PRETTY_PRINT = ['production', 'ci']
 
-class Server {
+class Server implements Log {
   #app: express.Application
-  #log: HttpLogger
   #server: HttpServer | undefined
-  #connection: Awaited<ReturnType<typeof dbConnection>> | undefined
+  #connection: Awaited<ReturnType<typeof dbConnection>>
 
   constructor() {
     this.#app = express()
-    this.#log = pino({
-      transport: !ENVIRONMENTS_WITHOUT_PRETTY_PRINT.includes(
-        process.env.NODE_ENV as string
-      )
-        ? {
-            target: 'pino-pretty',
-            options: {
-              translateTime: 'HH:MM:ss Z',
-              ignore: 'pid,hostname'
-            }
-          }
-        : undefined
-    })
-    this.#config()
+    this.#connection = dbConnection(d)
   }
 
   #config() {
     this.#app.use(cors())
     this.#app.use(express.json())
     this.#app.use(express.urlencoded({ extended: false }))
-    this.#app.use(this.#log)
     this.#app.use(
       (
         req: express.Request,
@@ -860,36 +315,55 @@ class Server {
     applyRoutes(this.#app)
   }
 
-  async #dbConnection() {
-    this.#connection = await dbConnection(this.#log.logger)
-  }
-
-  public async start(): Promise<void> {
+  async start(): Promise<void> {
     try {
-      await this.#dbConnection()
+      this.#config()
       await this.#connection?.connect()
       this.#server = this.#app.listen(PORT, () => {
-        this.#log.logger.info(\`Server running at port \${PORT}\`)
+        d(\`HTTP server listening on port \${PORT}.\`)
       })
     } catch (e) {
-      this.#log.logger.error(e)
+      this.log({
+        method: this.start.name,
+        value: 'error',
+        content: e
+      })
     }
   }
 
-  public async stop(): Promise<void> {
+  async stop(): Promise<void> {
     try {
       await this.#connection?.disconnect()
       this.#server?.close()
     } catch (e) {
-      this.#log.logger.error(e)
+      this.log({
+        method: this.stop.name,
+        value: 'error',
+        content: e
+      })
     }
   }
+
+  log({
+    method,
+    value,
+    content
+  }: {
+    method: string
+    value: string
+    content: unknown
+  }) {
+    d(
+      \`Server invoked -> \${
+        this.constructor.name
+      } ~ \${method} ~ value: \${value} ~ content: \${JSON.stringify(content)}\`
+    )
+  }
 }
 
 const server = new Server()
 
-export { server as Server }
-`,
+export { server as Server }\n`,
       file: `${projectName}/src/network/server.ts`
     },
     routes: {
@@ -920,89 +394,54 @@ ${graphQL ? '' : "export * from './user'\n"}`,
       },
       ...(!graphQL && {
         user: {
-          content: `import { NextFunction, Router } from 'express'
+          content: `import { type NextFunction, type Request, type Response, Router } from 'express'
 
 import { response } from 'network/response'
 import { UserService } from 'services'
-import { idSchema, storeUserDto, UserWithId } from 'schemas'
+import { idSchema, storeUserDto, UserDTO } from 'schemas'
 import { validatorCompiler } from './utils'
 
 const User = Router()
 
-User.route('/users')
-  .post(
-    validatorCompiler(storeUserDto, 'body'),
+User.route('/users').post(
+  validatorCompiler(storeUserDto, 'body'),
+  async (
+    req: Request<Params, Record<string, unknown>, { args: UserDTO }>,
+    res: Response,
+    next: NextFunction
+  ): Promise<void> => {
+    try {
+      const {
+        body: {
+          args: { lastName, name }
+        }
+      } = req
+      const us = new UserService()
+      const user = await us.store({ lastName, name })
+
+      response({ error: false, message: user, res, status: 201 })
+    } catch (error) {
+      next(error)
+    }
+  }
+)
+
+User.route('/user/:id')
+  .get(
+    validatorCompiler(idSchema, 'params'),
     async (
-      req: CustomRequest,
-      res: CustomResponse,
+      req: Request<{ id: string }, Record<string, unknown>>,
+      res: Response,
       next: NextFunction
     ): Promise<void> => {
       try {
         const {
-          body: { args: user }
+          params: { id }
         } = req
-        const us = new UserService({ user })
-        const result = await us.process({ type: 'store' })
+        const us = new UserService()
+        const user = await us.getById(${dbIsSQL ? 'parseInt(id)' : 'id'})
 
-        response({ error: false, message: result, res, status: 201 })
-      } catch (error) {
-        next(error)
-      }
-    }
-  )
-  .get(
-    async (
-      req: CustomRequest,
-      res: CustomResponse,
-      next: NextFunction
-    ): Promise<void> => {
-      try {
-        const us = new UserService()
-        const result = await us.process({ type: 'getAll' })
-
-        response({ error: false, message: result, res, status: 200 })
-      } catch (error) {
-        next(error)
-      }
-    }
-  )
-  .delete(
-    async (
-      req: CustomRequest,
-      res: CustomResponse,
-      next: NextFunction
-    ): Promise<void> => {
-      try {
-        const us = new UserService()
-        const result = await us.process({ type: 'deleteAll' })
-
-        response({ error: false, message: result, res, status: 200 })
-      } catch (error) {
-        next(error)
-      }
-    }
-  )
-
-User.route('/user/:id')
-  .get(
-    validatorCompiler(idSchema, 'params'),
-    async (
-      req: CustomRequest,
-      res: CustomResponse,
-      next: NextFunction
-    ): Promise<void> => {
-      try {
-        const {
-          params: { id }
-        } = req
-        ${
-          dbIsSQL
-            ? 'const us = new UserService({ id: parseInt(id) })'
-            : 'const us = new UserService({ id })'
-        }
-        const result = await us.process({ type: 'getOne' })
-
-        response({ error: false, message: result, res, status: 200 })
+        response({ error: false, message: user, res, status: 200 })
       } catch (error) {
         next(error)
       }
@@ -1012,23 +451,23 @@ User.route('/user/:id')
     validatorCompiler(idSchema, 'params'),
     validatorCompiler(storeUserDto, 'body'),
     async (
-      req: CustomRequest,
-      res: CustomResponse,
+      req: Request<{ id: string }, Record<string, unknown>, { args: UserDTO }>,
+      res: Response,
       next: NextFunction
     ): Promise<void> => {
       try {
         const {
-          body: { args },
+          body: {
+            args: { name, lastName }
+          },
           params: { id }
         } = req
-        const userWithId = {
-          id,
-          ...args
-        } as UserWithId
-        const us = new UserService({ userWithId })
-        const result = await us.process({ type: 'update' })
+        const us = new UserService()
+        const user = await us.update(${
+          dbIsSQL ? 'parseInt(id)' : 'id'
+        }, { name, lastName })
 
-        response({ error: false, message: result, res, status: 200 })
+        response({ error: false, message: user, res, status: 200 })
       } catch (error) {
         next(error)
       }
@@ -1037,20 +476,16 @@ User.route('/user/:id')
   .delete(
     validatorCompiler(idSchema, 'params'),
     async (
-      req: CustomRequest,
-      res: CustomResponse,
+      req: Request<{ id: string }>,
+      res: Response,
       next: NextFunction
     ): Promise<void> => {
       try {
         const {
           params: { id }
         } = req
-        ${
-          dbIsSQL
-            ? 'const us = new UserService({ id: parseInt(id) })'
-            : 'const us = new UserService({ id })'
-        }
-        const result = await us.process({ type: 'delete' })
+        const us = new UserService()
+        const result = await us.deleteById(${dbIsSQL ? 'parseInt(id)' : 'id'})
 
         response({ error: false, message: result, res, status: 200 })
       } catch (error) {
@@ -1059,516 +494,132 @@ User.route('/user/:id')
     }
   )
 
-export { User }
-`,
+export { User }\n`,
           file: `${projectName}/src/network/routes/user.ts`
         }
       }),
       utils: {
         index: {
-          content: `import { NextFunction } from 'express'
+          content: `import { type NextFunction, type Request, type Response } 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
-})
+import { ZodType } from 'zod'
 
-type Middleware = (
-  req: CustomRequest,
-  res: CustomResponse,
-  next: NextFunction
-) => void
+type Middleware = (req: Request, res: Response, next: NextFunction) => void
 
-const validatorCompiler = <T extends TProperties>(
-  schema: TObject<T>,
+const validatorCompiler = (
+  schema: ZodType,
   value: 'body' | 'params'
 ): Middleware => {
-  return (req: CustomRequest, res: CustomResponse, next: NextFunction) => {
-    const validate = ajv.compile(schema)
-    const ok = validate(req[value])
+  return (req: Request, res: Response, next: NextFunction) => {
+    const result = schema.safeParse(req[value])
 
-    if (!ok && validate.errors) {
-      const [error] = validate.errors
-      const errorMessage = \`\${error.dataPath.replace('.', '')} \${error.message}\`
+    if (result.success) return next()
 
-      return next(new httpErrors.UnprocessableEntity(errorMessage))
-    }
-
-    next()
+    return next(
+      new httpErrors.UnprocessableEntity(JSON.stringify(result.error))
+    )
   }
 }
 
-export { validatorCompiler }
-`,
+export { validatorCompiler }\n`,
           file: `${projectName}/src/network/routes/utils/index.ts`
         }
       }
     },
     ...(graphQL && {
-      graphQL: {
+      models: {
         index: {
-          content: "export * from './models'\n",
-          file: `${projectName}/src/graphQL/index.ts`
+          content: "export * from './User'\n",
+          file: `${projectName}/src/network/models/index.ts`
         },
-        models: {
-          User: {
-            index: {
-              content: `import { makeExecutableSchema } from '@graphql-tools/schema'
-
-import { User as UserTD } from './typeDefs'
-import { Query } from './queriesResolver'
-import { Mutation } from './mutationsResolver'
-
-const resolvers = {
-  Query,
-  Mutation
-}
-
-const User = makeExecutableSchema({
-  typeDefs: UserTD,
-  resolvers
-})
-
-export { User }
-`,
-              file: `${projectName}/src/graphQL/models/User/index.ts`
-            },
-            mutations: {
-              content: `import { ApolloError } from 'apollo-server-core'
-
-import { store, remove, update } from 'database'
-import { User, UserDTO, UserWithId } from 'schemas'
-import { EFU, MFU, GE, errorHandling } from '../utils'
-
-const storeUser = async (
-  { user }: { user: User },
-  { log }: Context
-): Promise<UserDTO> => {
-  try {
-    const result = await store(user)
-
-    return result
-  } catch (e) {
-    return errorHandling({
-      e,
-      message: GE.INTERNAL_SERVER_ERROR,
-      code: 'INTERNAL_SERVER_ERROR',
-      log
-    })
-  }
-}
+        User: {
+          content: `import 'reflect-metadata'
+import { Field, ${dbIsSQL ? 'Int' : 'ID'}, ObjectType } from 'type-graphql'
 
-const deleteAllUsers = async ({ log }: Context): Promise<string> => {
-  try {
-    const usersDeleted = (await remove()) as number
+@ObjectType()
+class User {
+  @Field(() => ${dbIsSQL ? 'Int' : 'ID'})
+  id!: number
 
-    if (usersDeleted >= 1) return MFU.ALL_USERS_DELETED
+  @Field()
+  lastName!: string
 
-    if (usersDeleted === 0)
-      throw new ApolloError(EFU.NOTHING_TO_DELETE, 'NOTHING_TO_DELETE')
+  @Field()
+  name!: string
 
-    throw new ApolloError(GE.INTERNAL_SERVER_ERROR, 'INTERNAL_SERVER_ERROR')
-  } catch (e) {
-    return errorHandling({
-      e,
-      message: GE.INTERNAL_SERVER_ERROR,
-      code: 'INTERNAL_SERVER_ERROR',
-      log
-    })
-  }
-}
+  @Field({ nullable: true })
+  createdAt?: string
 
-const updateUser = async (
-  { user }: { user: UserWithId },
-  { log }: Context
-): Promise<UserDTO> => {
-  try {
-    const updatedUser = await update(user)
-
-    if (!updatedUser) throw new ApolloError(EFU.NOT_FOUND, 'NOT_FOUND')
-
-    return updatedUser
-  } catch (e) {
-    return errorHandling({
-      e,
-      message: GE.INTERNAL_SERVER_ERROR,
-      code: 'INTERNAL_SERVER_ERROR',
-      log
-    })
-  }
+  @Field({ nullable: true })
+  updatedAt?: string
 }
 
-const deleteUser = async (
-  { id }: { id: ${dbIsSQL ? 'number' : 'string'} },
-  { log }: Context
-): Promise<string> => {
-  try {
-    const deletedUser = await remove(id)
-
-    if (!deletedUser) throw new ApolloError(EFU.NOT_FOUND, 'NOT_FOUND')
-
-    return MFU.USER_DELETED
-  } catch (e) {
-    return errorHandling({
-      e,
-      message: GE.INTERNAL_SERVER_ERROR,
-      code: 'INTERNAL_SERVER_ERROR',
-      log
-    })
-  }
-}
-
-export { storeUser, deleteAllUsers, updateUser, deleteUser }
-`,
-              file: `${projectName}/src/graphQL/models/User/mutations.ts`
-            },
-            mutationsResolver: {
-              content: `import { DefinedError } from 'ajv'
-import { ApolloError } from 'apollo-server-core'
-
-import {
-  ajv,
-  idSchema,
-  User,
-  user as storeUserSchema,
-  UserDTO,
-  UserWithId,
-  userWithId as updateUserSchema
-} from 'schemas'
-import { storeUser, updateUser, deleteUser, deleteAllUsers } from './mutations'
-import { errorHandling, GE } from '../utils'
-
-const Mutation = {
-  storeUser: async (
-    parent: unknown,
-    { user }: { user: User },
-    context: Context
-  ): Promise<UserDTO> => {
-    const { log } = context
-    const validate = ajv.compile(storeUserSchema)
-
-    try {
-      const ok = validate(user)
-
-      if (!ok)
-        throw new ApolloError(
-          \`\${(validate.errors as DefinedError[])[0].instancePath.replace(
-            '/',
-            ''
-          )} \${(validate.errors as DefinedError[])[0].message as string}\`,
-          'UNPROCESSABLE_ENTITY'
-        )
-
-      return await storeUser({ user }, context)
-    } catch (e) {
-      log.error(validate.errors)
-
-      return errorHandling({
-        e,
-        message: GE.INTERNAL_SERVER_ERROR,
-        code: 'INTERNAL_SERVER_ERROR',
-        log
-      })
-    }
-  },
-  updateUser: async (
-    parent: unknown,
-    { user }: { user: UserWithId },
-    context: Context
-  ): Promise<UserDTO> => {
-    const validate = ajv.compile(updateUserSchema)
-    const { log } = context
-
-    try {
-      const ok = validate(user)
-
-      if (!ok)
-        throw new ApolloError(
-          \`\${(validate.errors as DefinedError[])[0].instancePath.replace(
-            '/',
-            ''
-          )} \${(validate.errors as DefinedError[])[0].message as string}\`,
-          'UNPROCESSABLE_ENTITY'
-        )
-
-      return await updateUser({ user }, context)
-    } catch (e) {
-      log.error(validate.errors)
-
-      return errorHandling({
-        e,
-        message: GE.INTERNAL_SERVER_ERROR,
-        code: 'INTERNAL_SERVER_ERROR',
-        log
-      })
-    }
-  },
-  deleteUser: async (
-    parent: unknown,
-    { id }: { id: ${dbIsSQL ? 'number' : 'string'} },
-    context: Context
-  ): Promise<string> => {
-    const validate = ajv.compile(idSchema)
-    const { log } = context
-
-    try {
-      const ok = validate({ id })
-
-      if (!ok)
-        throw new ApolloError(
-          \`\${(validate.errors as DefinedError[])[0].instancePath.replace(
-            '/',
-            ''
-          )} \${(validate.errors as DefinedError[])[0].message as string}\`,
-          'UNPROCESSABLE_ENTITY'
-        )
-
-      return await deleteUser({ id }, context)
-    } catch (e) {
-      log.error(validate.errors)
-
-      return errorHandling({
-        e,
-        message: GE.INTERNAL_SERVER_ERROR,
-        code: 'INTERNAL_SERVER_ERROR',
-        log
-      })
-    }
-  },
-  deleteAllUsers: async (
-    parent: unknown,
-    args: unknown,
-    context: Context
-  ): Promise<string> => {
-    const { log } = context
-    try {
-      return await deleteAllUsers(context)
-    } catch (e) {
-      return errorHandling({
-        e,
-        message: GE.INTERNAL_SERVER_ERROR,
-        code: 'INTERNAL_SERVER_ERROR',
-        log
-      })
-    }
-  }
-}
+export { User }\n`,
+          file: `${projectName}/src/network/models/User.ts`
+        }
+      },
+      resolvers: {
+        index: {
+          content: `import { buildSchema } from 'type-graphql'
+import { UserResolver } from './User'
 
-export { Mutation }
-`,
-              file: `${projectName}/src/graphQL/models/User/mutationsResolver.ts`
-            },
-            queries: {
-              content: `import { ApolloError } from 'apollo-server-core'
-
-import { get } from 'database'
-import { UserDTO } from 'schemas'
-import { EFU, GE, errorHandling } from '../utils'
-
-const getUsers = async (
-  parent: unknown,
-  args: unknown,
-  { log }: Context
-): Promise<UserDTO[]> => {
-  try {
-    const users = (await get()) as UserDTO[]
-
-    return users
-  } catch (e) {
-    return errorHandling({
-      e,
-      message: GE.INTERNAL_SERVER_ERROR,
-      code: 'INTERNAL_SERVER_ERROR',
-      log
-    })
-  }
-}
+const buildSchemas = async () => {
+  const schema = await buildSchema({
+    resolvers: [UserResolver],
+    validate: { forbidUnknownValues: false }
+  })
 
-const getUser = async (
-  { id }: { id: ${dbIsSQL ? 'number' : 'string'} },
-  { log }: Context
-): Promise<UserDTO> => {
-  try {
-    const user = (await get(id${dbIsSQL ? '' : ' as string'})) as UserDTO | null
-
-    if (!user) throw new ApolloError(EFU.NOT_FOUND, 'NOT_FOUND')
-
-    return user
-  } catch (e) {
-    return errorHandling({
-      e,
-      message: GE.INTERNAL_SERVER_ERROR,
-      code: 'INTERNAL_SERVER_ERROR',
-      log
-    })
-  }
+  return schema
 }
 
-export { getUsers, getUser }
-`,
-              file: `${projectName}/src/graphQL/models/User/queries.ts`
-            },
-            queriesResolver: {
-              content: `import { DefinedError } from 'ajv'
-import { ApolloError } from 'apollo-server-core'
-
-import { ajv, idSchema, UserDTO } from 'schemas'
-import { getUser, getUsers } from './queries'
-import { errorHandling, GE } from '../utils'
-
-const Query = {
-  getUser: async (
-    parent: unknown,
-    { id }: { id: ${dbIsSQL ? 'number' : 'string'} },
-    context: Context
-  ): Promise<UserDTO> => {
-    const { log } = context
-    const validate = ajv.compile(idSchema)
-
-    try {
-      const ok = validate({ id })
+export { buildSchemas }\n`,
+          file: `${projectName}/src/network/resolvers/index.ts`
+        },
+        User: {
+          content: `import 'reflect-metadata'
+import { Arg, Field, InputType, Mutation, Query, Resolver } from 'type-graphql'
 
-      if (!ok)
-        throw new ApolloError(
-          \`id \${(validate.errors as DefinedError[])[0].message as string}\`,
-          'UNPROCESSABLE_ENTITY'
-        )
+import { User } from 'network/models'
+import { UserService } from 'services'
 
-      return await getUser({ id }, context)
-    } catch (e) {
-      log.error(validate.errors)
+@InputType()
+class UserInput {
+  @Field()
+  name!: string
 
-      return errorHandling({
-        e,
-        message: GE.INTERNAL_SERVER_ERROR,
-        code: 'INTERNAL_SERVER_ERROR',
-        log
-      })
-    }
-  },
-  getUsers
+  @Field()
+  lastName!: string
 }
 
-export { Query }
-`,
-              file: `${projectName}/src/graphQL/models/User/queriesResolver.ts`
-            },
-            typeDefs: {
-              content: `import { gql } from 'apollo-server-core'
-
-const User = gql\`
-  type User {
-    id: ${dbIsSQL ? 'Int' : 'ID'}!
-    name: String!
-    lastName: String!
-    createdAt: String!
-    updatedAt: String!
-  }
+@Resolver(User)
+class UserResolver {
+  readonly #userService = new UserService()
 
-  type Query {
-    getUsers: [User!]!
-    getUser(id: ${dbIsSQL ? 'Int' : 'ID'}!): User!
+  @Query(() => User)
+  async getById(@Arg('id') id: ${dbIsSQL ? 'number' : 'string'}) {
+    return this.#userService.getById(id)
   }
 
-  input StoreUserInput {
-    lastName: String!
-    name: String!
+  @Mutation(() => User)
+  async store(@Arg('user') user: UserInput) {
+    return this.#userService.store(user)
   }
 
-  input UpdateUserInput {
-    id: ${dbIsSQL ? 'Int' : 'String'}!
-    lastName: String!
-    name: String!
+  @Mutation(() => User)
+  async update(@Arg('id') id: ${
+    dbIsSQL ? 'number' : 'string'
+  }, @Arg('user') user: UserInput) {
+    return this.#userService.update(id, user)
   }
 
-  type Mutation {
-    storeUser(user: StoreUserInput!): User!
-    deleteAllUsers: String
-    updateUser(user: UpdateUserInput!): User!
-    deleteUser(id: ${dbIsSQL ? 'Int' : 'ID'}!): String
+  @Mutation(() => String)
+  async deleteById(@Arg('id') id: ${dbIsSQL ? 'number' : 'string'}) {
+    return this.#userService.deleteById(id)
   }
-\`
-
-export { User }
-`,
-              file: `${projectName}/src/graphQL/models/User/typeDefs.ts`
-            }
-          },
-          utils: {
-            messages: {
-              index: {
-                content: `enum GenericErrors {
-  INTERNAL_SERVER_ERROR = 'Something went wrong'
-}
-
-export { GenericErrors as GE }
-export * from './user'
-`,
-                file: `${projectName}/src/graphQL/models/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/graphQL/models/utils/messages/user.ts`
-              }
-            },
-            index: {
-              content: `import { ApolloError } from 'apollo-server-core'
-import { HttpLogger } from 'express-pino-logger'
-
-const errorHandling = ({
-  e,
-  message,
-  code,
-  log
-}: {
-  // eslint-disable-next-line @typescript-eslint/no-explicit-any
-  e: any
-  message: string
-  code: string
-  log: HttpLogger['logger']
-}): never => {
-  log.error(e)
-
-  if (e instanceof ApolloError) throw e
-
-  throw new ApolloError(message ?? e.message, code)
 }
 
-export { errorHandling }
-export * from './messages'
-`,
-              file: `${projectName}/src/graphQL/models/utils/index.ts`
-            }
-          },
-          index: {
-            content: `import { mergeSchemas } from '@graphql-tools/schema'
-
-import { User } from './User'
-
-const mergedSchema = mergeSchemas({
-  schemas: [User]
-})
-
-export { mergedSchema }
-`,
-            file: `${projectName}/src/graphQL/models/index.ts`
-          }
+export { UserResolver }\n`,
+          file: `${projectName}/src/network/resolvers/User.ts`
         }
       }
     })
@@ -1588,47 +639,10 @@ export { mergedSchema }
 
   if (graphQL)
     processes.concat([
-      writeFile(network.graphQL?.index.file, network.graphQL?.index.content),
-      writeFile(
-        network.graphQL?.models.User.index.file,
-        network.graphQL?.models.User.index.content
-      ),
-      writeFile(
-        network.graphQL?.models.User.mutations.file,
-        network.graphQL?.models.User.mutations.content
-      ),
-      writeFile(
-        network.graphQL?.models.User.mutationsResolver.file,
-        network.graphQL?.models.User.mutationsResolver.content
-      ),
-      writeFile(
-        network.graphQL?.models.User.queries.file,
-        network.graphQL?.models.User.queries.content
-      ),
-      writeFile(
-        network.graphQL?.models.User.queriesResolver.file,
-        network.graphQL?.models.User.queriesResolver.content
-      ),
-      writeFile(
-        network.graphQL?.models.User.typeDefs.file,
-        network.graphQL?.models.User.typeDefs.content
-      ),
-      writeFile(
-        network.graphQL?.models.utils.messages.index.file,
-        network.graphQL?.models.utils.messages.index.content
-      ),
-      writeFile(
-        network.graphQL?.models.utils.messages.user.file,
-        network.graphQL?.models.utils.messages.user.content
-      ),
-      writeFile(
-        network.graphQL?.models.utils.index.file,
-        network.graphQL?.models.utils.index.content
-      ),
-      writeFile(
-        network.graphQL?.models.index.file,
-        network.graphQL?.models.index.content
-      )
+      writeFile(network.models.index.file, network.models.index.content),
+      writeFile(network.models.User.file, network.models.User.content),
+      writeFile(network.resolvers.index.file, network.resolvers.index.content),
+      writeFile(network.resolvers.User.file, network.resolvers.User.content)
     ])
   else
     processes.push(
@@ -1641,349 +655,33 @@ export { mergedSchema }
 /**
  * @param {Object} args
  * @param {String} args.projectName
- * @param {Boolean} args.dbIsSQL
- * @param {Boolean} args.graphQL
- */
-const schemas = async ({ projectName, dbIsSQL, graphQL }) => {
-  const createFoldersCommand = `mkdir ${projectName}/src/schemas`
-
-  if (platform() === 'win32')
-    await exec(createFoldersCommand.replaceAll('/', '\\'))
-  else await exec(createFoldersCommand)
-
-  const schemas = {
-    index: {
-      content: graphQL
-        ? `import { Static, Type } from '@sinclair/typebox'
-import Ajv from 'ajv/dist/2019.js'
-import addFormats from 'ajv-formats'
-
-const id = ${
-            dbIsSQL
-              ? `Type.Number()`
-              : `Type.String({ pattern: '^[a-zA-Z0-9]{24,}$' })`
-          }
-type ID = Static<typeof id>
-
-const idSchema = Type.Object({ id })
-
-type IDSchema = Static<typeof idSchema>
-
-const ajv = addFormats(new Ajv(), ['email'])
-  .addKeyword('kind')
-  .addKeyword('modifier')
-
-export { id, ID, idSchema, IDSchema, ajv }
-export * from './user'
-`
-        : `import { Static, Type } from '@sinclair/typebox'
-
-const id = ${
-            dbIsSQL
-              ? `Type.Number()`
-              : `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 userWithId = Type.Intersect([user, Type.Object({ id })])
-
-type UserWithId = Static<typeof userWithId>
-
-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 storeUserDto = Type.Object({
-  args: user
-})
-
-type StoreUserDTO = Static<typeof storeUserDto>
-
-export {
-  userDto,
-  UserDTO,
-  userWithId,
-  UserWithId,
-  user,
-  User,
-  storeUserDto,
-  StoreUserDTO
-}
-`,
-      file: `${projectName}/src/schemas/user.ts`
-    }
-  }
-
-  await Promise.all([
-    writeFile(schemas.index.file, schemas.index.content),
-    writeFile(schemas.user.file, schemas.user.content)
-  ])
-}
-
-/**
- * @param {Object} args
- * @param {String} args.projectName
- * @param {Boolean} args.dbIsSQL
- */
-const services = async ({ projectName, dbIsSQL }) => {
-  const createFoldersCommand = `mkdir ${projectName}/src/services \
-${projectName}/src/services/utils \
-${projectName}/src/services/utils/messages`
-
-  if (platform() === 'win32')
-    await exec(createFoldersCommand.replaceAll('/', '\\'))
-  else await exec(createFoldersCommand)
-
-  const 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 { User, UserDTO, UserWithId } from 'schemas'
-import { EFU, MFU, GE, errorHandling } from './utils'
-
-type Process = {
-  type: 'store' | 'getAll' | 'deleteAll' | 'getOne' | 'update' | 'delete'
-}
-
-type Arguments = {
-  id?: ${dbIsSQL ? 'number' : 'string'}
-  user?: User
-  userWithId?: UserWithId
-}
-
-class UserService {
-  #args: Arguments
-
-  constructor(args: Arguments = {}) {
-    this.#args = args
-  }
-
-  public process({ type }: Process): Promise<string | UserDTO | UserDTO[]> {
-    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)
-    }
-  }
-
-  async #store(): Promise<UserDTO> {
-    try {
-      if (!this.#args.user)
-        throw new httpErrors.UnprocessableEntity(GE.INTERNAL_SERVER_ERROR)
-
-      const result = await store(this.#args.user)
-
-      return result
-    } catch (e) {
-      return errorHandling(e, GE.INTERNAL_SERVER_ERROR)
-    }
-  }
-
-  async #getAll(): Promise<UserDTO[]> {
-    try {
-      const users = (await get()) as UserDTO[]
-
-      return users
-    } catch (e) {
-      return errorHandling(e, GE.INTERNAL_SERVER_ERROR)
-    }
-  }
-
-  async #deleteAll(): Promise<string> {
-    try {
-      const usersDeleted = (await remove()) as number
-
-      ${
-        dbIsSQL
-          ? 'if (usersDeleted !== 0) return MFU.ALL_USERS_DELETED'
-          : `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)
-    }
-  }
-
-  async #getOne(): Promise<UserDTO> {
-    try {
-      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)
-
-      return user
-    } catch (e) {
-      return errorHandling(e, GE.INTERNAL_SERVER_ERROR)
-    }
-  }
-
-  async #update(): Promise<UserDTO> {
-    try {
-      if (!this.#args.userWithId || !this.#args.userWithId.id)
-        throw new httpErrors.UnprocessableEntity(GE.INTERNAL_SERVER_ERROR)
-
-      const updatedUser = await update(this.#args.userWithId)
-
-      if (!updatedUser) throw new httpErrors.NotFound(EFU.NOT_FOUND)
-
-      return updatedUser
-    } catch (e) {
-      return errorHandling(e, GE.INTERNAL_SERVER_ERROR)
-    }
-  }
-
-  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)
-
-      return MFU.USER_DELETED
-    } catch (e) {
-      return errorHandling(e, GE.INTERNAL_SERVER_ERROR)
-    }
-  }
-}
-
-export { UserService }
-`,
-      file: `${projectName}/src/services/user.ts`
-    },
-    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`
-      }
-    },
-    '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`
-      }
-    }
-  }
-
-  await Promise.all([
-    writeFile(services.index.file, services.index.content),
-    writeFile(services.user.file, services.user.content),
-    writeFile(services.utils.index.file, services.utils.index.content),
-    writeFile(
-      services['utils/messages'].index.file,
-      services['utils/messages'].index.content
-    ),
-    writeFile(
-      services['utils/messages'].user.file,
-      services['utils/messages'].user.content
-    )
-  ])
-}
-
-/**
- * @param {Object} args
- * @param {String} args.projectName
+ * @param {String} args.email
+ * @param {String} args.projectVersion
  * @param {Boolean} args.graphQL
  * @param {import('../../../../').Config['database']} args.database
  */
-const main = async ({ projectName, graphQL, database }) => {
+const main = async ({
+  projectName,
+  email,
+  projectVersion,
+  graphQL,
+  database
+}) => {
   const dbIsSQL = database !== 'mongo'
 
+  await utils({
+    fastify: false,
+    projectName,
+    email,
+    projectVersion,
+    graphQL,
+    dbIsSQL
+  })
   await types({ projectName, graphQL, dbIsSQL })
   await network({ projectName, graphQL, dbIsSQL })
   await schemas({ projectName, dbIsSQL, graphQL })
-
-  if (!graphQL) await services({ projectName, dbIsSQL })
-
-  if (dbIsSQL) await sql({ projectName, db: database })
-  else await mongo({ projectName })
+  await services({ projectName, dbIsSQL })
+  await db({ projectName, database })
 }
 
 module.exports = main