@anthonylzq/simba.js 7.2.0 → 8.0.0

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

@@ -3,299 +3,260 @@ const { promisify } = require('util')
 const exec = promisify(require('child_process').exec)
 const writeFile = require('../../utils/writeFile')
 
+const dbPrismaName = {
+  postgres: 'postgresql',
+  mysql: 'mysql',
+  mariadb: 'mysql',
+  sqlite: 'sqlite',
+  sqlServer: 'sqlserver',
+  mongo: 'mongodb'
+}
+
+const dbPrettyName = {
+  postgres: 'PostgreSQL',
+  mysql: 'MySQL',
+  mariadb: 'MariaDB',
+  sqlite: 'SQLite',
+  sqlServer: 'SQL Server',
+  mongo: 'MongoDB'
+}
+
 /**
  * @param {Object} args
  * @param {String} args.projectName
- * @param {Boolean} args.fastify
+ * @param {import('../../../../').Config['database']} args.db
  */
-const mongoF = async ({ projectName, fastify }) => {
-  const createFoldersCommand = `mkdir ${projectName}/src/database/mongo \
-${projectName}/src/database/mongo/models \
-${projectName}/src/database/mongo/queries`
+const db = async ({ projectName, db }) => {
+  const isMongo = db === 'mongo'
+  const createFoldersCommands = `mkdir ${projectName}/prisma \
+${projectName}/src/database/${db} \
+${projectName}/src/database/${db}/queries`
 
   if (platform() === 'win32')
-    await exec(createFoldersCommand.replaceAll('/', '\\'))
-  else await exec(createFoldersCommand)
+    await exec(createFoldersCommands.replaceAll('/', '\\'))
+  else await exec(createFoldersCommands)
 
   const database = {
-    index: {
-      content: "export * from './mongo'\n",
-      file: `${projectName}/src/database/index.ts`
-    },
-    mongo: {
-      connection: {
-        content: fastify
-          ? `import { connect, connection } from 'mongoose'
-import { FastifyLoggerInstance } from 'fastify'
-
-const ENVIRONMENTS_WITHOUT_RECONNECTION = ['ci', 'local']
-const dbConnection = async (
-  logger: FastifyLoggerInstance
-): Promise<{
-  connect: () => Promise<typeof import('mongoose')>
-  disconnect: () => Promise<void>
-}> => {
-  const connectionConfig = {
-    keepAlive: true,
-    useNewUrlParser: true,
-    useUnifiedTopology: true
-  }
-
-  connection.on('connected', () => {
-    logger.info('Mongo connection established.')
-  })
-  connection.on('reconnected', () => {
-    logger.info('Mongo connection reestablished')
-  })
-  connection.on('disconnected', () => {
-    if (
-      !ENVIRONMENTS_WITHOUT_RECONNECTION.includes(
-        process.env.NODE_ENV as string
-      )
-    ) {
-      logger.info(
-        'Mongo connection disconnected. Trying to reconnected to Mongo...'
-      )
-      setTimeout(() => {
-        connect(process.env.DB_URI as string, {
-          ...connection,
-          connectTimeoutMS: 3000,
-          socketTimeoutMS: 3000
-        })
-      }, 3000)
-    }
-  })
-  connection.on('close', () => {
-    logger.info('Mongo connection closed')
-  })
-  connection.on('error', (e: Error) => {
-    logger.info('Mongo connection error:')
-    logger.error(e)
-  })
+    schema: {
+      content: `generator client {
+  provider = "prisma-client-js"
+}
 
-  return {
-    connect: () => connect(process.env.DB_URI as string, connectionConfig),
-    disconnect: () => connection.close()
-  }
+datasource db {
+  provider = "${dbPrismaName[db]}"
+  url      = ${db !== 'sqlite' ? 'env("DATABASE_URL")' : '"file:./dev.db"'}
 }
 
-export { dbConnection }
-`
-          : `import { connect, connection } from 'mongoose'
-import { HttpLogger } from 'express-pino-logger'
-
-const ENVIRONMENTS_WITHOUT_RECONNECTION = ['ci', 'local']
-const dbConnection = async (
-  logger: HttpLogger['logger']
-): Promise<{
-  connect: () => Promise<typeof import('mongoose')>
-  disconnect: () => Promise<void>
-}> => {
-  const connectionConfig = {
-    keepAlive: true,
-    useNewUrlParser: true,
-    useUnifiedTopology: true
+model User {
+  ${
+    isMongo
+      ? `id       String @id @default(auto()) @map("_id") @db.ObjectId
+  lastName String
+  name     String`
+      : `id       Int    @id @default(autoincrement())
+  lastName String
+  name     String`
   }
 
-  connection.on('connected', () => {
-    logger.info('Mongo connection established.')
-  })
-  connection.on('reconnected', () => {
-    logger.info('Mongo connection reestablished')
-  })
-  connection.on('disconnected', () => {
-    if (
-      !ENVIRONMENTS_WITHOUT_RECONNECTION.includes(
-        process.env.NODE_ENV as string
-      )
-    ) {
-      logger.info(
-        'Mongo connection disconnected. Trying to reconnected to Mongo...'
-      )
-      setTimeout(() => {
-        connect(process.env.DB_URI as string, {
-          ...connection,
-          connectTimeoutMS: 3000,
-          socketTimeoutMS: 3000
-        })
-      }, 3000)
-    }
-  })
-  connection.on('close', () => {
-    logger.info('Mongo connection closed')
-  })
-  connection.on('error', (e: Error) => {
-    logger.info('Mongo connection error:')
-    logger.error(e)
-  })
+  createdAt DateTime @default(now())
+  updatedAt DateTime @updatedAt
 
-  return {
-    connect: () => connect(process.env.DB_URI as string, connectionConfig),
-    disconnect: () => connection.close()
-  }
+  @@map("users")
 }
-
-export { dbConnection }
 `,
-        file: `${projectName}/src/database/mongo/connection.ts`
-      },
+      file: `${projectName}/prisma/schema.prisma`
+    },
+    index: {
+      content: `export * from './${db}'\n`,
+      file: `${projectName}/src/database/index.ts`
+    },
+    [db]: {
       index: {
-        content: `export * from './models'
-export * from './queries'
-export * from './connection'
-`,
-        file: `${projectName}/src/database/mongo/index.ts`
+        content: `export * from './connection'
+export * from './queries'\n`,
+        file: `${projectName}/src/database/${db}/index.ts`
       },
-      models: {
-        index: {
-          content: "export * from './user'\n",
-          file: `${projectName}/src/database/mongo/models/index.ts`
-        },
-        user: {
-          content: `import { model, Schema } from 'mongoose'
+      connection: {
+        content: `import { PrismaClient } from '@prisma/client'
+import { Debugger } from 'debug'
+
+let dbConnected = false
+
+declare global {
+  // eslint-disable-next-line no-var
+  var __client__: PrismaClient
+}
 
-const UserSchema = new Schema<UserDBO>(
-  {
-    lastName: {
-      required: true,
-      type: String
+const dbConnection = (
+  d?: Debugger
+): {
+  connect: () => Promise<PrismaClient>
+  disconnect: () => Promise<boolean>
+} => {
+  return {
+    connect: async () => {
+      if (!global.__client__) {
+        global.__client__ = new PrismaClient()
+        await global.__client__.$connect()
+        dbConnected = true
+        d?.('${dbPrettyName[db]} connection established.')
+      }
+
+      return global.__client__
     },
-    name: {
-      required: true,
-      type: String
-    }
-  },
-  {
-    timestamps: true,
-    versionKey: false,
-    toObject: {
-      transform: (_, ret) => {
-        ret.id = ret._id.toString()
-        delete ret._id
+    disconnect: async () => {
+      if (global.__client__) {
+        dbConnected = false
+        await global.__client__.$disconnect()
+        d?.('${dbPrettyName[db]} connection closed.')
       }
+
+      return dbConnected
     }
   }
-)
-
-const UserModel = model<UserDBO>('users', UserSchema)
+}
 
-export { UserModel }
-`,
-          file: `${projectName}/src/database/mongo/models/user.ts`
-        }
+export { dbConnection }\n`,
+        file: `${projectName}/src/database/${db}/connection.ts`
       },
       queries: {
         index: {
           content: "export * from './user'\n",
-          file: `${projectName}/src/database/mongo/queries/index.ts`
+          file: `${projectName}/src/database/${db}/queries/index.ts`
         },
         user: {
-          content: `import { Document, MergeType, Types } from 'mongoose'
-
-import { UserModel } from '..'
-import { User, UserDTO, UserWithId } from 'schemas'
-
-const userDBOtoDTO = (
-  userDBO: Document<unknown, unknown, MergeType<UserDBO, UserDBO>> &
-    Omit<UserDBO, keyof UserDBO> &
-    UserDBO & {
-      _id: Types.ObjectId
-    }
-): UserDTO => ({
-  ...userDBO.toObject(),
-  createdAt: userDBO.createdAt.toISOString(),
-  updatedAt: userDBO.updatedAt.toISOString()
-})
-
-const store = async (userData: User): Promise<UserDTO> => {
-  const user = new UserModel(userData)
-
-  await user.save()
-
-  return userDBOtoDTO(user)
+          content: `import { User } from '@prisma/client'
+import debug from 'debug'
+
+import { dbConnection } from '../connection'
+import { Id, User as UserSchema, UserDTO } from 'schemas'
+import { Logger } from 'utils'
+
+const LOGGER = new Logger(debug('App:Database:Queries:User'))
+
+const userDBOtoDTO = (userDBO: User): UserDTO =>
+  ({
+    ...userDBO,
+    createdAt: userDBO.createdAt.toISOString(),
+    updatedAt: userDBO.updatedAt.toISOString()
+  }) as UserDTO
+
+const store = async (userData: UserSchema) => {
+  try {
+    const client = await dbConnection().connect()
+    const user = await client.user.create({
+      data: userData
+    })
+
+    return userDBOtoDTO(user)
+  } catch (error) {
+    LOGGER.log({
+      origin: 'queries/user.ts',
+      method: store.name,
+      value: 'error',
+      content: error
+    })
+
+    return null
+  }
 }
 
-const remove = async (
-  id: string | null = null
-): Promise<UserDTO | number | null> => {
-  if (id) {
-    const removedUser = await UserModel.findByIdAndRemove(id)
-
-    if (!removedUser) return null
-
-    return userDBOtoDTO(removedUser)
+const removeById = async (id: Id) => {
+  try {
+    const client = await dbConnection().connect()
+    await client.user.delete({
+      where: { id }
+    })
+
+    return true
+  } catch (error) {
+    LOGGER.log({
+      origin: 'queries/user.ts',
+      method: removeById.name,
+      value: 'error',
+      content: error
+    })
+
+    return false
   }
-
-  return (await UserModel.deleteMany({})).deletedCount
 }
 
-const get = async (
-  id: string | null = null
-): Promise<UserDTO[] | UserDTO | null> => {
-  if (id) {
-    const user = await UserModel.findById(id)
-
-    return user ? userDBOtoDTO(user) : null
+const getById = async (id: Id) => {
+  try {
+    const client = await dbConnection().connect()
+    const user = await client.user.findUnique({
+      where: { id }
+    })
+
+    if (!user) return null
+
+    return userDBOtoDTO(user)
+  } catch (error) {
+    LOGGER.log({
+      origin: 'queries/user.ts',
+      method: getById.name,
+      value: 'error',
+      content: error
+    })
+
+    return null
   }
-
-  const users = await UserModel.find({})
-
-  return users.map(u => userDBOtoDTO(u))
 }
 
-const update = async (userData: UserWithId): Promise<UserDTO | null> => {
-  const { id, ...rest } = userData
-  const user = await UserModel.findByIdAndUpdate(id, rest, { new: true })
-
-  return user ? userDBOtoDTO(user) : null
+const update = async (id: Id, user: UserSchema) => {
+  try {
+    const client = await dbConnection().connect()
+    const userUpdated = await client.user.update({
+      where: { id },
+      data: user
+    })
+
+    if (!userUpdated) return null
+
+    return userDBOtoDTO(userUpdated)
+  } catch (error) {
+    LOGGER.log({
+      origin: 'queries/user.ts',
+      method: update.name,
+      value: 'error',
+      content: error
+    })
+
+    return null
+  }
 }
 
-export { store, remove, get, update }
-`,
-          file: `${projectName}/src/database/mongo/queries/user.ts`
+export { store, removeById, getById, update }\n`,
+          file: `${projectName}/src/database/${db}/queries/user.ts`
         }
       }
     }
   }
 
   await Promise.all([
+    writeFile(database.schema.file, database.schema.content),
     writeFile(database.index.file, database.index.content),
+    writeFile(database[db].connection.file, database[db].connection.content),
+    writeFile(database[db].index.file, database[db].index.content),
     writeFile(
-      database.mongo.connection.file,
-      database.mongo.connection.content
-    ),
-    writeFile(database.mongo.index.file, database.mongo.index.content),
-    writeFile(
-      database.mongo.models.index.file,
-      database.mongo.models.index.content
-    ),
-    writeFile(
-      database.mongo.models.user.file,
-      database.mongo.models.user.content
-    ),
-    writeFile(
-      database.mongo.queries.index.file,
-      database.mongo.queries.index.content
+      database[db].queries.index.file,
+      database[db].queries.index.content
     ),
-    writeFile(
-      database.mongo.queries.user.file,
-      database.mongo.queries.user.content
-    )
+    writeFile(database[db].queries.user.file, database[db].queries.user.content)
   ])
 }
 
 /**
  * @param {Object} args
- * @param {Boolean|undefined} args.mongo
+ * @param {import('../../../../').Config['database']} args.database
  * @param {String} args.projectName
- * @param {Boolean} args.fastify
  */
-module.exports = async ({ mongo = true, projectName, fastify }) => {
+module.exports = async ({ database, projectName }) => {
   const createFoldersCommand = `mkdir ${projectName}/src/database`
 
   if (platform() === 'win32')
     await exec(createFoldersCommand.replaceAll('/', '\\'))
   else await exec(createFoldersCommand)
 
-  if (mongo) await mongoF({ projectName, fastify })
+  await db({ db: database, projectName })
 }