Added linting and enforced code styling.

src-ssr/routes/chat.js

@@ -10,17 +10,21 @@ const router = Router();
 router.use(requireAuth);
 
 // POST /api/chat/threads - Create a new chat thread (optionally with a first message)
-router.post('/threads', async (req, res) => {
+router.post('/threads', async(req, res) => 
+{
   const { content } = req.body; // Content is now optional
 
   // If content is provided, validate it
-  if (content && (typeof content !== 'string' || content.trim().length === 0)) {
+  if (content && (typeof content !== 'string' || content.trim().length === 0)) 
+  {
     return res.status(400).json({ error: 'Message content cannot be empty if provided.' });
   }
 
-  try {
+  try 
+  {
     const createData = {};
-    if (content) {
+    if (content) 
+    {
       // If content exists, create the thread with the first message
       createData.messages = {
         create: [
@@ -48,21 +52,25 @@ router.post('/threads', async (req, res) => {
 
     // Respond with the new thread ID and messages (if any)
     res.status(201).json({
-        threadId: newThread.id,
-        // Ensure messages array is empty if no content was provided
-        messages: newThread.messages ? newThread.messages.map(msg => ({ ...msg, createdAt: msg.createdAt.toISOString() })) : []
+      threadId: newThread.id,
+      // Ensure messages array is empty if no content was provided
+      messages: newThread.messages ? newThread.messages.map(msg => ({ ...msg, createdAt: msg.createdAt.toISOString() })) : []
     });
-  } catch (error) {
+  }
+  catch (error) 
+  {
     console.error('Error creating chat thread:', error);
     res.status(500).json({ error: 'Failed to create chat thread.' });
   }
 });
 
 // GET /api/chat/threads/:threadId/messages - Get messages for a specific thread
-router.get('/threads/:threadId/messages', async (req, res) => {
+router.get('/threads/:threadId/messages', async(req, res) => 
+{
   const { threadId } = req.params;
 
-  try {
+  try 
+  {
     const messages = await prisma.chatMessage.findMany({
       where: {
         threadId: threadId,
@@ -72,45 +80,55 @@ router.get('/threads/:threadId/messages', async (req, res) => {
       },
     });
 
-    if (!messages) { // Check if thread exists indirectly
-        // If findMany returns empty, the thread might not exist or has no messages.
-        // Check if thread exists explicitly
-        const thread = await prisma.chatThread.findUnique({ where: { id: threadId } });
-        if (!thread) {
-            return res.status(404).json({ error: 'Chat thread not found.' });
-        }
+    if (!messages) 
+    { // Check if thread exists indirectly
+      // If findMany returns empty, the thread might not exist or has no messages.
+      // Check if thread exists explicitly
+      const thread = await prisma.chatThread.findUnique({ where: { id: threadId } });
+      if (!thread) 
+      {
+        return res.status(404).json({ error: 'Chat thread not found.' });
+      }
     }
 
     res.status(200).json(messages.map(msg => ({ ...msg, createdAt: msg.createdAt.toISOString() })));
-  } catch (error) {
+  }
+  catch (error) 
+  {
     console.error(`Error fetching messages for thread ${threadId}:`, error);
     // Basic error handling, check for specific Prisma errors if needed
-    if (error.code === 'P2023' || error.message.includes('Malformed UUID')) { // Example: Invalid UUID format
-        return res.status(400).json({ error: 'Invalid thread ID format.' });
+    if (error.code === 'P2023' || error.message.includes('Malformed UUID')) 
+    { // Example: Invalid UUID format
+      return res.status(400).json({ error: 'Invalid thread ID format.' });
     }
     res.status(500).json({ error: 'Failed to fetch messages.' });
   }
 });
 
 // POST /api/chat/threads/:threadId/messages - Add a message to an existing thread
-router.post('/threads/:threadId/messages', async (req, res) => {
+router.post('/threads/:threadId/messages', async(req, res) => 
+{
   const { threadId } = req.params;
   const { content, sender = 'user' } = req.body; // Default sender to 'user'
 
-  if (!content || typeof content !== 'string' || content.trim().length === 0) {
+  if (!content || typeof content !== 'string' || content.trim().length === 0) 
+  {
     return res.status(400).json({ error: 'Message content cannot be empty.' });
   }
-  if (sender !== 'user' && sender !== 'bot') {
-      return res.status(400).json({ error: 'Invalid sender type.' });
+  if (sender !== 'user' && sender !== 'bot') 
+  {
+    return res.status(400).json({ error: 'Invalid sender type.' });
   }
 
-  try {
+  try 
+  {
     // Verify thread exists first
     const thread = await prisma.chatThread.findUnique({
       where: { id: threadId },
     });
 
-    if (!thread) {
+    if (!thread) 
+    {
       return res.status(404).json({ error: 'Chat thread not found.' });
     }
 
@@ -124,17 +142,20 @@ router.post('/threads/:threadId/messages', async (req, res) => {
 
     // Optionally: Update the thread's updatedAt timestamp
     await prisma.chatThread.update({
-        where: { id: threadId },
-        data: { updatedAt: new Date() }
+      where: { id: threadId },
+      data: { updatedAt: new Date() }
     });
 
     await askGeminiChat(threadId, content); // Call the function to handle the bot response
 
     res.status(201).json({ ...newMessage, createdAt: newMessage.createdAt.toISOString() });
-  } catch (error) {
+  }
+  catch (error) 
+  {
     console.error(`Error adding message to thread ${threadId}:`, error);
-     if (error.code === 'P2023' || error.message.includes('Malformed UUID')) { // Example: Invalid UUID format
-        return res.status(400).json({ error: 'Invalid thread ID format.' });
+    if (error.code === 'P2023' || error.message.includes('Malformed UUID')) 
+    { // Example: Invalid UUID format
+      return res.status(400).json({ error: 'Invalid thread ID format.' });
     }
     res.status(500).json({ error: 'Failed to add message.' });
   }