refactor: modularize backup service by extracting S3 client, core logic, scheduling, authentication, and UI into separate modules.

Author: ciro-maciel

jsconfig.json

@@ -0,0 +1,7 @@
+{
+  "compilerOptions": {
+    "jsx": "react",
+    "jsxFactory": "Html.createElement",
+    "jsxFragmentFactory": "Html.Fragment"
+  }
+}

src/core/config.js

@@ -0,0 +1,70 @@
+import { readFileSync, existsSync } from 'node:fs'
+import { writeFile } from 'node:fs/promises'
+
+/**
+ * Load configuration from a JSON file
+ * @param {string} configPath - Path to the config file
+ * @returns {Object} Loaded configuration or empty object
+ */
+export const loadConfig = configPath => {
+    if (!existsSync(configPath)) {
+        return {}
+    }
+
+    try {
+        const fileContent = readFileSync(configPath, 'utf-8')
+        const config = JSON.parse(fileContent)
+        console.log('Loaded backup config from', configPath)
+        return config
+    } catch (e) {
+        console.error('Failed to load backup config:', e)
+        return {}
+    }
+}
+
+/**
+ * Save configuration to a JSON file
+ * @param {string} configPath - Path to save the config
+ * @param {Object} config - Configuration object to save
+ */
+export const saveConfig = async (configPath, config) => {
+    try {
+        await writeFile(configPath, JSON.stringify(config, null, 2))
+        return true
+    } catch (e) {
+        console.error('Failed to save config:', e)
+        return false
+    }
+}
+
+/**
+ * Create a configuration manager
+ * @param {Object} initialConfig - Initial configuration from code
+ * @returns {Object} Configuration manager with get/set/save methods
+ */
+export const createConfigManager = initialConfig => {
+    const configPath = initialConfig.configPath || './config.json'
+    const savedConfig = loadConfig(configPath)
+
+    let config = { ...initialConfig, ...savedConfig }
+
+    return {
+        get: () => config,
+        getPath: () => configPath,
+
+        set: newConfig => {
+            config = { ...config, ...newConfig }
+            return config
+        },
+
+        save: async () => {
+            return saveConfig(configPath, config)
+        },
+
+        update: async newConfig => {
+            config = { ...config, ...newConfig }
+            await saveConfig(configPath, config)
+            return config
+        },
+    }
+}

src/core/scheduler.js

@@ -0,0 +1,99 @@
+import { CronJob } from 'cron'
+
+/**
+ * Create a backup scheduler
+ * @param {Function} onBackup - Callback to execute on scheduled backup
+ * @returns {Object} Scheduler with setup/stop/getStatus methods
+ */
+export const createScheduler = onBackup => {
+    let backupJob = null
+
+    return {
+        /**
+         * Setup or restart the cron scheduler
+         * @param {string} cronSchedule - Cron expression
+         * @param {boolean} enabled - Whether scheduling is enabled
+         */
+        setup: (cronSchedule, enabled = true) => {
+            // Stop existing job if any
+            if (backupJob) {
+                backupJob.stop()
+                backupJob = null
+            }
+
+            if (!cronSchedule || enabled === false) {
+                return
+            }
+
+            console.log(`Setting up backup cron: ${cronSchedule}`)
+
+            try {
+                backupJob = new CronJob(
+                    cronSchedule,
+                    async () => {
+                        console.log('Running scheduled backup...')
+                        try {
+                            // Generate timestamp for the backup
+                            const now = new Date()
+                            const timestamp =
+                                now.getFullYear() +
+                                '-' +
+                                String(now.getMonth() + 1).padStart(2, '0') +
+                                '-' +
+                                String(now.getDate()).padStart(2, '0') +
+                                '_' +
+                                String(now.getHours()).padStart(2, '0') +
+                                '-' +
+                                String(now.getMinutes()).padStart(2, '0') +
+                                '-' +
+                                String(now.getSeconds()).padStart(2, '0')
+
+                            await onBackup(timestamp)
+                            console.log('Scheduled backup completed')
+                        } catch (e) {
+                            console.error('Scheduled backup failed:', e)
+                        }
+                    },
+                    null,
+                    true // start immediately
+                )
+            } catch (e) {
+                console.error('Invalid cron schedule:', e.message)
+            }
+        },
+
+        /**
+         * Stop the scheduler
+         */
+        stop: () => {
+            if (backupJob) {
+                backupJob.stop()
+                backupJob = null
+            }
+        },
+
+        /**
+         * Get current scheduler status
+         * @param {boolean} cronEnabled - Whether cron is enabled in config
+         * @returns {Object} Status with isRunning and nextRun
+         */
+        getStatus: cronEnabled => {
+            const isRunning = !!backupJob && cronEnabled !== false
+            let nextRun = null
+
+            if (isRunning && backupJob) {
+                try {
+                    const nextDate = backupJob.nextDate()
+                    if (nextDate) {
+                        // cron returns Luxon DateTime, convert to JS Date
+                        nextRun = nextDate.toJSDate().toISOString()
+                    }
+                } catch (e) {
+                    console.error('Error getting next date', e)
+                }
+            }
+
+            return { isRunning, nextRun }
+        },
+    }
+}

src/core/session.js

@@ -0,0 +1,90 @@
+/**
+ * Session Management Module
+ * Handles secure session creation, validation, and cleanup
+ */
+
+/**
+ * Generate a secure random session token
+ * @returns {string} 64-character hex token
+ */
+export const generateSessionToken = () => {
+    const array = new Uint8Array(32)
+    crypto.getRandomValues(array)
+    return Array.from(array, byte => byte.toString(16).padStart(2, '0')).join('')
+}
+
+/**
+ * Create a session manager instance
+ * @returns {Object} Session manager with create/get/delete methods
+ */
+export const createSessionManager = () => {
+    const sessions = new Map()
+
+    return {
+        /**
+         * Create a new session for a user
+         * @param {string} username - Username for the session
+         * @param {number} sessionDuration - Duration in milliseconds (default: 24h)
+         * @returns {Object} Session token and expiration
+         */
+        create: (username, sessionDuration = 24 * 60 * 60 * 1000) => {
+            const token = generateSessionToken()
+            const expiresAt = Date.now() + sessionDuration
+            sessions.set(token, { username, expiresAt })
+            return { token, expiresAt }
+        },
+
+        /**
+         * Get and validate a session by token
+         * @param {string} token - Session token
+         * @returns {Object|null} Session data or null if invalid/expired
+         */
+        get: token => {
+            if (!token) return null
+
+            const session = sessions.get(token)
+            if (!session) return null
+
+            if (Date.now() > session.expiresAt) {
+                sessions.delete(token)
+                return null
+            }
+
+            return session
+        },
+
+        /**
+         * Delete a session
+         * @param {string} token - Session token to delete
+         */
+        delete: token => {
+            if (token) {
+                sessions.delete(token)
+            }
+        },
+
+        /**
+         * Get the number of active sessions
+         * @returns {number} Count of active sessions
+         */
+        count: () => sessions.size,
+
+        /**
+         * Clean up expired sessions
+         * @returns {number} Number of sessions cleaned
+         */
+        cleanup: () => {
+            const now = Date.now()
+            let cleaned = 0
+
+            for (const [token, session] of sessions) {
+                if (now > session.expiresAt) {
+                    sessions.delete(token)
+                    cleaned++
+                }
+            }
+
+            return cleaned
+        },
+    }
+}