feat(backend): add settings service with env var handling

New features:
* Settings initialised on startup rather than first request
* Settings are cached in memory for performance
* Reduction of code duplication/defensive coding practices

backend/src/services/settingsService.js

@@ -0,0 +1,170 @@
+const { PrismaClient } = require('@prisma/client');
+const { v4: uuidv4 } = require('uuid');
+
+const prisma = new PrismaClient();
+
+// Cached settings instance
+let cachedSettings = null;
+
+// Environment variable to settings field mapping
+const ENV_TO_SETTINGS_MAP = {
+    'SERVER_PROTOCOL': 'server_protocol',
+    'SERVER_HOST': 'server_host',
+    'SERVER_PORT': 'server_port',
+};
+
+// Create settings from environment variables and/or defaults
+async function createSettingsFromEnvironment() {
+    const protocol = process.env.SERVER_PROTOCOL || 'http';
+    const host = process.env.SERVER_HOST || 'localhost';
+    const port = parseInt(process.env.SERVER_PORT, 10) || 3001;
+    const serverUrl = `${protocol}://${host}:${port}`.toLowerCase();
+
+    const settings = await prisma.settings.create({
+        data: {
+            id: uuidv4(),
+            server_url: serverUrl,
+            server_protocol: protocol,
+            server_host: host,
+            server_port: port,
+            update_interval: 60,
+            auto_update: false,
+            signup_enabled: false,
+            updated_at: new Date()
+        }
+    });
+
+    console.log('Created settings');
+    return settings;
+}
+
+// Sync environment variables with existing settings
+async function syncEnvironmentToSettings(currentSettings) {
+    const updates = {};
+    let hasChanges = false;
+
+    // Check each environment variable mapping
+    for (const [envVar, settingsField] of Object.entries(ENV_TO_SETTINGS_MAP)) {
+        if (process.env[envVar]) {
+            const envValue = process.env[envVar];
+            const currentValue = currentSettings[settingsField];
+
+            // Convert environment value to appropriate type
+            let convertedValue = envValue;
+            if (settingsField === 'server_port') {
+                convertedValue = parseInt(envValue, 10);
+            }
+
+            // Only update if values differ
+            if (currentValue !== convertedValue) {
+                updates[settingsField] = convertedValue;
+                hasChanges = true;
+                console.log(`Environment variable ${envVar} (${envValue}) differs from settings ${settingsField} (${currentValue}), updating...`);
+            }
+        }
+    }
+
+    // Construct server_url from components if any components were updated
+    const protocol = updates.server_protocol || currentSettings.server_protocol;
+    const host = updates.server_host || currentSettings.server_host;
+    const port = updates.server_port || currentSettings.server_port;
+    const constructedServerUrl = `${protocol}://${host}:${port}`.toLowerCase();
+
+    // Update server_url if it differs from the constructed value
+    if (currentSettings.server_url !== constructedServerUrl) {
+        updates.server_url = constructedServerUrl;
+        hasChanges = true;
+        console.log(`Updating server_url to: ${constructedServerUrl}`);
+    }
+
+    // Update settings if there are changes
+    if (hasChanges) {
+        const updatedSettings = await prisma.settings.update({
+            where: { id: currentSettings.id },
+            data: {
+                ...updates,
+                updated_at: new Date()
+            }
+        });
+        console.log(`Synced ${Object.keys(updates).length} environment variables to settings`);
+        return updatedSettings;
+    }
+
+    return currentSettings;
+}
+
+// Initialise settings - create from environment or sync existing
+async function initSettings() {
+    if (cachedSettings) {
+        return cachedSettings;
+    }
+
+    try {
+        let settings = await prisma.settings.findFirst({
+            orderBy: { updated_at: 'desc' }
+        });
+
+        if (!settings) {
+            // No settings exist, create from environment variables and defaults
+            settings = await createSettingsFromEnvironment();
+        } else {
+            // Settings exist, sync with environment variables
+            settings = await syncEnvironmentToSettings(settings);
+        }
+
+        // Cache the initialised settings
+        cachedSettings = settings;
+        return settings;
+    } catch (error) {
+        console.error('Failed to initialise settings:', error);
+        throw error;
+    }
+}
+
+// Get current settings (returns cached if available)
+async function getSettings() {
+    return cachedSettings || await initSettings();
+}
+
+// Update settings and refresh cache
+async function updateSettings(id, updateData) {
+    try {
+        const updatedSettings = await prisma.settings.update({
+            where: { id },
+            data: {
+                ...updateData,
+                updated_at: new Date()
+            }
+        });
+
+        // Reconstruct server_url from components
+        const serverUrl = `${updatedSettings.server_protocol}://${updatedSettings.server_host}:${updatedSettings.server_port}`.toLowerCase();
+        if (updatedSettings.server_url !== serverUrl) {
+            updatedSettings.server_url = serverUrl;
+            await prisma.settings.update({
+                where: { id },
+                data: { server_url: serverUrl }
+            });
+        }
+
+        // Update cache
+        cachedSettings = updatedSettings;
+        return updatedSettings;
+    } catch (error) {
+        console.error('Failed to update settings:', error);
+        throw error;
+    }
+}
+
+// Invalidate cache (useful for testing or manual refresh)
+function invalidateCache() {
+    cachedSettings = null;
+}
+
+module.exports = {
+    initSettings,
+    getSettings,
+    updateSettings,
+    invalidateCache,
+    syncEnvironmentToSettings // Export for startup use
+};