feat(caching): add redis

Author: chertik77

.env.example

@@ -2,6 +2,10 @@ CLOUDINARY_API_KEY=
 CLOUDINARY_API_SECRET=
 CLOUDINARY_CLOUD_NAME=
 DATABASE_URL=
+REDIS_USERNAME=
+REDIS_PASSWORD=
+REDIS_HOST=
+REDIS_PORT=
 GOOGLE_CLIENT_ID=
 GOOGLE_CLIENT_SECRET=
 PORT=

app/config/env.config.ts

@@ -11,9 +11,19 @@ const envSchema = z.object({
   DATABASE_URL: z.string(),
   GOOGLE_CLIENT_ID: z.string(),
   GOOGLE_CLIENT_SECRET: z.string(),
+  REDIS_USERNAME: z.string(),
+  REDIS_PASSWORD: z.string(),
+  REDIS_HOST: z.string(),
+  REDIS_PORT: z.preprocess(
+    v => (v ? v : undefined),
+    z.coerce.number().int().positive()
+  ),
   ACCESS_JWT_SECRET: z.string().transform(v => new TextEncoder().encode(v)),
   REFRESH_JWT_SECRET: z.string().transform(v => new TextEncoder().encode(v)),
-  PORT: z.preprocess(v => (v ? v : undefined), z.coerce.number().int()),
+  PORT: z.preprocess(
+    v => (v ? v : undefined),
+    z.coerce.number().int().positive()
+  ),
   API_PREFIX: z.string(),
   NODE_ENV: z.enum(['development', 'production']),
   ALLOWED_ORIGINS: z

app/config/index.ts

@@ -1,3 +1,4 @@
 export { transport } from './mailer.config'
 export { default } from './cloudinary.config'
 export { env } from './env.config'
+export { redis } from './redis.config'

app/config/redis.config.ts

@@ -0,0 +1,10 @@
+import Redis from 'ioredis'
+
+import { env } from './env.config'
+
+export const redis = new Redis({
+  username: env.REDIS_USERNAME,
+  password: env.REDIS_PASSWORD,
+  host: env.REDIS_HOST,
+  port: env.REDIS_PORT
+})

app/controllers/auth.controller.ts

@@ -170,7 +170,7 @@ class AuthController {
   logout = async ({ session }: Request, res: Response) => {
     await prisma.session.delete({ where: { id: session } })
 
-    res.status(204).send()
+    res.sendStatus(204)
   }
 
   private getNewTokens = async (payload: JwtPayload) => {

app/controllers/board.controller.ts

@@ -13,33 +13,54 @@ import type { NextFunction, Request, Response } from 'express'
 import { prisma } from '@/prisma'
 import { NotFound } from 'http-errors'
 
+import { redis } from '@/config'
 import boardImages from '@/data/board-bg-images.json'
 
 class BoardController {
   getAll = async ({ user }: Request, res: Response) => {
-    const boards = await prisma.board.findMany({ where: { userId: user.id } })
+    const cacheKey = `boards:user:${user.id}:all`
 
-    res.json(boards)
+    const cachedBoards = await redis.get(cacheKey)
+
+    if (cachedBoards) {
+      res.json(JSON.parse(cachedBoards))
+    } else {
+      const boards = await prisma.board.findMany({ where: { userId: user.id } })
+
+      await redis.set(cacheKey, JSON.stringify(boards))
+
+      res.json(boards)
+    }
   }
 
   getById = async (
     { user, params }: TypedRequestParams<typeof BoardParamsSchema>,
     res: Response,
     next: NextFunction
   ) => {
-    const board = await prisma.board.findFirst({
-      where: { id: params.boardId, userId: user.id },
-      include: {
-        columns: {
-          orderBy: { order: 'asc' },
-          include: { cards: { orderBy: { order: 'asc' } } }
+    const cacheKey = `board:${params.boardId}:user:${user.id}`
+
+    const cachedBoard = await redis.get(cacheKey)
+
+    if (cachedBoard) {
+      res.json(JSON.parse(cachedBoard))
+    } else {
+      const board = await prisma.board.findFirst({
+        where: { id: params.boardId, userId: user.id },
+        include: {
+          columns: {
+            orderBy: { order: 'asc' },
+            include: { cards: { orderBy: { order: 'asc' } } }
+          }
         }
-      }
-    })
+      })
+
+      if (!board) return next(NotFound('Board not found'))
 
-    if (!board) return next(NotFound('Board not found'))
+      await redis.set(cacheKey, JSON.stringify(board))
 
-    res.json(board)
+      res.json(board)
+    }
   }
 
   add = async (
@@ -54,6 +75,8 @@ class BoardController {
       }
     })
 
+    await redis.del(`boards:user:${user.id}:all`)
+
     res.json(newBoard)
   }
 
@@ -76,6 +99,9 @@ class BoardController {
 
     if (!updatedBoard) return next(NotFound('Board not found'))
 
+    await redis.del(`board:${updatedBoard.id}:user:${user.id}`)
+    await redis.del(`boards:user:${user.id}:all`)
+
     res.json(updatedBoard)
   }
 
@@ -90,7 +116,10 @@ class BoardController {
 
     if (!deletedBoard) return next(NotFound('Board not found'))
 
-    res.status(204).send()
+    await redis.del(`board:${deletedBoard.id}:user:${user.id}`)
+    await redis.del(`boards:user:${user.id}:all`)
+
+    res.sendStatus(204)
   }
 }
 

app/controllers/card.controller.ts

@@ -12,6 +12,8 @@ import type { NextFunction, Response } from 'express'
 import { prisma } from '@/prisma'
 import { BadRequest, NotFound } from 'http-errors'
 
+import { redis } from '@/config'
+
 class CardController {
   add = async (
     {
@@ -22,7 +24,8 @@ class CardController {
     next: NextFunction
   ) => {
     const column = await prisma.column.findFirst({
-      where: { id: params.columnId }
+      where: { id: params.columnId },
+      select: { id: true, boardId: true, board: { select: { userId: true } } }
     })
 
     if (!column) return next(NotFound('Column not found'))
@@ -33,6 +36,8 @@ class CardController {
       data: { ...body, columnId: column.id, order: newOrder }
     })
 
+    await redis.del(`board:${column.boardId}:user:${column.board.userId}`)
+
     res.json(newCard)
   }
 
@@ -46,11 +51,20 @@ class CardController {
   ) => {
     const updatedCard = await prisma.card.updateIgnoreNotFound({
       where: { id: params.cardId },
-      data: body
+      data: body,
+      select: {
+        column: {
+          select: { boardId: true, board: { select: { userId: true } } }
+        }
+      }
     })
 
     if (!updatedCard) return next(NotFound('Card not found'))
 
+    await redis.del(
+      `board:${updatedCard.column.boardId}:user:${updatedCard.column.board.userId}`
+    )
+
     res.json(updatedCard)
   }
 
@@ -63,7 +77,8 @@ class CardController {
     next: NextFunction
   ) => {
     const column = await prisma.column.findFirst({
-      where: { id: params.columnId }
+      where: { id: params.columnId },
+      select: { id: true, boardId: true, board: { select: { userId: true } } }
     })
 
     if (!column) return next(NotFound('Column not found'))
@@ -77,6 +92,9 @@ class CardController {
 
     try {
       const updatedCards = await prisma.$transaction(transaction)
+
+      await redis.del(`board:${column.boardId}:user:${column.board.userId}`)
+
       res.json(updatedCards)
     } catch {
       return next(BadRequest('Invalid order'))
@@ -89,7 +107,8 @@ class CardController {
     next: NextFunction
   ) => {
     const column = await prisma.column.findFirst({
-      where: { id: params.newColumnId }
+      where: { id: params.newColumnId },
+      select: { id: true, boardId: true, board: { select: { userId: true } } }
     })
 
     if (!column) return next(NotFound('Column not found'))
@@ -103,6 +122,8 @@ class CardController {
 
     if (!updatedCard) return next(NotFound('Card not found'))
 
+    await redis.del(`board:${column.boardId}:user:${column.board.userId}`)
+
     res.json(updatedCard)
   }
 
@@ -112,12 +133,21 @@ class CardController {
     next: NextFunction
   ) => {
     const deletedCard = await prisma.card.deleteIgnoreNotFound({
-      where: { id: params.cardId }
+      where: { id: params.cardId },
+      select: {
+        column: {
+          select: { boardId: true, board: { select: { userId: true } } }
+        }
+      }
     })
 
     if (!deletedCard) return next(NotFound('Card not found'))
 
-    res.status(204).send()
+    await redis.del(
+      `board:${deletedCard.column.boardId}:user:${deletedCard.column.board.userId}`
+    )
+
+    res.sendStatus(204)
   }
 
   private getNewCardOrder = async (columnId: string) => {

app/controllers/column.controller.ts

@@ -11,6 +11,8 @@ import type { NextFunction, Response } from 'express'
 import { prisma } from '@/prisma'
 import { BadRequest, NotFound } from 'http-errors'
 
+import { redis } from '@/config'
+
 class ColumnController {
   add = async (
     {
@@ -39,6 +41,8 @@ class ColumnController {
       data: { ...body, order: newOrder, boardId: board.id }
     })
 
+    await redis.del(`board:${params.boardId}:user:${user.id}`)
+
     res.json(column)
   }
 
@@ -52,11 +56,16 @@ class ColumnController {
   ) => {
     const updatedColumn = await prisma.column.updateIgnoreNotFound({
       where: { id: params.columnId },
+      select: { boardId: true, board: { select: { userId: true } } },
       data: body
     })
 
     if (!updatedColumn) return next(NotFound('Column not found'))
 
+    await redis.del(
+      `board:${updatedColumn.boardId}:user:${updatedColumn.board.userId}`
+    )
+
     res.json(updatedColumn)
   }
 
@@ -83,6 +92,9 @@ class ColumnController {
 
     try {
       const updatedColumns = await prisma.$transaction(transaction)
+
+      await redis.del(`board:${board.id}:user:${board.userId}`)
+
       res.json(updatedColumns)
     } catch {
       return next(BadRequest('Invalid order'))
@@ -95,12 +107,17 @@ class ColumnController {
     next: NextFunction
   ) => {
     const deletedColumn = await prisma.column.deleteIgnoreNotFound({
-      where: { id: params.columnId }
+      where: { id: params.columnId },
+      select: { boardId: true, board: { select: { userId: true } } }
     })
 
     if (!deletedColumn) return next(NotFound('Column not found'))
 
-    res.status(204).send()
+    await redis.del(
+      `board:${deletedColumn.boardId}:user:${deletedColumn.board.userId}`
+    )
+
+    res.sendStatus(204)
   }
 }
 

app/controllers/user.controller.ts

@@ -8,17 +8,27 @@ import { prisma } from '@/prisma'
 import { hash } from 'argon2'
 import { Conflict, InternalServerError, NotAcceptable } from 'http-errors'
 
-import { env } from '@/config'
+import { env, redis } from '@/config'
 import cloudinary from '@/config/cloudinary.config'
 import { transport } from '@/config/mailer.config'
 
 class UserController {
   me = async (req: Request, res: Response) => {
-    const user = await prisma.user.findFirst({
-      where: { id: req.user.id }
-    })
+    const cacheKey = `user:${req.user.id}`
+
+    const cachedUser = await redis.get(cacheKey)
+
+    if (cachedUser) {
+      res.json(JSON.parse(cachedUser))
+    } else {
+      const user = await prisma.user.findFirst({
+        where: { id: req.user.id }
+      })
 
-    res.json(user)
+      await redis.set(cacheKey, JSON.stringify(user))
+
+      res.json(user)
+    }
   }
 
   update = async (
@@ -74,6 +84,8 @@ class UserController {
       data: updateData
     })
 
+    await redis.del(`user:${updatedUser.id}`)
+
     res.json(updatedUser)
   }
 

package.json

@@ -25,6 +25,7 @@
     "express": "^5.1.0",
     "google-auth-library": "^10.1.0",
     "http-errors": "^2.0.0",
+    "ioredis": "^5.6.1",
     "jose": "^6.0.11",
     "morgan": "1.10.0",
     "multer": "^2.0.1",