refactor: use rr actions/loader

refactor: use rr actions

apps/server/src/db/schema.ts

@@ -42,3 +42,5 @@ export const volumesTable = sqliteTable("volumes_table", {
 		.$type<typeof volumeConfigSchema.inferOut>()
 		.notNull(),
 });
+
+export type Volume = typeof volumesTable.$inferSelect;

apps/server/src/modules/backends/backend.ts

@@ -0,0 +1,24 @@
+import type { Volume } from "../../db/schema";
+import { makeDirectoryBackend } from "./directory/directory-backend";
+import { makeNfsBackend } from "./nfs/nfs-backend";
+
+export type VolumeBackend = {
+	mount: () => Promise<void>;
+	unmount: () => Promise<void>;
+};
+
+export const createVolumeBackend = (volume: Volume): VolumeBackend => {
+	const { config, path } = volume;
+
+	switch (config.backend) {
+		case "nfs": {
+			return makeNfsBackend(config, path);
+		}
+		case "directory": {
+			return makeDirectoryBackend();
+		}
+		default: {
+			throw new Error(`Backend ${config.backend} not implemented`);
+		}
+	}
+};

apps/server/src/modules/backends/directory/directory-backend.ts

@@ -0,0 +1,14 @@
+import type { VolumeBackend } from "../backend";
+
+const mount = async () => {
+	console.log("Mounting directory volume...");
+};
+
+const unmount = async () => {
+	console.log("Cannot unmount directory volume.");
+};
+
+export const makeDirectoryBackend = (): VolumeBackend => ({
+	mount,
+	unmount,
+});

apps/server/src/modules/backends/nfs/nfs-backend.ts

@@ -0,0 +1,39 @@
+import { exec } from "node:child_process";
+import * as os from "node:os";
+import type { BackendConfig } from "../../../db/schema";
+import type { VolumeBackend } from "../backend";
+
+const mount = async (config: BackendConfig, path: string) => {
+	if (config.backend !== "nfs") {
+		throw new Error("Invalid backend config for NFS");
+	}
+
+	if (os.platform() !== "linux") {
+		console.error("NFS mounting is only supported on Linux hosts.");
+		return;
+	}
+
+	const source = `${config.server}:${config.exportPath}`;
+	const options = [`vers=${config.version}`, `port=${config.port}`];
+	const cmd = `mount -t nfs -o ${options.join(",")} ${source} ${path}`;
+
+	return new Promise<void>((resolve, reject) => {
+		exec(cmd, (error, stdout, stderr) => {
+			if (error) {
+				console.error(`Error mounting NFS volume: ${stderr}`);
+				return reject(new Error(`Failed to mount NFS volume: ${stderr}`));
+			}
+			console.log(`NFS volume mounted successfully: ${stdout}`);
+			resolve();
+		});
+	});
+};
+
+const unmount = async () => {
+	console.log("Unmounting nfs volume...");
+};
+
+export const makeNfsBackend = (config: BackendConfig, path: string): VolumeBackend => ({
+	mount: () => mount(config, path),
+	unmount,
+});

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

@@ -1,12 +1,7 @@
 import { Hono } from "hono";
 import { validator } from "hono-openapi/arktype";
 import { handleServiceError } from "../../utils/errors";
-import {
-	createVolumeBody,
-	createVolumeDto,
-	type ListVolumesResponseDto,
-	listVolumesDto,
-} from "./volume.dto";
+import { createVolumeBody, createVolumeDto, type ListVolumesResponseDto, listVolumesDto } from "./volume.dto";
 import { volumeService } from "./volume.service";
 
 export const volumeController = new Hono()
@@ -23,22 +18,17 @@ export const volumeController = new Hono()
 
 		return c.json(response, 200);
 	})
-	.post(
-		"/",
-		createVolumeDto,
-		validator("json", createVolumeBody),
-		async (c) => {
-			const body = c.req.valid("json");
-			const res = await volumeService.createVolume(body.name, body.config);
+	.post("/", createVolumeDto, validator("json", createVolumeBody), async (c) => {
+		const body = c.req.valid("json");
+		const res = await volumeService.createVolume(body.name, body.config);
 
-			if (res.error) {
-				const { message, status } = handleServiceError(res.error);
-				return c.json(message, status);
-			}
+		if (res.error) {
+			const { message, status } = handleServiceError(res.error);
+			return c.json(message, status);
+		}
 
-			return c.json({ message: "Volume created", volume: res.volume });
-		},
-	)
+		return c.json({ message: "Volume created", volume: res.volume });
+	})
 	.get("/:name", (c) => {
 		return c.json({ message: `Details of volume ${c.req.param("name")}` });
 	})

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

@@ -18,6 +18,8 @@ export type ListVolumesResponseDto = typeof listVolumesResponse.infer;
 export const listVolumesDto = describeRoute({
 	description: "List all volumes",
 	tags: ["Volumes"],
+	operationId: "listVolumes",
+	validateResponse: true,
 	responses: {
 		200: {
 			description: "A list of volumes",
@@ -46,6 +48,8 @@ export const createVolumeResponse = type({
 
 export const createVolumeDto = describeRoute({
 	description: "Create a new volume",
+	operationId: "createVolume",
+	validateResponse: true,
 	tags: ["Volumes"],
 	responses: {
 		201: {

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

@@ -1,10 +1,11 @@
 import * as path from "node:path";
 import { eq } from "drizzle-orm";
-import { ConflictError } from "http-errors-enhanced";
+import { ConflictError, InternalServerError, NotFoundError } from "http-errors-enhanced";
 import slugify from "slugify";
 import { config } from "../../core/config";
 import { db } from "../../db/db";
 import { type BackendConfig, volumesTable } from "../../db/schema";
+import { createVolumeBackend } from "../backends/backend";
 
 const listVolumes = async () => {
 	const volumes = await db.query.volumesTable.findMany({});
@@ -38,7 +39,29 @@ const createVolume = async (name: string, backendConfig: BackendConfig) => {
 	return { volume: val[0], status: 201 };
 };
 
+const mountVolume = async (name: string) => {
+	try {
+		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();
+	} catch (error) {
+		return {
+			error: new InternalServerError("Failed to mount volume", {
+				cause: error,
+			}),
+		};
+	}
+};
+
 export const volumeService = {
 	listVolumes,
 	createVolume,
+	mountVolume,
 };

apps/server/src/utils/errors.ts

@@ -1,8 +1,14 @@
-import { ConflictError } from "http-errors-enhanced";
+import { ConflictError, NotFoundError } from "http-errors-enhanced";
 
 export const handleServiceError = (error: unknown) => {
 	if (error instanceof ConflictError) {
 		return { message: error.message, status: 409 as const };
 	}
+
+	if (error instanceof NotFoundError) {
+		return { message: error.message, status: 404 as const };
+	}
+
+	console.error("Unhandled service error:", error);
 	return { message: "Internal Server Error", status: 500 as const };
 };