@anthonylzq/simba.js 9.0.0 → 9.1.0

package/lib/templates/api/express/network/resolvers/entity.ts.ejs

@@ -0,0 +1,41 @@
+import 'reflect-metadata'
+import { Arg, Field, InputType, Mutation, Query, Resolver } from 'type-graphql'
+
+import { <%- Entity %> } from 'network/models'
+import { <%- Entity %>Service } from 'services'
+
+@InputType()
+class <%- Entity %>Input {
+<% entityFields.forEach(function(f) { -%>
+  @Field()
+  <%- f.name %>!: string
+
+<% }) -%>
+}
+
+@Resolver(<%- Entity %>)
+class <%- Entity %>Resolver {
+  readonly #<%- entity %>Service = new <%- Entity %>Service()
+
+  @Query(() => <%- Entity %>)
+  async getById(@Arg('id') id: <%- dbIsSQL ? 'number' : 'string' %>) {
+    return this.#<%- entity %>Service.getById(id)
+  }
+
+  @Mutation(() => <%- Entity %>)
+  async store(@Arg('<%- entity %>') <%- entity %>: <%- Entity %>Input) {
+    return this.#<%- entity %>Service.store(<%- entity %>)
+  }
+
+  @Mutation(() => <%- Entity %>)
+  async update(@Arg('id') id: <%- dbIsSQL ? 'number' : 'string' %>, @Arg('<%- entity %>') <%- entity %>: <%- Entity %>Input) {
+    return this.#<%- entity %>Service.update(id, <%- entity %>)
+  }
+
+  @Mutation(() => String)
+  async deleteById(@Arg('id') id: <%- dbIsSQL ? 'number' : 'string' %>) {
+    return this.#<%- entity %>Service.deleteById(id)
+  }
+}
+
+export { <%- Entity %>Resolver }

package/lib/templates/api/express/network/resolvers/index.ts.ejs

@@ -0,0 +1,13 @@
+import { buildSchema } from 'type-graphql'
+import { <%- Entity %>Resolver } from './<%-Entity%>'
+
+const buildSchemas = async () => {
+  const schema = await buildSchema({
+    resolvers: [<%- Entity %>Resolver],
+    validate: { forbidUnknownValues: false }
+  })
+
+  return schema
+}
+
+export { buildSchemas }

package/lib/templates/api/express/network/response.ts.ejs

@@ -0,0 +1,17 @@
+import type { Response } from 'express'
+
+const response = ({
+  error,
+  message,
+  res,
+  status
+}: {
+  error: boolean
+  message: unknown
+  res: Response
+  status: number
+}) => {
+  res.status(status).send({ error, message })
+}
+
+export { response }

package/lib/templates/api/express/network/router.ts.ejs

@@ -0,0 +1,39 @@
+import type { Application, Response, Request, Router, NextFunction } from 'express'
+import httpErrors from 'http-errors'
+
+import { response } from './response'
+<% if (graphQL) { -%>
+import { Home, Docs } from './routes'
+<% } else { -%>
+import { Home, Docs, <%- Entity %> } from './routes'
+<% } %>
+<%- graphQL ? 'const routers: Router[] = [Docs]' : `const routers = [${Entity}, Docs]` %>
+const applyRoutes = (app: Application): void => {
+  app.use('/', Home)
+  routers.forEach((router: Router) => {
+    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 }

package/lib/templates/api/express/network/routes/docs.ts.ejs

@@ -0,0 +1,43 @@
+import { Router } from 'express'
+import swaggerUi from 'swagger-ui-express'
+import { OpenApiGeneratorV31 } from '@asteasolutions/zod-to-openapi'
+
+import { registry } from 'network/utils'
+import pkg from '../../../package.json'
+
+const Docs = Router()
+
+const generator = new OpenApiGeneratorV31(registry.definitions)
+const docs = generator.generateDocument({
+  openapi: '3.1.0',
+  info: {
+    title: pkg.name,
+    description: pkg.description,
+    version: pkg.version,
+    contact: {
+      email: '<%- email %>'
+    },
+    license: {
+      name: 'MIT',
+      url: 'https://opensource.org/licenses/MIT'
+    }
+  },
+  servers: [
+    {
+      url: 'http://localhost:1996/api',
+      description: `${pkg.name} local API`
+    }
+  ],
+  tags: [
+<% if (!graphQL) { -%>
+    {
+      name: '<%- entity %>',
+      description: '<%- Entity %> related endpoints'
+    }
+<% } -%>
+  ]
+})
+
+Docs.use('/docs', swaggerUi.serve, swaggerUi.setup(docs))
+
+export { Docs }

package/lib/templates/api/express/network/routes/entity.ts.ejs

@@ -0,0 +1,165 @@
+import { type NextFunction, type Request, type Response, Router } from 'express'
+import z from 'zod'
+
+import { response } from 'network/response'
+import { jsonBody, jsonResponse, registry, validatorCompiler } from 'network/utils'
+import { <%- entity %>Dto, idSchema, store<%- Entity %>Dto, type <%- Entity %>DTO } from 'schemas'
+import { <%- Entity %>Service } from 'services'
+
+const <%- Entity %> = Router()
+const <%- entity %>Tag = '<%- entity %>'
+
+// POST /<%- entities %>
+<%- Entity %>.post(
+  '/<%-entities%>',
+  validatorCompiler(store<%- Entity %>Dto, 'body'),
+  async (
+    req: Request<
+      {
+        [key: string]: string
+      },
+      Record<string, unknown>,
+      { args: <%- Entity %>DTO }
+    >,
+    res: Response,
+    next: NextFunction
+  ): Promise<void> => {
+    try {
+      const {
+        body: {
+          args: { <%- entityFields.map(f => f.name).join(', ') %> }
+        }
+      } = req
+      const us = new <%- Entity %>Service()
+      const <%- entity %> = await us.store({ <%- entityFields.map(f => f.name).join(', ') %> })
+
+      response({ error: false, message: <%- entity %>, res, status: 201 })
+    } catch (error) {
+      next(error)
+    }
+  }
+)
+
+registry.registerPath({
+  method: 'post',
+  path: '/<%- entities %>',
+  tags: [<%- entity %>Tag],
+  request: {
+    body: jsonBody(store<%- Entity %>Dto)
+  },
+  responses: {
+    201: jsonResponse(<%- entity %>Dto, '<%- Entity %> created successfully')
+  }
+})
+
+// GET /<%- entity %>/:id
+<%- Entity %>.get(
+  '/<%-entity%>/:id',
+  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 <%- Entity %>Service()
+      const <%- entity %> = await us.getById(<%- dbIsSQL ? 'parseInt(id)' : 'id' %>)
+
+      response({ error: false, message: <%- entity %>, res, status: 200 })
+    } catch (error) {
+      next(error)
+    }
+  }
+)
+
+registry.registerPath({
+  method: 'get',
+  path: '/<%- entity %>/{id}',
+  tags: [<%- entity %>Tag],
+  request: {
+    params: idSchema
+  },
+  responses: {
+    200: jsonResponse(<%- entity %>Dto, '<%- Entity %> found')
+  }
+})
+
+// PATCH /<%- entity %>/:id
+<%- Entity %>.patch(
+  '/<%-entity%>/:id',
+  validatorCompiler(idSchema, 'params'),
+  validatorCompiler(store<%- Entity %>Dto, 'body'),
+  async (
+    req: Request<{ id: string }, Record<string, unknown>, { args: <%- Entity %>DTO }>,
+    res: Response,
+    next: NextFunction
+  ): Promise<void> => {
+    try {
+      const {
+        body: {
+          args: { <%- entityFields.map(f => f.name).join(', ') %> }
+        },
+        params: { id }
+      } = req
+      const us = new <%- Entity %>Service()
+      const <%- entity %> = await us.update(<%- dbIsSQL ? 'parseInt(id)' : 'id' %>, { <%- entityFields.map(f => f.name).join(', ') %> })
+
+      response({ error: false, message: <%- entity %>, res, status: 200 })
+    } catch (error) {
+      next(error)
+    }
+  }
+)
+
+registry.registerPath({
+  method: 'patch',
+  path: '/<%- entity %>/{id}',
+  tags: [<%- entity %>Tag],
+  request: {
+    params: idSchema,
+    body: jsonBody(store<%- Entity %>Dto)
+  },
+  responses: {
+    200: jsonResponse(<%- entity %>Dto, '<%- Entity %> updated successfully')
+  }
+})
+
+// DELETE /<%- entity %>/:id
+<%- Entity %>.delete(
+  '/<%-entity%>/:id',
+  validatorCompiler(idSchema, 'params'),
+  async (
+    req: Request<{ id: string }>,
+    res: Response,
+    next: NextFunction
+  ): Promise<void> => {
+    try {
+      const {
+        params: { id }
+      } = req
+      const us = new <%- Entity %>Service()
+      const result = await us.deleteById(<%- dbIsSQL ? 'parseInt(id)' : 'id' %>)
+
+      response({ error: false, message: result, res, status: 200 })
+    } catch (error) {
+      next(error)
+    }
+  }
+)
+
+registry.registerPath({
+  method: 'delete',
+  path: '/<%- entity %>/{id}',
+  tags: [<%- entity %>Tag],
+  request: {
+    params: idSchema
+  },
+  responses: {
+    200: jsonResponse(z.string(), '<%- Entity %> deleted successfully')
+  }
+})
+
+export { <%- Entity %> }

package/lib/templates/api/express/network/routes/home.ts.ejs

@@ -0,0 +1,16 @@
+import { type Response, type 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 }

package/lib/templates/api/express/network/routes/index.ts.ejs

@@ -0,0 +1,5 @@
+export * from './home'
+export * from './docs'
+<% if (!graphQL) { -%>
+export * from './<%-entity%>'
+<% } -%>

package/lib/templates/api/express/network/server.ts.ejs

@@ -0,0 +1,139 @@
+import type { Server as HttpServer } from 'node:http'
+import express from 'express'
+import cors from 'cors'
+import debug from 'debug'
+<% if (graphQL) { -%>
+import { ApolloServer } from '@apollo/server'
+import { expressMiddleware } from '@as-integrations/express5'
+
+import { dbConnection } from 'database'
+import { applyRoutes } from './router'
+import { buildSchemas } from './resolvers'
+<% } else { -%>
+
+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>>
+<% if (graphQL) { -%>
+  #apolloServer: ApolloServer | undefined
+<% } %>
+  constructor() {
+    this.#app = express()
+    this.#connection = dbConnection(d)
+  }
+
+<% if (graphQL) { -%>
+  async #config() {
+    await this.#apolloConfig()
+    this.#app.use(cors())
+<% } else { -%>
+  #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)
+  }
+
+<% if (graphQL) { -%>
+  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() {
+<% } else { -%>
+  async start(): Promise<void> {
+<% } -%>
+    try {
+<% if (graphQL) { -%>
+      await this.#config()
+<% } else { -%>
+      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
+      })
+    }
+  }
+
+<% if (graphQL) { -%>
+  async stop() {
+<% } else { -%>
+  async stop(): Promise<void> {
+<% } -%>
+    try {
+      await this.#connection?.disconnect()
+      this.#server?.close()
+<% if (graphQL) { -%>
+      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: ${<%- graphQL ? 'content' : 'JSON.stringify(content)' %>}`
+    )
+  }
+}
+
+const server = new Server()
+
+export { server as Server }

package/lib/templates/api/express/network/utils/index.ts.ejs

@@ -0,0 +1,45 @@
+import type { NextFunction, Request, Response } from 'express'
+import httpErrors from 'http-errors'
+import { OpenAPIRegistry } from '@asteasolutions/zod-to-openapi'
+import { type ZodType, z } from 'zod'
+
+type Middleware = (req: Request, res: Response, next: NextFunction) => void
+
+const registry = new OpenAPIRegistry()
+
+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 jsonResponse = (schema: ZodType, description: string) => ({
+  description,
+  content: {
+    'application/json': {
+      schema: z.object({
+        error: z.boolean(),
+        message: schema
+      })
+    }
+  }
+})
+
+const jsonBody = (schema: ZodType) => ({
+  content: {
+    'application/json': {
+      schema
+    }
+  }
+})
+
+export { registry, validatorCompiler, jsonResponse, jsonBody }

package/lib/templates/api/express/types/graphQL/context.d.ts.ejs

@@ -0,0 +1,3 @@
+type Context = {
+  log: (...args: unknown[]) => void
+}

package/lib/templates/api/express/types/index.d.ts.ejs

@@ -0,0 +1,4 @@
+/* eslint-disable no-var */
+declare global {}
+
+export {}

package/lib/templates/api/fastify/network/index.ts.ejs

@@ -0,0 +1,2 @@
+export * from './routes'
+export * from './server'

package/lib/templates/api/fastify/network/models/entity.ts.ejs

@@ -0,0 +1,21 @@
+import 'reflect-metadata'
+import { Field, <%- dbIsSQL ? 'Int' : 'ID' %>, ObjectType } from 'type-graphql'
+
+@ObjectType()
+class <%- Entity %> {
+  @Field(() => <%- dbIsSQL ? 'Int' : 'ID' %>)
+  id!: number
+
+<% entityFields.forEach(function(f) { -%>
+  @Field()
+  <%- f.name %>!: string
+
+<% }) -%>
+  @Field({ nullable: true })
+  createdAt?: string
+
+  @Field({ nullable: true })
+  updatedAt?: string
+}
+
+export { <%- Entity %> }

package/lib/templates/api/fastify/network/models/index.ts.ejs

@@ -0,0 +1 @@
+export * from './<%-Entity%>'

package/lib/templates/api/fastify/network/resolvers/entity.ts.ejs

@@ -0,0 +1,41 @@
+import 'reflect-metadata'
+import { Arg, Field, InputType, Mutation, Query, Resolver } from 'type-graphql'
+
+import { <%- Entity %> } from 'network/models'
+import { <%- Entity %>Service } from 'services'
+
+@InputType()
+class <%- Entity %>Input {
+<% entityFields.forEach(function(f) { -%>
+  @Field()
+  <%- f.name %>!: string
+
+<% }) -%>
+}
+
+@Resolver(<%- Entity %>)
+class <%- Entity %>Resolver {
+  readonly #<%- entity %>Service = new <%- Entity %>Service()
+
+  @Query(() => <%- Entity %>)
+  async getById(@Arg('id') id: <%- dbIsSQL ? 'number' : 'string' %>) {
+    return this.#<%- entity %>Service.getById(id)
+  }
+
+  @Mutation(() => <%- Entity %>)
+  async store(@Arg('<%- entity %>') <%- entity %>: <%- Entity %>Input) {
+    return this.#<%- entity %>Service.store(<%- entity %>)
+  }
+
+  @Mutation(() => <%- Entity %>)
+  async update(@Arg('id') id: <%- dbIsSQL ? 'number' : 'string' %>, @Arg('<%- entity %>') <%- entity %>: <%- Entity %>Input) {
+    return this.#<%- entity %>Service.update(id, <%- entity %>)
+  }
+
+  @Mutation(() => String)
+  async deleteById(@Arg('id') id: <%- dbIsSQL ? 'number' : 'string' %>) {
+    return this.#<%- entity %>Service.deleteById(id)
+  }
+}
+
+export { <%- Entity %>Resolver }

package/lib/templates/api/fastify/network/resolvers/index.ts.ejs

@@ -0,0 +1,13 @@
+import { buildSchema } from 'type-graphql'
+import { <%- Entity %>Resolver } from './<%-Entity%>'
+
+const buildSchemas = async () => {
+  const schema = await buildSchema({
+    resolvers: [<%- Entity %>Resolver],
+    validate: { forbidUnknownValues: false }
+  })
+
+  return schema
+}
+
+export { buildSchemas }

package/lib/templates/api/fastify/network/response.ts.ejs

@@ -0,0 +1,17 @@
+import type { 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 }

package/lib/templates/api/fastify/network/router.ts.ejs

@@ -0,0 +1,36 @@
+import type { FastifyInstance } from 'fastify'
+import { HttpError } from 'http-errors'
+
+import { response } from './response'
+<% if (graphQL) { -%>
+import { Home, Docs } from './routes'
+<% } else { -%>
+import { Home, <%- Entity %>, Docs } from './routes'
+<% } %>
+<%- graphQL ? 'const routers = [Home]' : `const routers = [Home, ${Entity}]` %>
+const applyRoutes = async (app: FastifyInstance) => {
+  routers.forEach(router => {
+    router(app)
+  })
+  await Docs(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 }