plum-e2e 2.2.0 → 2.3.0

package/backend/prisma/migrations/20260621000001_add_backup_config/migration.sql

@@ -0,0 +1,11 @@
+-- AlterTable Project: add S3 backup configuration fields
+ALTER TABLE "Project" ADD COLUMN "backupEnabled"    BOOLEAN NOT NULL DEFAULT false;
+ALTER TABLE "Project" ADD COLUMN "backupCron"       TEXT    NOT NULL DEFAULT '0 2 * * *';
+ALTER TABLE "Project" ADD COLUMN "backupS3Endpoint" TEXT    NOT NULL DEFAULT '';
+ALTER TABLE "Project" ADD COLUMN "backupS3Region"   TEXT    NOT NULL DEFAULT '';
+ALTER TABLE "Project" ADD COLUMN "backupS3Bucket"   TEXT    NOT NULL DEFAULT '';
+ALTER TABLE "Project" ADD COLUMN "backupS3AccessKey" TEXT   NOT NULL DEFAULT '';
+ALTER TABLE "Project" ADD COLUMN "backupS3SecretKey" TEXT   NOT NULL DEFAULT '';
+ALTER TABLE "Project" ADD COLUMN "backupS3Prefix"   TEXT    NOT NULL DEFAULT '';
+ALTER TABLE "Project" ADD COLUMN "backupLastRunAt"  TIMESTAMP(3);
+ALTER TABLE "Project" ADD COLUMN "backupLastStatus" TEXT    NOT NULL DEFAULT '';

package/backend/prisma/schema.prisma

@@ -70,16 +70,26 @@ model Report {
 }
 
 model Project {
-  id                Int    @id @default(autoincrement())
-  name              String @default("")
-  logoUrl           String @default("")
-  testCasePrefix    String @default("TC")
-  testSuitePrefix   String @default("TS")
-  caseSeqNext       Int    @default(0)
-  suiteSeqNext      Int    @default(0)
-  discordWebhookUrl String @default("")
-  slackWebhookUrl   String @default("")
-  notifyPublicUrl   String @default("")
+  id                 Int       @id @default(autoincrement())
+  name               String    @default("")
+  logoUrl            String    @default("")
+  testCasePrefix     String    @default("TC")
+  testSuitePrefix    String    @default("TS")
+  caseSeqNext        Int       @default(0)
+  suiteSeqNext       Int       @default(0)
+  discordWebhookUrl  String    @default("")
+  slackWebhookUrl    String    @default("")
+  notifyPublicUrl    String    @default("")
+  backupEnabled      Boolean   @default(false)
+  backupCron         String    @default("0 2 * * *")
+  backupS3Endpoint   String    @default("")
+  backupS3Region     String    @default("")
+  backupS3Bucket     String    @default("")
+  backupS3AccessKey  String    @default("")
+  backupS3SecretKey  String    @default("")
+  backupS3Prefix     String    @default("")
+  backupLastRunAt    DateTime?
+  backupLastStatus   String    @default("")
 }
 
 model User {

package/backend/routes/backup.routes.js

@@ -18,7 +18,10 @@
 const express = require('express');
 const router = express.Router();
 const backupService = require('../services/backupService');
+const settingsService = require('../services/settingsService');
 const cronService = require('../services/cronService');
+const backupCronService = require('../services/backupCronService');
+const prisma = require('../services/prisma');
 
 router.get('/export', async (req, res) => {
 	try {
@@ -35,11 +38,15 @@ router.get('/export', async (req, res) => {
 
 router.post('/import', async (req, res) => {
 	try {
-		const { cronJobs, reports, project } = req.body;
-		if (!Array.isArray(cronJobs) && !Array.isArray(reports) && !project) {
-			return res.status(400).json({ error: 'Invalid backup format' });
-		}
-		await backupService.importAll({ cronJobs, reports, project }, cronService);
+		const { cronJobs, project, users, runners, testSuites, testRuns } = req.body;
+		const hasData = [cronJobs, project, users, runners, testSuites, testRuns].some(
+			(v) => v !== undefined && v !== null
+		);
+		if (!hasData) return res.status(400).json({ error: 'Invalid backup format' });
+		await backupService.importAll(
+			{ cronJobs, project, users, runners, testSuites, testRuns },
+			cronService
+		);
 		res.json({ message: 'Import successful' });
 	} catch (error) {
 		console.error('Import failed:', error);
@@ -47,4 +54,62 @@ router.post('/import', async (req, res) => {
 	}
 });
 
+router.get('/config', async (req, res) => {
+	try {
+		const config = await settingsService.getBackupConfig();
+		res.json(config);
+	} catch (error) {
+		console.error('Failed to get backup config:', error);
+		res.status(500).json({ error: 'Failed to get backup configuration' });
+	}
+});
+
+router.post('/config', async (req, res) => {
+	try {
+		await settingsService.updateBackupConfig(req.body);
+		await backupCronService.reload();
+		const config = await settingsService.getBackupConfig();
+		res.json(config);
+	} catch (error) {
+		console.error('Failed to save backup config:', error);
+		res.status(500).json({ error: 'Failed to save backup configuration' });
+	}
+});
+
+router.post('/test-s3', async (req, res) => {
+	try {
+		// If no secret key provided in the request, fall back to the stored one
+		let config = { ...req.body };
+		if (!config.backupS3SecretKey) {
+			const stored = await prisma.project.findUnique({ where: { id: 1 } });
+			config.backupS3SecretKey = stored?.backupS3SecretKey ?? '';
+		}
+
+		const required = ['backupS3Bucket', 'backupS3AccessKey', 'backupS3SecretKey'];
+		const missing = required.filter((k) => !config[k]);
+		if (missing.length > 0) {
+			return res.status(400).json({ error: `Missing required fields: ${missing.join(', ')}` });
+		}
+
+		await backupService.testS3Connection(config);
+		res.json({ ok: true });
+	} catch (error) {
+		res.status(400).json({ error: error.message || 'Connection failed' });
+	}
+});
+
+router.post('/run-now', async (req, res) => {
+	try {
+		await backupCronService.runBackup();
+		const config = await settingsService.getBackupConfig();
+		if (config.backupLastStatus?.startsWith('error:')) {
+			return res.status(500).json({ error: config.backupLastStatus.replace('error:', '') });
+		}
+		res.json({ ok: true, lastRunAt: config.backupLastRunAt, lastStatus: config.backupLastStatus });
+	} catch (error) {
+		console.error('Backup run-now failed:', error);
+		res.status(500).json({ error: error.message || 'Backup failed' });
+	}
+});
+
 module.exports = router;

package/backend/server.js

@@ -41,15 +41,18 @@ const isNodeMode = process.env.PLUM_MODE === 'node';
 const port = parseInt(process.env.PORT || '3001', 10);
 
 let cronService = null;
+let backupCronService = null;
 if (!isNodeMode) {
 	const socketHandler = require('./websockets/socketHandler.js');
 	cronService = require('./services/cronService');
+	backupCronService = require('./services/backupCronService');
 	socketHandler(io);
 	cronService.setSocketIO(io);
 }
 
 async function start() {
 	if (cronService) await cronService.init();
+	if (backupCronService) await backupCronService.init();
 
 	server.listen(port, async () => {
 		console.log(`Backend running on port ${port}${isNodeMode ? ' (node/runner mode)' : ''}`);

package/backend/services/backupCronService.js

@@ -0,0 +1,82 @@
+/*
+ * This file is part of Plum.
+ *
+ * Plum is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * Plum is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with Plum. If not, see https://www.gnu.org/licenses/.
+ */
+
+const cron = require('node-cron');
+const prisma = require('./prisma');
+const backupService = require('./backupService');
+
+let scheduledJob = null;
+
+const runBackup = async () => {
+	let project;
+	try {
+		project = await prisma.project.findUnique({ where: { id: 1 } });
+	} catch (err) {
+		console.error('❌ Backup: could not read project config:', err.message);
+		return;
+	}
+
+	if (!project?.backupEnabled) return;
+
+	try {
+		const data = await backupService.exportAll();
+		const key = await backupService.uploadToS3(data, project);
+
+		await prisma.project.update({
+			where: { id: 1 },
+			data: {
+				backupLastRunAt: new Date(),
+				backupLastStatus: `success:${key}`
+			}
+		});
+		console.log(`✅ Backup uploaded: ${key}`);
+	} catch (err) {
+		console.error('❌ Backup failed:', err.message);
+		try {
+			await prisma.project.update({
+				where: { id: 1 },
+				data: {
+					backupLastRunAt: new Date(),
+					backupLastStatus: `error:${err.message}`
+				}
+			});
+		} catch {}
+	}
+};
+
+const schedule = (cronExpr, enabled) => {
+	if (scheduledJob) {
+		scheduledJob.stop();
+		scheduledJob = null;
+	}
+	if (!enabled || !cronExpr || !cron.validate(cronExpr)) return;
+	scheduledJob = cron.schedule(cronExpr, runBackup);
+	console.log(`⏰ Backup scheduled: ${cronExpr}`);
+};
+
+const init = async () => {
+	try {
+		const project = await prisma.project.findUnique({ where: { id: 1 } });
+		schedule(project?.backupCron, project?.backupEnabled);
+	} catch (err) {
+		console.error('Failed to initialize backup cron:', err.message);
+	}
+};
+
+const reload = init;
+
+module.exports = { init, reload, runBackup };

package/backend/services/backupService.js

@@ -17,45 +17,272 @@
 
 const prisma = require('./prisma');
 
+// ---------------------------------------------------------------------------
+// Export — all data except reports (reports are too large; use pg_dump instead)
+// ---------------------------------------------------------------------------
+
 const exportAll = async () => {
-	const [cronJobs, project] = await Promise.all([
+	const [cronJobs, project, testSuites, testRuns, users, runners] = await Promise.all([
 		prisma.cronJob.findMany({ orderBy: { createdAt: 'asc' } }),
-		prisma.project.findUnique({ where: { id: 1 } })
+		prisma.project.findUnique({ where: { id: 1 } }),
+		prisma.testSuite.findMany({
+			orderBy: { createdAt: 'asc' },
+			include: {
+				cases: {
+					include: { steps: { orderBy: { order: 'asc' } } },
+					orderBy: { createdAt: 'asc' }
+				}
+			}
+		}),
+		prisma.testRun.findMany({
+			orderBy: { createdAt: 'asc' },
+			include: { entries: { orderBy: { order: 'asc' } } }
+		}),
+		prisma.user.findMany({ orderBy: { createdAt: 'asc' } }),
+		prisma.runner.findMany({ orderBy: { createdAt: 'asc' } })
 	]);
 
 	return {
-		version: '1',
+		version: '2',
 		exportedAt: new Date().toISOString(),
-		cronJobs: cronJobs.map(({ id, createdAt, updatedAt, reports: _, ...r }) => r),
-		project: project ? { name: project.name, logoUrl: project.logoUrl } : null
+		disclaimer:
+			'Reports are not included in this backup. Use pg_dump on the PostgreSQL volume to back up report history.',
+		cronJobs: cronJobs.map(({ id, createdAt, updatedAt, reports: _, runnerId: __, ...r }) => r),
+		project: project
+			? {
+					name: project.name,
+					logoUrl: project.logoUrl,
+					testCasePrefix: project.testCasePrefix,
+					testSuitePrefix: project.testSuitePrefix,
+					discordWebhookUrl: project.discordWebhookUrl,
+					slackWebhookUrl: project.slackWebhookUrl,
+					notifyPublicUrl: project.notifyPublicUrl
+				}
+			: null,
+		users: users.map(({ updatedAt: _, ...u }) => u),
+		runners: runners.map(({ createdAt: _, cronJobs: __, reports: ___, ...r }) => r),
+		testSuites: testSuites.map(({ cases, ...suite }) => ({
+			...suite,
+			cases: cases.map(({ steps, runEntries: _, history: __, ...tc }) => ({
+				...tc,
+				steps: steps.map(({ createdAt: ___, ...step }) => step)
+			}))
+		})),
+		testRuns: testRuns.map(({ entries, history: _, ...run }) => ({
+			...run,
+			entries: entries.map(({ executedAt, ...entry }) => ({ ...entry, executedAt }))
+		}))
 	};
 };
 
-const importAll = async ({ cronJobs = [], project = null }, cronService) => {
-	await prisma.$transaction(async (tx) => {
-		for (const job of cronJobs) {
-			await tx.cronJob.upsert({
-				where: { taskName: job.taskName },
-				create: {
-					taskName: job.taskName,
-					cronExpression: job.cronExpression,
-					tags: job.tags,
-					workers: job.workers ?? 1
-				},
-				update: { cronExpression: job.cronExpression, tags: job.tags, workers: job.workers ?? 1 }
-			});
+// ---------------------------------------------------------------------------
+// Import — upsert all exported data, preserve IDs for relational integrity
+// ---------------------------------------------------------------------------
+
+const importAll = async (
+	{ cronJobs = [], project = null, users = [], runners = [], testSuites = [], testRuns = [] },
+	cronService
+) => {
+	await prisma.$transaction(
+		async (tx) => {
+			// 1. Users (needed before suites/runs reference createdById)
+			for (const user of users) {
+				await tx.user.upsert({
+					where: { email: user.email },
+					create: user,
+					update: { name: user.name, role: user.role }
+				});
+			}
+
+			// 2. Runners
+			for (const runner of runners) {
+				await tx.runner.upsert({
+					where: { id: runner.id },
+					create: runner,
+					update: {
+						name: runner.name,
+						url: runner.url,
+						token: runner.token,
+						browser: runner.browser
+					}
+				});
+			}
+
+			// 3. CronJobs
+			for (const job of cronJobs) {
+				await tx.cronJob.upsert({
+					where: { taskName: job.taskName },
+					create: {
+						taskName: job.taskName,
+						cronExpression: job.cronExpression,
+						tags: job.tags,
+						workers: job.workers ?? 1,
+						browser: job.browser ?? 'chromium',
+						enabled: job.enabled ?? true,
+						runnerIds: job.runnerIds ?? 'built-in',
+						notifyDiscord: job.notifyDiscord ?? false,
+						notifySlack: job.notifySlack ?? false
+					},
+					update: {
+						cronExpression: job.cronExpression,
+						tags: job.tags,
+						workers: job.workers ?? 1,
+						browser: job.browser ?? 'chromium',
+						runnerIds: job.runnerIds ?? 'built-in',
+						notifyDiscord: job.notifyDiscord ?? false,
+						notifySlack: job.notifySlack ?? false
+					}
+				});
+			}
+
+			// 4. Project settings
+			if (project) {
+				await tx.project.upsert({
+					where: { id: 1 },
+					create: { id: 1, ...project },
+					update: project
+				});
+			}
+
+			// 5. Test suites + cases + steps
+			for (const suite of testSuites) {
+				const { cases = [], ...suiteData } = suite;
+				await tx.testSuite.upsert({
+					where: { displayId: suiteData.displayId },
+					create: suiteData,
+					update: {
+						name: suiteData.name,
+						description: suiteData.description,
+						priority: suiteData.priority
+					}
+				});
+
+				for (const tc of cases) {
+					const { steps = [], ...caseData } = tc;
+					await tx.testCase.upsert({
+						where: { displayId: caseData.displayId },
+						create: caseData,
+						update: {
+							title: caseData.title,
+							description: caseData.description,
+							priority: caseData.priority,
+							isAutomated: caseData.isAutomated
+						}
+					});
+
+					// Replace all steps for this case (order may have changed)
+					await tx.testStep.deleteMany({ where: { caseId: caseData.id } });
+					for (const step of steps) {
+						await tx.testStep.create({ data: step });
+					}
+				}
+			}
+
+			// 6. Test runs + entries
+			for (const run of testRuns) {
+				const { entries = [], ...runData } = run;
+				await tx.testRun.upsert({
+					where: { id: runData.id },
+					create: runData,
+					update: { title: runData.title, status: runData.status }
+				});
+
+				for (const entry of entries) {
+					await tx.testRunEntry.upsert({
+						where: { id: entry.id },
+						create: entry,
+						update: { status: entry.status, notes: entry.notes, order: entry.order }
+					});
+				}
+			}
+		},
+		{ timeout: 30000 }
+	);
+
+	if (cronService) await cronService.reload();
+};
+
+// ---------------------------------------------------------------------------
+// S3 upload — S3-compatible object storage (AWS, R2, B2, MinIO)
+// ---------------------------------------------------------------------------
+
+const uploadToS3 = async (jsonData, config) => {
+	const { S3Client, PutObjectCommand } = await import('@aws-sdk/client-s3');
+
+	const {
+		backupS3Endpoint,
+		backupS3Region,
+		backupS3Bucket,
+		backupS3AccessKey,
+		backupS3SecretKey,
+		backupS3Prefix
+	} = config;
+
+	const clientConfig = {
+		region: backupS3Region || 'auto',
+		credentials: {
+			accessKeyId: backupS3AccessKey,
+			secretAccessKey: backupS3SecretKey
 		}
+	};
+	if (backupS3Endpoint) clientConfig.endpoint = backupS3Endpoint;
+
+	const client = new S3Client(clientConfig);
+
+	const date = new Date().toISOString().slice(0, 10);
+	const prefix = backupS3Prefix ? backupS3Prefix.replace(/\/?$/, '/') : '';
+	const key = `${prefix}plum-backup-${date}.json`;
+
+	await client.send(
+		new PutObjectCommand({
+			Bucket: backupS3Bucket,
+			Key: key,
+			Body: JSON.stringify(jsonData, null, 2),
+			ContentType: 'application/json'
+		})
+	);
+
+	return key;
+};
+
+const testS3Connection = async (config) => {
+	const { S3Client, PutObjectCommand, DeleteObjectCommand } = await import('@aws-sdk/client-s3');
 
-		if (project) {
-			await tx.project.upsert({
-				where: { id: 1 },
-				create: { id: 1, name: project.name ?? '', logoUrl: project.logoUrl ?? '' },
-				update: { name: project.name ?? '', logoUrl: project.logoUrl ?? '' }
-			});
+	const {
+		backupS3Endpoint,
+		backupS3Region,
+		backupS3Bucket,
+		backupS3AccessKey,
+		backupS3SecretKey,
+		backupS3Prefix
+	} = config;
+
+	const clientConfig = {
+		region: backupS3Region || 'auto',
+		credentials: {
+			accessKeyId: backupS3AccessKey,
+			secretAccessKey: backupS3SecretKey
 		}
-	});
+	};
+	if (backupS3Endpoint) clientConfig.endpoint = backupS3Endpoint;
 
-	if (cronService) await cronService.reload();
+	const client = new S3Client(clientConfig);
+	const prefix = backupS3Prefix ? backupS3Prefix.replace(/\/?$/, '/') : '';
+	const key = `${prefix}.plum-connection-test`;
+
+	await client.send(
+		new PutObjectCommand({
+			Bucket: backupS3Bucket,
+			Key: key,
+			Body: 'ok',
+			ContentType: 'text/plain'
+		})
+	);
+
+	// Clean up the test file
+	try {
+		await client.send(new DeleteObjectCommand({ Bucket: backupS3Bucket, Key: key }));
+	} catch {}
 };
 
-module.exports = { exportAll, importAll };
+module.exports = { exportAll, importAll, uploadToS3, testS3Connection };

package/backend/services/settingsService.js

@@ -70,11 +70,56 @@ const updateWebhooks = async ({ discordWebhookUrl, slackWebhookUrl, notifyPublic
 	});
 };
 
+const getBackupConfig = async () => {
+	const project = await getProject();
+	return {
+		backupEnabled: project.backupEnabled,
+		backupCron: project.backupCron,
+		backupS3Endpoint: project.backupS3Endpoint,
+		backupS3Region: project.backupS3Region,
+		backupS3Bucket: project.backupS3Bucket,
+		backupS3AccessKey: project.backupS3AccessKey,
+		backupS3SecretKeySet: project.backupS3SecretKey.length > 0,
+		backupS3Prefix: project.backupS3Prefix,
+		backupLastRunAt: project.backupLastRunAt,
+		backupLastStatus: project.backupLastStatus
+	};
+};
+
+const updateBackupConfig = async ({
+	backupEnabled,
+	backupCron,
+	backupS3Endpoint,
+	backupS3Region,
+	backupS3Bucket,
+	backupS3AccessKey,
+	backupS3SecretKey,
+	backupS3Prefix
+}) => {
+	const update = {
+		...(backupEnabled !== undefined && { backupEnabled }),
+		...(backupCron !== undefined && { backupCron }),
+		...(backupS3Endpoint !== undefined && { backupS3Endpoint }),
+		...(backupS3Region !== undefined && { backupS3Region }),
+		...(backupS3Bucket !== undefined && { backupS3Bucket }),
+		...(backupS3AccessKey !== undefined && { backupS3AccessKey }),
+		...(backupS3SecretKey && { backupS3SecretKey }),
+		...(backupS3Prefix !== undefined && { backupS3Prefix })
+	};
+	return prisma.project.upsert({
+		where: { id: 1 },
+		create: { id: 1, ...update },
+		update
+	});
+};
+
 module.exports = {
 	getProject,
 	updateProject,
 	getTestPrefixes,
 	updateTestPrefixes,
 	getWebhooks,
-	updateWebhooks
+	updateWebhooks,
+	getBackupConfig,
+	updateBackupConfig
 };

package/frontend/src/lib/api/settings.js

@@ -47,6 +47,47 @@ export async function importBackup(data) {
 	return res.json();
 }
 
+export async function fetchBackupConfig() {
+	const res = await fetch(`${API_BASE}/backup/config`);
+	if (!res.ok)
+		return {
+			backupEnabled: false,
+			backupCron: '0 2 * * *',
+			backupS3Endpoint: '',
+			backupS3Region: '',
+			backupS3Bucket: '',
+			backupS3AccessKey: '',
+			backupS3SecretKeySet: false,
+			backupS3Prefix: '',
+			backupLastRunAt: null,
+			backupLastStatus: ''
+		};
+	return res.json();
+}
+
+export async function saveBackupConfig(config) {
+	const res = await fetch(`${API_BASE}/backup/config`, {
+		method: 'POST',
+		headers: { 'Content-Type': 'application/json' },
+		body: JSON.stringify(config)
+	});
+	return res.json();
+}
+
+export async function testBackupS3(config) {
+	const res = await fetch(`${API_BASE}/backup/test-s3`, {
+		method: 'POST',
+		headers: { 'Content-Type': 'application/json' },
+		body: JSON.stringify(config)
+	});
+	return res.json();
+}
+
+export async function runBackupNow() {
+	const res = await fetch(`${API_BASE}/backup/run-now`, { method: 'POST' });
+	return res.json();
+}
+
 export async function fetchIntegrations() {
 	const res = await fetch(`${API_BASE}/settings/integrations`);
 	if (!res.ok) return { discordWebhookUrl: '', slackWebhookUrl: '', notifyPublicUrl: '' };