add mysql, mariadb, postgresql, sqlite volumes support

app/server/utils/database-dump.ts

@@ -0,0 +1,282 @@
+import * as fs from "node:fs/promises";
+import * as path from "node:path";
+import { safeSpawn } from "./spawn";
+import { logger } from "./logger";
+import { toMessage } from "./errors";
+import type { BackendConfig } from "~/schemas/volumes";
+
+export type DatabaseConfig = Extract<
+	BackendConfig,
+	{ backend: "mariadb" | "mysql" | "postgres" | "sqlite" }
+>;
+
+// MariaDB
+export const dumpMariaDB = async (config: DatabaseConfig, outputPath: string): Promise<void> => {
+	if (config.backend !== "mariadb") {
+		throw new Error("Invalid backend type for MariaDB dump");
+	}
+
+	logger.info(`Starting MariaDB dump for database: ${config.database}`);
+
+	const args = [
+		`--host=${config.host}`,
+		`--port=${config.port}`,
+		`--user=${config.username}`,
+		`--skip-ssl`,
+		`--single-transaction`,
+		`--quick`,
+		`--lock-tables=false`,
+		...(config.dumpOptions || []),
+		config.database,
+	];
+
+	const env = {
+		...process.env,
+		MYSQL_PWD: config.password,
+	};
+
+	try {
+		const result = await safeSpawn({ command: "mariadb-dump", args, env });
+		await fs.writeFile(outputPath, result.stdout);
+		logger.info(`MariaDB dump completed: ${outputPath}`);
+	} catch (error) {
+		logger.error(`MariaDB dump failed: ${toMessage(error)}`);
+		throw error;
+	}
+};
+
+export const testMariaDBConnection = async (config: DatabaseConfig): Promise<void> => {
+	if (config.backend !== "mariadb") {
+		throw new Error("Invalid backend type for MariaDB connection test");
+	}
+
+	logger.debug(`Testing MariaDB connection to: ${config.host}:${config.port}`);
+
+	const args = [
+		`--host=${config.host}`,
+		`--port=${config.port}`,
+		`--user=${config.username}`,
+		`--database=${config.database}`,
+		"--skip-ssl",
+		"--execute=SELECT 1",
+	];
+
+	const env = {
+		...process.env,
+		MYSQL_PWD: config.password,
+	};
+
+	try {
+		await safeSpawn({ command: "mariadb", args, env, timeout: 10000 });
+		logger.debug("MariaDB connection test successful");
+	} catch (error) {
+		logger.error(`MariaDB connection test failed: ${toMessage(error)}`);
+		throw error;
+	}
+};
+
+// MySQL
+export const dumpMySQL = async (config: DatabaseConfig, outputPath: string): Promise<void> => {
+	if (config.backend !== "mysql") {
+		throw new Error("Invalid backend type for MySQL dump");
+	}
+
+	logger.info(`Starting MySQL dump for database: ${config.database}`);
+
+	const args = [
+		`--host=${config.host}`,
+		`--port=${config.port}`,
+		`--user=${config.username}`,
+		`--skip-ssl`,
+		`--single-transaction`,
+		`--quick`,
+		`--lock-tables=false`,
+		...(config.dumpOptions || []),
+		config.database,
+	];
+
+	const env = {
+		...process.env,
+		MYSQL_PWD: config.password,
+	};
+
+	try {
+		const result = await safeSpawn({ command: "mysqldump", args, env });
+		await fs.writeFile(outputPath, result.stdout);
+		logger.info(`MySQL dump completed: ${outputPath}`);
+	} catch (error) {
+		logger.error(`MySQL dump failed: ${toMessage(error)}`);
+		throw error;
+	}
+};
+
+export const testMySQLConnection = async (config: DatabaseConfig): Promise<void> => {
+	if (config.backend !== "mysql") {
+		throw new Error("Invalid backend type for MySQL connection test");
+	}
+
+	logger.debug(`Testing MySQL connection to: ${config.host}:${config.port}`);
+
+	const args = [
+		`--host=${config.host}`,
+		`--port=${config.port}`,
+		`--user=${config.username}`,
+		`--database=${config.database}`,
+		"--skip-ssl",
+		"--execute=SELECT 1",
+	];
+
+	const env = {
+		...process.env,
+		MYSQL_PWD: config.password,
+	};
+
+	try {
+		await safeSpawn({ command: "mysql", args, env, timeout: 10000 });
+		logger.debug("MySQL connection test successful");
+	} catch (error) {
+		logger.error(`MySQL connection test failed: ${toMessage(error)}`);
+		throw error;
+	}
+};
+
+// PostgreSQL
+export const dumpPostgres = async (config: DatabaseConfig, outputPath: string): Promise<void> => {
+	if (config.backend !== "postgres") {
+		throw new Error("Invalid backend type for PostgreSQL dump");
+	}
+
+	logger.info(`Starting PostgreSQL dump for database: ${config.database}`);
+
+	const args = [
+		`--host=${config.host}`,
+		`--port=${config.port}`,
+		`--username=${config.username}`,
+		`--dbname=${config.database}`,
+		`--format=${config.dumpFormat}`,
+		`--file=${outputPath}`,
+		"--no-password",
+		...(config.dumpOptions || []),
+	];
+
+	const env = {
+		...process.env,
+		PGPASSWORD: config.password,
+		PGSSLMODE: "disable",
+	};
+
+	try {
+		await safeSpawn({ command: "pg_dump", args, env });
+		logger.info(`PostgreSQL dump completed: ${outputPath}`);
+	} catch (error) {
+		logger.error(`PostgreSQL dump failed: ${toMessage(error)}`);
+		throw error;
+	}
+};
+
+export const testPostgresConnection = async (config: DatabaseConfig): Promise<void> => {
+	if (config.backend !== "postgres") {
+		throw new Error("Invalid backend type for PostgreSQL connection test");
+	}
+
+	logger.debug(`Testing PostgreSQL connection to: ${config.host}:${config.port}`);
+
+	const args = [
+		`--host=${config.host}`,
+		`--port=${config.port}`,
+		`--username=${config.username}`,
+		`--dbname=${config.database}`,
+		"--command=SELECT 1",
+		"--no-password",
+	];
+
+	const env = {
+		...process.env,
+		PGPASSWORD: config.password,
+		PGSSLMODE: "disable",
+	};
+
+	try {
+		await safeSpawn({ command: "psql", args, env, timeout: 10000 });
+		logger.debug("PostgreSQL connection test successful");
+	} catch (error) {
+		logger.error(`PostgreSQL connection test failed: ${toMessage(error)}`);
+		throw error;
+	}
+};
+
+// SQLite
+export const dumpSQLite = async (config: DatabaseConfig, outputPath: string): Promise<void> => {
+	if (config.backend !== "sqlite") {
+		throw new Error("Invalid backend type for SQLite dump");
+	}
+
+	logger.info(`Starting SQLite dump for database: ${config.path}`);
+
+	try {
+		await fs.access(config.path);
+
+		const result = await safeSpawn({ command: "sqlite3", args: [config.path, ".dump"] });
+		await fs.writeFile(outputPath, result.stdout);
+		logger.info(`SQLite dump completed: ${outputPath}`);
+	} catch (error) {
+		logger.error(`SQLite dump failed: ${toMessage(error)}`);
+		throw error;
+	}
+};
+
+export const testSQLiteConnection = async (config: DatabaseConfig): Promise<void> => {
+	if (config.backend !== "sqlite") {
+		throw new Error("Invalid backend type for SQLite connection test");
+	}
+
+	logger.debug(`Testing SQLite connection to: ${config.path}`);
+
+	try {
+		await fs.access(config.path, fs.constants.R_OK);
+		const result = await safeSpawn({ command: "sqlite3", args: [config.path, "SELECT 1"] });
+
+		if (!result.stdout.includes("1")) {
+			throw new Error("SQLite database query failed");
+		}
+
+		logger.debug("SQLite connection test successful");
+	} catch (error) {
+		logger.error(`SQLite connection test failed: ${toMessage(error)}`);
+		throw error;
+	}
+};
+
+// Utils
+export const executeDatabaseDump = async (config: DatabaseConfig, outputPath: string): Promise<void> => {
+	const outputDir = path.dirname(outputPath);
+	await fs.mkdir(outputDir, { recursive: true });
+
+	switch (config.backend) {
+		case "mariadb":
+			return dumpMariaDB(config, outputPath);
+		case "mysql":
+			return dumpMySQL(config, outputPath);
+		case "postgres":
+			return dumpPostgres(config, outputPath);
+		case "sqlite":
+			return dumpSQLite(config, outputPath);
+		default:
+			throw new Error(`Unsupported database backend: ${(config as any).backend}`);
+	}
+};
+
+export const testDatabaseConnection = async (config: DatabaseConfig): Promise<void> => {
+	switch (config.backend) {
+		case "mariadb":
+			return testMariaDBConnection(config);
+		case "mysql":
+			return testMySQLConnection(config);
+		case "postgres":
+			return testPostgresConnection(config);
+		case "sqlite":
+			return testSQLiteConnection(config);
+		default:
+			throw new Error(`Unsupported database backend: ${(config as any).backend}`);
+	}
+};

app/server/utils/spawn.ts

@@ -5,6 +5,8 @@ interface Params {
 	args: string[];
 	env?: NodeJS.ProcessEnv;
 	signal?: AbortSignal;
+	stdin?: string;
+	timeout?: number;
 	onStdout?: (data: string) => void;
 	onStderr?: (error: string) => void;
 	onError?: (error: Error) => Promise<void> | void;
@@ -19,17 +21,32 @@ type SpawnResult = {
 };
 
 export const safeSpawn = (params: Params) => {
-	const { command, args, env = {}, signal, ...callbacks } = params;
+	const { command, args, env = {}, signal, stdin, timeout, ...callbacks } = params;
 
-	return new Promise<SpawnResult>((resolve) => {
+	return new Promise<SpawnResult>((resolve, reject) => {
 		let stdoutData = "";
 		let stderrData = "";
+		let timeoutId: NodeJS.Timeout | undefined;
 
 		const child = spawn(command, args, {
 			env: { ...process.env, ...env },
 			signal: signal,
 		});
 
+		// Handle timeout if specified
+		if (timeout) {
+			timeoutId = setTimeout(() => {
+				child.kill("SIGTERM");
+				reject(new Error(`Command timed out after ${timeout}ms`));
+			}, timeout);
+		}
+
+		// Write stdin if provided
+		if (stdin && child.stdin) {
+			child.stdin.write(stdin);
+			child.stdin.end();
+		}
+
 		child.stdout.on("data", (data) => {
 			if (callbacks.onStdout) {
 				callbacks.onStdout(data.toString());
@@ -47,6 +64,7 @@ export const safeSpawn = (params: Params) => {
 		});
 
 		child.on("error", async (error) => {
+			if (timeoutId) clearTimeout(timeoutId);
 			if (callbacks.onError) {
 				await callbacks.onError(error);
 			}
@@ -54,14 +72,11 @@ export const safeSpawn = (params: Params) => {
 				await callbacks.finally();
 			}
 
-			resolve({
-				exitCode: -1,
-				stdout: stdoutData,
-				stderr: stderrData,
-			});
+			reject(error);
 		});
 
 		child.on("close", async (code) => {
+			if (timeoutId) clearTimeout(timeoutId);
 			if (callbacks.onClose) {
 				await callbacks.onClose(code);
 			}
@@ -69,11 +84,15 @@ export const safeSpawn = (params: Params) => {
 				await callbacks.finally();
 			}
 
-			resolve({
-				exitCode: code === null ? -1 : code,
-				stdout: stdoutData,
-				stderr: stderrData,
-			});
+			if (code !== 0 && code !== null) {
+				reject(new Error(`Command failed with exit code ${code}: ${stderrData || stdoutData}`));
+			} else {
+				resolve({
+					exitCode: code === null ? -1 : code,
+					stdout: stdoutData,
+					stderr: stderrData,
+				});
+			}
 		});
 	});
 };