refactor: database package

Author: winverse

apps/book-server/scripts/createMock.mts

@@ -107,7 +107,7 @@ class Seeder {
 }
 
 const main = async () => {
-  const mongo = new MongoService()
+  const mongo = new MongoService({ datasourceUrl: process.env.MONGO_URL })
   const seeder = new Seeder(mongo)
 
   try {

apps/cron/src/lib/db/DbService.ts

@@ -1,6 +1,13 @@
+import { ENV } from '@env'
 import { PrismaClient } from '@packages/database/velog-rds'
 import { injectable, singleton } from 'tsyringe'
 
 @injectable()
 @singleton()
-export class DbService extends PrismaClient {}
+export class DbService extends PrismaClient {
+  constructor() {
+    super({
+      datasourceUrl: ENV.databaseUrl,
+    })
+  }
+}

apps/server/package.json

@@ -23,7 +23,8 @@
     "test": "pnpm jest --detectOpenHandles",
     "create-service": "tsx ./scripts/createService.ts",
     "create-mock": "NODE_ENV=development tsx ./scripts/createMock.ts",
-    "ssm": "tsx ./scripts/ssm.mts"
+    "ssm": "tsx ./scripts/ssm.mts",
+    "turbo": "turbo build"
   },
   "dependencies": {
     "@aws-sdk/client-s3": "^3.473.0",

apps/server/src/lib/db/DbService.ts

@@ -1,6 +1,13 @@
+import { ENV } from '@env'
 import { PrismaClient } from '@packages/database/velog-rds'
 import { injectable, singleton } from 'tsyringe'
 
 @injectable()
 @singleton()
-export class DbService extends PrismaClient {}
+export class DbService extends PrismaClient {
+  constructor() {
+    super({
+      datasourceUrl: ENV.databaseUrl,
+    })
+  }
+}

apps/server/src/lib/discord/DiscordService.ts

@@ -1,14 +1,15 @@
-import { container, injectable, singleton } from 'tsyringe'
+import { injectable, singleton } from 'tsyringe'
 import { Client, GatewayIntentBits } from 'discord.js'
 import { ENV } from '@env'
-import { RedisService } from '@lib/redis/RedisService.js'
 import { Time } from '@constants/TimeConstants.js'
+import { RedisService } from '@lib/redis/RedisService.js'
 
 @injectable()
 @singleton()
 export class DiscordService {
   private client!: Client
   public isSending: boolean = false
+  constructor(private readonly redis: RedisService) {}
   public connection(): Promise<Client> {
     return new Promise((resolve) => {
       this.client = new Client({
@@ -57,11 +58,10 @@ export class DiscordService {
     }
 
     if (typeof payload === 'object' && message.includes('WritePost') && payload?.user?.id) {
-      const redisService = container.resolve(RedisService)
-      const key = redisService.generateKey.errorMessageCache(payload.type, payload?.user?.id)
-      const exists = await redisService.exists(key)
+      const key = this.redis.generateKey.errorMessageCache(payload.type, payload?.user?.id)
+      const exists = await this.redis.exists(key)
       if (exists === 1) return
-      await redisService.setex(key, Time.ONE_MINUTE_IN_S * 10, 'true')
+      await this.redis.setex(key, Time.ONE_MINUTE_IN_S * 10, 'true')
     }
 
     try {

apps/server/src/main.mts

@@ -11,17 +11,14 @@ async function main() {
   app.listen({ port: ENV.port, host: '::' })
 
   const dbService = container.resolve(DbService)
-  await dbService.$connect()
+  await dbService.connection()
 
   const redis = container.resolve(RedisService)
-  await redis.connection().then((message) => console.log(message))
+  await redis.connection()
 
   const discord = container.resolve(DiscordService)
   await discord.connection()
 
-  console.info(`INFO: Database connected to "${ENV.databaseUrl.split('@')[1]}"`)
-  console.info(`INFO: Redis connected to "${ENV.redisHost}:${ENV.redisPort}"`)
-
   process.send?.('ready')
   process.on('SIGINT', function () {
     startClosing()

apps/server/src/services/UserService/index.ts

@@ -19,11 +19,10 @@ import { UtilsService } from '@lib/utils/UtilsService.js'
 import DataLoader from 'dataloader'
 import { AuthService } from '@services/AuthService/index.js'
 import { FastifyReply } from 'fastify'
-import { RedisService } from '@lib/redis/RedisService.js'
+import { RedisService, ChangeEmailArgs } from '@lib/redis/RedisService.js'
 import { changeEmailTemplate } from '@template/changeEmailTemplate.js'
 import { ENV } from '@env'
 import { MailService } from '@lib/mail/MailService.js'
-import { ChangeEmailArgs } from '@lib/redis/RedisService.js'
 import { differenceInDays } from 'date-fns'
 
 interface Service {

apps/web/package.json

@@ -30,7 +30,7 @@
     "@sentry/browser": "^7.75.0",
     "@tanstack/react-query": "^5.29.0",
     "axios": "^1.4.0",
-    "codemirror": "5.51",
+    "codemirror": "~6.0.1",
     "date-fns": "^2.30.0",
     "date-fns-tz": "^2.0.0",
     "dotenv": "^16.3.1",

packages/database/prisma/velog-rds/schema.prisma

@@ -653,8 +653,3 @@ model DynamicConfigItem {
   @@index([value])
   @@map("dynamic_config_items")
 }
-
-model HiDgimon {
-  id    String @id @default(dbgenerated("uuid_generate_v4()")) @db.Uuid
-  value String @db.VarChar(50)
-}

packages/database/scripts/env.mts

@@ -0,0 +1,34 @@
+import path from 'path'
+import { z } from 'zod'
+import { existsSync } from 'fs'
+import dotenv from 'dotenv'
+
+// Only used for migration and deployment
+if (!process.env.DOCKER_ENV && process.env.NODE_ENV !== undefined) {
+  console.error(
+    'Development environment was initiated, despite the absence of the Docker environment.',
+  )
+}
+
+const configPath = path.resolve(process.cwd(), '.env')
+
+if (!existsSync(configPath)) {
+  console.log(`Read target: ${configPath}`)
+  throw new Error('Not found environment file')
+}
+
+dotenv.config({ path: configPath })
+
+const env = z.object({
+  velogRdsUrl: z.string(),
+  velogBookMongoUrl: z.string(),
+  velogRedisHost: z.string(),
+  velogRedisPort: z.number(),
+})
+
+export const ENV = env.parse({
+  velogRdsUrl: process.env.VELOG_RDS_URL,
+  velogBookMongoUrl: process.env.VELOG_BOOK_MONGO_URL,
+  velogRedisHost: process.env.VELOG_REDIS_HOST,
+  velogRedisPort: Number(process.env.VELOG_REDIS_PORT),
+})

packages/database/scripts/mongoDeploy.mts

@@ -1,5 +1,6 @@
 import inquirer from 'inquirer'
 import { exec } from 'child_process'
+import { ENV } from 'scripts/env.mjs'
 
 const main = async () => {
   const { answer } = await inquirer.prompt([
@@ -12,6 +13,8 @@ const main = async () => {
     },
   ])
 
+  console.log(`Target Database Info: ${ENV.velogBookMongoUrl}`)
+
   if (answer === 'No') {
     console.info('🚫 db push process stopped by user.')
     process.exit(0)

packages/database/scripts/rdsDeploy.mts

@@ -3,18 +3,21 @@ import path from 'path'
 import fs from 'fs'
 import inquirer from 'inquirer'
 import { exec } from 'child_process'
+import { ENV } from 'scripts/env.mjs'
 
 // "prisma-migrate:deploy": "pnpm env:copy && pnpm prisma migrate deploy --schema=./prisma/velog-rds/schema.prisma"
 
-const db = new PrismaClient()
+const db = new PrismaClient({ datasourceUrl: ENV.velogRdsUrl })
+const migraionsPath = './prisma/velog-rds/migrations'
 
 const main = async () => {
   const filenames = getMigrationFilenames()
   const appliedMigrationNames = await getAppliedMigrationNames()
   const diff = filenames.filter((filename) => !appliedMigrationNames.includes(filename))
 
   const message = getMessage(diff)
-  console.log(`Target Database Info: ${process.env.DATABASE_URL}\n`)
+
+  console.log(`Target Database Info: ${ENV.velogRdsUrl}`)
 
   const { answer } = await inquirer.prompt([
     {
@@ -45,7 +48,7 @@ const main = async () => {
 main()
 
 function getMigrationFilenames() {
-  const dirPath = path.resolve(process.cwd(), './prisma/migrations/')
+  const dirPath = path.resolve(process.cwd(), migraionsPath)
   return fs.readdirSync(dirPath).filter((file) => path.extname(file) !== '.toml')
 }
 
@@ -66,12 +69,7 @@ function getMessage(migrationDiff: string[]): string {
 }
 
 function getMigrationSummary(filename: string) {
-  const filepath = path.resolve(
-    process.cwd(),
-    `./prisma/migrations`,
-    `${filename}`,
-    './migration.sql',
-  )
+  const filepath = path.resolve(process.cwd(), migraionsPath, `${filename}`, './migration.sql')
 
   const sql = fs.readFileSync(filepath, { encoding: 'utf-8' })
   const lines = sql.split('\n')

packages/database/src/lib/env/EnvService.mts

@@ -1 +1,19 @@
+import type { PrismaClientOptions } from '@prisma/client/runtime/library'
+import { PrismaClient as Client } from '@prisma/velog-book-mongo/client/index.js'
 export * from '@prisma/velog-book-mongo/client/index.js'
+
+type Options = Omit<PrismaClientOptions, 'transactionOptions'>
+
+export class PrismaClient extends Client {
+  private datasourceUrl: string
+  constructor(options: Options) {
+    if (!options.datasourceUrl) throw new Error('velog book datasourceUrl is required')
+    super(options)
+    this.datasourceUrl = options.datasourceUrl
+  }
+
+  public async connection(): Promise<void> {
+    await super.$connect()
+    console.info(`INFO: Database connected to "${this.datasourceUrl.split('@')[1]}"`)
+  }
+}

packages/database/src/velog-book-mongo/index.mts

@@ -1 +1,19 @@
+import type { PrismaClientOptions } from '@prisma/client/runtime/library'
+import { PrismaClient as Client } from '@prisma/velog-rds/client/index.js'
 export * from '@prisma/velog-rds/client/index.js'
+
+type Options = Omit<PrismaClientOptions, 'transactionOptions'>
+
+export class PrismaClient extends Client {
+  private datasourceUrl: string
+  constructor(options: Options) {
+    if (!options.datasourceUrl) throw new Error('velog rds datasourceUrl is required')
+    super(options)
+    this.datasourceUrl = options.datasourceUrl
+  }
+
+  public async connection(): Promise<void> {
+    await super.$connect()
+    console.info(`INFO: Database connected to "${this.datasourceUrl.split('@')[1]}"`)
+  }
+}

packages/database/src/velog-rds/index.mts

@@ -1,7 +1,7 @@
 import Redis from 'ioredis'
 
 interface Service {
-  connection(): Promise<string>
+  connection(): Promise<void>
   get generateKey(): GenerateRedisKey
   get queueName(): Record<QueueName, string>
   createFeedQueue(data: CreateFeedArgs): Promise<number>
@@ -14,15 +14,20 @@ type RedisOptions = {
 
 export class RedisService extends Redis.default implements Service {
   host: string
+  port: number
   constructor({ port, host }: RedisOptions) {
+    if (!port) throw new Error('redis port is required')
+    if (!host) throw new Error('redis host is required')
     super({ port: port, host })
     this.host = host
+    this.port = port
   }
 
-  public async connection(): Promise<string> {
+  public async connection(): Promise<void> {
     return new Promise((resolve) => {
-      this.connect(() => {
-        resolve(`Redis connection established to ${this.host}`)
+      super.connect(() => {
+        resolve()
+        console.info(`INFO: Redis connected to "${this.host}:${this.port}"`)
       })
     })
   }