SQLITECLOUD update

Author: thisIsAnVariableOfACoder

backend/.env

@@ -4,4 +4,4 @@ GROQ_MODEL=openai/gpt-oss-120b
 LLM_TIMEOUT_MS=30000
 
 DB_PROVIDER=sqlitecloud
-SQLITECLOUD_URL=sqlitecloud://cn2gr5hvdk.g2.sqlite.cloud:8860/auth.sqlitecloud?apikey=V2ktpR7JkdaZTnRXp2MAGcjhOzi9adtOSjzkaGAcf4k
+SQLITECLOUD_URL=sqlitecloud://cn2gr5hvdk.g2.sqlite.cloud:8860/userDATA?apikey=V2ktpR7JkdaZTnRXp2MAGcjhOzi9adtOSjzkaGAcf4k

backend/index.js

@@ -11,6 +11,7 @@ const {
 
 const { initDbIfNeeded } = require('./services/dbInit');
 const { initCatalogSchema } = require('./services/careerCatalog');
+const { getUserDataDb } = require('./services/userDataStore');
 
 const authRoutes = require('./routes/auth');
 const profileRoutes = require('./routes/profile');
@@ -76,6 +77,16 @@ async function initializeMainDb() {
 
     await initCatalogSchema();
     console.log('📚 Catalog schema ready');
+
+    try {
+      const userDataDb = await getUserDataDb();
+      if (userDataDb) {
+        console.log('🗂️ userDATA schema ready');
+      }
+    } catch (userDataErr) {
+      console.warn('⚠️ userDATA initialization warning:', userDataErr.message);
+    }
+
     startServer();
   } catch (e) {
     console.error('❌ DB init failed:', e.message);

backend/routes/auth.js

@@ -6,6 +6,7 @@ const jwt = require('jsonwebtoken');
 const router = express.Router();
 const { JWT_SECRET, ADMIN_EMAIL } = require('../config');
 const { requireAuth } = require('../middleware/auth');
+const { mirrorUserAccount } = require('../services/userDataStore');
 
 function hasColumn(tableName, columnName) {
   return new Promise((resolve) => {
@@ -165,6 +166,15 @@ router.post('/register', async (req, res) => {
       throw new Error('Đăng ký thất bại: dữ liệu email lưu không khớp');
     }
 
+    await mirrorUserAccount({
+      appUserId: result.lastID,
+      username: loginName,
+      email: normalizedEmail,
+      passwordHash,
+      userType,
+      source: 'auth_register'
+    });
+
     const token = jwt.sign({
       user_id: result.lastID,
       username: loginName,
@@ -220,6 +230,19 @@ router.post('/login', async (req, res) => {
 
     const resolvedUsername = (usernameExists ? user.username : null) || getEmailLocalPart(user.email) || user.email;
 
+    try {
+      await mirrorUserAccount({
+        appUserId: user.id,
+        username: resolvedUsername,
+        email: user.email,
+        passwordHash: user.password_hash || '',
+        userType: user.user_type,
+        source: 'auth_login'
+      });
+    } catch (mirrorError) {
+      console.warn('Login mirror warning:', mirrorError.message);
+    }
+
     const token = jwt.sign({
       user_id: user.id,
       username: resolvedUsername,

backend/routes/chat.js

@@ -12,6 +12,12 @@ const {
 } = require('../services/questionEngine');
 const llmScorer = require('../services/llmScorer');
 const { isEnabled: isLlmEnabled } = llmScorer;
+const {
+  mirrorChatMessage,
+  mirrorCareerProbabilities,
+  deleteMirroredConversationData,
+  deleteMirroredUserHistory
+} = require('../services/userDataStore');
 
 const MEMORY_MESSAGES = [];
 const MIN_CONF_SCORE = 1;
@@ -664,24 +670,38 @@ router.put('/conversation/:conversationId', requireAuth, async (req, res) => {
   );
 });
 
-router.delete('/history/:userId', requireAuth, (req, res) => {
+router.delete('/history/:userId', requireAuth, async (req, res) => {
   const { userId } = req.params;
   if (req.user.user_type !== 'admin' && String(req.user.user_id) !== String(userId)) {
     return res.status(403).json({ success: false, error: 'Forbidden' });
   }
   const delMessages = 'DELETE FROM chat_messages WHERE user_id = ?';
   const delRecs = 'DELETE FROM recommendations WHERE user_id = ?';
+  const delState = 'DELETE FROM conversation_state WHERE user_id = ?';
   const delConversations = 'DELETE FROM conversations WHERE user_id = ?';
-  global.db.serialize(() => {
-    global.db.run(delMessages, [userId]);
-    global.db.run(delRecs, [userId], function (err) {
-      if (err) return res.status(500).json({ success: false, error: err.message });
-      global.db.run(delConversations, [userId], (err2) => {
-        if (err2) return res.status(500).json({ success: false, error: err2.message });
-        res.json({ success: true, data: { deleted: true } });
+  try {
+    await new Promise((resolve, reject) => {
+      global.db.serialize(() => {
+        global.db.run(delMessages, [userId]);
+        global.db.run(delRecs, [userId]);
+        global.db.run(delState, [userId]);
+        global.db.run(delConversations, [userId], (err) => {
+          if (err) return reject(err);
+          resolve();
+        });
       });
     });
-  });
+
+    try {
+      await deleteMirroredUserHistory({ appUserId: Number(userId) || userId });
+    } catch (mirrorError) {
+      console.warn('[CHAT DEBUG] deleteMirroredUserHistory warning:', mirrorError.message);
+    }
+
+    res.json({ success: true, data: { deleted: true } });
+  } catch (error) {
+    res.status(500).json({ success: false, error: error.message });
+  }
 });
 
 router.get('/messages/:conversationId', requireAuth, (req, res) => {
@@ -739,12 +759,24 @@ router.delete('/conversation/:conversationId', requireAuth, (req, res) => {
 
     const deleteMessages = 'DELETE FROM chat_messages WHERE conversation_id = ?';
     const deleteRecs = 'DELETE FROM recommendations WHERE conversation_id = ?';
+    const deleteState = 'DELETE FROM conversation_state WHERE conversation_id = ?';
     const deleteConv = 'DELETE FROM conversations WHERE id = ?';
     global.db.serialize(() => {
       global.db.run(deleteMessages, [conversationId]);
       global.db.run(deleteRecs, [conversationId]);
-      global.db.run(deleteConv, [conversationId], function (err2) {
+      global.db.run(deleteState, [conversationId]);
+      global.db.run(deleteConv, [conversationId], async function (err2) {
         if (err2) return res.status(500).json({ success: false, error: err2.message });
+
+        try {
+          await deleteMirroredConversationData({
+            appUserId: row?.user_id || null,
+            conversationId
+          });
+        } catch (mirrorError) {
+          console.warn('[CHAT DEBUG] deleteMirroredConversationData warning:', mirrorError.message);
+        }
+
         res.json({ success: true, data: { deleted: true } });
       });
     });
@@ -776,9 +808,25 @@ async function saveMessage(convId, userId, sender, message, nodeId) {
         reject(err);
       } else {
         console.log('[CHAT DEBUG] saveMessage SUCCESS - messageId:', this.lastID);
-        resolve(this.lastID);
+        const insertedId = this.lastID;
+        resolve(insertedId);
       }
     });
+  }).then(async (messageId) => {
+    try {
+      await mirrorChatMessage({
+        appUserId: userId,
+        conversationId: convId,
+        messageId,
+        sender,
+        message,
+        nodeId,
+        createdAt: new Date().toISOString()
+      });
+    } catch (mirrorError) {
+      console.warn('[CHAT DEBUG] mirrorChatMessage warning:', mirrorError.message);
+    }
+    return messageId;
   });
 }
 
@@ -881,6 +929,16 @@ async function saveRecommendations(convId, userId, recommendations) {
       );
     });
   }
+
+  try {
+    await mirrorCareerProbabilities({
+      appUserId: userId,
+      conversationId: convId,
+      recommendations
+    });
+  } catch (mirrorError) {
+    console.warn('[CHAT DEBUG] mirrorCareerProbabilities warning:', mirrorError.message);
+  }
 }
 
 async function logEvent(eventType, userId, metadata) {

backend/routes/profile.js

@@ -3,6 +3,7 @@
 const express = require('express');
 const router = express.Router();
 const { requireAuth } = require('../middleware/auth');
+const { mirrorUserAccount } = require('../services/userDataStore');
 
 function normalizeUserType(value) {
   const normalized = String(value || '').trim().toLowerCase();
@@ -57,10 +58,37 @@ router.put('/:id', requireAuth, (req, res) => {
         global.db.run(
           'UPDATE users SET user_type = ? WHERE id = ?',
           [normalizedEducationLevel, targetId],
-          (userErr) => {
+          async (userErr) => {
             if (userErr) {
               return res.status(500).json({ success: false, error: userErr.message });
             }
+
+            try {
+              const userRow = await new Promise((resolve) => {
+                global.db.get(
+                  'SELECT id, email, username, password_hash, user_type FROM users WHERE id = ? LIMIT 1',
+                  [targetId],
+                  (getErr, row) => {
+                    if (getErr) return resolve(null);
+                    resolve(row || null);
+                  }
+                );
+              });
+
+              if (userRow?.email) {
+                await mirrorUserAccount({
+                  appUserId: userRow.id,
+                  username: userRow.username || userRow.email,
+                  email: userRow.email,
+                  passwordHash: userRow.password_hash || '',
+                  userType: userRow.user_type || normalizedEducationLevel,
+                  source: 'profile_update'
+                });
+              }
+            } catch (mirrorError) {
+              console.warn('Profile mirror warning:', mirrorError.message);
+            }
+
             res.json({ success: true, data: { updated: true, user_type: normalizedEducationLevel } });
           }
         );