mongodb-backup-service 1.0.0 → 1.0.2

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "mongodb-backup-service",
-  "version": "1.0.0",
+  "version": "1.0.2",
   "description": "Reusable Node.js service for automated MongoDB backups with scheduling, startup recovery, Excel export, retention, email notifications, and backup locking.",
   "main": "src/index.js",
   "bin": {
@@ -46,13 +46,13 @@
     "node": ">=18.0.0"
   },
   "dependencies": {
+    "dotenv": "^17.4.2",
     "exceljs": "^4.4.0",
     "mongodb": "^7.6.0",
     "node-cron": "^4.0.0",
     "nodemailer": "^10.0.0"
   },
   "devDependencies": {
-    "dotenv": "^17.4.2",
     "jest": "^30.5.1"
   }
 }

package/src/index.js

@@ -46,10 +46,14 @@ class DatabaseBackupService {
         if (!this.backupManager) {
             this.backupManager = new BackupManager();
         }
-        
+    
         const DateUtils = require('./utils/dateUtils');
-        const targetDate = dateStr || DateUtils.getCurrentDateString(configManager.get().schedule.timezone);
-        
+        const config = configManager.get();
+    
+        const targetDate = dateStr || DateUtils.getCurrentDateString(
+            config.schedule?.timezone || 'UTC'
+        );
+    
         return this.backupManager.storage.readMetadata(targetDate);
     }
 

package/src/scheduler/scheduler.js

@@ -91,70 +91,162 @@ class Scheduler {
     getMostRecentExpectedBackupDate() {
         const tz = this.config.schedule.timezone;
         const { type, time, day } = this.config.schedule;
+    
         const [hourStr, minuteStr] = time.split(':');
         const schedHour = parseInt(hourStr, 10);
         const schedMin = parseInt(minuteStr, 10);
-
-        // Get the current time parts in the configured timezone (no moment.js needed)
+    
         const now = new Date();
+    
         const tzParts = new Intl.DateTimeFormat('en-US', {
             timeZone: tz,
-            hour: 'numeric', minute: 'numeric', hour12: false,
-            year: 'numeric', month: '2-digit', day: '2-digit',
+            hour: 'numeric',
+            minute: 'numeric',
+            hour12: false,
+            year: 'numeric',
+            month: '2-digit',
+            day: '2-digit',
             weekday: 'long'
         }).formatToParts(now);
-
-        const get = (type) => tzParts.find(p => p.type === type);
-        const tzHour   = parseInt(get('hour').value, 10);
-        const tzMinute = parseInt(get('minute').value, 10);
-        const tzDay    = parseInt(get('day').value, 10);
-        const tzWeekday = get('weekday').value.toLowerCase(); // e.g. 'wednesday'
-
+    
+        const getPart = (type) =>
+            tzParts.find((part) => part.type === type)?.value;
+    
+        const tzHour = parseInt(getPart('hour'), 10);
+        const tzMinute = parseInt(getPart('minute'), 10);
+        const tzDay = parseInt(getPart('day'), 10);
+        const tzWeekday = getPart('weekday').toLowerCase();
+    
         const currentDateStr = DateUtils.getCurrentDateString(tz);
-
-        // Has the scheduled time already passed today (in configured timezone)?
-        const passedToday = (tzHour > schedHour) || (tzHour === schedHour && tzMinute >= schedMin);
-
+    
+        const passedToday =
+            tzHour > schedHour ||
+            (tzHour === schedHour && tzMinute >= schedMin);
+    
+        const dayMap = {
+            sunday: 0,
+            monday: 1,
+            tuesday: 2,
+            wednesday: 3,
+            thursday: 4,
+            friday: 5,
+            saturday: 6
+        };
+    
+        // ---------------------------------------------------------
+        // DAILY
+        // ---------------------------------------------------------
         if (type.toLowerCase() === 'daily') {
-            if (passedToday) return currentDateStr;
-            // Scheduled time hasn't arrived yet today — yesterday's backup is the expected one
-            const yesterday = new Date(now.getTime() - 24 * 60 * 60 * 1000);
-            return new Intl.DateTimeFormat('en-CA', { timeZone: tz, year: 'numeric', month: '2-digit', day: '2-digit' }).format(yesterday);
+            if (!passedToday) {
+                return null;
+            }
+    
+            return currentDateStr;
         }
-
+    
+        // ---------------------------------------------------------
+        // WEEKLY
+        // ---------------------------------------------------------
         if (type.toLowerCase() === 'weekly') {
-            // Check if today is the scheduled weekday AND the time has passed
             const scheduledWeekday = (day || '').toLowerCase();
-            if (tzWeekday === scheduledWeekday && passedToday) {
-                return currentDateStr;
+    
+            if (dayMap[scheduledWeekday] === undefined) {
+                return null;
             }
-            // Otherwise: find the most recent occurrence of that weekday
-            const dayMap = { 'sunday': 0, 'monday': 1, 'tuesday': 2, 'wednesday': 3, 'thursday': 4, 'friday': 5, 'saturday': 6 };
-            const targetDow = dayMap[scheduledWeekday];
+    
             const currentDow = dayMap[tzWeekday];
-            if (targetDow === undefined) return null;
-            let daysBack = (currentDow - targetDow + 7) % 7;
-            if (daysBack === 0) daysBack = 7; // same weekday but time hasn't passed
-            const prevDate = new Date(now.getTime() - daysBack * 24 * 60 * 60 * 1000);
-            return new Intl.DateTimeFormat('en-CA', { timeZone: tz, year: 'numeric', month: '2-digit', day: '2-digit' }).format(prevDate);
+            const targetDow = dayMap[scheduledWeekday];
+    
+            // Today is the scheduled weekday
+            if (currentDow === targetDow) {
+                // Scheduled time has not arrived yet.
+                // Therefore there is no missed backup yet.
+                if (!passedToday) {
+                    return null;
+                }
+    
+                // Scheduled time has passed today.
+                return currentDateStr;
+            }
+    
+            // Today is after the scheduled weekday.
+            // Find the most recent scheduled weekday.
+            const daysBack = (currentDow - targetDow + 7) % 7;
+    
+            const previousOccurrence = new Date(
+                now.getTime() - daysBack * 24 * 60 * 60 * 1000
+            );
+    
+            return new Intl.DateTimeFormat('en-CA', {
+                timeZone: tz,
+                year: 'numeric',
+                month: '2-digit',
+                day: '2-digit'
+            }).format(previousOccurrence);
         }
-
+    
+        // ---------------------------------------------------------
+        // MONTHLY
+        // ---------------------------------------------------------
         if (type.toLowerCase() === 'monthly') {
-            const scheduledDayOfMonth = parseInt(day, 10);
-            if (tzDay === scheduledDayOfMonth && passedToday) {
+            const scheduledDay = parseInt(day, 10);
+    
+            if (
+                Number.isNaN(scheduledDay) ||
+                scheduledDay < 1 ||
+                scheduledDay > 28
+            ) {
+                return null;
+            }
+    
+            // Today is the scheduled day.
+            if (tzDay === scheduledDay) {
+                // Scheduled time has not arrived yet.
+                if (!passedToday) {
+                    return null;
+                }
+    
                 return currentDateStr;
             }
-            // Otherwise: check the previous month's occurrence
-            // Go back to the 1st of this month, then subtract one day to get last month, then format day
-            const prevMonthDate = new Date(now);
-            prevMonthDate.setDate(0); // last day of previous month
-            const prevMonthParts = new Intl.DateTimeFormat('en-US', { timeZone: tz, year: 'numeric', month: '2-digit' }).formatToParts(prevMonthDate);
-            const prevYear  = prevMonthParts.find(p => p.type === 'year').value;
-            const prevMonth = prevMonthParts.find(p => p.type === 'month').value;
-            const dayPadded = String(scheduledDayOfMonth).padStart(2, '0');
-            return `${prevYear}-${prevMonth}-${dayPadded}`;
+    
+            // Today is after the scheduled day.
+            if (tzDay > scheduledDay) {
+                const currentYear = parseInt(
+                    getPart('year'),
+                    10
+                );
+    
+                const currentMonth = parseInt(
+                    getPart('month'),
+                    10
+                );
+    
+                return `${currentYear}-${String(currentMonth).padStart(2, '0')}-${String(scheduledDay).padStart(2, '0')}`;
+            }
+    
+            // Today is before the scheduled day.
+            // Therefore the most recent occurrence was last month.
+            const currentYear = parseInt(
+                getPart('year'),
+                10
+            );
+    
+            const currentMonth = parseInt(
+                getPart('month'),
+                10
+            );
+    
+            let previousYear = currentYear;
+            let previousMonth = currentMonth - 1;
+    
+            if (previousMonth === 0) {
+                previousMonth = 12;
+                previousYear--;
+            }
+    
+            return `${previousYear}-${String(previousMonth).padStart(2, '0')}-${String(scheduledDay).padStart(2, '0')}`;
         }
-
+    
         return null;
     }
 }