More Course migration: Add/Remove/List course members, get all courses of a user, update course (#343)

* Created zod schemas for permissions and default roles

* Refactoring of add_course_member and adding tests

* get courses by user id

* update courses

* Finished refactoring add_course_member (modified error checking) and added tests

* Implemented remove course and fixfixed issues in add course member and delete course

* Fixed errors with get courses by useuserId and update course. Added Tests

* Implemented get course members

---------

Co-authored-by: Ray Zhou <rayzhou4@gmail.com>

Author: VictorAKang

server/supabase/functions/_shared/errors.ts

@@ -37,4 +37,11 @@ export class UserStatusError extends Error {
 //     constructor(message: string) {
 //         super(message)
 //     }
-// }
+// }
+
+export class PermissionError extends Error {
+    constructor(message: string) {
+        super(message);
+        this.name = "PermissionError";
+    }
+}

server/supabase/functions/courses/controller/add_course_member_activity.ts

@@ -1,25 +1,60 @@
 import { supa } from "../../_shared/db.ts"; 
+import { Course, DefaultRoles, studentRole } from '../../../../../shared/schema/course.ts';
+import { NotFoundError, PermissionError, InputValidationError } from '../../_shared/errors.ts';
 
 export async function addUserToCourse(
   course_id: string,
   user_id: string,
-  role?: any // TODO: @victor: fix this
-): Promise<boolean> { // TODO: @victor: probably good for this function to use one of error handling or return false/true instead of a mix of both
+  role?: DefaultRoles 
+) { 
+    const course = await getCourse(course_id);
+
+    await checkIfUserExistsAndInCourse(user_id, course_id);
+
+    const roleData = await getRole(role);
+
+    const { error: joinError } = await supa
+        .from("course_members")
+        .insert([{ 
+            course_id: course_id, 
+            user_id: user_id, 
+            role_id: roleData.id 
+        }]);
+
+    if (joinError) {
+        throw new Error(`Failed to add user to course: ${joinError.message}`);
+    }
+
+    return true;
+}
+
+async function getCourse(course_id: string): Promise<Course> { 
     const { data: course, error: courseError } = await supa.from("courses")
-        .select("*").eq("id", course_id).single();
+        .select("*").eq("id", course_id);
+
+    if (courseError) {
+        throw new Error(`Database error when retrieving course with id ${course_id}: ${courseError.message}`);
+    }
 
-    if (courseError || !course) {
-        throw new Error("Course not found");
+    if (!course || course.length !== 1) {
+        throw new NotFoundError(`Course with id ${course_id} not found`);
     }
 
-    if (course.access === "private") {
-        throw new Error("Cannot join a private course");
+    if (course[0].access === "private") {
+        throw new PermissionError("Cannot join a private course");
     }
+    
+    return course[0] as Course;
+}
 
-    const { data: user, error: userError } = await supa.from("profiles").select("*").eq("id", user_id).single();
+async function checkIfUserExistsAndInCourse(user_id: string, course_id: string) {
+    const { data: user, error: userError } = await supa.from("profiles").select("*").eq("id", user_id);
 
-    if (userError || !user) {
-        throw new Error("User not found");
+    if (userError) {
+        throw new Error(`Database error when retrieving user with id ${user_id}: ${userError.message}`);
+    } 
+    if (!user || user.length !== 1) {
+        throw new NotFoundError(`User ${user_id} not found`);
     }
 
     const { data: existingUserCourse } = await supa
@@ -30,30 +65,26 @@ export async function addUserToCourse(
         .single();
 
     if (existingUserCourse) {
-        throw new Error("User already registered in course");
+        throw new InputValidationError(`User ${user_id} already registered in course ${course_id}`);
     }
+}
 
-    // TODO: @victor: check shared/schema/course.ts for notes on how to get this is a more type safe way
+async function getRole(role: DefaultRoles | undefined ): Promise<{ id: string }> {
     if (!role) {
-        role = "student"; // use student by default
+        role = studentRole; // use student by default
     }
 
     const { data: roleData, error: roleError } = await supa.from("account_roles")
         .select("id")
-        .eq("name", role)
-        .single();
+        .eq("name", role);
 
-    if (roleError || !roleData) {
-        throw new Error("Role not found: " + (roleError?.message || "No data returned"));
+    if (roleError) {
+        throw new Error("Database error ")
     }
 
-    const { error: joinError } = await supa
-        .from("user_courses")
-        .insert([{ course_id: course_id, user_id: user_id, role_id: roleData.id }]);
-
-    if (joinError) {
-        throw new Error(`Failed to add user to course: ${joinError.message}`);
+    if (!roleData || roleData.length !== 1) {
+        throw new NotFoundError(`Role ${role} not found`);
     }
 
-    return true;
-}
+    return roleData[0];
+}

server/supabase/functions/courses/controller/create_course_activity.ts

@@ -1,6 +1,6 @@
 import { supa } from "../../_shared/db.ts";
 
-import { Course, NewCourse } from "@shared/mod.ts";
+import { Course, NewCourse, DEFAULT_ROLES, instructorRole } from "@shared/mod.ts";
 import { NotFoundError, InputValidationError } from '../../_shared/errors.ts';
 
 export async function createCourse(
@@ -28,13 +28,10 @@ export async function createCourse(
 }
 
 async function createCourseRoles(courseId: string) {
-  // Assumes that the roles are already created
-  const roleNames = ["instructor", "staff", "student"];
-
   const { data: rolesData, error: rolesError } = await supa
     .from("account_roles")
     .select("id, name")
-    .in("name", roleNames);
+    .in("name", DEFAULT_ROLES);
 
   if (rolesError || !rolesData || rolesData.length !== 3) {
     throw new Error(
@@ -65,7 +62,7 @@ async function addInstructorToCourse(courseId: string, userId: string) {
   const { data: instructorRoleData, error: instructorRoleError } = await supa
     .from("account_roles")
     .select("id")
-    .eq("name", "instructor")
+    .eq("name", instructorRole)
     .single();
 
   if (instructorRoleError || !instructorRoleData) {

server/supabase/functions/courses/controller/get_all_courses_activity.ts

@@ -1,9 +1,21 @@
 import { supa } from "../../_shared/db.ts";
+import { Course } from '../../../../../shared/schema/course.ts';
 
 export async function getAllCourses() {
   const { data, error } = await supa.from("courses").select("*");
   if (error) {
-    throw new Error("Failed to get all courses: " + error.message);
+    throw new Error(`Database error when retrieving courses: ${error.message}`);
   }
   return data;
+}
+
+export async function getUserCourses(user_id: string): Promise<Course[]> {
+    const { data: courses, error: coursesError } = await supa.from("course_members")
+        .select("courses(*)").eq("user_id", user_id);
+
+    if(coursesError || !courses) {
+        throw new Error(`Database error when retrieving courses for user with id ${user_id}: ${coursesError.message}`);
+    }
+
+    return courses.flatMap(entry => entry.courses) as Course[];
 }

server/supabase/functions/courses/controller/get_course_activity.ts

@@ -4,14 +4,18 @@ import {
 } from "@shared/schema/course.ts";
 import { NotFoundError } from "../../_shared/errors.ts";
 
+// get course by course ID
 export async function getCourse(course_id: string): Promise<Course> {
-    const { data: course, error: _ } = await supa.from("courses")
-        .select("*").eq("id", course_id).single();
+    const { data: course, error: courseError } = await supa.from("courses")
+        .select("*").eq("id", course_id);
 
-  if (!course) {
-    throw new NotFoundError("Course not found");
-  }
-  
-  return course as Course;
-}
+    if (courseError) {
+        throw new Error(`Database error when retrieving course with id ${course_id}: ${courseError.message}`);
+    }
 
+    if (!course || course.length === 0) {
+        throw new NotFoundError("Course not found");
+    }
+
+    return course[0] as Course;
+}

server/supabase/functions/courses/controller/get_course_members_activity.ts

@@ -0,0 +1,13 @@
+import { supa } from "../../_shared/db.ts";
+import { User } from '../../../../../shared/schema/users.ts';
+
+export async function getCourseMembers(course_id: string): Promise<User[]> {
+    const { data: courses, error: coursesError } = await supa.from("course_members")
+        .select("profiles(*)").eq("course_id", course_id);
+
+    if(coursesError || !courses) {
+        throw new Error(`Database error when retrieving members for course with id ${course_id}: ${coursesError.message}`);
+    }
+
+    return courses.flatMap(entry => entry.profiles) as User[];
+}

server/supabase/functions/courses/controller/remove_course_member_activity.ts

@@ -0,0 +1,58 @@
+import { supa } from "../../_shared/db.ts"; 
+import { Course, DefaultRoles, studentRole } from '../../../../../shared/schema/course.ts';
+import { NotFoundError, PermissionError, InputValidationError } from '../../_shared/errors.ts';
+
+export async function removeCourseMember(course_id: string, user_id: string) {
+    await getCourse(course_id);
+    await checkIfUserExists(user_id);
+    await checkIfUserInCourse(user_id, course_id);
+
+    const { error: deleteError } = await supa
+        .from("course_members")
+        .delete()
+        .eq("course_id", course_id)
+        .eq("user_id", user_id);
+    
+    if (deleteError) {
+        throw new Error(`Failed to remove user from course: ${deleteError.message}`);
+    }
+}
+
+async function getCourse(course_id: string): Promise<Course> { 
+    const { data: course, error: courseError } = await supa.from("courses")
+        .select("*").eq("id", course_id);
+
+    if (courseError) {
+        throw new Error(`Database error when retrieving course with id ${course_id}: ${courseError.message}`);
+    }
+
+    if (!course || course.length !== 1) {
+        throw new NotFoundError(`Course with id ${course_id} not found`);
+    }
+    
+    return course[0] as Course;
+}
+
+async function checkIfUserExists(user_id: string) {
+    const { data: user, error: userError } = await supa.from("profiles").select("*").eq("id", user_id);
+
+    if (userError) {
+        throw new Error(`Database error when retrieving user with id ${user_id}: ${userError.message}`);
+    } 
+    if (!user || user.length !== 1) {
+        throw new NotFoundError(`User ${user_id} not found`);
+    }
+}
+
+async function checkIfUserInCourse(user_id: string, course_id: string) {
+    const { data: existingUserCourse } = await supa
+        .from("course_members")
+        .select("*")
+        .eq("course_id", course_id)
+        .eq("user_id", user_id)
+        .single();
+
+    if (!existingUserCourse) {
+        throw new InputValidationError(`User ${user_id} already registered in course ${course_id}`);
+    }
+}

server/supabase/functions/courses/controller/update_course_activity.ts

@@ -0,0 +1,30 @@
+import { supa } from "../../_shared/db.ts";
+import { Course } from "@shared/schema/course.ts";
+import { NotFoundError } from "../../_shared/errors.ts";
+import { UpdateCourseReq } from "@shared/schema/course.ts";
+
+export async function updateCourse(createCourseReq: UpdateCourseReq, course_id: string) {
+    let course = await getCourse(course_id);
+
+    const { id, ...updatedCourse } = { ...course, ...createCourseReq }; 
+
+    const { error: updateError } = await supa.from("courses").update(updatedCourse).eq("id", course_id);
+
+    if (updateError) {
+        throw new Error(`Failed to update course: ${updateError.message}`);
+    }
+}
+
+async function getCourse(course_id: string): Promise<Course> {
+    const { data: course, error } = await supa.from("courses").select('*').eq('id', course_id);
+
+    if (error) {
+        throw new Error(`Failed to get course ${course_id}: ${error.message}`);
+    }
+
+    if (!course || course.length === 0) {
+        throw new NotFoundError(`Course with id ${course_id} not found`);
+    }
+
+    return course[0] as Course;
+}