Update app.js

app.js

@@ -2,12 +2,17 @@ import express from 'express';
 import cors from 'cors';
 import { createClient } from '@supabase/supabase-js';
 
-// --- CONFIG ---
-const PORT = 7860; 
+// ==========================================
+// ⚙️ CONFIGURATION & SETTINGS
+// ==========================================
+const PORT = process.env.PORT || 7860; 
 const SUPABASE_URL = process.env.SUPABASE_URL;
 const SUPABASE_KEY = process.env.SUPABASE_SERVICE_KEY;
 const CRON_SECRET = process.env.CRON_SECRET || "default_secret";
 
+// 🔴 VARIABLE BOOLEAN: Should past/missed jobs fire immediately on server startup?
+const RUN_PAST_EVENTS_ON_STARTUP = false; 
+
 if (!SUPABASE_URL || !SUPABASE_KEY) {
     console.error("❌ Missing Supabase Credentials");
     process.exit(1);
@@ -16,34 +21,67 @@ if (!SUPABASE_URL || !SUPABASE_KEY) {
 const app = express();
 const supabase = createClient(SUPABASE_URL, SUPABASE_KEY);
 
-// Map will now store job details and absolute timestamps (nextRunAt)
 const activeJobs = new Map();
 
 app.use(express.json());
 app.use(cors());
 
-// --- BULLETPROOF DELAY MATH ---
+// ==========================================
+// ⏱️ YOUR EXACT ORIGINAL MATH (RESTORED)
+// ==========================================
 function getMsUntilNextFiveAM(offset = 0) {
     const now = new Date();
-    const target = new Date(now);
+    const target = new Date(now.getTime());
     
-    // Calculate target UTC minutes for local 5 AM
+    // Using your exact original calculation
     const targetUtcMinutes = (5 * 60) - (offset * 60); 
-
     target.setUTCHours(0, targetUtcMinutes, 0, 0); 
     
-    // BUFFER: If the target is in the past OR within the next 2 minutes 
-    // (meaning we just fired it), schedule for TOMORROW.
-    if (target.getTime() <= now.getTime() + 120000) {
+    if (target <= now) {
         target.setDate(target.getDate() + 1);
     }
 
     return target.getTime() - now.getTime();
 }
 
-function startJobInternal(jobId, intervalMs, url, payload, initialDelay) {
-    // Calculate absolute timestamp for when this should run next
-    const nextRunAt = Date.now() + initialDelay;
+// ==========================================
+// 🚀 JOB EXECUTION & SCHEDULING
+// ==========================================
+async function executeJob(jobId) {
+    const job = activeJobs.get(jobId);
+    if (!job) return;
+
+    console.log(`⏰ [${new Date().toLocaleTimeString()}] Executing: ${jobId}`);
+    try {
+        const res = await fetch(job.url, {
+            method: 'POST',
+            headers: { 'Content-Type': 'application/json' },
+            body: JSON.stringify(job.payload)
+        });
+        console.log(`   └─ Response: ${res.status}`);
+    } catch (e) {
+        console.error(`❌ Job ${jobId} HTTP Failed:`, e.message);
+    }
+}
+
+function startJobInternal(jobId, intervalMs, url, payload, initialDelay, isHydration = false) {
+    let delay = initialDelay;
+    let runImmediately = false;
+
+    // Failsafe: If delay is somehow massive (e.g. accidentally passed a timestamp), reset it
+    if (delay > 31536000000) { 
+        delay = getMsUntilNextFiveAM(payload?.timezoneOffset || 0);
+    }
+
+    // Handle the past events boolean for DB hydration
+    if (isHydration && RUN_PAST_EVENTS_ON_STARTUP) {
+        runImmediately = true;
+        delay = getMsUntilNextFiveAM(payload?.timezoneOffset || 0);
+    }
+
+    const nextRunAt = Date.now() + delay;
+    const hours = (delay / 1000 / 60 / 60).toFixed(2);
+    const minutes = (delay / 1000 / 60).toFixed(2);
 
     activeJobs.set(jobId, {
         url,
@@ -53,48 +91,40 @@ function startJobInternal(jobId, intervalMs, url, payload, initialDelay) {
         nextRunAt
     });
 
-    console.log(`⏳ Job ${jobId} scheduled. Next run: ${new Date(nextRunAt).toLocaleString()}`);
+    if (runImmediately) {
+        console.log(`⚡ [Startup] Firing past/missed event immediately: ${jobId}`);
+        executeJob(jobId); // Fire right now
+        console.log(`⏳ Job ${jobId} re-scheduled. Next 5AM run in ${hours} hours (${minutes} mins).`);
+    } else {
+        console.log(`⏳ Job ${jobId} scheduled. First 5AM run in ${hours} hours (${minutes} mins).`);
+    }
 }
 
 // ==========================================
-// ⚙️ THE CRON ENGINE (HEARTBEAT)
+// ⚙️ THE TICK ENGINE (REPLACES CRASHING TIMEOUTS)
 // ==========================================
-// This loop checks every 60 seconds if any job is ready to fire.
-// This survives container sleeps, CPU throttling, and timer drifts.
-setInterval(async () => {
+// We keep this because native setTimeouts die after 24 hours on cloud servers.
+// This 60-second tick just acts as a watchdog to fire your jobs accurately.
+setInterval(() => {
     const now = Date.now();
 
     for (const [jobId, job] of activeJobs.entries()) {
         if (now >= job.nextRunAt) {
-            console.log(`⏰ [${new Date().toLocaleTimeString()}] Executing: ${jobId}`);
+            executeJob(jobId); // Fire the webhook
             
-            // 1. Immediately push the next run time forward to prevent double-firing
-            // We lock it back to exactly the next 5 AM based on their timezone
+            // Calculate exact time until NEXT 5 AM
             const nextDelay = getMsUntilNextFiveAM(job.offset);
             job.nextRunAt = now + nextDelay;
-
-            // 2. Fire the webhook asynchronously
-            try {
-                fetch(job.url, {
-                    method: 'POST',
-                    headers: { 'Content-Type': 'application/json' },
-                    body: JSON.stringify(job.payload)
-                }).then(res => {
-                    console.log(`   └─ Response [${jobId}]: ${res.status}`);
-                }).catch(err => {
-                    console.error(`❌ Fetch Error [${jobId}]:`, err.message);
-                });
-            } catch (e) {
-                console.error(`❌ Job ${jobId} HTTP Failed:`, e.message);
-            }
             
-            console.log(`🔄 Job ${jobId} entered 24h cycle. Next run in ${(nextDelay/1000/60/60).toFixed(2)} hours.`);
+            const hours = (nextDelay / 1000 / 60 / 60).toFixed(2);
+            console.log(`🔄 Job ${jobId} entering 24h interval cycle. Next run in ${hours} hours.`);
         }
     }
 }, 60000); // Ticks every 60 seconds
 
-
-// --- DB HYDRATION ---
+// ==========================================
+// 💾 DB HYDRATION & ROUTES
+// ==========================================
 async function hydrateJobs() {
     console.log("💧 Hydrating Cron Jobs from DB...");
     const { data, error } = await supabase.from('system_jobs').select('*');
@@ -109,13 +139,13 @@ async function hydrateJobs() {
         const offset = job.payload?.timezoneOffset ?? 0;
         const newDelay = getMsUntilNextFiveAM(offset);
 
-        startJobInternal(job.id, job.interval_ms, job.webhook_url, job.payload, newDelay);
+        // Pass 'true' at the end to signify this is a startup hydration
+        startJobInternal(job.id, job.interval_ms, job.webhook_url, job.payload, newDelay, true);
         count++;
     }
     console.log(`✅ Successfully hydrated and scheduled ${count} jobs.`);
 }
 
-// --- ENDPOINTS ---
 app.get('/', (req, res) => res.json({ status: "Cron Registry Active", active_jobs: activeJobs.size }));
 
 app.post('/register', async (req, res) => {
@@ -136,9 +166,10 @@ app.post('/register', async (req, res) => {
 
     const delay = (initialDelay !== undefined) ? initialDelay : getMsUntilNextFiveAM(payload?.timezoneOffset || 0);
     
-    startJobInternal(jobId, intervalMs, webhookUrl, payload, delay);
+    // Pass 'false' at the end to signify this is a fresh registration
+    startJobInternal(jobId, intervalMs, webhookUrl, payload, delay, false);
 
-    console.log(`➕ Registered Job: ${jobId}`);
+    console.log(`➕ Registered & Scheduled Job (5AM Anchor): ${jobId}`);
     res.json({ success: true, jobId });
 });
 
@@ -147,7 +178,6 @@ app.post('/deregister', async (req, res) => {
     if (secret !== CRON_SECRET) return res.status(403).json({ error: "Unauthorized" });
     
     await supabase.from('system_jobs').delete().eq('id', jobId);
-    
     if (activeJobs.has(jobId)) {
         activeJobs.delete(jobId);
     }