@anthonylzq/simba.js 9.0.1 → 9.1.0

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

@@ -1,37 +1,39 @@
-const { platform } = require('node:os')
-const { promisify } = require('node:util')
-const exec = promisify(require('node:child_process').exec)
+const mkdirs = require('../../utils/mkdirs')
 
 const db = require('./database')
 const schemas = require('./schemas')
 const services = require('./services')
 const writeFile = require('../../utils/writeFile')
+const { renderTemplate } = require('../../utils/renderTemplate')
 const utils = require('./utils')
 
+const t = (templatePath, data = {}) =>
+  renderTemplate(`api/express/${templatePath}`, data)
+
 /**
  * @param {Object} args
  * @param {String} args.projectName
  * @param {Boolean} args.dbIsSQL
+ * @param {Boolean} args.graphQL
  */
-const types = async ({ projectName, dbIsSQL }) => {
-  const createFoldersCommand = `mkdir ${projectName}/src/@types \
-${!dbIsSQL ? ` ${projectName}/src/@types/models` : ''}`
+const types = async ({ projectName, dbIsSQL, graphQL }) => {
+  const dirs = [`${projectName}/src/@types`]
+  if (!dbIsSQL) dirs.push(`${projectName}/src/@types/models`)
+  if (graphQL) dirs.push(`${projectName}/src/@types/graphQL`)
 
-  if (platform() === 'win32')
-    await exec(createFoldersCommand.replaceAll('/', '\\'))
-  else await exec(createFoldersCommand)
+  await mkdirs(...dirs)
 
-  const types = {
-    index: {
-      content: `/* eslint-disable no-var */
-declare global {}
+  const processes = [
+    writeFile(`${projectName}/src/@types/index.d.ts`, t('types/index.d.ts.ejs'))
+  ]
 
-export {}
-`,
-      file: `${projectName}/src/@types/index.d.ts`
-    }
-  }
-  const processes = [writeFile(types.index.file, types.index.content)]
+  if (graphQL)
+    processes.push(
+      writeFile(
+        `${projectName}/src/@types/graphQL/context.d.ts`,
+        t('types/graphQL/context.d.ts.ejs')
+      )
+    )
 
   await Promise.all(processes)
 }
@@ -39,589 +41,90 @@ export {}
 /**
  * @param {Object} args
  * @param {String} args.projectName
- * @param {String} args.graphQL
- * @param {String} args.dbIsSQL
+ * @param {String} args.email
+ * @param {Boolean} args.graphQL
+ * @param {Boolean} args.dbIsSQL
+ * @param {import('../../utils/entity').EntityContext} args.entityContext
  */
-const network = async ({ projectName, graphQL, dbIsSQL }) => {
-  const createFoldersCommand = `mkdir ${projectName}/src/network \
-${projectName}/src/network/routes ${projectName}/src/network/routes/utils ${
-    graphQL
-      ? ` ${projectName}/src/network/models ${projectName}/src/network/resolvers`
-      : ''
-  }`
-
-  if (platform() === 'win32')
-    await exec(createFoldersCommand.replaceAll('/', '\\'))
-  else await exec(createFoldersCommand)
-
-  const network = {
-    index: {
-      content: `export * from './routes'\nexport * from './server'\n`,
-      file: `${projectName}/src/network/index.ts`
-    },
-    response: {
-      content: `import { type Response } from 'express'
-
-const response = ({
-  error,
-  message,
-  res,
-  status
-}: {
-  error: boolean
-  message: unknown
-  res: Response
-  status: number
+const network = async ({
+  projectName,
+  email,
+  graphQL,
+  dbIsSQL,
+  entityContext
 }) => {
-  res.status(status).send({ error, message })
-}
-
-export { response }\n`,
-      file: `${projectName}/src/network/response.ts`
-    },
-    router: {
-      content: `import { Application, Response, Request, Router, NextFunction } from 'express'
-import swaggerUi from 'swagger-ui-express'
-import httpErrors from 'http-errors'
-
-import { response } from './response'
-${
-  graphQL
-    ? "import { Home } from './routes'"
-    : "import { Home, User } from './routes'"
-}
-import { docs } from 'utils'
-
-${graphQL ? 'const routers: Router[] = []' : 'const routers = [User]'}
-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.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 }
-`,
-      file: `${projectName}/src/network/router.ts`
-    },
-    server: {
-      content: graphQL
-        ? `import type { Server as HttpServer } from 'node:http'
-import express from 'express'
-import cors from 'cors'
-import debug from 'debug'
-import { ApolloServer } from '@apollo/server'
-import { expressMiddleware } from '@as-integrations/express5'
-
-import { dbConnection } from 'database'
-import { applyRoutes } from './router'
-import { buildSchemas } from './resolvers'
-import { type Log } from 'utils'
-
-const d = debug('App:Network:Server')
-const PORT = (process.env.PORT as string) || 1996
-
-class Server implements Log {
-  #app: express.Application
-  #server: HttpServer | undefined
-  #connection: Awaited<ReturnType<typeof dbConnection>>
-  #apolloServer: ApolloServer | undefined
-
-  constructor() {
-    this.#app = express()
-    this.#connection = dbConnection(d)
-  }
-
-  async #config() {
-    await this.#apolloConfig()
-    this.#app.use(cors())
-    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()
-      }
-    )
-    applyRoutes(this.#app)
-  }
-
-  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 this.#config()
-      await this.#connection?.connect()
-      this.#server = this.#app.listen(PORT, () => {
-        d(\`HTTP server listening on port \${PORT}.\`)
-      })
-    } catch (e) {
-      this.log({
-        method: this.start.name,
-        value: 'error',
-        content: e
-      })
-    }
-  }
-
-  async stop() {
-    try {
-      await this.#connection?.disconnect()
-      this.#server?.close()
-      await this.#apolloServer?.stop()
-    } catch (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 }\n`
-        : `import type { Server as HttpServer } from 'node:http'
-import express from 'express'
-import cors from 'cors'
-import debug from 'debug'
-
-import { dbConnection } from 'database'
-import { applyRoutes } from './router'
-import { type Log } from 'utils'
-
-const d = debug('App:Network:Server')
-const PORT = (process.env.PORT as string) || 1996
-
-class Server implements Log {
-  #app: express.Application
-  #server: HttpServer | undefined
-  #connection: Awaited<ReturnType<typeof dbConnection>>
-
-  constructor() {
-    this.#app = express()
-    this.#connection = dbConnection(d)
-  }
-
-  #config() {
-    this.#app.use(cors())
-    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()
-      }
-    )
-    applyRoutes(this.#app)
-  }
-
-  async start(): Promise<void> {
-    try {
-      this.#config()
-      await this.#connection?.connect()
-      this.#server = this.#app.listen(PORT, () => {
-        d(\`HTTP server listening on port \${PORT}.\`)
-      })
-    } catch (e) {
-      this.log({
-        method: this.start.name,
-        value: 'error',
-        content: e
-      })
-    }
-  }
-
-  async stop(): Promise<void> {
-    try {
-      await this.#connection?.disconnect()
-      this.#server?.close()
-    } catch (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 }\n`,
-      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 Express Backend!',
-    res,
-    status: 200
-  })
-})
-
-export { Home }
-`,
-        file: `${projectName}/src/network/routes/home.ts`
-      },
-      index: {
-        content: `export * from './home'
-${graphQL ? '' : "export * from './user'\n"}`,
-        file: `${projectName}/src/network/routes/index.ts`
-      },
-      ...(!graphQL && {
-        user: {
-          content: `import { type NextFunction, type Request, type Response, Router } from 'express'
-
-import { response } from 'network/response'
-import { UserService } from 'services'
-import { idSchema, storeUserDto, UserDTO } from 'schemas'
-import { validatorCompiler } from './utils'
-
-const User = Router()
-
-User.route('/users').post(
-  validatorCompiler(storeUserDto, 'body'),
-  async (
-    req: Request<
-      {
-        [key: string]: string
-      },
-      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: Request<{ id: string }, Record<string, unknown>>,
-      res: Response,
-      next: NextFunction
-    ): Promise<void> => {
-      try {
-        const {
-          params: { id }
-        } = req
-        const us = new UserService()
-        const user = await us.getById(${dbIsSQL ? 'parseInt(id)' : 'id'})
-
-        response({ error: false, message: user, res, status: 200 })
-      } catch (error) {
-        next(error)
-      }
-    }
-  )
-  .patch(
-    validatorCompiler(idSchema, 'params'),
-    validatorCompiler(storeUserDto, 'body'),
-    async (
-      req: Request<{ id: string }, Record<string, unknown>, { args: UserDTO }>,
-      res: Response,
-      next: NextFunction
-    ): Promise<void> => {
-      try {
-        const {
-          body: {
-            args: { name, lastName }
-          },
-          params: { id }
-        } = req
-        const us = new UserService()
-        const user = await us.update(${
-          dbIsSQL ? 'parseInt(id)' : 'id'
-        }, { name, lastName })
-
-        response({ error: false, message: user, res, status: 200 })
-      } catch (error) {
-        next(error)
-      }
-    }
-  )
-  .delete(
-    validatorCompiler(idSchema, 'params'),
-    async (
-      req: Request<{ id: string }>,
-      res: Response,
-      next: NextFunction
-    ): Promise<void> => {
-      try {
-        const {
-          params: { id }
-        } = req
-        const us = new UserService()
-        const result = await us.deleteById(${dbIsSQL ? 'parseInt(id)' : 'id'})
-
-        response({ error: false, message: result, res, status: 200 })
-      } catch (error) {
-        next(error)
-      }
-    }
-  )
-
-export { User }\n`,
-          file: `${projectName}/src/network/routes/user.ts`
-        }
-      }),
-      utils: {
-        index: {
-          content: `import { type NextFunction, type Request, type Response } from 'express'
-import httpErrors from 'http-errors'
-import { ZodType } from 'zod'
-
-type Middleware = (req: Request, res: Response, next: NextFunction) => void
-
-const validatorCompiler = (
-  schema: ZodType,
-  value: 'body' | 'params'
-): Middleware => {
-  return (req: Request, _res: Response, next: NextFunction) => {
-    const result = schema.safeParse(req[value])
-
-    if (result.success) return next()
-
-    return next(
-      new httpErrors.UnprocessableEntity(JSON.stringify(result.error))
+  const dirs = [
+    `${projectName}/src/network`,
+    `${projectName}/src/network/routes`,
+    `${projectName}/src/network/utils`
+  ]
+  if (graphQL) {
+    dirs.push(
+      `${projectName}/src/network/models`,
+      `${projectName}/src/network/resolvers`
     )
   }
-}
-
-export { validatorCompiler }\n`,
-          file: `${projectName}/src/network/routes/utils/index.ts`
-        }
-      }
-    },
-    ...(graphQL && {
-      models: {
-        index: {
-          content: "export * from './User'\n",
-          file: `${projectName}/src/network/models/index.ts`
-        },
-        User: {
-          content: `import 'reflect-metadata'
-import { Field, ${dbIsSQL ? 'Int' : 'ID'}, ObjectType } from 'type-graphql'
-
-@ObjectType()
-class User {
-  @Field(() => ${dbIsSQL ? 'Int' : 'ID'})
-  id!: number
 
-  @Field()
-  lastName!: string
+  await mkdirs(...dirs)
 
-  @Field()
-  name!: string
-
-  @Field({ nullable: true })
-  createdAt?: string
-
-  @Field({ nullable: true })
-  updatedAt?: string
-}
-
-export { User }\n`,
-          file: `${projectName}/src/network/models/User.ts`
-        }
-      },
-      resolvers: {
-        index: {
-          content: `import { buildSchema } from 'type-graphql'
-import { UserResolver } from './User'
-
-const buildSchemas = async () => {
-  const schema = await buildSchema({
-    resolvers: [UserResolver],
-    validate: { forbidUnknownValues: false }
-  })
-
-  return schema
-}
-
-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'
-
-import { User } from 'network/models'
-import { UserService } from 'services'
-
-@InputType()
-class UserInput {
-  @Field()
-  name!: string
-
-  @Field()
-  lastName!: string
-}
-
-@Resolver(User)
-class UserResolver {
-  readonly #userService = new UserService()
-
-  @Query(() => User)
-  async getById(@Arg('id') id: ${dbIsSQL ? 'number' : 'string'}) {
-    return this.#userService.getById(id)
-  }
-
-  @Mutation(() => User)
-  async store(@Arg('user') user: UserInput) {
-    return this.#userService.store(user)
-  }
-
-  @Mutation(() => User)
-  async update(@Arg('id') id: ${
-    dbIsSQL ? 'number' : 'string'
-  }, @Arg('user') user: UserInput) {
-    return this.#userService.update(id, user)
-  }
-
-  @Mutation(() => String)
-  async deleteById(@Arg('id') id: ${dbIsSQL ? 'number' : 'string'}) {
-    return this.#userService.deleteById(id)
-  }
-}
-
-export { UserResolver }\n`,
-          file: `${projectName}/src/network/resolvers/User.ts`
-        }
-      }
-    })
-  }
+  const data = { graphQL, dbIsSQL, ...entityContext }
   const processes = [
-    writeFile(network.index.file, network.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(`${projectName}/src/network/index.ts`, t('network/index.ts.ejs')),
+    writeFile(
+      `${projectName}/src/network/response.ts`,
+      t('network/response.ts.ejs')
+    ),
     writeFile(
-      network.routes.utils.index.file,
-      network.routes.utils.index.content
+      `${projectName}/src/network/router.ts`,
+      t('network/router.ts.ejs', data)
+    ),
+    writeFile(
+      `${projectName}/src/network/server.ts`,
+      t('network/server.ts.ejs', data)
+    ),
+    writeFile(
+      `${projectName}/src/network/routes/home.ts`,
+      t('network/routes/home.ts.ejs')
+    ),
+    writeFile(
+      `${projectName}/src/network/routes/docs.ts`,
+      t('network/routes/docs.ts.ejs', { email, graphQL, ...entityContext })
+    ),
+    writeFile(
+      `${projectName}/src/network/routes/index.ts`,
+      t('network/routes/index.ts.ejs', data)
+    ),
+    writeFile(
+      `${projectName}/src/network/utils/index.ts`,
+      t('network/utils/index.ts.ejs')
     )
   ]
 
   if (graphQL)
-    processes.concat([
-      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)
-    ])
+    processes.push(
+      writeFile(
+        `${projectName}/src/network/models/index.ts`,
+        t('network/models/index.ts.ejs', entityContext)
+      ),
+      writeFile(
+        `${projectName}/src/network/models/${entityContext.Entity}.ts`,
+        t('network/models/entity.ts.ejs', data)
+      ),
+      writeFile(
+        `${projectName}/src/network/resolvers/index.ts`,
+        t('network/resolvers/index.ts.ejs', entityContext)
+      ),
+      writeFile(
+        `${projectName}/src/network/resolvers/${entityContext.Entity}.ts`,
+        t('network/resolvers/entity.ts.ejs', data)
+      )
+    )
   else
     processes.push(
-      writeFile(network.routes.user.file, network.routes.user.content)
+      writeFile(
+        `${projectName}/src/network/routes/${entityContext.entity}.ts`,
+        t('network/routes/entity.ts.ejs', data)
+      )
     )
 
   await Promise.all(processes)
@@ -631,32 +134,25 @@ export { UserResolver }\n`,
  * @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
+ * @param {import('../../utils/entity').EntityContext} args.entityContext
  */
 const main = async ({
   projectName,
   email,
-  projectVersion,
   graphQL,
-  database
+  database,
+  entityContext
 }) => {
   const dbIsSQL = database !== 'mongo'
 
-  await utils({
-    fastify: false,
-    projectName,
-    email,
-    projectVersion,
-    graphQL,
-    dbIsSQL
-  })
-  await types({ projectName, dbIsSQL })
-  await network({ projectName, graphQL, dbIsSQL })
-  await schemas({ projectName, dbIsSQL })
-  await services({ projectName, dbIsSQL })
-  await db({ projectName, database })
+  await utils({ projectName })
+  await types({ projectName, dbIsSQL, graphQL })
+  await network({ projectName, email, graphQL, dbIsSQL, entityContext })
+  await schemas({ projectName, dbIsSQL, entityContext })
+  await services({ projectName, dbIsSQL, entityContext })
+  await db({ projectName, database, entityContext })
 }
 
 module.exports = main