@anthonylzq/simba.js 7.2.0 → 8.0.0

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

@@ -4,10 +4,17 @@ const exec = util.promisify(require('child_process').exec)
 
 const express = require('./express')
 const fastifyF = require('./fastify')
-const utils = require('./utils')
 const writeFile = require('../../utils/writeFile')
 const { ENVIRONMENTS_WITH_DB_URI } = require('../../utils/constants')
 
+const dbDefaultPorts = {
+  mongo: 27017,
+  postgres: 5432,
+  mysql: 3306,
+  mariadb: 3306,
+  mssql: 1433
+}
+
 /**
  * @param {Object} args
  * @param {String} args.projectName
@@ -40,12 +47,6 @@ Content-Type: application/json
   }
 }
 
-### Testing getAll users
-GET http://localhost:1996/api/users
-
-### Testing deleteAll users
-DELETE http://localhost:1996/api/users
-
 ### Testing getOne user
 GET http://localhost:1996/api/user/60e7e3b93b01c1a7aa74cd6b
 
@@ -67,17 +68,20 @@ DELETE http://localhost:1996/api/user/60e7e3b93b01c1a7aa74cd6b
       }
     },
     '.env': {
-      content: dbIsSQL
-        ? `DB_URI = ${
-            ENVIRONMENTS_WITH_DB_URI.includes(process.env.NODE_ENV)
-              ? process.env.DB_URI
-              : `${database}://${database}:${database}@${database}:27017/${projectName}`
-          }`
-        : `DB_URI = ${
-            ENVIRONMENTS_WITH_DB_URI.includes(process.env.NODE_ENV)
-              ? process.env.MONGO_URI
-              : `mongodb://mongo:mongo@mongo:27017/${projectName}`
-          }`,
+      content:
+        dbIsSQL && database !== 'sqlite'
+          ? `DATABASE_URL = ${
+              ENVIRONMENTS_WITH_DB_URI.includes(process.env.NODE_ENV)
+                ? process.env.DATABASE_URL
+                : `${database}://${database}:${database}@${database}:${dbDefaultPorts[database]}/${projectName}`
+            }`
+          : database === 'sqlite'
+          ? ''
+          : `DATABASE_URL = ${
+              ENVIRONMENTS_WITH_DB_URI.includes(process.env.NODE_ENV)
+                ? process.env.MONGO_URI
+                : `mongodb://mongo:mongo@mongo:27017/${projectName}`
+            }`,
       file: `${projectName}/.env`
     },
     index: {
@@ -104,17 +108,23 @@ Server.start()
   ]
 
   if (fastify)
-    processes.push(fastifyF({ projectName, graphQL: graphql, database }))
+    processes.push(
+      fastifyF({
+        projectName,
+        email,
+        projectVersion,
+        graphQL: graphql,
+        database
+      })
+    )
   else
     processes.concat([
-      express({ projectName, graphQL: graphql, database }),
-      // /utils
-      utils({
-        express: !fastify,
+      express({
         projectName,
         email,
         projectVersion,
-        graphql
+        graphQL: graphql,
+        database
       })
     ])
 

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

@@ -6,9 +6,10 @@ const writeFile = require('../../utils/writeFile')
 /**
  * @param {Object} args
  * @param {String} args.projectName
+ * @param {Boolean} args.dbIsSQL
  * @param {Boolean} args.graphql
  */
-module.exports = async ({ projectName, graphql }) => {
+module.exports = async ({ projectName, dbIsSQL, graphQL }) => {
   const createFoldersCommand = `mkdir ${projectName}/src/schemas`
 
   if (platform() === 'win32')
@@ -17,54 +18,40 @@ module.exports = async ({ projectName, graphql }) => {
 
   const schemas = {
     index: {
-      content: `import { Static, Type } from '@sinclair/typebox'
-
-const id = 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'
-`,
+      content: `export * from './id'\nexport * from './user'\n`,
       file: `${projectName}/src/schemas/index.ts`
     },
     user: {
-      content: `import { Static, Type } from '@sinclair/typebox'
+      content: `import z from 'zod'
 
-import { id } from '.'
+import { id } from './id'
 
-const user = Type.Object({
-  lastName: Type.String(),
-  name: Type.String()
+const user = z.object({
+  lastName: z.string(),
+  name: z.string()
 })
 
-type User = Static<typeof user>
+type User = z.infer<typeof user>
 
-const userWithId = Type.Intersect([user, Type.Object({ id })])
+const userWithId = user.extend({ id })
 
-type UserWithId = Static<typeof userWithId>
+type UserWithId = z.infer<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())
+const userDto = z.object({
+  id: id.optional(),
+  lastName: z.string(),
+  name: z.string(),
+  createdAt: z.string().optional(),
+  updatedAt: z.string().optional()
 })
 
-type UserDTO = Static<typeof userDto>
+type UserDTO = z.infer<typeof userDto>
 
-const storeUserDto = Type.Object({
+const storeUserDto = z.object({
   args: user
 })
 
-type StoreUserDTO = Static<typeof storeUserDto>
+type StoreUserDTO = z.infer<typeof storeUserDto>
 
 export {
   userDto,
@@ -75,37 +62,32 @@ export {
   User,
   storeUserDto,
   StoreUserDTO
-}
-`,
+}\n`,
       file: `${projectName}/src/schemas/user.ts`
-    }
-  }
-
-  if (graphql)
-    schemas.index.content = `import { Static, Type } from '@sinclair/typebox'
-import Ajv from 'ajv/dist/2019.js'
-import addFormats from 'ajv-formats'
-
-const id = Type.String({
-  pattern: '^[a-zA-Z0-9]{24,}$'
-})
+    },
+    id: {
+      content: `import z from 'zod'
 
-type ID = Static<typeof id>
+const id = ${
+        dbIsSQL ? 'z.preprocess(val => Number(val), z.number())' : 'z.string()'
+      }
 
-const idSchema = Type.Object({ id })
+type Id = z.infer<typeof id>
 
-type IDSchema = Static<typeof idSchema>
+const idSchema = z.object({ id })
 
-const ajv = addFormats(new Ajv(), ['email'])
-  .addKeyword('kind')
-  .addKeyword('modifier')
+type IdSchema = z.infer<typeof idSchema>
 
-export { id, ID, idSchema, IDSchema, ajv }
-export * from './user'
-`
+export { id, Id, idSchema, IdSchema }\n`,
+      file: `${projectName}/src/schemas/id.ts`
+    }
+  }
 
-  await Promise.all([
+  const processes = [
     writeFile(schemas.index.file, schemas.index.content),
-    writeFile(schemas.user.file, schemas.user.content)
-  ])
+    writeFile(schemas.user.file, schemas.user.content),
+    writeFile(schemas.id.file, schemas.id.content)
+  ]
+
+  await Promise.all(processes)
 }

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

@@ -1,6 +1,7 @@
 const { platform } = require('os')
 const { promisify } = require('util')
 const exec = promisify(require('child_process').exec)
+
 const writeFile = require('../../utils/writeFile')
 
 /**
@@ -18,201 +19,212 @@ ${projectName}/src/services/utils/messages`
 
   const services = {
     index: {
-      content: "export * from './user'\n",
+      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?: string
-  user?: User
-  userWithId?: UserWithId
-}
-
-class UserService {
-  #args: Arguments
-
-  constructor(args: Arguments = {}) {
-    this.#args = args
+    base: {
+      content: `import { Debugger } from 'debug'
+import httpErrors, {
+  HttpErrorConstructor,
+  NamedConstructors
+} from 'http-errors'
+
+import { Log } from 'utils'
+import { GE } from './utils'
+
+type FilterNumberKeys<T> = {
+  [K in keyof T]: T[K] extends HttpErrorConstructor<infer N>
+    ? N extends number
+      ? K
+      : never
+    : never
+}[keyof T]
+
+type ErrorCodes = FilterNumberKeys<NamedConstructors>
+
+class BaseHttpService implements Log {
+  #debug: Debugger
+
+  constructor(debug: Debugger) {
+    this.#debug = debug
   }
 
-  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)
-    }
+  log({
+    method,
+    value,
+    content
+  }: {
+    method: string
+    value: string
+    content: unknown
+  }) {
+    this.#debug(
+      \`Service invoked -> \${
+        this.constructor.name
+      } ~ \${method} ~ value: \${value} ~ content: \${JSON.stringify(content)}\`
+    )
   }
 
-  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)
+  errorHandling(
+    error: unknown,
+    {
+      message,
+      code
+    }:
+      | {
+          message?: string
+          code?: never
+        }
+      | {
+          message?: never
+          code: ErrorCodes
+        } = {
+      message: GE.INTERNAL_SERVER_ERROR
     }
+  ): never {
+    this.log({
+      method: this.errorHandling.name,
+      value: 'error',
+      content: error
+    })
+
+    if (code)
+      throw new httpErrors[code](
+        message ?? (error as { message: string }).message
+      )
+
+    throw new httpErrors.InternalServerError(
+      message ?? (error as { message: string }).message
+    )
   }
+}
 
-  async #getAll(): Promise<UserDTO[]> {
-    try {
-      const users = (await get()) as UserDTO[]
+export { BaseHttpService }\n`,
+      file: `${projectName}/src/services/BaseHttp.ts`
+    },
+    user: {
+      content: `import debug from 'debug'
 
-      return users
-    } catch (e) {
-      return errorHandling(e, GE.INTERNAL_SERVER_ERROR)
-    }
+import { getById, removeById, store, update } from 'database'
+import { Id, User as UserSchema } from 'schemas'
+import { BaseHttpService } from './BaseHttp'
+import { EFU, MFU, GE } from './utils'
+
+class UserService extends BaseHttpService {
+  constructor() {
+    super(debug('App:Services:User'))
   }
 
-  async #deleteAll(): Promise<string> {
+  async store(userDto: UserSchema) {
     try {
-      const usersDeleted = (await remove()) as number
-
-      if (usersDeleted >= 1) return MFU.ALL_USERS_DELETED
-
-      if (usersDeleted === 0)
-        throw new httpErrors.Conflict(EFU.NOTHING_TO_DELETE)
+      const result = await store(userDto)
+      super.log({ method: this.store.name, value: 'result', content: result })
 
-      throw new httpErrors.InternalServerError(GE.INTERNAL_SERVER_ERROR)
+      return result
     } catch (e) {
-      return errorHandling(e, GE.INTERNAL_SERVER_ERROR)
+      return super.errorHandling(e)
     }
   }
 
-  async #getOne(): Promise<UserDTO> {
+  async getById(id: Id) {
     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
+      const user = await getById(id)
+      super.log({ method: this.getById.name, value: 'result', content: user })
 
-      if (!user) throw new httpErrors.NotFound(EFU.NOT_FOUND)
+      if (!user)
+        return super.errorHandling(new Error(EFU.NOT_FOUND), { code: '404' })
 
       return user
     } catch (e) {
-      return errorHandling(e, GE.INTERNAL_SERVER_ERROR)
+      return super.errorHandling(e)
     }
   }
 
-  async #update(): Promise<UserDTO> {
+  async update(id: Id, user: UserSchema) {
     try {
-      if (!this.#args.userWithId || !this.#args.userWithId.id)
-        throw new httpErrors.UnprocessableEntity(GE.INTERNAL_SERVER_ERROR)
-
-      const updatedUser = await update(this.#args.userWithId)
+      const updatedUser = await update(id, user)
+      super.log({
+        method: this.update.name,
+        value: 'result',
+        content: updatedUser
+      })
 
-      if (!updatedUser) throw new httpErrors.NotFound(EFU.NOT_FOUND)
+      if (!updatedUser)
+        return super.errorHandling(new Error(EFU.NOT_FOUND), { code: '404' })
 
       return updatedUser
     } catch (e) {
-      return errorHandling(e, GE.INTERNAL_SERVER_ERROR)
+      return super.errorHandling(e, { message: GE.INTERNAL_SERVER_ERROR })
     }
   }
 
-  async #delete(): Promise<string> {
+  async deleteById(id: Id) {
     try {
-      if (!this.#args.id)
-        throw new httpErrors.UnprocessableEntity(GE.INTERNAL_SERVER_ERROR)
+      const deletedUser = await removeById(id)
+      super.log({
+        method: this.deleteById.name,
+        value: 'result',
+        content: deletedUser
+      })
 
-      const { id } = this.#args
-      const deletedUser = await remove(id)
-
-      if (!deletedUser) throw new httpErrors.NotFound(EFU.NOT_FOUND)
+      if (!deletedUser)
+        return super.errorHandling(new Error(EFU.NOT_FOUND), { code: '404' })
 
       return MFU.USER_DELETED
     } catch (e) {
-      return errorHandling(e, GE.INTERNAL_SERVER_ERROR)
+      return super.errorHandling(e)
     }
   }
 }
 
-export { UserService }
-`,
-      file: `${projectName}/src/services/user.ts`
+export { UserService }\n`,
+      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'
-`,
+        content: `export * from './messages'\n`,
         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'
-}
+      messages: {
+        index: {
+          content: `const GenericErrors = {
+  INTERNAL_SERVER_ERROR: 'Something went wrong'
+} as const
 
-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`
+export { GenericErrors as GE }
+export * from './user'\n`,
+          file: `${projectName}/src/services/utils/messages/index.ts`
+        },
+        user: {
+          content: `const ErrorForUser = {
+  NOT_FOUND: 'The requested user does not exists',
+  NOTHING_TO_DELETE: 'There is no user to be deleted'
+} as const
+
+const MessageForUser = {
+  ALL_USERS_DELETED: 'All the users were deleted successfully',
+  USER_DELETED: 'The requested user was successfully deleted'
+} as const
+
+export { ErrorForUser as EFU, MessageForUser as MFU }\n`,
+          file: `${projectName}/src/services/utils/messages/user.ts`
+        }
       }
     }
   }
 
   await Promise.all([
     writeFile(services.index.file, services.index.content),
+    writeFile(services.base.file, services.base.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
+      services.utils.messages.index.file,
+      services.utils.messages.index.content
     ),
     writeFile(
-      services['utils/messages'].user.file,
-      services['utils/messages'].user.content
+      services.utils.messages.user.file,
+      services.utils.messages.user.content
     )
   ])
 }