centralizing logic

nextjs/src/services/fileStorage/assignmentsFileStorageService.ts

@@ -6,37 +6,44 @@ import { assignmentMarkdownSerializer } from "@/models/local/assignment/utils/as
 import path from "path";
 import { basePath, directoryOrFileExists } from "./utils/fileSystemUtils";
 import { promises as fs } from "fs";
+import { courseItemFileStorageService } from "./courseItemFileStorageService";
 
+const getAssignmentNames = async (courseName: string, moduleName: string) => {
+  const filePath = path.join(basePath, courseName, moduleName, "assignments");
+  if (!(await directoryOrFileExists(filePath))) {
+    console.log(
+      `Error loading course by name, assignments folder does not exist in ${filePath}`
+    );
+    await fs.mkdir(filePath);
+  }
+
+  const assignmentFiles = await fs.readdir(filePath);
+  return assignmentFiles.map((f) => f.replace(/\.md$/, ""));
+};
+const getAssignment = async (
+  courseName: string,
+  moduleName: string,
+  assignmentName: string
+) => {
+  const filePath = path.join(
+    basePath,
+    courseName,
+    moduleName,
+    "assignments",
+    assignmentName + ".md"
+  );
+  const rawFile = (await fs.readFile(filePath, "utf-8")).replace(/\r\n/g, "\n");
+  return localAssignmentMarkdown.parseMarkdown(rawFile);
+};
 export const assignmentsFileStorageService = {
-  async getAssignmentNames(courseName: string, moduleName: string) {
-    const filePath = path.join(basePath, courseName, moduleName, "assignments");
-    if (!(await directoryOrFileExists(filePath))) {
-      console.log(
-        `Error loading course by name, assignments folder does not exist in ${filePath}`
-      );
-      await fs.mkdir(filePath);
-    }
-
-    const assignmentFiles = await fs.readdir(filePath);
-    return assignmentFiles.map((f) => f.replace(/\.md$/, ""));
-  },
-  async getAssignment(
-    courseName: string,
-    moduleName: string,
-    assignmentName: string
-  ) {
-    const filePath = path.join(
-      basePath,
+  getAssignmentNames,
+  getAssignment,
+  async getAssignments(courseName: string, moduleName: string) {
+    return await courseItemFileStorageService.getItems(
       courseName,
       moduleName,
-      "assignments",
-      assignmentName + ".md"
+      "Assignment"
     );
-    const rawFile = (await fs.readFile(filePath, "utf-8")).replace(
-      /\r\n/g,
-      "\n"
-    );
-    return localAssignmentMarkdown.parseMarkdown(rawFile);
   },
   async updateOrCreateAssignment({
     courseName,
@@ -74,7 +81,6 @@ export const assignmentsFileStorageService = {
     moduleName: string;
     assignmentName: string;
   }) {
-
     const filePath = path.join(
       basePath,
       courseName,
@@ -83,6 +89,6 @@ export const assignmentsFileStorageService = {
       assignmentName + ".md"
     );
     console.log("removing assignment", filePath);
-    await fs.unlink(filePath)
-  }
+    await fs.unlink(filePath);
+  },
 };

nextjs/src/services/fileStorage/courseItemFileStorageService.ts

@@ -0,0 +1,102 @@
+import path from "path";
+import { basePath, directoryOrFileExists } from "./utils/fileSystemUtils";
+import fs from "fs/promises";
+import {
+  LocalAssignment,
+  localAssignmentMarkdown,
+} from "@/models/local/assignment/localAssignment";
+import {
+  LocalQuiz,
+  localQuizMarkdownUtils,
+} from "@/models/local/quiz/localQuiz";
+import {
+  LocalCoursePage,
+  localPageMarkdownUtils,
+} from "@/models/local/page/localCoursePage";
+
+const typeToFolder = {
+  Assignment: "assignments",
+  Quiz: "quizzes",
+  Page: "pages",
+} as const;
+
+export type CourseItemType = "Assignment" | "Quiz" | "Page";
+
+const getItemFileNames = async (
+  courseName: string,
+  moduleName: string,
+  type: CourseItemType
+) => {
+  const folder = typeToFolder[type];
+  const filePath = path.join(basePath, courseName, moduleName, folder);
+  if (!(await directoryOrFileExists(filePath))) {
+    console.log(
+      `Error loading ${type}, ${folder} folder does not exist in ${filePath}`
+    );
+    await fs.mkdir(filePath);
+  }
+
+  const itemFiles = await fs.readdir(filePath);
+  return itemFiles.map((f) => f.replace(/\.md$/, ""));
+};
+type CourseItemReturnType<T extends CourseItemType> = T extends "Assignment"
+  ? LocalAssignment
+  : T extends "Quiz"
+  ? LocalQuiz
+  : LocalCoursePage;
+
+const getItem = async <T extends CourseItemType>(
+  courseName: string,
+  moduleName: string,
+  name: string,
+  type: T
+): Promise<CourseItemReturnType<T>> => {
+  const folder = typeToFolder[type];
+  const filePath = path.join(
+    basePath,
+    courseName,
+    moduleName,
+    folder,
+    name + ".md"
+  );
+  const rawFile = (await fs.readFile(filePath, "utf-8")).replace(/\r\n/g, "\n");
+  if (type === "Assignment") {
+    return localAssignmentMarkdown.parseMarkdown(
+      rawFile
+    ) as CourseItemReturnType<T>;
+  } else if (type === "Quiz") {
+    return localQuizMarkdownUtils.parseMarkdown(
+      rawFile
+    ) as CourseItemReturnType<T>;
+  } else if (type === "Page") {
+    return localPageMarkdownUtils.parseMarkdown(
+      rawFile
+    ) as CourseItemReturnType<T>;
+  }
+
+  throw Error(`cannot read item, invalid type: ${type} in ${filePath}`);
+};
+
+export const courseItemFileStorageService = {
+  getItem,
+  getItems: async <T extends CourseItemType>(
+    courseName: string,
+    moduleName: string,
+    type: T
+  ): Promise<CourseItemReturnType<T>[]> => {
+    const fileNames = await getItemFileNames(courseName, moduleName, type);
+    const items = (
+      await Promise.all(
+        fileNames.map(async (name) => {
+          try {
+            const item = await getItem(courseName, moduleName, name, type);
+            return item;
+          } catch {
+            return null;
+          }
+        })
+      )
+    ).filter((a) => a !== null);
+    return items;
+  },
+};

nextjs/src/services/fileStorage/pageFileStorageService.ts

@@ -1,36 +1,23 @@
-import { localPageMarkdownUtils, LocalCoursePage } from "@/models/local/page/localCoursePage";
+import {
+  localPageMarkdownUtils,
+  LocalCoursePage,
+} from "@/models/local/page/localCoursePage";
 import { promises as fs } from "fs";
 import path from "path";
-import { basePath, directoryOrFileExists } from "./utils/fileSystemUtils";
+import { basePath } from "./utils/fileSystemUtils";
+import { courseItemFileStorageService } from "./courseItemFileStorageService";
 
 export const pageFileStorageService = {
-  async getPageNames(courseName: string, moduleName: string) {
-    const filePath = path.join(basePath, courseName, moduleName, "pages");
-    if (!(await directoryOrFileExists(filePath))) {
-      console.log(
-        `Error loading course by name, pages folder does not exist in ${filePath}`
-      );
-      await fs.mkdir(filePath);
-    }
-
-    const files = await fs.readdir(filePath);
-    return files.map((f) => f.replace(/\.md$/, ""));
-  },
-
-  async getPage(courseName: string, moduleName: string, pageName: string) {
-    const filePath = path.join(
-      basePath,
+  getPage: async (courseName: string, moduleName: string, name: string) =>
+    await courseItemFileStorageService.getItem(
       courseName,
       moduleName,
-      "pages",
-      pageName + ".md"
-    );
-    const rawFile = (await fs.readFile(filePath, "utf-8")).replace(
-      /\r\n/g,
-      "\n"
-    );
-    return localPageMarkdownUtils.parseMarkdown(rawFile);
-  },
+      name,
+      "Page"
+    ),
+  getPages: async (courseName: string, moduleName: string) =>
+    await courseItemFileStorageService.getItems(courseName, moduleName, "Page"),
+
   async updatePage(
     courseName: string,
     moduleName: string,
@@ -82,6 +69,6 @@ export const pageFileStorageService = {
       pageName + ".md"
     );
     console.log("removing page", filePath);
-    await fs.unlink(filePath)
-  }
-};
+    await fs.unlink(filePath);
+  },
+};

nextjs/src/services/fileStorage/quizFileStorageService.ts

@@ -1,60 +1,23 @@
 import {
-  localQuizMarkdownUtils,
   LocalQuiz,
 } from "@/models/local/quiz/localQuiz";
 import { quizMarkdownUtils } from "@/models/local/quiz/utils/quizMarkdownUtils";
 import path from "path";
-import { basePath, directoryOrFileExists } from "./utils/fileSystemUtils";
+import { basePath } from "./utils/fileSystemUtils";
 import { promises as fs } from "fs";
+import { courseItemFileStorageService } from "./courseItemFileStorageService";
 
-const getQuizNames = async (courseName: string, moduleName: string) => {
-  const filePath = path.join(basePath, courseName, moduleName, "quizzes");
-  if (!(await directoryOrFileExists(filePath))) {
-    console.log(
-      `Error loading course by name, quiz folder does not exist in ${filePath}`
-    );
-    await fs.mkdir(filePath);
-  }
-
-  const files = await fs.readdir(filePath);
-  return files.map((f) => f.replace(/\.md$/, ""));
-};
-
-const getQuiz = async (
-  courseName: string,
-  moduleName: string,
-  quizName: string
-) => {
-  const filePath = path.join(
-    basePath,
-    courseName,
-    moduleName,
-    "quizzes",
-    quizName + ".md"
-  );
-  const rawFile = (await fs.readFile(filePath, "utf-8")).replace(/\r\n/g, "\n");
-  return localQuizMarkdownUtils.parseMarkdown(rawFile);
-};
 
 export const quizFileStorageService = {
-  getQuizNames,
-  getQuiz,
-  async getQuizzes(courseName: string, moduleName: string) {
-    const fileNames = await getQuizNames(courseName, moduleName);
-    const quizzes = (
-      await Promise.all(
-        fileNames.map(async (name) => {
-          try {
-            return await getQuiz(courseName, moduleName, name);
-          } catch {
-            return null;
-          }
-        })
-      )
-    ).filter((a) => a !== null);
-
-    return quizzes;
-  },
+  getQuiz: async (courseName: string, moduleName: string, quizName: string) =>
+    await courseItemFileStorageService.getItem(
+      courseName,
+      moduleName,
+      quizName,
+      "Quiz"
+    ),
+  getQuizzes: async (courseName: string, moduleName: string) =>
+    await courseItemFileStorageService.getItems(courseName, moduleName, "Quiz"),
 
   async updateQuiz(
     courseName: string,