feat: implement token refresh scheduler and enhance Google OAuth hand…

apps/http-backend/src/index.ts

@@ -10,6 +10,7 @@ import { userRouter } from "./routes/userRoutes/userRoutes.js";
 import cors from "cors"
 import { sheetRouter } from "./routes/nodes.routes.js";
 import { googleAuth } from "./routes/google_callback.js";
+import { tokenScheduler } from "./scheduler/token-scheduler.js";
 
 const app = express()
 
@@ -40,7 +41,7 @@ app.use('/google', googleAuth)
 const PORT= 3002
 async function startServer() {
   await NodeRegistry.registerAll()
-
+  tokenScheduler.start();
   app.listen(PORT, () => {
 		console.log(`Server running on port ${PORT}`);
 	 })

apps/http-backend/src/routes/google_callback.ts

@@ -23,10 +23,24 @@ googleAuth.get('/callback', async(req: Request, res: Response)=>{
     try {
         const { tokens }  = await oauth2.getToken(code);
 
+        // DEBUG: Log tokens received from Google
+        console.log('\n🔐 Google OAuth Callback - Tokens received:');
+        console.log('   access_token:', tokens.access_token ? '✅ Present' : '❌ Missing');
+        console.log('   refresh_token:', tokens.refresh_token ? '✅ Present' : '❌ Missing');
+        console.log('   expiry_date:', tokens.expiry_date);
+        console.log('   token_type:', tokens.token_type);
+        console.log('   scope:', tokens.scope);
+
+        if (!tokens.refresh_token) {
+            console.warn('⚠️  WARNING: No refresh_token received! User may have already authorized this app.');
+            console.warn('   To force new refresh_token, user needs to revoke access at: https://myaccount.google.com/permissions');
+        }
+
         // Save tokens to database if userId (state) is provided
         if (state && typeof state === 'string') {
-
+            console.log('   Saving tokens for userId:', state);
             await Oauth.saveCredentials(state, tokens as OAuthTokens)
+            console.log('   ✅ Tokens saved to database');
         }
 
         // Redirect to success page
@@ -38,5 +52,42 @@ googleAuth.get('/callback', async(req: Request, res: Response)=>{
         `http://localhost:3000/workflow?google=error&msg=${encodeURIComponent(err?.message ?? 'Token exchange failed')}`);
     }
 }) 
-
 
+// Debug endpoint to check stored credentials
+googleAuth.get('/debug/credentials', async(req: Request, res: Response)=>{
+    try {
+        const { prismaClient } = await import('@repo/db/client');
+
+        const credentials = await prismaClient.credential.findMany({
+            where: { type: 'google_oauth' },
+            select: {
+                id: true,
+                userId: true,
+                type: true,
+                config: true
+            }
+        });
+
+        const debugInfo = credentials.map(cred => {
+            const config = cred.config as any;
+            return {
+                id: cred.id,
+                userId: cred.userId,
+                hasAccessToken: !!config?.access_token,
+                hasRefreshToken: !!config?.refresh_token,
+                refreshTokenLength: config?.refresh_token?.length || 0,
+                expiryDate: config?.expiry_date,
+                expiresIn: config?.expiry_date ? Math.round((config.expiry_date - Date.now()) / 1000 / 60) + ' minutes' : 'N/A',
+                isInvalid: config?.invalid || false,
+                scope: config?.scope
+            };
+        });
+
+        console.log('\n📋 Stored Credentials Debug:');
+        console.table(debugInfo);
+
+        return res.json({ credentials: debugInfo });
+    } catch (err) {
+        return res.status(500).json({ error: err instanceof Error ? err.message : 'Unknown error' });
+    }
+});

apps/http-backend/src/routes/userRoutes/userRoutes.ts

@@ -10,6 +10,8 @@ import {
   TriggerSchema,
   WorkflowSchema,
   NodeSchema,
+  NodeUpdateSchema,
+  TriggerUpdateSchema,
 } from "@repo/common/zod";
 import { GoogleSheetsNodeExecutor } from "@repo/nodes";
 const router: Router = Router();
@@ -336,6 +338,7 @@ router.get('/empty/workflow', userMiddleware, async(req:AuthRequest, res: Respon
     });
   }
 })
+
 router.get("/workflow/:workflowId",
   userMiddleware,
   async (req: AuthRequest, res: Response) => {
@@ -437,7 +440,7 @@ router.post('/create/node', userMiddleware, async(req: AuthRequest, res: Respons
         });
     }
     const data = req.body;
-    console.log(data," from http-backeden" );
+    // console.log(data," from http-backeden" );
 
     const dataSafe = NodeSchema.safeParse(data)
     if(!dataSafe.success) {
@@ -469,6 +472,79 @@ router.post('/create/node', userMiddleware, async(req: AuthRequest, res: Respons
   }
 })
 
+// ------------------------- UPDATE NODES AND TRIGGES ---------------------------
+
+router.put('/update/node', userMiddleware, async(req: AuthRequest, res: Response)=>{
+  try{
+    if(!req.user){
+      return res.status(statusCodes.BAD_REQUEST).json({
+          message: "User is not logged in ",
+        });
+    }
+    const data = req.body;
+    const dataSafe = NodeUpdateSchema.safeParse(data)
+
+    if(!dataSafe.success) {
+      return res.status(statusCodes.BAD_REQUEST).json({
+        message:  "Invalid input"
+    })
+    }
+
+    const updateNode = await prismaClient.node.update({
+      where: {id: dataSafe.data.NodeId},
+      data:{
+        config: dataSafe.data.Config
+      }
+    })
+
+    if(updateNode)
+      return res.status(statusCodes.CREATED).json({
+        message: "Node updated",
+        data: updateNode
+      })
+
+  }catch(e){
+    console.log("This is the error from Node updating", e);
+    return res.status(statusCodes.INTERNAL_SERVER_ERROR).json({
+      message: "Internal server Error from Node Updation.",
+    });
+  }
+})
+
+router.put('/update/trigger', userMiddleware, async(req: AuthRequest, res: Response)=>{
+  try{
+    if(!req.user){
+      return res.status(statusCodes.BAD_REQUEST).json({
+          message: "User is not logged in ",
+        });
+    }
+    const data = req.body;
+    const dataSafe = TriggerUpdateSchema.safeParse(data)
+
+    if(!dataSafe.success)
+      return res.status(statusCodes.BAD_REQUEST).json({
+        message:  "Invalid input"
+    })
+
+    const updatedTrigger = await prismaClient.trigger.update({
+      where:{id: dataSafe.data.TriggerId},
+      data:{
+        config: dataSafe.data.Config
+      }
+    })
+
+    if(updatedTrigger)
+      return res.status(statusCodes.CREATED).json({
+        message: "Trigger updated",
+        data: updatedTrigger
+      })
+  }catch(e){
+    console.log("This is the error from Trigger updating", e);
+    return res.status(statusCodes.INTERNAL_SERVER_ERROR).json({
+      message: "Internal server Error from Trigger Updation",
+    });
+  }
+})
 
 // ----------------------- GET WORKFLOW DATA(NODES, TRIGGER)---------------------
 

apps/http-backend/src/scheduler/token-scheduler.ts

@@ -0,0 +1,68 @@
+import { tokenRefreshService } from "../services/token-refresh.service.js";
+
+class TokenScheduler {
+    private intervalId: NodeJS.Timeout | null = null;
+    private intervalMinutes: number;
+
+    constructor(intervalMinutes: number = 60) {
+        this.intervalMinutes = intervalMinutes;
+    }
+
+    /**
+     * Start the token refresh scheduler
+     */
+    start(): void {
+        console.log(`\n🚀 Token Refresh Scheduler started`);
+        console.log(`   Interval: Every ${this.intervalMinutes} minutes`);
+        console.log(`   Next run: Immediately + every ${this.intervalMinutes} min\n`);
+
+        // Run immediately on start
+        this.runRefreshJob();
+
+        // Then run at specified interval
+        const intervalMs = this.intervalMinutes * 60 * 1000;
+        this.intervalId = setInterval(() => {
+            this.runRefreshJob();
+        }, intervalMs);
+    }
+
+    /**
+     * Stop the scheduler
+     */
+    stop(): void {
+        if (this.intervalId) {
+            clearInterval(this.intervalId);
+            this.intervalId = null;
+            console.log('🛑 Token Refresh Scheduler stopped');
+        }
+    }
+
+    /**
+     * Run the refresh job
+     */
+    private async runRefreshJob(): Promise<void> {
+        try {
+            const timestamp = new Date().toISOString();
+            console.log(`\n⏱️  [${timestamp}] Running scheduled token refresh...`);
+
+            await tokenRefreshService.refreshAllExpiringTokens();
+
+        } catch (error) {
+            console.error('❌ Scheduled token refresh failed:', error);
+        }
+    }
+
+    /**
+     * Manually trigger a refresh (useful for testing or on-demand refresh)
+     */
+    async triggerManualRefresh(): Promise<void> {
+        console.log('\n🔧 Manual token refresh triggered...');
+        await this.runRefreshJob();
+    }
+}
+
+// Default scheduler instance - runs every 30 minutes
+export const tokenScheduler = new TokenScheduler(60);
+
+// Export class for custom configurations
+export { TokenScheduler };