refactor: add improvements to the genai routes with zod validation

Author: WillACosta

src/common/middlewares/body-validation.middleware.ts

@@ -1,31 +1,36 @@
-import { NextFunction, Request, Response } from 'express'
+import { NextFunction, Request } from 'express'
 import { z, ZodError } from 'zod'
+import { AppResponse } from '../types'
 
-const userSchema = z.object({
+export const userSchema = z.object({
 	email: z.string().email('Invalid email address'),
 	password: z.string().min(6, 'Password must be at least 6 characters long'),
 	name: z.string().optional(),
 })
 
-const userCredentialsSchema = z.object({
+export const userCredentialsSchema = z.object({
 	email: z.string().email('Invalid email address'),
 })
 
-const validateRequestBody = (schema: z.ZodSchema<any>) => {
-	return (req: Request, res: Response, next: NextFunction) => {
+export const translateTextSchema = z.object({
+	text: z.string().min(1, 'text field is required'),
+	language: z.string().min(1, 'language field is required'),
+})
+
+export const validateRequestBody = (schema: z.ZodSchema<any>) => {
+	return (req: Request, res: AppResponse, next: NextFunction) => {
 		try {
 			schema.parse(req.body)
 			return next()
 		} catch (error) {
 			if (error instanceof ZodError) {
-				return res
-					.status(400)
-					.json({ data: null, errors: error.errors.map((e) => e.message) })
+				return res.status(400).json({
+					success: false,
+					error: { message: error.errors.map((e) => e.message) },
+				})
 			}
 
 			return next(error)
 		}
 	}
 }
-
-export { userCredentialsSchema, userSchema, validateRequestBody }

src/common/types/network.types.ts

@@ -16,5 +16,5 @@ export interface AppRequest<
 export type AppResponse<T = any> = Response<{
 	success: boolean
 	data?: T
-	error?: { message: string; code?: string }
+	error?: { message: string | string[]; code?: string }
 }>

src/di/index.ts

@@ -1,10 +1,6 @@
 import { PrismaClient } from '@prisma/client'
 
-import {
-  ChatMemory,
-  DocumentsService,
-  LLMService,
-} from '@/modules/genai/adapters'
+import { DocumentsService, LLMService } from '@/modules/genai/adapters'
 
 import {
   SearchInDocumentUseCase,
@@ -17,15 +13,13 @@ import { UserDataProvider } from '@/modules/users/adapters/dataproviders/user.da
 import { UsersController } from '@/modules/users/application/controllers/users.controller'
 
 // Common
-const chatMemory = new ChatMemory()
 const llmService = new LLMService()
 const prismaClient = new PrismaClient()
 
 // Gen AI Module
 const genAIController = new GenAIController()
 const documentService = new DocumentsService(llmService)
 const searchInDocumentUseCase = new SearchInDocumentUseCase(
-	chatMemory,
 	llmService,
 	documentService,
 )
@@ -41,7 +35,6 @@ const authController = new AuthController(userDatProvider)
 
 export {
   authController,
-  chatMemory,
   documentService,
   genAIController,
   llmService,

src/modules/genai/adapters/dataproviders/chat-memory/chat-memory.ts

@@ -2,10 +2,10 @@ import { RedisChatMessageHistory } from '@langchain/redis'
 import { BufferMemory } from 'langchain/memory'
 
 export class ChatMemory {
-	constructor() {
+	constructor(private userId: string) {
 		this._memory = new BufferMemory({
 			chatHistory: new RedisChatMessageHistory({
-				sessionId: 'a168c61a-c431-4ef8-bc1c-fedd808d45ea',
+				sessionId: userId,
 				sessionTTL: 3600,
 				config: {
 					url: process.env['REDIS_URL'],

src/modules/genai/application/controllers/gen-ai.controller.ts

@@ -1,38 +1,33 @@
-import { Request, Response } from 'express'
-
-import { searchInDocumentUseCase, translateUseCase } from '@/di'
-import { upload } from '../../core'
+import { AppRequest, AppResponse } from '@/common/types';
+import { searchInDocumentUseCase, translateUseCase } from '@/di';
+import { upload } from '../../core';
 
 export class GenAIController {
 	async translateText(
-		req: Request<any, any, { text: string; language: string }>,
-		res: Response,
+		req: AppRequest<any, any, { text: string; language: string }>,
+		res: AppResponse,
 	) {
 		const { text, language } = req.body
-
-		if (language === undefined || text === undefined) {
-			return res.status(400).send({
-				message: 'Invalid request, set language and text in the request body!',
-			})
-		}
-
 		const result = await translateUseCase.invoke({ text, language })
-		return res.send(result)
+		return res.send({ success: true, data: result })
 	}
 
 	async searchInDocument(
-		req: Request<any, any, { query: string }>,
-		res: Response,
+		req: AppRequest<any, any, { query: string }>,
+		res: AppResponse,
 	) {
 		upload(req, res, async (err) => {
 			if (err) {
 				return res
 					.status(500)
-					.json({ message: 'File upload failed!', error: err })
+					.json({ success: false, error: { message: 'File upload failed!' } })
 			}
 
 			if (!req.file) {
-				return res.status(400).json({ message: 'Please provide a valid file!' })
+				return res.status(400).json({
+					success: false,
+					error: { message: 'Please provide a valid file!' },
+				})
 			}
 
 			const query = req.body.query
@@ -41,12 +36,12 @@ export class GenAIController {
 			const { result } = await searchInDocumentUseCase.invoke({
 				query,
 				filePath,
+				userId: req.user!.id,
 			})
 
 			return res.json({
-				message: 'File and query received successfully!',
-				data: { query, filePath },
-				result,
+				success: true,
+				data: result,
 			})
 		})
 	}

src/modules/genai/application/routes/index.ts

@@ -1,11 +1,21 @@
 import express from 'express'
 
-import { isAuthenticated } from '@/common/middlewares'
+import {
+	isAuthenticated,
+	translateTextSchema,
+	validateRequestBody,
+} from '@/common/middlewares'
+
 import { genAIController } from '@/di'
 
 const router = express.Router()
 
-router.post('/translate', isAuthenticated, genAIController.translateText)
+router.post(
+	'/translate',
+	isAuthenticated,
+	validateRequestBody(translateTextSchema),
+	genAIController.translateText,
+)
 
 router.post(
 	'/search-in-document',

src/modules/genai/core/usecases/search-in-document/search-in-document.usecase.ts

@@ -26,12 +26,12 @@ import {
 
 export class SearchInDocumentUseCase implements UseCase<Result, Params> {
 	constructor(
-		private _memory: ChatMemory,
 		private _llmService: LLMService,
 		private _documentService: DocumentsService,
 	) {}
 
-	async invoke({ filePath, query }: Params): Promise<Result> {
+	async invoke({ filePath, query, userId }: Params): Promise<Result> {
+		const chatMemory = new ChatMemory(userId)
 		const llmModel = this._llmService.llm
 		const docs = await this._documentService.loadDocument(filePath)
 		const { retriever } = await this._documentService.initializeVectorStore(
@@ -75,13 +75,13 @@ export class SearchInDocumentUseCase implements UseCase<Result, Params> {
 			new StringOutputParser(),
 		])
 
-		const history = await this._memory.retrieveMemoryHistory()
+		const history = await chatMemory.retrieveMemoryHistory()
 		const result = await retrievalChain.invoke({
 			question: query,
 			chat_history: history,
 		})
 
-		this._memory.saveChatHistory(query, result)
+		chatMemory.saveChatHistory(query, result)
 		return { result }
 	}
 }

src/modules/genai/core/usecases/search-in-document/types.ts

@@ -1,4 +1,5 @@
 export type Params = {
+	userId: string
 	query: string
 	filePath: string
 }