refactor: improve error handling with global router catchall

apps/server/src/modules/volumes/volume.service.ts

@@ -9,7 +9,6 @@ import { config } from "../../core/config";
 import { db } from "../../db/db";
 import { volumesTable } from "../../db/schema";
 import { createVolumeBackend } from "../backends/backend";
-import { logger } from "../../utils/logger";
 import { toMessage } from "../../utils/errors";
 
 const listVolumes = async () => {
@@ -26,7 +25,7 @@ const createVolume = async (name: string, backendConfig: BackendConfig) => {
 	});
 
 	if (existing) {
-		return { error: new ConflictError("Volume already exists") };
+		throw new ConflictError("Volume already exists");
 	}
 
 	const volumePathHost = path.join(config.volumeRootHost);
@@ -45,82 +44,54 @@ const createVolume = async (name: string, backendConfig: BackendConfig) => {
 };
 
 const deleteVolume = async (name: string) => {
-	try {
-		const volume = await db.query.volumesTable.findFirst({
-			where: eq(volumesTable.name, name),
-		});
+	const volume = await db.query.volumesTable.findFirst({
+		where: eq(volumesTable.name, name),
+	});
 
-		if (!volume) {
-			return { error: new NotFoundError("Volume not found") };
-		}
-
-		const backend = createVolumeBackend(volume);
-		await backend.unmount();
-		await db.delete(volumesTable).where(eq(volumesTable.name, name));
-		return { status: 200 };
-	} catch (error) {
-		return {
-			error: new InternalServerError("Failed to delete volume", {
-				cause: error,
-			}),
-		};
+	if (!volume) {
+		throw new NotFoundError("Volume not found");
 	}
+
+	const backend = createVolumeBackend(volume);
+	await backend.unmount();
+	await db.delete(volumesTable).where(eq(volumesTable.name, name));
 };
 
 const mountVolume = async (name: string) => {
-	try {
-		const volume = await db.query.volumesTable.findFirst({
-			where: eq(volumesTable.name, name),
-		});
+	const volume = await db.query.volumesTable.findFirst({
+		where: eq(volumesTable.name, name),
+	});
 
-		if (!volume) {
-			return { error: new NotFoundError("Volume not found") };
-		}
-
-		const backend = createVolumeBackend(volume);
-		await backend.mount();
-
-		await db
-			.update(volumesTable)
-			.set({ status: "mounted", lastHealthCheck: new Date(), lastError: null })
-			.where(eq(volumesTable.name, name));
-
-		return { status: 200 };
-	} catch (error) {
-		return {
-			error: new InternalServerError("Failed to mount volume", {
-				cause: error,
-			}),
-		};
+	if (!volume) {
+		throw new NotFoundError("Volume not found");
 	}
+
+	const backend = createVolumeBackend(volume);
+	const { error, status } = await backend.mount();
+
+	await db
+		.update(volumesTable)
+		.set({ status, lastError: error, lastHealthCheck: new Date() })
+		.where(eq(volumesTable.name, name));
+
+	return { error, status };
 };
 
 const unmountVolume = async (name: string) => {
-	try {
-		const volume = await db.query.volumesTable.findFirst({
-			where: eq(volumesTable.name, name),
-		});
+	const volume = await db.query.volumesTable.findFirst({
+		where: eq(volumesTable.name, name),
+	});
 
-		if (!volume) {
-			return { error: new NotFoundError("Volume not found") };
-		}
-
-		const backend = createVolumeBackend(volume);
-		await backend.unmount();
-
-		await db
-			.update(volumesTable)
-			.set({ status: "unmounted", lastHealthCheck: new Date() })
-			.where(eq(volumesTable.name, name));
-
-		return { status: 200 };
-	} catch (error) {
-		return {
-			error: new InternalServerError("Failed to unmount volume", {
-				cause: error,
-			}),
-		};
+	if (!volume) {
+		throw new NotFoundError("Volume not found");
 	}
+
+	const backend = createVolumeBackend(volume);
+	const { status, error } = await backend.unmount();
+
+	await db.update(volumesTable).set({ status }).where(eq(volumesTable.name, name));
+
+	return { error, status };
 };
 
 const getVolume = async (name: string) => {
@@ -129,121 +100,88 @@ const getVolume = async (name: string) => {
 	});
 
 	if (!volume) {
-		return { error: new NotFoundError("Volume not found") };
+		throw new NotFoundError("Volume not found");
 	}
 
 	return { volume };
 };
 
 const updateVolume = async (name: string, backendConfig: BackendConfig) => {
-	try {
-		const existing = await db.query.volumesTable.findFirst({
-			where: eq(volumesTable.name, name),
-		});
+	const existing = await db.query.volumesTable.findFirst({
+		where: eq(volumesTable.name, name),
+	});
 
-		if (!existing) {
-			return { error: new NotFoundError("Volume not found") };
-		}
-
-		const [updated] = await db
-			.update(volumesTable)
-			.set({
-				config: backendConfig,
-				type: backendConfig.backend,
-				updatedAt: new Date(),
-				status: "unmounted",
-			})
-			.where(eq(volumesTable.name, name))
-			.returning();
-
-		if (!updated) {
-			return { error: new InternalServerError("Failed to update volume") };
-		}
-
-		return { volume: updated };
-	} catch (error) {
-		return {
-			error: new InternalServerError("Failed to update volume", {
-				cause: error,
-			}),
-		};
+	if (!existing) {
+		throw new NotFoundError("Volume not found");
 	}
+
+	const [updated] = await db
+		.update(volumesTable)
+		.set({
+			config: backendConfig,
+			type: backendConfig.backend,
+			updatedAt: new Date(),
+			status: "unmounted",
+		})
+		.where(eq(volumesTable.name, name))
+		.returning();
+
+	if (!updated) {
+		throw new InternalServerError("Failed to update volume");
+	}
+
+	return { volume: updated };
 };
 
 const testConnection = async (backendConfig: BackendConfig) => {
-	let tempDir: string | null = null;
+	const tempDir = await fs.mkdtemp(path.join(os.tmpdir(), "ironmount-test-"));
 
-	try {
-		tempDir = await fs.mkdtemp(path.join(os.tmpdir(), "ironmount-test-"));
+	const mockVolume = {
+		id: 0,
+		name: "test-connection",
+		path: tempDir,
+		config: backendConfig,
+		createdAt: new Date(),
+		updatedAt: new Date(),
+		lastHealthCheck: new Date(),
+		type: backendConfig.backend,
+		status: "unmounted" as const,
+		lastError: null,
+		autoRemount: 0 as const,
+	};
 
-		const mockVolume = {
-			id: 0,
-			name: "test-connection",
-			path: tempDir,
-			config: backendConfig,
-			createdAt: new Date(),
-			updatedAt: new Date(),
-			lastHealthCheck: new Date(),
-			type: backendConfig.backend,
-			status: "unmounted" as const,
-			lastError: null,
-			autoRemount: 0,
-		};
+	const backend = createVolumeBackend(mockVolume);
+	const { error } = await backend.mount();
 
-		const backend = createVolumeBackend(mockVolume);
+	await backend.unmount();
 
-		await backend.mount();
-		await backend.unmount();
+	await fs.access(tempDir);
+	await fs.rm(tempDir, { recursive: true, force: true });
 
-		return {
-			success: true,
-			message: "Connection successful",
-		};
-	} catch (error) {
-		return {
-			success: false,
-			message: toMessage(error),
-		};
-	} finally {
-		if (tempDir) {
-			try {
-				await fs.access(tempDir);
-				await fs.rm(tempDir, { recursive: true, force: true });
-			} catch (cleanupError) {
-				logger.warn("Failed to cleanup temp directory:", cleanupError);
-			}
-		}
-	}
+	return {
+		success: !error,
+		message: error ? toMessage(error) : "Connection successful",
+	};
 };
 
 const checkHealth = async (name: string) => {
-	try {
-		const volume = await db.query.volumesTable.findFirst({
-			where: eq(volumesTable.name, name),
-		});
+	const volume = await db.query.volumesTable.findFirst({
+		where: eq(volumesTable.name, name),
+	});
 
-		if (!volume) {
-			return { error: new NotFoundError("Volume not found") };
-		}
-
-		const backend = createVolumeBackend(volume);
-		const { error } = await backend.checkHealth();
-
-		if (error) {
-			await db
-				.update(volumesTable)
-				.set({ status: "error", lastError: error, lastHealthCheck: new Date() })
-				.where(eq(volumesTable.name, volume.name));
-
-			return { error };
-		}
-
-		await db.update(volumesTable).set({ lastHealthCheck: new Date() }).where(eq(volumesTable.name, volume.name));
-
-		return { status: 200 };
-	} catch (err) {
-		return { error: new InternalServerError("Health check failed", { cause: err }) };
+	if (!volume) {
+		throw new NotFoundError("Volume not found");
 	}
+
+	const backend = createVolumeBackend(volume);
+	const { error, status } = await backend.checkHealth();
+
+	await db
+		.update(volumesTable)
+		.set({ lastHealthCheck: new Date(), status, lastError: error })
+		.where(eq(volumesTable.name, volume.name));
+
+	return { status, error };
 };
 
 export const volumeService = {