refactor: unify backend and frontend servers (#3)

* refactor: unify backend and frontend servers

* refactor: correct paths for openapi & drizzle

* refactor: move api-client to client

* fix: drizzle paths

* chore: fix linting issues

* fix: form reset issue

app/server/modules/backends/webdav/webdav-backend.ts

@@ -0,0 +1,168 @@
+import { execFile as execFileCb } from "node:child_process";
+import * as fs from "node:fs/promises";
+import * as os from "node:os";
+import { promisify } from "node:util";
+import { OPERATION_TIMEOUT } from "../../../core/constants";
+import { toMessage } from "../../../utils/errors";
+import { logger } from "../../../utils/logger";
+import { getMountForPath } from "../../../utils/mountinfo";
+import { withTimeout } from "../../../utils/timeout";
+import type { VolumeBackend } from "../backend";
+import { createTestFile, executeMount, executeUnmount } from "../utils/backend-utils";
+import { BACKEND_STATUS, type BackendConfig } from "~/schemas/volumes";
+
+const execFile = promisify(execFileCb);
+
+const mount = async (config: BackendConfig, path: string) => {
+	logger.debug(`Mounting WebDAV volume ${path}...`);
+
+	if (config.backend !== "webdav") {
+		logger.error("Provided config is not for WebDAV backend");
+		return { status: BACKEND_STATUS.error, error: "Provided config is not for WebDAV backend" };
+	}
+
+	if (os.platform() !== "linux") {
+		logger.error("WebDAV mounting is only supported on Linux hosts.");
+		return { status: BACKEND_STATUS.error, error: "WebDAV mounting is only supported on Linux hosts." };
+	}
+
+	const { status } = await checkHealth(path, config.readOnly ?? false);
+	if (status === "mounted") {
+		return { status: BACKEND_STATUS.mounted };
+	}
+
+	logger.debug(`Trying to unmount any existing mounts at ${path} before mounting...`);
+	await unmount(path);
+
+	const run = async () => {
+		await fs.mkdir(path, { recursive: true }).catch((err) => {
+			logger.warn(`Failed to create directory ${path}: ${err.message}`);
+		});
+
+		const protocol = config.ssl ? "https" : "http";
+		const defaultPort = config.ssl ? 443 : 80;
+		const port = config.port !== defaultPort ? `:${config.port}` : "";
+		const source = `${protocol}://${config.server}${port}${config.path}`;
+
+		const options = config.readOnly
+			? ["uid=1000", "gid=1000", "file_mode=0444", "dir_mode=0555", "ro"]
+			: ["uid=1000", "gid=1000", "file_mode=0664", "dir_mode=0775"];
+
+		if (config.username && config.password) {
+			const secretsFile = "/etc/davfs2/secrets";
+			const secretsContent = `${source} ${config.username} ${config.password}\n`;
+			await fs.appendFile(secretsFile, secretsContent, { mode: 0o600 });
+		}
+
+		logger.debug(`Mounting WebDAV volume ${path}...`);
+
+		const args = ["-t", "davfs", source, path];
+		await executeMount(args);
+
+		const { stderr } = await execFile("mount", ["-t", "davfs", "-o", options.join(","), source, path], {
+			timeout: OPERATION_TIMEOUT,
+			maxBuffer: 1024 * 1024,
+		});
+
+		if (stderr?.trim()) {
+			logger.warn(stderr.trim());
+		}
+
+		logger.info(`WebDAV volume at ${path} mounted successfully.`);
+		return { status: BACKEND_STATUS.mounted };
+	};
+
+	try {
+		return await withTimeout(run(), OPERATION_TIMEOUT, "WebDAV mount");
+	} catch (error) {
+		const errorMsg = toMessage(error);
+
+		if (errorMsg.includes("already mounted")) {
+			return { status: BACKEND_STATUS.mounted };
+		}
+
+		logger.error("Error mounting WebDAV volume", { error: errorMsg });
+
+		if (errorMsg.includes("option") && errorMsg.includes("requires argument")) {
+			return {
+				status: BACKEND_STATUS.error,
+				error: "Invalid mount options. Please check your WebDAV server configuration.",
+			};
+		} else if (errorMsg.includes("connection refused") || errorMsg.includes("Connection refused")) {
+			return {
+				status: BACKEND_STATUS.error,
+				error: "Cannot connect to WebDAV server. Please check the server address and port.",
+			};
+		} else if (errorMsg.includes("unauthorized") || errorMsg.includes("Unauthorized")) {
+			return {
+				status: BACKEND_STATUS.error,
+				error: "Authentication failed. Please check your username and password.",
+			};
+		}
+
+		return { status: BACKEND_STATUS.error, error: errorMsg };
+	}
+};
+
+const unmount = async (path: string) => {
+	if (os.platform() !== "linux") {
+		logger.error("WebDAV unmounting is only supported on Linux hosts.");
+		return { status: BACKEND_STATUS.error, error: "WebDAV unmounting is only supported on Linux hosts." };
+	}
+
+	const run = async () => {
+		try {
+			await fs.access(path);
+		} catch (e) {
+			logger.warn(`Path ${path} does not exist. Skipping unmount.`, e);
+			return { status: BACKEND_STATUS.unmounted };
+		}
+
+		await executeUnmount(path);
+
+		await fs.rmdir(path);
+
+		logger.info(`WebDAV volume at ${path} unmounted successfully.`);
+		return { status: BACKEND_STATUS.unmounted };
+	};
+
+	try {
+		return await withTimeout(run(), OPERATION_TIMEOUT, "WebDAV unmount");
+	} catch (error) {
+		logger.error("Error unmounting WebDAV volume", { path, error: toMessage(error) });
+		return { status: BACKEND_STATUS.error, error: toMessage(error) };
+	}
+};
+
+const checkHealth = async (path: string, readOnly: boolean) => {
+	const run = async () => {
+		logger.debug(`Checking health of WebDAV volume at ${path}...`);
+		await fs.access(path);
+
+		const mount = await getMountForPath(path);
+
+		if (!mount || mount.fstype !== "fuse") {
+			throw new Error(`Path ${path} is not mounted as WebDAV.`);
+		}
+
+		if (!readOnly) {
+			await createTestFile(path);
+		}
+
+		logger.debug(`WebDAV volume at ${path} is healthy and mounted.`);
+		return { status: BACKEND_STATUS.mounted };
+	};
+
+	try {
+		return await withTimeout(run(), OPERATION_TIMEOUT, "WebDAV health check");
+	} catch (error) {
+		logger.error("WebDAV volume health check failed:", toMessage(error));
+		return { status: BACKEND_STATUS.error, error: toMessage(error) };
+	}
+};
+
+export const makeWebdavBackend = (config: BackendConfig, path: string): VolumeBackend => ({
+	mount: () => mount(config, path),
+	unmount: () => unmount(path),
+	checkHealth: () => checkHealth(path, config.readOnly ?? false),
+});