@anthonylzq/simba.js 4.4.0 → 5.0.0

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

@@ -75,25 +75,33 @@ export { applyRoutes }
     server: {
       content: `import express from 'express'
 import mongoose from 'mongoose'
-import morgan from 'morgan'
 import cors from 'cors'
+import pino, { HttpLogger } from 'express-pino-logger'
 
 import { applyRoutes } from './router'
 
-const PORT = (process.env.PORT as string) || '1996'
+const PORT = (process.env.PORT as string) || 1996
 
 class Server {
   #app: express.Application
   #connection: mongoose.Connection | undefined
+  #log: HttpLogger
 
   constructor() {
     this.#app = express()
+    this.#log = pino({
+      transport: {
+        target: 'pino-pretty',
+        options: {
+          colorize: true
+        }
+      }
+    })
     this.#config()
   }
 
   #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(
@@ -108,10 +116,10 @@ class Server {
           'Access-Control-Allow-Headers',
           'Authorization, Content-Type'
         )
+        res.header('x-powered-by', 'Simba.js')
         next()
       }
     )
-
     applyRoutes(this.#app)
   }
 
@@ -123,14 +131,14 @@ class Server {
       useUnifiedTopology: true
     }
     this.#connection.on('connected', () => {
-      console.log('Mongo connection established.')
+      this.#log.logger.info('Mongo connection established.')
     })
     this.#connection.on('reconnected', () => {
-      console.log('Mongo connection reestablished')
+      this.#log.logger.info('Mongo connection reestablished')
     })
     this.#connection.on('disconnected', () => {
-      console.log('Mongo connection disconnected')
-      console.log('Trying to reconnected to Mongo...')
+      this.#log.logger.info('Mongo connection disconnected')
+      this.#log.logger.info('Trying to reconnected to Mongo...')
       setTimeout(() => {
         mongoose.connect(process.env.MONGO_URI as string, {
           ...connection,
@@ -140,24 +148,24 @@ class Server {
       }, 3000)
     })
     this.#connection.on('close', () => {
-      console.log('Mongo connection closed')
+      this.#log.logger.info('Mongo connection closed')
     })
     this.#connection.on('error', (e: Error) => {
-      console.log('Mongo connection error:')
-      console.error(e)
+      this.#log.logger.info('Mongo connection error:')
+      this.#log.logger.error(e)
     })
     await mongoose.connect(process.env.MONGO_URI as string, connection)
   }
 
   public start(): void {
     this.#app.listen(PORT, () => {
-      console.log(\`Server running at port \${PORT}\`)
+      this.#log.logger.info(\`Server running at port \${PORT}\`)
     })
 
     try {
       this.#mongo()
     } catch (e) {
-      console.error(e)
+      this.#log.logger.error(e)
     }
   }
 }
@@ -378,45 +386,524 @@ export { validatorCompiler }
     }
   }
 
-  await writeFile(network.response.file, network.response.content)
-  await writeFile(network.router.file, network.router.content)
-  await writeFile(network.server.file, network.server.content)
-  await writeFile(network.routes.home.file, network.routes.home.content)
-  await writeFile(network.routes.index.file, network.routes.index.content)
-  await writeFile(network.routes.user.file, network.routes.user.content)
-  await writeFile(
-    network.routes.utils.index.file,
-    network.routes.utils.index.content
-  )
+  await Promise.all([
+    writeFile(network.response.file, network.response.content),
+    writeFile(network.router.file, network.router.content),
+    writeFile(network.server.file, network.server.content),
+    writeFile(network.routes.home.file, network.routes.home.content),
+    writeFile(network.routes.index.file, network.routes.index.content),
+    writeFile(network.routes.user.file, network.routes.user.content),
+    writeFile(
+      network.routes.utils.index.file,
+      network.routes.utils.index.content
+    )
+  ])
 }
 
 /**
  * @param {Object} args
  * @param {String} args.projectName
  */
-const fastifyRestNetwork = async ({ projectName }) => {
-  const createFoldersCommand = `mkdir ${projectName}/src/network/utils`
+const expressGraphQLNetwork = async ({ projectName }) => {
+  const createFoldersCommand = `mkdir ${projectName}/src/network/routes/utils \
+${projectName}/src/graphQL/models \
+${projectName}/src/graphQL/models/User \
+${projectName}/src/graphQL/models/utils \
+${projectName}/src/graphQL/models/utils/messages`
 
   if (platform() === 'win32')
     await exec(createFoldersCommand.replaceAll('/', '\\'))
   else await exec(createFoldersCommand)
 
-  const network = {
-    response: {
-      content: `import { FastifyReply } from 'fastify'
+  const graphQL = {
+    index: {
+      content: "export * from './models'\n",
+      file: `${projectName}/src/graphQL/index.ts`
+    },
+    models: {
+      User: {
+        index: {
+          content: `import { makeExecutableSchema } from '@graphql-tools/schema'
 
-const response = ({
-  error,
+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 { UserDTO } from 'schemas'
+import { EFU, MFU, GE, errorHandling } from '../utils'
+
+const storeUser = async (
+  { user }: { user: UserDTO },
+  { 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
+    })
+  }
+}
+
+const deleteAllUsers = async ({ log }: Context): Promise<string> => {
+  try {
+    const usersDeleted = (await remove()) as number
+
+    if (usersDeleted >= 1) return MFU.ALL_USERS_DELETED
+
+    if (usersDeleted === 0)
+      throw new ApolloError(EFU.NOTHING_TO_DELETE, 'NOTHING_TO_DELETE')
+
+    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
+    })
+  }
+}
+
+const updateUser = async (
+  { user }: { user: UserDTO },
+  { 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
+    })
+  }
+}
+
+const deleteUser = async (
+  { id }: { id: 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, UserDTO } from 'schemas'
+import { storeUserSchema, updateUserSchema } from './schemas'
+import { storeUser, updateUser, deleteUser, deleteAllUsers } from './mutations'
+import { errorHandling, GE } from '../utils'
+
+const Mutation = {
+  storeUser: async (
+    parent: unknown,
+    { user }: { user: UserDTO },
+    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: UserDTO },
+    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: 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 { 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 getUser = async (
+  { id }: { id: string },
+  { log }: Context
+): Promise<UserDTO> => {
+  try {
+    const user = (await get(id 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
+    })
+  }
+}
+
+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: string },
+    context: Context
+  ): Promise<UserDTO> => {
+    const { log } = context
+    const validate = ajv.compile(idSchema)
+
+    try {
+      const ok = validate({ id })
+
+      if (!ok)
+        throw new ApolloError(
+          \`id \${(validate.errors as DefinedError[])[0].message as string}\`,
+          'UNPROCESSABLE_ENTITY'
+        )
+
+      return await getUser({ id }, context)
+    } catch (e) {
+      log.error(validate.errors)
+
+      return errorHandling({
+        e,
+        message: GE.INTERNAL_SERVER_ERROR,
+        code: 'INTERNAL_SERVER_ERROR',
+        log
+      })
+    }
+  },
+  getUsers
+}
+
+export { Query }
+`,
+          file: `${projectName}/src/graphQL/models/User/queriesResolver.ts`
+        },
+        schemas: {
+          content: `import { Type } from '@sinclair/typebox'
+
+const updateUserSchema = Type.Object(
+  {
+    id: Type.String({ minLength: 24, maxLength: 24 }),
+    lastName: Type.String(),
+    name: Type.String()
+  },
+  { additionalProperties: false }
+)
+
+const storeUserSchema = Type.Object(
+  {
+    lastName: Type.String({ minLength: 1 }),
+    name: Type.String({ minLength: 1 })
+  },
+  { additionalProperties: false }
+)
+
+export { updateUserSchema, storeUserSchema }
+`,
+          file: `${projectName}/src/graphQL/models/User/schemas.ts`
+        },
+        typeDefs: {
+          content: `import { gql } from 'apollo-server-core'
+
+const User = gql\`
+  type User {
+    id: ID!
+    name: String!
+    lastName: String!
+    updatedAt: String!
+  }
+
+  type Query {
+    getUsers: [User!]!
+    getUser(id: ID!): User!
+  }
+
+  input StoreUserInput {
+    lastName: String!
+    name: String!
+  }
+
+  input UpdateUserInput {
+    id: String!
+    lastName: String!
+    name: String!
+  }
+
+  type Mutation {
+    storeUser(user: StoreUserInput!): User!
+    deleteAllUsers: String
+    updateUser(user: UpdateUserInput!): User!
+    deleteUser(id: ID!): String
+  }
+\`
+
+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 { FastifyLoggerInstance } from 'fastify'
+
+const errorHandling = ({
+  e,
   message,
-  reply,
-  status
+  code,
+  log
 }: {
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  e: any
+  message: string
+  code: string
+  log: FastifyLoggerInstance
+}): 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`
+      }
+    }
+  }
+
+  const network = {
+    response: {
+      content: `interface ResponseProps {
   error: boolean
   message: unknown
-  reply: FastifyReply
+  res: CustomResponse
   status: number
-}): void => {
-  reply.code(status).send({ error, message })
+}
+
+const response = ({ error, message, res, status }: ResponseProps): void => {
+  res.status(status).send({ error, message })
 }
 
 export { response }
@@ -424,35 +911,40 @@ export { response }
       file: `${projectName}/src/network/response.ts`
     },
     router: {
-      content: `import { FastifyInstance } from 'fastify'
-import { HttpError } from 'http-errors'
+      content: `import { Application, Response, Request, Router, NextFunction } from 'express'
+import swaggerUi from 'swagger-ui-express'
+import httpErrors from 'http-errors'
 
 import { response } from './response'
-import { Home, User, Docs } from './routes'
-
-const routers = [Docs, User]
+import { Home } from './routes'
+import { docs } from 'utils'
 
-const applyRoutes = (app: FastifyInstance): void => {
-  Home(app)
-  routers.forEach(router => router(app))
+const routers: Router[] = []
+const applyRoutes = (app: Application): void => {
+  app.use('/', Home)
+  app.use('/api/docs', swaggerUi.serve, swaggerUi.setup(docs))
+  routers.forEach((router: Router): Application => app.use('/api', router))
 
   // Handling 404 error
-  app.setNotFoundHandler((request, reply) => {
-    response({
-      error: true,
-      message: 'This route does not exists',
-      reply,
-      status: 404
-    })
-  })
-  app.setErrorHandler<HttpError>((error, request, reply) => {
-    response({
-      error: true,
-      message: error.message,
-      reply,
-      status: error.status ?? 500
-    })
+  app.use((req, res, next) => {
+    next(new httpErrors.NotFound('This route does not exists'))
   })
+  app.use(
+    (
+      error: httpErrors.HttpError,
+      req: Request,
+      res: Response,
+      next: NextFunction
+    ) => {
+      response({
+        error: true,
+        message: error.message,
+        res,
+        status: error.status
+      })
+      next()
+    }
+  )
 }
 
 export { applyRoutes }
@@ -460,36 +952,64 @@ export { applyRoutes }
       file: `${projectName}/src/network/router.ts`
     },
     server: {
-      content: `import fastify, { FastifyInstance } from 'fastify'
+      content: `import http from 'http'
+import express from 'express'
 import mongoose from 'mongoose'
+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 { mergedSchema as schema } from 'graphQL'
 import { applyRoutes } from './router'
-import { validatorCompiler } from './utils'
 
-const PORT = process.env.PORT ?? '1996'
+const PORT = (process.env.PORT as string) || 1996
 
 class Server {
-  #app: FastifyInstance
+  #app: express.Application
   #connection: mongoose.Connection | undefined
+  #httpServer: http.Server
+  #log: HttpLogger
 
   constructor() {
-    this.#app = fastify({ logger: { prettyPrint: true } })
+    this.#app = express()
+    this.#httpServer = http.createServer(this.#app)
+    this.#log = pino({
+      transport: {
+        target: 'pino-pretty',
+        options: {
+          colorize: true
+        }
+      }
+    })
     this.#config()
   }
 
   #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(
-        'Access-Control-Allow-Headers',
-        'Authorization, Content-Type'
-      )
-      done()
-    })
-    this.#app.setValidatorCompiler(validatorCompiler)
-    applyRoutes(this.#app)
+    this.#app.use(cors())
+    this.#app.use(this.#log)
+    this.#app.use(express.json())
+    this.#app.use(express.urlencoded({ extended: false }))
+    this.#app.use(
+      (
+        req: express.Request,
+        res: express.Response,
+        next: express.NextFunction
+      ) => {
+        res.header('Access-Control-Allow-Methods', 'GET, POST, PATCH, DELETE')
+        res.header('Access-Control-Allow-Origin', '*')
+        res.header(
+          'Access-Control-Allow-Headers',
+          'Authorization, Content-Type'
+        )
+        res.header('x-powered-by', 'Simba.js')
+        next()
+      }
+    )
   }
 
   async #mongo(): Promise<void> {
@@ -500,10 +1020,313 @@ class Server {
       useUnifiedTopology: true
     }
     this.#connection.on('connected', () => {
-      this.#app.log.info('Mongo connection established.')
+      this.#log.logger.info('Mongo connection established.')
     })
     this.#connection.on('reconnected', () => {
-      this.#app.log.info('Mongo connection reestablished')
+      this.#log.logger.info('Mongo connection reestablished')
+    })
+    this.#connection.on('disconnected', () => {
+      this.#log.logger.info('Mongo connection disconnected')
+      this.#log.logger.info('Trying to reconnected to Mongo...')
+      setTimeout(() => {
+        mongoose.connect(process.env.MONGO_URI as string, {
+          ...connection,
+          connectTimeoutMS: 3000,
+          socketTimeoutMS: 3000
+        })
+      }, 3000)
+    })
+    this.#connection.on('close', () => {
+      this.#log.logger.info('Mongo connection closed')
+    })
+    this.#connection.on('error', (e: Error) => {
+      this.#log.logger.info('Mongo connection error:')
+      this.#log.logger.error(e)
+    })
+    await mongoose.connect(process.env.MONGO_URI as string, connection)
+  }
+
+  public async start(): Promise<void> {
+    const server = new ApolloServer({
+      schema,
+      plugins: [
+        ApolloServerPluginDrainHttpServer({ httpServer: this.#httpServer }),
+        process.env.NODE_ENV === 'production'
+          ? ApolloServerPluginLandingPageDisabled()
+          : ApolloServerPluginLandingPageGraphQLPlayground()
+      ],
+      context: (): Context => ({
+        log: this.#log.logger
+      })
+    })
+
+    try {
+      await server.start()
+      server.applyMiddleware({
+        app: this.#app,
+        path: '/api'
+      })
+      applyRoutes(this.#app)
+      await this.#mongo()
+      this.#httpServer.listen(PORT, () => {
+        this.#log.logger.info(\`Server listening at port: \${PORT}\`)
+        this.#log.logger.info(
+          \`GraphQL server listening at: http://localhost:\${PORT}\${server.graphqlPath}\`
+        )
+      })
+    } catch (e) {
+      console.error(e)
+    }
+  }
+}
+
+const server = new Server()
+
+export { server as Server }
+`,
+      file: `${projectName}/src/network/server.ts`
+    },
+    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({
+    error: false,
+    message: 'Welcome to your GraphQL Express Backend!',
+    res,
+    status: 200
+  })
+})
+
+export { Home }
+`,
+        file: `${projectName}/src/network/routes/home.ts`
+      },
+      index: {
+        content: "export * from './home'\n",
+        file: `${projectName}/src/network/routes/index.ts`
+      },
+      utils: {
+        index: {
+          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
+})
+
+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))
+    }
+
+    next()
+  }
+}
+
+export { validatorCompiler }
+`,
+          file: `${projectName}/src/network/routes/utils/index.ts`
+        }
+      }
+    }
+  }
+
+  await Promise.all([
+    writeFile(graphQL.index.file, graphQL.index.content),
+    writeFile(
+      graphQL.models.User.index.file,
+      graphQL.models.User.index.content
+    ),
+    writeFile(
+      graphQL.models.User.mutations.file,
+      graphQL.models.User.mutations.content
+    ),
+    writeFile(
+      graphQL.models.User.mutationsResolver.file,
+      graphQL.models.User.mutationsResolver.content
+    ),
+    writeFile(
+      graphQL.models.User.queries.file,
+      graphQL.models.User.queries.content
+    ),
+    writeFile(
+      graphQL.models.User.queriesResolver.file,
+      graphQL.models.User.queriesResolver.content
+    ),
+    writeFile(
+      graphQL.models.User.schemas.file,
+      graphQL.models.User.schemas.content
+    ),
+    writeFile(
+      graphQL.models.User.typeDefs.file,
+      graphQL.models.User.typeDefs.content
+    ),
+    writeFile(
+      graphQL.models.utils.messages.index.file,
+      graphQL.models.utils.messages.index.content
+    ),
+    writeFile(
+      graphQL.models.utils.messages.user.file,
+      graphQL.models.utils.messages.user.content
+    ),
+    writeFile(
+      graphQL.models.utils.index.file,
+      graphQL.models.utils.index.content
+    ),
+    writeFile(graphQL.models.index.file, graphQL.models.index.content),
+    writeFile(network.response.file, network.response.content),
+    writeFile(network.router.file, network.router.content),
+    writeFile(network.server.file, network.server.content),
+    writeFile(network.routes.home.file, network.routes.home.content),
+    writeFile(network.routes.index.file, network.routes.index.content),
+    writeFile(
+      network.routes.utils.index.file,
+      network.routes.utils.index.content
+    )
+  ])
+}
+
+/**
+ * @param {Object} args
+ * @param {String} args.projectName
+ */
+const fastifyRestNetwork = async ({ projectName }) => {
+  const createFoldersCommand = `mkdir ${projectName}/src/network/utils`
+
+  if (platform() === 'win32')
+    await exec(createFoldersCommand.replaceAll('/', '\\'))
+  else await exec(createFoldersCommand)
+
+  const network = {
+    response: {
+      content: `import { FastifyReply } from 'fastify'
+
+const response = ({
+  error,
+  message,
+  reply,
+  status
+}: {
+  error: boolean
+  message: unknown
+  reply: FastifyReply
+  status: number
+}): void => {
+  reply.code(status).send({ error, message })
+}
+
+export { response }
+`,
+      file: `${projectName}/src/network/response.ts`
+    },
+    router: {
+      content: `import { FastifyInstance } from 'fastify'
+import { HttpError } from 'http-errors'
+
+import { response } from './response'
+import { Home, User, Docs } from './routes'
+
+const routers = [Docs, User]
+const applyRoutes = (app: FastifyInstance): void => {
+  Home(app)
+  routers.forEach(router => router(app))
+
+  // Handling 404 error
+  app.setNotFoundHandler((request, reply) => {
+    response({
+      error: true,
+      message: 'This route does not exists',
+      reply,
+      status: 404
+    })
+  })
+  app.setErrorHandler<HttpError>((error, request, reply) => {
+    response({
+      error: true,
+      message: error.message,
+      reply,
+      status: error.status ?? 500
+    })
+  })
+}
+
+export { applyRoutes }
+`,
+      file: `${projectName}/src/network/router.ts`
+    },
+    server: {
+      content: `import fastify, { FastifyInstance } from 'fastify'
+import mongoose from 'mongoose'
+
+import { applyRoutes } from './router'
+import { validatorCompiler } from './utils'
+
+const PORT = process.env.PORT ?? 1996
+
+class Server {
+  #app: FastifyInstance
+  #connection: mongoose.Connection | undefined
+
+  constructor() {
+    this.#app = fastify({ logger: { prettyPrint: true } })
+    this.#config()
+  }
+
+  #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(
+        'Access-Control-Allow-Headers',
+        'Authorization, Content-Type'
+      )
+      reply.header('x-powered-by', 'Simba.js')
+      done()
+    })
+    this.#app.setValidatorCompiler(validatorCompiler)
+    applyRoutes(this.#app)
+  }
+
+  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('reconnected', () => {
+      this.#app.log.info('Mongo connection reestablished')
     })
     this.#connection.on('disconnected', () => {
       this.#app.log.info('Mongo connection disconnected')
@@ -868,39 +1691,846 @@ export { validatorCompiler }
     }
   }
 
-  await writeFile(network.response.file, network.response.content)
-  await writeFile(network.router.file, network.router.content)
-  await writeFile(network.server.file, network.server.content)
-  await writeFile(network.routes.docs.file, network.routes.docs.content)
-  await writeFile(network.routes.home.file, network.routes.home.content)
-  await writeFile(network.routes.index.file, network.routes.index.content)
-  await writeFile(network.routes.user.file, network.routes.user.content)
-  await writeFile(network.utils.index.file, network.utils.index.content)
+  await Promise.all([
+    writeFile(network.response.file, network.response.content),
+    writeFile(network.router.file, network.router.content),
+    writeFile(network.server.file, network.server.content),
+    writeFile(network.routes.docs.file, network.routes.docs.content),
+    writeFile(network.routes.home.file, network.routes.home.content),
+    writeFile(network.routes.index.file, network.routes.index.content),
+    writeFile(network.routes.user.file, network.routes.user.content),
+    writeFile(network.utils.index.file, network.utils.index.content)
+  ])
 }
+
 /**
  * @param {Object} args
- * @param {Boolean} args.fastify
  * @param {String} args.projectName
  */
-module.exports = async ({ fastify, projectName }) => {
-  const createFoldersCommand = `mkdir ${projectName}/src/network \
-${projectName}/src/network/routes`
+const fastifyGraphQLNetwork = async ({ projectName }) => {
+  const createFoldersCommand = `mkdir ${projectName}/src/graphQL/models \
+${projectName}/src/graphQL/models/User \
+${projectName}/src/graphQL/models/utils \
+${projectName}/src/graphQL/models/utils/messages`
 
   if (platform() === 'win32')
     await exec(createFoldersCommand.replaceAll('/', '\\'))
   else await exec(createFoldersCommand)
 
-  const network = {
+  const graphQL = {
     index: {
-      content: `export * from './routes'
-export * from './server'
+      content: "export * from './models'\n",
+      file: `${projectName}/src/graphQL/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/network/index.ts`
-    }
+          file: `${projectName}/src/graphQL/models/User/index.ts`
+        },
+        mutations: {
+          content: `import { ApolloError } from 'apollo-server-core'
+
+import { store, remove, update } from 'database'
+import { UserDTO } from 'schemas'
+import { EFU, MFU, GE, errorHandling } from '../utils'
+
+const storeUser = async (
+  { user }: { user: UserDTO },
+  { 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
+    })
   }
+}
 
-  await writeFile(network.index.file, network.index.content)
+const deleteAllUsers = async ({ log }: Context): Promise<string> => {
+  try {
+    const usersDeleted = (await remove()) as number
+
+    if (usersDeleted >= 1) return MFU.ALL_USERS_DELETED
+
+    if (usersDeleted === 0)
+      throw new ApolloError(EFU.NOTHING_TO_DELETE, 'NOTHING_TO_DELETE')
+
+    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
+    })
+  }
+}
+
+const updateUser = async (
+  { user }: { user: UserDTO },
+  { 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
+    })
+  }
+}
+
+const deleteUser = async (
+  { id }: { id: 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, UserDTO } from 'schemas'
+import { storeUserSchema, updateUserSchema } from './schemas'
+import { storeUser, updateUser, deleteUser, deleteAllUsers } from './mutations'
+import { errorHandling, GE } from '../utils'
+
+const Mutation = {
+  storeUser: async (
+    parent: unknown,
+    { user }: { user: UserDTO },
+    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: UserDTO },
+    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: 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 { 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 getUser = async (
+  { id }: { id: string },
+  { log }: Context
+): Promise<UserDTO> => {
+  try {
+    const user = (await get(id 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
+    })
+  }
+}
+
+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: string },
+    context: Context
+  ): Promise<UserDTO> => {
+    const { log } = context
+    const validate = ajv.compile(idSchema)
+
+    try {
+      const ok = validate({ id })
+
+      if (!ok)
+        throw new ApolloError(
+          \`id \${(validate.errors as DefinedError[])[0].message as string}\`,
+          'UNPROCESSABLE_ENTITY'
+        )
+
+      return await getUser({ id }, context)
+    } catch (e) {
+      log.error(validate.errors)
+
+      return errorHandling({
+        e,
+        message: GE.INTERNAL_SERVER_ERROR,
+        code: 'INTERNAL_SERVER_ERROR',
+        log
+      })
+    }
+  },
+  getUsers
+}
+
+export { Query }
+`,
+          file: `${projectName}/src/graphQL/models/User/queriesResolver.ts`
+        },
+        schemas: {
+          content: `import { Type } from '@sinclair/typebox'
+
+const updateUserSchema = Type.Object(
+  {
+    id: Type.String({ minLength: 24, maxLength: 24 }),
+    lastName: Type.String(),
+    name: Type.String()
+  },
+  { additionalProperties: false }
+)
+
+const storeUserSchema = Type.Object(
+  {
+    lastName: Type.String({ minLength: 1 }),
+    name: Type.String({ minLength: 1 })
+  },
+  { additionalProperties: false }
+)
+
+export { updateUserSchema, storeUserSchema }
+`,
+          file: `${projectName}/src/graphQL/models/User/schemas.ts`
+        },
+        typeDefs: {
+          content: `import { gql } from 'apollo-server-core'
+
+const User = gql\`
+  type User {
+    id: ID!
+    name: String!
+    lastName: String!
+    updatedAt: String!
+  }
+
+  type Query {
+    getUsers: [User!]!
+    getUser(id: ID!): User!
+  }
+
+  input StoreUserInput {
+    lastName: String!
+    name: String!
+  }
+
+  input UpdateUserInput {
+    id: String!
+    lastName: String!
+    name: String!
+  }
+
+  type Mutation {
+    storeUser(user: StoreUserInput!): User!
+    deleteAllUsers: String
+    updateUser(user: UpdateUserInput!): User!
+    deleteUser(id: ID!): String
+  }
+\`
+
+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 { FastifyLoggerInstance } from 'fastify'
+
+const errorHandling = ({
+  e,
+  message,
+  code,
+  log
+}: {
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  e: any
+  message: string
+  code: string
+  log: FastifyLoggerInstance
+}): 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`
+      }
+    }
+  }
+  const network = {
+    response: {
+      content: `import { FastifyReply } from 'fastify'
+
+const response = ({
+  error,
+  message,
+  reply,
+  status
+}: {
+  error: boolean
+  message: unknown
+  reply: FastifyReply
+  status: number
+}): void => {
+  reply.code(status).send({ error, message })
+}
+
+export { response }
+`,
+      file: `${projectName}/src/network/response.ts`
+    },
+    router: {
+      content: `import { FastifyInstance } from 'fastify'
+import { HttpError } from 'http-errors'
+
+import { response } from './response'
+import { Home, Docs } from './routes'
+
+const routers = [Docs]
+const applyRoutes = (app: FastifyInstance): void => {
+  Home(app)
+  routers.forEach(router => router(app))
+
+  // Handling 404 error
+  app.setNotFoundHandler((request, reply) => {
+    response({
+      error: true,
+      message: 'This route does not exists',
+      reply,
+      status: 404
+    })
+  })
+  app.setErrorHandler<HttpError>((error, request, reply) => {
+    response({
+      error: true,
+      message: error.message,
+      reply,
+      status: error.status ?? 500
+    })
+  })
+}
+
+export { applyRoutes }
+`,
+      file: `${projectName}/src/network/router.ts`
+    },
+    server: {
+      content: `import fastify, { FastifyInstance } from 'fastify'
+import { ApolloServer } from 'apollo-server-fastify'
+import {
+  ApolloServerPluginDrainHttpServer,
+  ApolloServerPluginLandingPageGraphQLPlayground,
+  ApolloServerPluginLandingPageDisabled
+} from 'apollo-server-core'
+import { ApolloServerPlugin } from 'apollo-server-plugin-base'
+import mongoose from 'mongoose'
+
+import { mergedSchema as schema } from 'graphQL'
+import { applyRoutes } from './router'
+
+const PORT = process.env.PORT ?? 1996
+
+class Server {
+  #app: FastifyInstance
+  #connection: mongoose.Connection | undefined
+
+  constructor() {
+    this.#app = fastify({ logger: { prettyPrint: true } })
+    this.#config()
+  }
+
+  #config() {
+    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(
+        'Access-Control-Allow-Headers',
+        'Authorization, Content-Type'
+      )
+      reply.header('x-powered-by', 'Simba.js')
+      done()
+    })
+    applyRoutes(this.#app)
+  }
+
+  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('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...')
+      setTimeout(() => {
+        mongoose.connect(process.env.MONGO_URI as string, {
+          ...connection,
+          connectTimeoutMS: 3000,
+          socketTimeoutMS: 3000
+        })
+      }, 3000)
+    })
+    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)
+    })
+    await mongoose.connect(process.env.MONGO_URI as string, connection)
+  }
+
+  #fastifyAppClosePlugin(): ApolloServerPlugin {
+    const app = this.#app
+
+    return {
+      async serverWillStart() {
+        return {
+          async drainServer() {
+            await app.close()
+          }
+        }
+      }
+    }
+  }
+
+  public async start(): Promise<void> {
+    const server = new ApolloServer({
+      schema,
+      plugins: [
+        this.#fastifyAppClosePlugin(),
+        ApolloServerPluginDrainHttpServer({ httpServer: this.#app.server }),
+        process.env.NODE_ENV === 'production'
+          ? ApolloServerPluginLandingPageDisabled()
+          : ApolloServerPluginLandingPageGraphQLPlayground()
+      ],
+      context: (): Context => ({
+        log: this.#app.log
+      })
+    })
+
+    try {
+      await server.start()
+      this.#app.register(
+        server.createHandler({
+          path: '/api'
+        })
+      )
+      await this.#mongo()
+      await this.#app.listen(PORT)
+      this.#app.log.info(
+        \`GraphQL server listening at: http://localhost:\${PORT}\${server.graphqlPath}\`
+      )
+    } catch (e) {
+      console.error(e)
+    }
+  }
+}
+
+const server = new Server()
+
+export { server as Server }
+`,
+      file: `${projectName}/src/network/server.ts`
+    },
+    routes: {
+      docs: {
+        content: `import { FastifyInstance } from 'fastify'
+import fastifySwagger from 'fastify-swagger'
+
+const Docs = (app: FastifyInstance, prefix = '/api'): void => {
+  app.register(fastifySwagger, {
+    routePrefix: \`\${prefix}/docs\`,
+    openapi: {
+      info: {
+        title: 'Test swagger',
+        description: 'Testing the Fastify swagger API',
+        version: '0.1.0',
+        contact: {
+          email: 'sluzquinosa@uni.pe'
+        },
+        license: {
+          name: 'MIT',
+          url: 'https://opensource.org/licenses/MIT'
+        }
+      },
+      servers: [
+        {
+          url: 'http://localhost:1996/api',
+          description: 'test-fastify local API'
+        }
+      ],
+      tags: [
+        {
+          name: 'user',
+          description: 'User related endpoints'
+        }
+      ]
+    },
+    exposeRoute: true
+  })
+}
+
+export { Docs }
+`,
+        file: `${projectName}/src/network/routes/docs.ts`
+      },
+      home: {
+        content: `import { FastifyInstance } from 'fastify'
+import { response } from 'network/response'
+
+const Home = (app: FastifyInstance, prefix = '/'): void => {
+  app.get(\`\${prefix}\`, (request, reply) => {
+    response({
+      error: false,
+      message: 'Welcome to your Fastify GraphQL Backend!',
+      reply,
+      status: 200
+    })
+  })
+}
+
+export { Home }
+`,
+        file: `${projectName}/src/network/routes/home.ts`
+      },
+      index: {
+        content: `export * from './home'
+export * from './docs'
+`,
+        file: `${projectName}/src/network/routes/index.ts`
+      }
+    }
+  }
+
+  await Promise.all([
+    writeFile(graphQL.index.file, graphQL.index.content),
+    writeFile(
+      graphQL.models.User.index.file,
+      graphQL.models.User.index.content
+    ),
+    writeFile(
+      graphQL.models.User.mutations.file,
+      graphQL.models.User.mutations.content
+    ),
+    writeFile(
+      graphQL.models.User.mutationsResolver.file,
+      graphQL.models.User.mutationsResolver.content
+    ),
+    writeFile(
+      graphQL.models.User.queries.file,
+      graphQL.models.User.queries.content
+    ),
+    writeFile(
+      graphQL.models.User.queriesResolver.file,
+      graphQL.models.User.queriesResolver.content
+    ),
+    writeFile(
+      graphQL.models.User.schemas.file,
+      graphQL.models.User.schemas.content
+    ),
+    writeFile(
+      graphQL.models.User.typeDefs.file,
+      graphQL.models.User.typeDefs.content
+    ),
+    writeFile(
+      graphQL.models.utils.messages.index.file,
+      graphQL.models.utils.messages.index.content
+    ),
+    writeFile(
+      graphQL.models.utils.messages.user.file,
+      graphQL.models.utils.messages.user.content
+    ),
+    writeFile(
+      graphQL.models.utils.index.file,
+      graphQL.models.utils.index.content
+    ),
+    writeFile(graphQL.models.index.file, graphQL.models.index.content),
+    writeFile(network.response.file, network.response.content),
+    writeFile(network.router.file, network.router.content),
+    writeFile(network.server.file, network.server.content),
+    writeFile(network.routes.docs.file, network.routes.docs.content),
+    writeFile(network.routes.home.file, network.routes.home.content),
+    writeFile(network.routes.index.file, network.routes.index.content)
+  ])
+}
+
+/**
+ * @param {Object} args
+ * @param {Boolean} args.fastify
+ * @param {String} args.projectName
+ * @param {Boolean} args.graphql
+ */
+module.exports = async ({ fastify, projectName, graphql }) => {
+  const createFoldersCommand = `mkdir ${projectName}/src/network \
+${projectName}/src/network/routes ${
+    graphql ? `${projectName}/src/graphQL` : ''
+  }`
+
+  if (platform() === 'win32')
+    await exec(createFoldersCommand.replaceAll('/', '\\'))
+  else await exec(createFoldersCommand)
+
+  const network = {
+    index: {
+      content: `export * from './routes'
+export * from './server'
+`,
+      file: `${projectName}/src/network/index.ts`
+    }
+  }
+
+  await writeFile(network.index.file, network.index.content)
+
+  if (fastify && graphql) return await fastifyGraphQLNetwork({ projectName })
+
+  if (fastify) return await fastifyRestNetwork({ projectName })
+
+  if (graphql) return await expressGraphQLNetwork({ projectName })
 
-  if (fastify) await fastifyRestNetwork({ projectName })
-  else await expressRestNetwork({ projectName })
+  return await expressRestNetwork({ projectName })
 }