sami7777/dashcaddy
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

refactor(routes): Phase 3.6-10 - standardize 5 utility routes

Browse Source 
- credentials.js (2 deps: credentialManager, asyncHandler)
- backups.js (2 deps: backupManager, asyncHandler)
- license.js (2 deps: licenseManager, asyncHandler)
- errorlogs.js (3 deps: ERROR_LOG_FILE, auditLogger, asyncHandler)
- themes.js (0 deps! Standalone route)

Total: 9 routes refactored so far
This commit is contained in:
Krystie
2026-03-28 19:32:01 -07:00
parent f095ef24aa
commit 51d6c37e4a
6 changed files with 121 additions and 71 deletions
Download Patch File Download Diff File Expand all files Collapse all files

40
dashcaddy-api/routes/backups.js
View File

@@ -1,37 +1,45 @@
const express = require('express'); const express = require('express');
const { success } = require('../response-helpers');
module.exports = function(ctx) { /**
* Backups routes factory
* @param {Object} deps - Explicit dependencies
* @param {Object} deps.backupManager - Backup management module
* @param {Function} deps.asyncHandler - Async route handler wrapper
* @returns {express.Router}
*/
module.exports = function({ backupManager, asyncHandler }) {
const router = express.Router(); const router = express.Router();
// Get backup configuration // Get backup configuration
router.get('/backups/config', ctx.asyncHandler(async (req, res) => { router.get('/backups/config', asyncHandler(async (req, res) => {
const config = ctx.backupManager.getConfig(); const config = backupManager.getConfig();
res.json({ success: true, config }); success(res, { config });
}, 'backups-config-get')); }, 'backups-config-get'));
// Update backup configuration // Update backup configuration
router.post('/backups/config', ctx.asyncHandler(async (req, res) => { router.post('/backups/config', asyncHandler(async (req, res) => {
ctx.backupManager.updateConfig(req.body); backupManager.updateConfig(req.body);
res.json({ success: true, message: 'Backup configuration updated' }); success(res, { message: 'Backup configuration updated' });
}, 'backups-config-update')); }, 'backups-config-update'));
// Execute manual backup // Execute manual backup
router.post('/backups/execute', ctx.asyncHandler(async (req, res) => { router.post('/backups/execute', asyncHandler(async (req, res) => {
const backup = await ctx.backupManager.executeBackup('manual', req.body); const backup = await backupManager.executeBackup('manual', req.body);
res.json({ success: true, backup }); success(res, { backup });
}, 'backups-execute')); }, 'backups-execute'));
// Get backup history // Get backup history
router.get('/backups/history', ctx.asyncHandler(async (req, res) => { router.get('/backups/history', asyncHandler(async (req, res) => {
const limit = parseInt(req.query.limit) || 50; const limit = parseInt(req.query.limit) || 50;
const history = ctx.backupManager.getHistory(limit); const history = backupManager.getHistory(limit);
res.json({ success: true, history }); success(res, { history });
}, 'backups-history')); }, 'backups-history'));
// Restore from backup // Restore from backup
router.post('/backups/restore/:backupId', ctx.asyncHandler(async (req, res) => { router.post('/backups/restore/:backupId', asyncHandler(async (req, res) => {
const result = await ctx.backupManager.restoreBackup(req.params.backupId, req.body); const result = await backupManager.restoreBackup(req.params.backupId, req.body);
res.json({ success: true, result }); success(res, { result });
}, 'backups-restore')); }, 'backups-restore'));
return router; return router;

26
dashcaddy-api/routes/credentials.js
View File

@@ -1,21 +1,29 @@
const express = require('express'); const express = require('express');
const { success, error: errorResponse } = require('../response-helpers');
module.exports = function(ctx) { /**
* Credentials routes factory
* @param {Object} deps - Explicit dependencies
* @param {Object} deps.credentialManager - Credential storage manager
* @param {Function} deps.asyncHandler - Async route handler wrapper
* @returns {express.Router}
*/
module.exports = function({ credentialManager, asyncHandler }) {
const router = express.Router(); const router = express.Router();
// List all stored credentials (keys only, no values) // List all stored credentials (keys only, no values)
router.get('/credentials/list', ctx.asyncHandler(async (req, res) => { router.get('/credentials/list', asyncHandler(async (req, res) => {
const keys = await ctx.credentialManager.list(); const keys = await credentialManager.list();
res.json({ success: true, credentials: keys, count: keys.length }); success(res, { credentials: keys, count: keys.length });
}, 'credentials-list')); }, 'credentials-list'));
// Rotate encryption key — re-encrypts all stored credentials // Rotate encryption key — re-encrypts all stored credentials
router.post('/credentials/rotate-key', ctx.asyncHandler(async (req, res) => { router.post('/credentials/rotate-key', asyncHandler(async (req, res) => {
const success = await ctx.credentialManager.rotateEncryptionKey(); const rotateSuccess = await credentialManager.rotateEncryptionKey();
if (success) { if (rotateSuccess) {
res.json({ success: true, message: 'Encryption key rotated, all credentials re-encrypted' }); success(res, { message: 'Encryption key rotated, all credentials re-encrypted' });
} else { } else {
ctx.errorResponse(res, 500, 'Key rotation failed'); errorResponse(res, 'Key rotation failed', 500);
} }
}, 'credentials-rotate')); }, 'credentials-rotate'));

45
dashcaddy-api/routes/errorlogs.js
View File

@@ -3,17 +3,26 @@ const fs = require('fs');
const fsp = require('fs').promises; const fsp = require('fs').promises;
const { exists } = require('../fs-helpers'); const { exists } = require('../fs-helpers');
const { paginate, parsePaginationParams } = require('../pagination'); const { paginate, parsePaginationParams } = require('../pagination');
const { success } = require('../response-helpers');
module.exports = function(ctx) { /**
* Error logs routes factory
* @param {Object} deps - Explicit dependencies
* @param {string} deps.ERROR_LOG_FILE - Path to error log file
* @param {Object} deps.auditLogger - Audit logger instance
* @param {Function} deps.asyncHandler - Async route handler wrapper
* @returns {express.Router}
*/
module.exports = function({ ERROR_LOG_FILE, auditLogger, asyncHandler }) {
const router = express.Router(); const router = express.Router();
// Get error logs // Get error logs
router.get('/error-logs', ctx.asyncHandler(async (req, res) => { router.get('/error-logs', asyncHandler(async (req, res) => {
if (!await exists(ctx.ERROR_LOG_FILE)) { if (!await exists(ERROR_LOG_FILE)) {
return res.json({ success: true, logs: [] }); return success(res, { logs: [] });
} }
const logContent = await fsp.readFile(ctx.ERROR_LOG_FILE, 'utf8'); const logContent = await fsp.readFile(ERROR_LOG_FILE, 'utf8');
const logEntries = logContent.split('='.repeat(80)).filter(entry => entry.trim()); const logEntries = logContent.split('='.repeat(80)).filter(entry => entry.trim());
const logs = logEntries.map(entry => { const logs = logEntries.map(entry => {
@@ -31,37 +40,37 @@ module.exports = function(ctx) {
return null; return null;
}).filter(Boolean); }).filter(Boolean);
res.json({ success: true, logs: logs.slice(-50).reverse() }); success(res, { logs: logs.slice(-50).reverse() });
}, 'error-logs-get')); }, 'error-logs-get'));
// Clear error logs // Clear error logs
router.delete('/error-logs', ctx.asyncHandler(async (req, res) => { router.delete('/error-logs', asyncHandler(async (req, res) => {
if (await exists(ctx.ERROR_LOG_FILE)) { if (await exists(ERROR_LOG_FILE)) {
await fsp.writeFile(ctx.ERROR_LOG_FILE, ''); await fsp.writeFile(ERROR_LOG_FILE, '');
} }
res.json({ success: true, message: 'Error logs cleared' }); success(res, { message: 'Error logs cleared' });
}, 'error-logs-clear')); }, 'error-logs-clear'));
// Audit log // Audit log
router.get('/audit-logs', ctx.asyncHandler(async (req, res) => { router.get('/audit-logs', asyncHandler(async (req, res) => {
const paginationParams = parsePaginationParams(req.query); const paginationParams = parsePaginationParams(req.query);
const action = req.query.action || ''; const action = req.query.action || '';
if (paginationParams) { if (paginationParams) {
// When paginating, fetch all matching entries and let pagination slice // When paginating, fetch all matching entries and let pagination slice
const entries = await ctx.auditLogger.query({ limit: Number.MAX_SAFE_INTEGER, offset: 0, action }); const entries = await auditLogger.query({ limit: Number.MAX_SAFE_INTEGER, offset: 0, action });
const result = paginate(entries, paginationParams); const result = paginate(entries, paginationParams);
res.json({ success: true, entries: result.data, pagination: result.pagination }); success(res, { entries: result.data, pagination: result.pagination });
} else { } else {
const limit = parseInt(req.query.limit) || 50; const limit = parseInt(req.query.limit) || 50;
const offset = parseInt(req.query.offset) || 0; const offset = parseInt(req.query.offset) || 0;
const entries = await ctx.auditLogger.query({ limit, offset, action }); const entries = await auditLogger.query({ limit, offset, action });
res.json({ success: true, entries }); success(res, { entries });
} }
}, 'audit-log')); }, 'audit-log'));
router.delete('/audit-logs', ctx.asyncHandler(async (req, res) => { router.delete('/audit-logs', asyncHandler(async (req, res) => {
await ctx.auditLogger.clear(); await auditLogger.clear();
res.json({ success: true, message: 'Audit log cleared' }); success(res, { message: 'Audit log cleared' });
}, 'audit-log-clear')); }, 'audit-log-clear'));
return router; return router;

44
dashcaddy-api/routes/license.js
View File

@@ -1,53 +1,59 @@
const express = require('express'); const express = require('express');
const { success, error: errorResponse } = require('../response-helpers');
module.exports = function(ctx) { /**
* License routes factory
* @param {Object} deps - Explicit dependencies
* @param {Object} deps.licenseManager - License management module
* @param {Function} deps.asyncHandler - Async route handler wrapper
* @returns {express.Router}
*/
module.exports = function({ licenseManager, asyncHandler }) {
const router = express.Router(); const router = express.Router();
// Activate a license code // Activate a license code
router.post('/activate', ctx.asyncHandler(async (req, res) => { router.post('/activate', asyncHandler(async (req, res) => {
const { code } = req.body; const { code } = req.body;
if (!code) { if (!code) {
return ctx.errorResponse(res, 400, 'License code is required'); return errorResponse(res, 'License code is required', 400);
} }
const result = await ctx.licenseManager.activate(code); const result = await licenseManager.activate(code);
if (result.success) { if (result.success) {
res.json({ success(res, {
success: true,
message: result.message, message: result.message,
license: result.activation license: result.activation
}); });
} else { } else {
ctx.errorResponse(res, 400, result.message); errorResponse(res, result.message, 400);
} }
}, 'license-activate')); }, 'license-activate'));
// Get current license status // Get current license status
router.get('/status', ctx.asyncHandler(async (req, res) => { router.get('/status', asyncHandler(async (req, res) => {
const status = ctx.licenseManager.getStatus(); const status = licenseManager.getStatus();
res.json({ success: true, license: status }); success(res, { license: status });
}, 'license-status')); }, 'license-status'));
// Deactivate current license // Deactivate current license
router.post('/deactivate', ctx.asyncHandler(async (req, res) => { router.post('/deactivate', asyncHandler(async (req, res) => {
const result = await ctx.licenseManager.deactivate(); const result = await licenseManager.deactivate();
if (result.success) { if (result.success) {
res.json({ success: true, message: result.message }); success(res, { message: result.message });
} else { } else {
ctx.errorResponse(res, 400, result.message); errorResponse(res, result.message, 400);
} }
}, 'license-deactivate')); }, 'license-deactivate'));
// Check if a specific feature is available (lightweight check for frontend) // Check if a specific feature is available (lightweight check for frontend)
router.get('/feature/:feature', ctx.asyncHandler(async (req, res) => { router.get('/feature/:feature', asyncHandler(async (req, res) => {
const { feature } = req.params; const { feature } = req.params;
const available = ctx.licenseManager.hasFeature(feature); const available = licenseManager.hasFeature(feature);
const status = ctx.licenseManager.getStatus(); const status = licenseManager.getStatus();
res.json({ success(res, {
success: true,
feature, feature,
available, available,
tier: status.tier, tier: status.tier,

14
dashcaddy-api/routes/themes.js
View File

@@ -1,8 +1,14 @@
const express = require('express'); const express = require('express');
const fs = require('fs'); const fs = require('fs');
const path = require('path'); const path = require('path');
const { success } = require('../response-helpers');
module.exports = function(ctx) { /**
* Themes routes factory
* Note: This route does not use asyncHandler - uses synchronous fs operations
* @returns {express.Router}
*/
module.exports = function() {
const router = express.Router(); const router = express.Router();
const THEMES_DIR = process.env.THEMES_DIR || path.join(path.dirname(process.env.SERVICES_FILE || '/app/services.json'), 'themes'); const THEMES_DIR = process.env.THEMES_DIR || path.join(path.dirname(process.env.SERVICES_FILE || '/app/services.json'), 'themes');
@@ -28,7 +34,7 @@ module.exports = function(ctx) {
// Get all user themes // Get all user themes
router.get('/themes', (req, res) => { router.get('/themes', (req, res) => {
res.json({ success: true, themes: readAllThemes() }); success(res, { themes: readAllThemes() });
}); });
// Save a theme (create or update) // Save a theme (create or update)
@@ -48,7 +54,7 @@ module.exports = function(ctx) {
if (lightBg) themeData.lightBg = true; if (lightBg) themeData.lightBg = true;
fs.writeFileSync(path.join(THEMES_DIR, slug + '.json'), JSON.stringify(themeData, null, 2), 'utf8'); fs.writeFileSync(path.join(THEMES_DIR, slug + '.json'), JSON.stringify(themeData, null, 2), 'utf8');
res.json({ success: true, message: name + ' theme saved' }); success(res, { message: name + ' theme saved' });
}); });
// Delete a theme // Delete a theme
@@ -64,7 +70,7 @@ module.exports = function(ctx) {
const name = data.name || slug; const name = data.name || slug;
fs.unlinkSync(filePath); fs.unlinkSync(filePath);
res.json({ success: true, message: name + ' theme deleted' }); success(res, { message: name + ' theme deleted' });
}); });
return router; return router;

23
dashcaddy-api/server.js
View File

@@ -1233,17 +1233,30 @@ apiRouter.use(monitoringRoutes({
apiRouter.use(updatesRoutes(ctx)); apiRouter.use(updatesRoutes(ctx));
apiRouter.use('/tailscale', tailscaleRoutes(ctx)); apiRouter.use('/tailscale', tailscaleRoutes(ctx));
apiRouter.use(sitesRoutes(ctx)); apiRouter.use(sitesRoutes(ctx));
apiRouter.use(credentialsRoutes(ctx)); apiRouter.use(credentialsRoutes({
credentialManager: ctx.credentialManager,
asyncHandler: ctx.asyncHandler
}));
apiRouter.use(arrRoutes(ctx)); apiRouter.use(arrRoutes(ctx));
apiRouter.use(appsRoutes(ctx)); apiRouter.use(appsRoutes(ctx));
apiRouter.use(logsRoutes(ctx)); apiRouter.use(logsRoutes(ctx));
apiRouter.use(backupsRoutes(ctx)); apiRouter.use(backupsRoutes({
backupManager: ctx.backupManager,
asyncHandler: ctx.asyncHandler
}));
apiRouter.use('/ca', caRoutes(ctx)); apiRouter.use('/ca', caRoutes(ctx));
apiRouter.use(browseRoutes(ctx)); apiRouter.use(browseRoutes(ctx));
apiRouter.use(errorLogsRoutes(ctx)); apiRouter.use(errorLogsRoutes({
apiRouter.use('/license', licenseRoutes(ctx)); ERROR_LOG_FILE: ctx.ERROR_LOG_FILE,
auditLogger: ctx.auditLogger,
asyncHandler: ctx.asyncHandler
}));
apiRouter.use('/license', licenseRoutes({
licenseManager: ctx.licenseManager,
asyncHandler: ctx.asyncHandler
}));
apiRouter.use('/recipes', recipesRoutes(ctx)); apiRouter.use('/recipes', recipesRoutes(ctx));
apiRouter.use(themesRoutes(ctx)); apiRouter.use(themesRoutes()); // No dependencies - standalone route
// Inline routes on the API router // Inline routes on the API router
apiRouter.get('/health', (req, res) => { apiRouter.get('/health', (req, res) => {