Updated backend to TypeScript

Author: TimWitzdam

.vscode/extensions.json

@@ -26,4 +26,4 @@ RUN npx prisma generate
 RUN apk add --no-cache git
 
 EXPOSE 3000
-CMD npx prisma db push && node server.js
+CMD npx prisma db push && npx tsx backend/server.ts 

.vscode/launch.json

@@ -0,0 +1,8 @@
+import { exit } from "process";
+
+export const PORT = 3000;
+if (!process.env.JWT_SECRET) {
+  console.error("JWT_SECRET is not set");
+  exit(1);
+}
+export const JWT_SECRET = process.env.JWT_SECRET;

Dockerfile

@@ -0,0 +1,23 @@
+import type { Request, Response } from "express";
+import { AccessTokenService } from "../services/accessToken.service";
+import { AuthenticatedRequest } from "../types/AuthenticatedRequest";
+
+export async function getAccessTokens(req: Request, res: Response) {
+  const username = (req as AuthenticatedRequest).user.username;
+  const accessTokens = await AccessTokenService.getAccessToken(username);
+
+  return res.json(accessTokens);
+}
+
+export async function createAccessToken(req: Request, res: Response) {
+  const { name, token } = req.body;
+  const username = (req as AuthenticatedRequest).user.username;
+
+  const accessToken = await AccessTokenService.createAccessToken(
+    name,
+    token,
+    username
+  );
+
+  return res.json(accessToken);
+}

backend/configs/app.config.ts

@@ -0,0 +1,55 @@
+import Logger from "../lib/logger";
+import { ConfigService } from "../services/config.service";
+import SambaClient from "samba-client";
+import { Request, Response } from "express";
+
+const logger = new Logger("config.controller");
+
+export async function getStorageConfig(req: Request, res: Response) {
+  const storageConfig = await ConfigService.getStorageConfig();
+
+  return res.json(storageConfig);
+}
+
+export async function updateStorageConfig(req: Request, res: Response) {
+  const { location, serverAddress, remoteLocation, username, password } =
+    req.body;
+
+  try {
+    if (location === "smb_share") {
+      if (!serverAddress || !remoteLocation || !username || !password) {
+        return res.status(400).json({ error: "Missing required fields" });
+      }
+
+      const client = new SambaClient({
+        address: `//${serverAddress}`,
+        username,
+        password,
+      });
+
+      // Test connection
+      await client.listFiles("", "");
+
+      // Update configurations
+      await Promise.all([
+        ConfigService.updateConfigEntry("default_location", "smb_share"),
+        ConfigService.updateConfigEntry("smb_address", serverAddress),
+        ConfigService.updateConfigEntry("smb_location", remoteLocation),
+        ConfigService.updateConfigEntry("smb_username", username),
+        ConfigService.updateConfigEntry("smb_password", password),
+      ]);
+    } else if (location === "local_folder") {
+      await ConfigService.updateConfigEntry("default_location", "local_folder");
+    }
+
+    res.json({ message: "Setting saved" });
+  } catch (error) {
+    logger.error(`Error in storage configuration: ${error.message}`);
+    res.status(500).json({
+      error:
+        "Error connecting to storage. Please check the wiki on GitHub for more information.",
+      details:
+        "https://github.com/TimWitzdam/GitSave/wiki/How-to-set-up-SMB-share",
+    });
+  }
+}

backend/controllers/accessToken.controller.ts

@@ -0,0 +1,39 @@
+import { HistoryService } from "../services/history.service";
+import { Request, Response } from "express";
+import { AuthenticatedRequest } from "../types/AuthenticatedRequest";
+
+interface PaginationQuery {
+  limit?: string;
+  offset?: string;
+}
+
+export async function getHistory(
+  req: Request<{}, {}, {}, PaginationQuery>,
+  res: Response
+) {
+  const { limit, offset } = req.query;
+  const username = (req as AuthenticatedRequest).user.username;
+
+  // Convert string values to numbers
+  const numLimit = limit ? parseInt(limit, 10) : undefined;
+  const numOffset = offset ? parseInt(offset, 10) : undefined;
+
+  // Check if values are missing or invalid
+  if (
+    numLimit === undefined ||
+    numOffset === undefined ||
+    isNaN(numLimit) ||
+    isNaN(numOffset) ||
+    numLimit <= 0 ||
+    numOffset < 0
+  ) {
+    return res.status(400).send("Invalid limit or offset");
+  }
+
+  const { backupHistory, totalCount } = await HistoryService.getHistory(
+    username,
+    numOffset,
+    numLimit
+  );
+  return res.json({ backupHistory, totalCount });
+}

backend/controllers/config.controller.ts

@@ -0,0 +1,176 @@
+import { ScheduleService } from "../services/schedule.service";
+import { execFile } from "child_process";
+import Logger from "../lib/logger";
+import {
+  createBackup,
+  resumeCronJob,
+  scheduleCronJobs,
+  stopCronJob,
+} from "../server";
+import { Request, Response } from "express";
+import { AuthenticatedRequest } from "../types/AuthenticatedRequest";
+
+const logger = new Logger("schedule.controller");
+
+export async function getSchedules(req: Request, res: Response) {
+  const username = (req as AuthenticatedRequest).user.username;
+  const schedules = await ScheduleService.getSchedulesByUser(username);
+  return res.json(schedules);
+}
+
+export async function createSchedule(req: Request, res: Response) {
+  const schedule = req.body;
+  const username = (req as AuthenticatedRequest).user.username;
+
+  let repoUrl: URL;
+  try {
+    repoUrl = new URL(schedule.repository);
+  } catch (error) {
+    return res.status(400).send("Invalid repository URL");
+  }
+
+  const initialUrl = repoUrl.href;
+  if (schedule.private) {
+    const accessToken = await ScheduleService.getAccessToken(
+      schedule.accessTokenId,
+    );
+    if (!accessToken) {
+      return res.status(400).send("Access token not found");
+    }
+
+    repoUrl.href = repoUrl.href.replace(
+      "https://",
+      `https://${accessToken.token}@`,
+    );
+  }
+
+  const options = {
+    env: {
+      ...process.env,
+      GIT_ASKPASS: "/bin/false",
+    },
+  };
+  const child = execFile(
+    "git",
+    ["ls-remote", repoUrl.href],
+    options,
+    async (error, stdout, stderr) => {
+      if (error) {
+        logger.error(error.toString());
+        return res
+          .status(400)
+          .send(
+            "Invalid repository. Either it does not exist or you forgot to select an access token.",
+          );
+      }
+
+      const newSchedule = await ScheduleService.addSchedule(
+        username,
+        schedule,
+        initialUrl,
+      );
+      scheduleCronJobs();
+      return res.json(newSchedule);
+    },
+  );
+
+  const timeout = setTimeout(() => {
+    child.kill();
+  }, 5000);
+
+  child.on("exit", (code) => {
+    clearTimeout(timeout);
+    if (code === null) {
+      return res.status(400).send("The process took too long and was aborted.");
+    }
+  });
+}
+
+export async function updateSchedule(req: Request, res: Response) {
+  const { id } = req.params;
+  const schedule = req.body;
+
+  let url: URL;
+
+  try {
+    url = new URL(schedule.repository);
+  } catch (error) {
+    return res.status(400).send("Invalid repository URL");
+  }
+
+  const options = {
+    env: {
+      ...process.env,
+      GIT_ASKPASS: "/bin/false",
+    },
+  };
+  const child = execFile(
+    "git",
+    ["ls-remote", url.href],
+    options,
+    async (error, stdout, stderr) => {
+      if (error) {
+        logger.error(error.toString());
+        return res
+          .status(400)
+          .send(
+            "Invalid repository. Either it does not exist or you forgot to select an access token.",
+          );
+      }
+
+      const updatedSchedule = await ScheduleService.editSchedule(schedule, id);
+      scheduleCronJobs();
+      return res.json(updatedSchedule);
+    },
+  );
+
+  const timeout = setTimeout(() => {
+    child.kill();
+  }, 5000);
+
+  child.on("exit", (code) => {
+    clearTimeout(timeout);
+    if (code === null) {
+      return res.status(400).send("The process took too long and was aborted.");
+    }
+  });
+}
+
+export async function backupScheduleNow(req: Request, res: Response) {
+  const { id } = req.params;
+
+  const schedule = await ScheduleService.getScheduleById(id);
+
+  if (!schedule) {
+    return res.status(404).send("Schedule not found");
+  }
+
+  createBackup(schedule.id, schedule.name, schedule.repository);
+  return res.send(
+    "Backup started. Depending on the size of the repository, this may take a while.",
+  );
+}
+
+export async function pauseSchedule(req: Request, res: Response) {
+  const { id } = req.params;
+
+  const pausedSchedule = await ScheduleService.pauseSchedule(id);
+  stopCronJob(parseInt(id));
+  return res.json(pausedSchedule);
+}
+
+export async function resumeSchedule(req: Request, res: Response) {
+  const { id } = req.params;
+
+  const resumedSchedule = await ScheduleService.resumeSchedule(id);
+  resumeCronJob(parseInt(id));
+  return res.json(resumedSchedule);
+}
+
+export async function deleteSchedule(req: Request, res: Response) {
+  const { id } = req.params;
+
+  await ScheduleService.deleteSchedule(id);
+  stopCronJob(parseInt(id), true);
+  return res.send("Schedule deleted");
+}