backend

Author: Ubuntu

package-lock.json

@@ -10,40 +10,42 @@
         "prisma:migrate": "prisma migrate deploy"
     },
     "dependencies": {
-        "@prisma/client": "^3.15.2",
-        "axios": "^0.27.2",
+        "@prisma/client": "^5.0.0",
+        "axios": "^1.6.0",
         "compression": "^1.7.4",
         "cors": "^2.8.5",
         "dotenv": "^16.4.5",
-        "express": "^4.18.1",
+        "express": "^4.18.2",
         "express-session": "^1.18.0",
-        "googleapis": "^140.0.0",
-        "helmet": "^5.1.1",
+        "googleapis": "^130.0.0",
+        "helmet": "^7.1.0",
         "joi": "^17.13.3",
-        "jsonwebtoken": "^8.5.1",
+        "jsonwebtoken": "^9.0.0",
+        "masterchat": "^1.1.0",
         "node-cron": "^3.0.3",
-        "passport": "^0.6.0",
+        "passport": "^0.7.0",
         "passport-google-oauth20": "^2.0.0",
         "passport-jwt": "^4.0.1",
         "redis": "^4.6.14",
-        "winston": "^3.8.1",
+        "socket.io": "^4.7.5",
+        "winston": "^3.11.0",
         "youtube-chat": "^2.2.0"
     },
     "devDependencies": {
-        "@types/compression": "^1.7.2",
-        "@types/cors": "^2.8.12",
-        "@types/express": "^4.17.13",
+        "@types/compression": "^1.7.5",
+        "@types/cors": "^2.8.17",
+        "@types/express": "^4.17.21",
         "@types/express-session": "^1.18.0",
         "@types/gapi": "^0.0.47",
         "@types/gapi.auth2": "^0.0.60",
-        "@types/jsonwebtoken": "^8.5.8",
-        "@types/node": "^18.0.0",
+        "@types/jsonwebtoken": "^9.0.5",
+        "@types/node": "^20.10.0",
         "@types/node-cron": "^3.0.11",
-        "@types/passport": "^1.0.9",
-        "@types/passport-google-oauth20": "^2.0.11",
+        "@types/passport": "^1.0.16",
+        "@types/passport-google-oauth20": "^2.0.14",
         "@types/passport-jwt": "^4.0.1",
-        "prisma": "^3.15.2",
+        "prisma": "^5.0.0",
         "ts-node-dev": "^2.0.0",
-        "typescript": "^4.7.4"
+        "typescript": "^5.3.0"
     }
 }

package.json

@@ -4,19 +4,31 @@ import cors from 'cors';
 import helmet from 'helmet';
 import compression from 'compression';
 import session from 'express-session';
+import http from 'http';
+import { Server } from 'socket.io';
 import { errorHandler } from './middlewares/errorHandler';
 import authRoutes from './routes/auth';
-import chessRoutes from './routes/chess';// Import the test routes
+import chessRoutes from './routes/chess';
+import setupChatRoutes from './routes/chat';
+import { setupChatSocket } from './controllers/chatController';
 import './config/passport';
+import { logger } from './utils/logger';
 import './utils/scheduler';
-import chatRoutes from './routes/chat'; // Added import for chatRoutes
 
 const app = express();
 
+const allowedOrigins = [process.env.FRONTEND, 'http://localhost:5173', 'https://www.bmsamay.com'];
+
 // Configure CORS to allow requests from the frontend
 app.use(cors({
-  origin: process.env.FRONTEND || 'wa', // Use the FRONTEND environment variable or default to localhost
-  credentials: true // Allow credentials (cookies, authorization headers, etc.)
+  origin: (origin, callback) => {
+    if (!origin || allowedOrigins.indexOf(origin) !== -1) {
+      callback(null, true);
+    } else {
+      callback(new Error('Not allowed by CORS'));
+    }
+  },
+  credentials: true
 }));
 
 app.use(helmet());
@@ -26,18 +38,38 @@ app.use(express.urlencoded({ extended: true }));
 
 // Configure express-session
 app.use(session({
-  secret: process.env.SESSION_SECRET || 'your_secret_key', // Use a strong secret key
+  secret: process.env.SESSION_SECRET || 'your_secret_key',
   resave: false,
   saveUninitialized: false,
-  cookie: { secure: process.env.NODE_ENV === 'production' } // Use secure cookies in production
+  cookie: { secure: process.env.NODE_ENV === 'production' }
 }));
 
 app.use(passport.initialize());
 app.use(passport.session());
 
+// Create HTTP server and setup Socket.IO
+const server = http.createServer(app);
+const io = new Server(server, {
+  cors: {
+    origin: allowedOrigins,
+    methods: ["GET", "POST"],
+    credentials: true
+  },
+  pingTimeout: 60000,
+  pingInterval: 25000,
+});
+
+// Setup routes
 app.use('/api/auth', authRoutes);
-app.use('/api/chess', chessRoutes);// Use the test routes
-app.use('/api/chat', chatRoutes); // Use the imported chatRoutes
+app.use('/api/chess', chessRoutes);
+app.use('/api/chat', setupChatRoutes(io));
 app.use(errorHandler);
 
+// Setup chat socket connections
+setupChatSocket(io);
+
+server.listen(2999, () => {
+  logger.info(`Server is running on port ${2999}`);
+});
+
 export default app;

src/app.ts

@@ -0,0 +1,89 @@
+import { Server, Socket } from 'socket.io';
+import { Masterchat, stringify } from 'masterchat';
+
+let masterchat: Masterchat | null = null;
+let activeSockets: Map<string, Socket> = new Map();
+
+const HEARTBEAT_INTERVAL = 30000; // 30 seconds
+const HEARTBEAT_TIMEOUT = 60000; // 60 seconds
+
+const setupChatSocket = (io: Server) => {
+  const startMasterchat = async (videoUrl: string) => {
+    console.log(`Attempting to initialize Masterchat for video: ${videoUrl}`);
+    if (masterchat) {
+      console.log('Stopping existing Masterchat instance');
+      await masterchat.stop();
+    }
+
+    try {
+      console.log('Creating new Masterchat instance');
+      masterchat = await Masterchat.init(videoUrl);
+      console.log('Masterchat initialized successfully');
+
+      const chats = masterchat.iter().filter((action) => action.type === "addChatItemAction");
+
+      for await (const chat of chats) {
+        console.log('Emitting chat message:', chat);
+        io.emit('chatMessage', {
+          author: {
+            name: chat.authorName,
+            channelId: chat.authorChannelId,
+          },
+          message: stringify(chat.message),
+          timestamp: new Date(),
+        });
+      }
+    } catch (error) {
+      console.error('Error initializing Masterchat:', error);
+      io.emit('error', 'Failed to start listening for live chat messages');
+      masterchat = null;
+    }
+  };
+
+  io.on('connection', (socket: Socket) => {
+    console.log(`New client connected: ${socket.id}`);
+    activeSockets.set(socket.id, socket);
+    console.log(`Active connections: ${activeSockets.size}`);
+
+    socket.on('switchChannel', (videoUrl: string) => {
+      startMasterchat(videoUrl);
+    });
+
+    socket.on('disconnect', (reason) => {
+      console.log(`Client disconnected: ${socket.id}, Reason: ${reason}`);
+      activeSockets.delete(socket.id);
+      console.log(`Active connections: ${activeSockets.size}`);
+    });
+
+    // Implement heartbeat
+    let heartbeatTimeout: NodeJS.Timeout;
+    const resetHeartbeat = () => {
+      if (heartbeatTimeout) clearTimeout(heartbeatTimeout);
+      heartbeatTimeout = setTimeout(() => {
+        console.log(`Heartbeat timeout for client: ${socket.id}`);
+        socket.disconnect(true);
+      }, HEARTBEAT_TIMEOUT);
+    };
+
+    socket.on('heartbeat', () => {
+      resetHeartbeat();
+    });
+
+    resetHeartbeat();
+  });
+
+  // Periodic cleanup of stale connections
+  setInterval(() => {
+    for (const [id, socket] of activeSockets) {
+      if (!socket.connected) {
+        activeSockets.delete(id);
+        socket.disconnect(true);
+        console.log(`Removed stale connection: ${id}`);
+      }
+    }
+
+    console.log(`Active connections after cleanup: ${activeSockets.size}`);
+  }, HEARTBEAT_INTERVAL);
+};
+
+export { setupChatSocket };

src/chatController.ts

@@ -19,7 +19,7 @@ interface ProfileJson {
 
 const clientID = process.env.GOOGLE_CLIENT_ID;
 const clientSecret = process.env.GOOGLE_CLIENT_SECRET;
-const callbackURL = process.env.GOOGLE_CALLBACK_URL || 'https://api.bmsamay.com/api/auth/google/callback';
+const callbackURL = process.env.GOOGLE_REDIRECT_URI;
 
 console.log('Google Client ID:', clientID);
 console.log('Google Callback URL:', callbackURL);
@@ -38,17 +38,6 @@ passport.use(
     },
     async (accessToken, refreshToken, profile: any, done) => {
       try {
-        const oauth2Client = new google.auth.OAuth2();
-        oauth2Client.setCredentials({ access_token: accessToken });
-        const youtube = google.youtube({ version: 'v3', auth: oauth2Client });
-        
-        const response = await youtube.channels.list({
-          part: ['id'],
-          mine: true,
-        });
-
-        const youtubeChannelId = response.data.items?.[0]?.id;
-
         let user = await prisma.user.findUnique({
           where: { googleId: profile.id },
           include: { chessInfo: true },
@@ -61,7 +50,6 @@ passport.use(
             data: {
               email: profile.emails?.[0].value,
               name: profile.displayName,
-              youtubeChannelId: youtubeChannelId,
             },
             include: { chessInfo: true },
           });
@@ -70,7 +58,24 @@ passport.use(
             await createOrUpdateChessInfo(user.chessUsername, user.id);
           }
         } else {
-          // New user: Create a new user record
+          // New user: Create a new user record and attempt to fetch YouTube channel ID
+          let youtubeChannelId = null;
+          try {
+            const oauth2Client = new google.auth.OAuth2();
+            oauth2Client.setCredentials({ access_token: accessToken });
+            const youtube = google.youtube({ version: 'v3', auth: oauth2Client });
+            
+            const response = await youtube.channels.list({
+              part: ['id'],
+              mine: true,
+            });
+
+            youtubeChannelId = response.data.items?.[0]?.id || null;
+          } catch (error) {
+            console.error('Error fetching YouTube channel ID:', error);
+            // Continue with account creation even if YouTube ID fetch fails
+          }
+
           user = await prisma.user.create({
             data: {
               googleId: profile.id,