@anthonylzq/simba.js 4.2.0 → 4.4.0

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

@@ -0,0 +1,72 @@
+const { platform } = require('os')
+const { promisify } = require('util')
+const exec = promisify(require('child_process').exec)
+const writeFile = require('../../utils/writeFile')
+
+/**
+ * @param {Object} args
+ * @param {String} args.projectName
+ */
+module.exports = async ({ projectName }) => {
+  const createFoldersCommand = `mkdir ${projectName}/src/schemas`
+
+  if (platform() === 'win32')
+    await exec(createFoldersCommand.replaceAll('/', '\\'))
+  else await exec(createFoldersCommand)
+
+  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'
+`,
+      file: `${projectName}/src/schemas/index.ts`
+    },
+    user: {
+      content: `import { Static, Type } from '@sinclair/typebox'
+
+import { id } from '.'
+
+const user = Type.Object({
+  lastName: Type.String(),
+  name: Type.String()
+})
+
+type User = Static<typeof user>
+
+const userDto = Type.Object({
+  id: Type.Optional(id),
+  lastName: Type.String(),
+  name: Type.String(),
+  createdAt: Type.Optional(Type.String()),
+  updatedAt: Type.Optional(Type.String())
+})
+
+type UserDTO = Static<typeof userDto>
+
+const storeUserSchema = Type.Object({
+  args: user
+})
+
+type StoreUser = Static<typeof storeUserSchema>
+
+export { userDto, UserDTO, user, User, storeUserSchema, StoreUser }
+`,
+      file: `${projectName}/src/schemas/user.ts`
+    }
+  }
+
+  await writeFile(schemas.index.file, schemas.index.content)
+  await writeFile(schemas.user.file, schemas.user.content)
+}

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

@@ -0,0 +1,218 @@
+const { platform } = require('os')
+const { promisify } = require('util')
+const exec = promisify(require('child_process').exec)
+const writeFile = require('../../utils/writeFile')
+
+/**
+ * @param {Object} args
+ * @param {String} args.projectName
+ */
+module.exports = async ({ projectName }) => {
+  const createFoldersCommand = `mkdir ${projectName}/src/services \
+${projectName}/src/services/utils \
+${projectName}/src/services/utils/messages`
+
+  if (platform() === 'win32')
+    await exec(createFoldersCommand.replaceAll('/', '\\'))
+  else await exec(createFoldersCommand)
+
+  const services = {
+    index: {
+      content: "export * from './user'\n",
+      file: `${projectName}/src/services/index.ts`
+    },
+    user: {
+      content: `import httpErrors from 'http-errors'
+
+import { store, remove, get, update } from 'database'
+import { UserDTO } from 'schemas'
+import { EFU, MFU, GE, errorHandling } from './utils'
+
+type Process = {
+  type: 'store' | 'getAll' | 'deleteAll' | 'getOne' | 'update' | 'delete'
+}
+
+type Arguments = {
+  id?: string
+  userDto?: UserDTO
+  userDtoWithoutId?: Omit<UserDTO, 'id'>
+}
+
+class UserService {
+  #args: Arguments
+
+  constructor(args: Arguments = {}) {
+    this.#args = args
+  }
+
+  public process({ type }: Process): Promise<string | UserDTO | UserDTO[]> {
+    switch (type) {
+      case 'store':
+        return this.#store()
+      case 'getAll':
+        return this.#getAll()
+      case 'deleteAll':
+        return this.#deleteAll()
+      case 'getOne':
+        return this.#getOne()
+      case 'update':
+        return this.#update()
+      case 'delete':
+        return this.#delete()
+      default:
+        throw new httpErrors.InternalServerError(GE.INTERNAL_SERVER_ERROR)
+    }
+  }
+
+  async #store(): Promise<UserDTO> {
+    try {
+      if (!this.#args.userDtoWithoutId)
+        throw new httpErrors.UnprocessableEntity(GE.INTERNAL_SERVER_ERROR)
+
+      const result = await store({
+        ...this.#args.userDtoWithoutId
+      })
+
+      return result
+    } catch (e) {
+      return errorHandling(e, GE.INTERNAL_SERVER_ERROR)
+    }
+  }
+
+  async #getAll(): Promise<UserDTO[]> {
+    try {
+      const users = (await get()) as UserDTO[]
+
+      return users
+    } catch (e) {
+      return errorHandling(e, GE.INTERNAL_SERVER_ERROR)
+    }
+  }
+
+  async #deleteAll(): Promise<string> {
+    try {
+      const usersDeleted = (await remove()) as number
+
+      if (usersDeleted >= 1) return MFU.ALL_USERS_DELETED
+
+      if (usersDeleted === 0)
+        throw new httpErrors.Conflict(EFU.NOTHING_TO_DELETE)
+
+      throw new httpErrors.InternalServerError(GE.INTERNAL_SERVER_ERROR)
+    } catch (e) {
+      return errorHandling(e, GE.INTERNAL_SERVER_ERROR)
+    }
+  }
+
+  async #getOne(): Promise<UserDTO> {
+    try {
+      if (!this.#args.id)
+        throw new httpErrors.UnprocessableEntity(GE.INTERNAL_SERVER_ERROR)
+
+      const { id } = this.#args
+      const user = (await get(id)) as UserDTO | null
+
+      if (!user) throw new httpErrors.NotFound(EFU.NOT_FOUND)
+
+      return user
+    } catch (e) {
+      return errorHandling(e, GE.INTERNAL_SERVER_ERROR)
+    }
+  }
+
+  async #update(): Promise<UserDTO> {
+    try {
+      if (!this.#args.userDto || !this.#args.userDto.id)
+        throw new httpErrors.UnprocessableEntity(GE.INTERNAL_SERVER_ERROR)
+
+      const updatedUser = await update(this.#args.userDto)
+
+      if (!updatedUser) throw new httpErrors.NotFound(EFU.NOT_FOUND)
+
+      return updatedUser
+    } catch (e) {
+      return errorHandling(e, GE.INTERNAL_SERVER_ERROR)
+    }
+  }
+
+  async #delete(): Promise<string> {
+    try {
+      if (!this.#args.id)
+        throw new httpErrors.UnprocessableEntity(GE.INTERNAL_SERVER_ERROR)
+
+      const { id } = this.#args
+      const deletedUser = await remove(id)
+
+      if (!deletedUser) throw new httpErrors.NotFound(EFU.NOT_FOUND)
+
+      return MFU.USER_DELETED
+    } catch (e) {
+      return errorHandling(e, GE.INTERNAL_SERVER_ERROR)
+    }
+  }
+}
+
+export { UserService }
+`,
+      file: `${projectName}/src/services/user.ts`
+    },
+    utils: {
+      index: {
+        content: `import httpErrors from 'http-errors'
+
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+const errorHandling = (e: any, message?: string): never => {
+  console.error(e)
+
+  if (e instanceof httpErrors.HttpError) throw e
+
+  throw new httpErrors.InternalServerError(message ?? e.message)
+}
+
+export { errorHandling }
+export * from './messages'
+`,
+        file: `${projectName}/src/services/utils/index.ts`
+      }
+    },
+    'utils/messages': {
+      index: {
+        content: `enum GenericErrors {
+  INTERNAL_SERVER_ERROR = 'Something went wrong'
+}
+
+export { GenericErrors as GE }
+export * from './user'
+`,
+        file: `${projectName}/src/services/utils/messages/index.ts`
+      },
+      user: {
+        content: `enum ErrorForUser {
+  NOT_FOUND = 'The requested user does not exists',
+  NOTHING_TO_DELETE = 'There is no user to be deleted'
+}
+
+enum MessageForUser {
+  ALL_USERS_DELETED = 'All the users were deleted successfully',
+  USER_DELETED = 'The requested user was successfully deleted'
+}
+
+export { ErrorForUser as EFU, MessageForUser as MFU }
+`,
+        file: `${projectName}/src/services/utils/messages/user.ts`
+      }
+    }
+  }
+
+  await writeFile(services.index.file, services.index.content)
+  await writeFile(services.user.file, services.user.content)
+  await writeFile(services.utils.index.file, services.utils.index.content)
+  await writeFile(
+    services['utils/messages'].index.file,
+    services['utils/messages'].index.content
+  )
+  await writeFile(
+    services['utils/messages'].user.file,
+    services['utils/messages'].user.content
+  )
+}

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

@@ -0,0 +1,80 @@
+const { platform } = require('os')
+const { promisify } = require('util')
+const exec = promisify(require('child_process').exec)
+const writeFile = require('../../utils/writeFile')
+
+/**
+ * @param {Object} args
+ * @param {Boolean} args.express
+ * @param {String} args.projectName
+ */
+module.exports = async ({ express, projectName }) => {
+  const createFoldersCommand = `mkdir ${projectName}/src/@types \
+${projectName}/src/@types/models \
+${express ? `${projectName}/src/@types/custom` : ''}`
+
+  if (platform() === 'win32')
+    await exec(createFoldersCommand.replaceAll('/', '\\'))
+  else await exec(createFoldersCommand)
+
+  const types = {
+    index: {
+      content: `/* eslint-disable no-var */
+declare global {}
+
+export {}
+`,
+      file: `${projectName}/src/@types/index.d.ts`
+    },
+    models: {
+      user: {
+        content: `interface UserDBO {
+  id: string
+  name: string
+  lastName: string
+  createdAt: Date
+  updatedAt: Date
+}
+`,
+        file: `${projectName}/src/@types/models/user.d.ts`
+      }
+    },
+    ...(express && {
+      custom: {
+        request: {
+          content: `type ExpressRequest = import('express').Request
+
+interface CustomRequest extends ExpressRequest {
+  body: {
+    args?: import('schemas').UserDTO
+  }
+  // We can add custom headers via intersection, remember that for some reason
+  // headers must be in Snake-Pascal-Case
+  headers: import('http').IncomingHttpHeaders & {
+    'Custom-Header'?: string
+  }
+}
+`,
+          file: `${projectName}/src/@types/custom/request.d.ts`
+        },
+        response: {
+          content: `type ExpressResponse = import('express').Response
+
+interface CustomResponse extends ExpressResponse {
+  newValue?: string
+}
+`,
+          file: `${projectName}/src/@types/custom/response.d.ts`
+        }
+      }
+    })
+  }
+
+  await writeFile(types.index.file, types.index.content)
+  await writeFile(types.models.user.file, types.models.user.content)
+
+  if (express) {
+    await writeFile(types.custom.request.file, types.custom.request.content)
+    await writeFile(types.custom.response.file, types.custom.response.content)
+  }
+}