mongodb-backup-service 1.0.0

package/src/retention/retentionManager.js

@@ -0,0 +1,44 @@
+const logger = require('../utils/logger');
+
+class RetentionManager {
+    constructor(config, storageProvider) {
+        this.config = config;
+        this.storage = storageProvider;
+    }
+
+    runCleanup() {
+        if (!this.config.retention.enabled) return;
+
+        logger.info(`Starting retention cleanup (Keeping last ${this.config.retention.days} days).`);
+        
+        const allBackupDates = this.storage.getAllBackupDates();
+        
+        // Sort dates descending (newest first)
+        allBackupDates.sort((a, b) => b.localeCompare(a));
+
+        let deletedCount = 0;
+
+        // Keep the first N backups
+        for (let i = 0; i < allBackupDates.length; i++) {
+            const dateStr = allBackupDates[i];
+            
+            // Basic validation to ensure we only process directories that look like YYYY-MM-DD
+            if (!/^\d{4}-\d{2}-\d{2}$/.test(dateStr)) {
+                continue;
+            }
+
+            if (i >= this.config.retention.days) {
+                try {
+                    this.storage.deleteBackup(dateStr);
+                    deletedCount++;
+                } catch (err) {
+                    logger.error(`Failed to delete old backup directory: ${dateStr}`, err);
+                }
+            }
+        }
+
+        logger.info(`Retention cleanup completed. Deleted ${deletedCount} old backup(s).`);
+    }
+}
+
+module.exports = RetentionManager;

package/src/scheduler/scheduler.js

@@ -0,0 +1,162 @@
+const cron = require('node-cron');
+const BackupManager = require('../core/backupManager');
+const configManager = require('../config/config');
+const logger = require('../utils/logger');
+const DateUtils = require('../utils/dateUtils');
+
+class Scheduler {
+    /**
+     * @param {BackupManager|null} backupManager
+     *   Pass the already-created BackupManager from DatabaseBackupService so
+     *   only one EmailNotifier and one SMTP verify call is made per startup.
+     *   If null/undefined, Scheduler creates its own (used in unit tests / standalone).
+     */
+    constructor(backupManager = null) {
+        this.config = configManager.get();
+        this.task = null;
+        this.backupManager = backupManager || new BackupManager();
+    }
+
+    start() {
+        if (this.task) {
+            logger.warn("Scheduler is already running.");
+            return;
+        }
+
+        this.performStartupRecovery();
+
+        const cronExpression = this.buildCronExpression();
+        logger.info(`Starting scheduler with expression: ${cronExpression} (Timezone: ${this.config.schedule.timezone})`);
+
+        this.task = cron.schedule(cronExpression, async () => {
+            logger.info("Scheduled backup triggered.");
+            await this.backupManager.createBackup();
+        }, {
+            scheduled: true,
+            timezone: this.config.schedule.timezone
+        });
+    }
+
+    stop() {
+        if (this.task) {
+            this.task.stop();
+            this.task = null;
+            logger.info("Scheduler gracefully stopped.");
+        }
+    }
+
+    buildCronExpression() {
+        const { type, time, day } = this.config.schedule;
+        // Split correctly: "HH:MM" -> [HH, MM]
+        const [hourStr, minuteStr] = time.split(':');
+        // cron format is: minute hour day month weekday
+        switch (type.toLowerCase()) {
+            case 'daily':
+                return `${minuteStr} ${hourStr} * * *`;
+            case 'weekly': {
+                const dayMap = { 'sunday': 0, 'monday': 1, 'tuesday': 2, 'wednesday': 3, 'thursday': 4, 'friday': 5, 'saturday': 6 };
+                if (!day || dayMap[day.toLowerCase()] === undefined) throw new Error("Invalid or missing 'day' for weekly schedule. Expected: sunday..saturday");
+                const dayOfWeek = dayMap[day.toLowerCase()];
+                return `${minuteStr} ${hourStr} * * ${dayOfWeek}`;
+            }
+            case 'monthly': {
+                if (!day || day < 1 || day > 28) throw new Error("Invalid or missing 'day' for monthly schedule. Expected: 1-28");
+                return `${minuteStr} ${hourStr} ${day} * *`;
+            }
+            default:
+                throw new Error(`Unsupported schedule type: ${type}. Expected: daily, weekly, monthly`);
+        }
+    }
+
+    async performStartupRecovery() {
+        logger.info("Checking for missed backups on startup...");
+        const expectedDateStr = this.getMostRecentExpectedBackupDate();
+        
+        if (expectedDateStr) {
+            const storage = this.backupManager.storage;
+            const existingMetadata = storage.readMetadata(expectedDateStr);
+            
+            if (!existingMetadata || existingMetadata.status !== 'success') {
+                logger.info(`Missed or failed backup detected for expected date: ${expectedDateStr}. Initiating recovery backup.`);
+                // Do not await this. Let it run in the background so it doesn't block startup.
+                this.backupManager.createBackup(expectedDateStr).catch(err => {
+                    logger.error("Startup recovery backup failed.", err);
+                });
+            } else {
+                logger.info(`Most recent expected backup (${expectedDateStr}) is already successful. No recovery needed.`);
+            }
+        }
+    }
+
+    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',
+            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 currentDateStr = DateUtils.getCurrentDateString(tz);
+
+        // Has the scheduled time already passed today (in configured timezone)?
+        const passedToday = (tzHour > schedHour) || (tzHour === schedHour && tzMinute >= schedMin);
+
+        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 (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;
+            }
+            // 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);
+        }
+
+        if (type.toLowerCase() === 'monthly') {
+            const scheduledDayOfMonth = parseInt(day, 10);
+            if (tzDay === scheduledDayOfMonth && passedToday) {
+                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}`;
+        }
+
+        return null;
+    }
+}
+
+module.exports = Scheduler;

package/src/storage/localStorage.js

@@ -0,0 +1,56 @@
+const fs = require('fs');
+const path = require('path');
+const FileManager = require('../utils/fileManager');
+const logger = require('../utils/logger');
+
+class LocalStorage {
+    constructor(basePath) {
+        this.basePath = path.resolve(basePath);
+        FileManager.ensureDirectoryExists(this.basePath);
+    }
+
+    getBackupDirectory(dateStr) {
+        return path.join(this.basePath, dateStr);
+    }
+
+    ensureBackupDirectory(dateStr) {
+        const dir = this.getBackupDirectory(dateStr);
+        FileManager.ensureDirectoryExists(dir);
+        return dir;
+    }
+
+    getMetadataPath(dateStr) {
+        return path.join(this.getBackupDirectory(dateStr), 'metadata.json');
+    }
+
+    writeMetadata(dateStr, metadata) {
+        const filePath = this.getMetadataPath(dateStr);
+        fs.writeFileSync(filePath, JSON.stringify(metadata, null, 4), 'utf8');
+    }
+
+    readMetadata(dateStr) {
+        const filePath = this.getMetadataPath(dateStr);
+        if (fs.existsSync(filePath)) {
+            try {
+                const data = fs.readFileSync(filePath, 'utf8');
+                return JSON.parse(data);
+            } catch (err) {
+                logger.error(`Failed to parse metadata for ${dateStr}`, err);
+                return null;
+            }
+        }
+        return null;
+    }
+
+    getAllBackupDates() {
+        return FileManager.getDirectories(this.basePath);
+    }
+
+    deleteBackup(dateStr) {
+        const dir = this.getBackupDirectory(dateStr);
+        FileManager.deleteDirectory(dir);
+        logger.info(`Deleted backup directory: ${dir}`);
+    }
+}
+
+module.exports = LocalStorage;

package/src/storage/storageManager.js

@@ -0,0 +1,14 @@
+const LocalStorage = require('./localStorage');
+
+class StorageManager {
+    constructor(config) {
+        // V1 uses local storage only. Future logic can instantiate cloud providers here.
+        this.provider = new LocalStorage(config.storage.path);
+    }
+
+    getProvider() {
+        return this.provider;
+    }
+}
+
+module.exports = StorageManager;

package/src/utils/commandRunner.js

@@ -0,0 +1,42 @@
+const { spawn } = require('child_process');
+const logger = require('./logger');
+
+class CommandRunner {
+    /**
+     * Executes a command safely using spawn.
+     * @param {string} command 
+     * @param {string[]} args 
+     * @param {object} options 
+     * @returns {Promise<{stdout: string, stderr: string}>}
+     */
+    static run(command, args, options = {}) {
+        return new Promise((resolve, reject) => {
+            const child = spawn(command, args, { shell: false, ...options });
+
+            let stdout = '';
+            let stderr = '';
+
+            child.stdout.on('data', (data) => {
+                stdout += data.toString();
+            });
+
+            child.stderr.on('data', (data) => {
+                stderr += data.toString();
+            });
+
+            child.on('error', (error) => {
+                reject({ error, stdout, stderr });
+            });
+
+            child.on('close', (code) => {
+                if (code === 0) {
+                    resolve({ stdout, stderr });
+                } else {
+                    reject({ error: new Error(`Command failed with code ${code}`), code, stdout, stderr });
+                }
+            });
+        });
+    }
+}
+
+module.exports = CommandRunner;

package/src/utils/dateUtils.js

@@ -0,0 +1,18 @@
+class DateUtils {
+    /**
+     * Get the current date string based on the given timezone.
+     * @param {string} timezone 
+     * @returns {string} YYYY-MM-DD
+     */
+    static getCurrentDateString(timezone = 'UTC') {
+        const options = { timeZone: timezone, year: 'numeric', month: '2-digit', day: '2-digit' };
+        const formatter = new Intl.DateTimeFormat('en-CA', options); // en-CA gives YYYY-MM-DD
+        return formatter.format(new Date());
+    }
+
+    static getIsoString() {
+        return new Date().toISOString();
+    }
+}
+
+module.exports = DateUtils;

package/src/utils/fileManager.js

@@ -0,0 +1,24 @@
+const fs = require('fs');
+const path = require('path');
+
+class FileManager {
+    static ensureDirectoryExists(dirPath) {
+        if (!fs.existsSync(dirPath)) {
+            fs.mkdirSync(dirPath, { recursive: true });
+        }
+    }
+
+    static deleteDirectory(dirPath) {
+        if (fs.existsSync(dirPath)) {
+            fs.rmSync(dirPath, { recursive: true, force: true });
+        }
+    }
+
+    static getDirectories(srcPath) {
+        if (!fs.existsSync(srcPath)) return [];
+        return fs.readdirSync(srcPath)
+            .filter(file => fs.statSync(path.join(srcPath, file)).isDirectory());
+    }
+}
+
+module.exports = FileManager;

package/src/utils/logger.js

@@ -0,0 +1,24 @@
+class Logger {
+    formatMessage(level, message) {
+        const timestamp = new Date().toISOString();
+        return `[${timestamp}] [BACKUP ${level}] ${message}`;
+    }
+
+    info(message) {
+        console.log(this.formatMessage('INFO', message));
+    }
+
+    warn(message) {
+        console.warn(this.formatMessage('WARN', message));
+    }
+
+    error(message, err = null) {
+        let msg = this.formatMessage('ERROR', message);
+        if (err) {
+            msg += `\n${err.stack || err.message || err}`;
+        }
+        console.error(msg);
+    }
+}
+
+module.exports = new Logger();