Implemented Tag functions and APIs (no permission checking yet) (#350)

* Implement tag functions

* Tag API implementation

Author: VictorAKang

server/supabase/functions/_dev/setup.ts

@@ -199,3 +199,10 @@ export async function courseTestSeedSetup(
   }
   return coursesCreated;
 }
+
+// emptyDatabase().then(() => {
+//   console.log("Database emptied");
+//   setupDevSeedData().then(() => {
+//     console.log("Database setup complete");
+//   });
+// });

server/supabase/functions/_shared/utils/tag_helper.ts

@@ -0,0 +1,27 @@
+import { Tag, NestedTag } from "@shared/schema/tag.ts";
+import { supa } from "../db.ts";
+import { NotFoundError } from "../errors.ts";
+
+export async function getTag(tag_id: string): Promise<Tag> {
+    const { data: tagData, error: tagError } = await supa.from("tags").select("*").eq("id", tag_id);
+
+    if (tagError) {
+        throw new Error(`Failed to get tag ${tag_id}: ${tagError.message}`);
+    }
+
+    if (!tagData || tagData.length !== 1) {
+        throw new NotFoundError(`Tag ${tag_id} was not found`);
+    }
+
+    return tagData[0] as Tag;
+}
+
+export async function getTagNested(tag_id: string): Promise<NestedTag> {
+    const { data: tagdata, error: tagError } = await supa.rpc('get_tag_with_nested_parents', {tag_id: tag_id});
+
+    if (tagError) {
+        throw new Error(`Failed to retrieve the nested tag ${tag_id}: ${tagError.message}`);
+    }
+
+    return tagdata as NestedTag;
+}

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

@@ -0,0 +1,32 @@
+import { supa } from "../../_shared/db.ts";
+
+import { NewTag, Tag } from "@shared/mod.ts";
+import { NotFoundError } from "../../_shared/errors.ts";
+
+export async function createTag(newTagData: NewTag, course_id: string): Promise<Tag> {
+    const { data: course, error: courseError } = await supa.from("courses")
+        .select("id")
+        .eq("id", course_id);
+    
+    if (courseError) {
+        throw new Error(`Failed to fetch course ${course_id}: ${courseError.message}`);
+    }
+
+    if (!course || course.length !== 1) {
+        throw new NotFoundError(`Course ${course_id} not found`);
+    }
+
+    const { data: tag, error: tagError } = await supa.from("tags")
+        .insert({
+            ...newTagData,
+            course_id: course_id
+        })
+        .select()
+        .single();
+
+    if (tagError) {
+        throw new Error(`Failed to create tag: ${tagError.message}`);   
+    }
+
+    return tag as Tag;
+}

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

@@ -0,0 +1,9 @@
+import { supa } from "../../_shared/db.ts";
+
+export async function deleteTag(tag_id: string, course_id: string) {
+    const { error } = await supa.from("tags").delete().eq("id", tag_id).eq("course_id", course_id);
+
+    if (error) {
+        throw new Error(`Failed to delete tag ${tag_id}: ${error.message}`);
+    }
+} 

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

@@ -0,0 +1,14 @@
+import { Tag } from "@shared/schema/tag.ts";
+import { supa } from "../../_shared/db.ts";
+
+export async function getAllTags(course_id: string): Promise<Tag[]> {
+    const { data: tagData, error } = await supa.from("tags")
+        .select("*")
+        .eq("course_id", course_id);
+    
+    if (error) {
+        throw new Error(`Failed to get tags of course ${course_id}: ${error.message}`);
+    }
+
+    return tagData as Tag[];
+}

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

@@ -0,0 +1,27 @@
+import { Tag, UpdateTag } from "@shared/schema/tag.ts";
+import { supa } from "../../_shared/db.ts";
+import { NotFoundError } from "../../_shared/errors.ts";
+
+export async function updateTag(updateTagData: UpdateTag, tag_id: string) {
+    const tag = await getTag(tag_id);
+    const { id, ...updatedTag } = { ...tag, ...updateTagData };
+    const { error } = await supa.from("tags").update(updatedTag).eq("id", tag_id);
+
+    if (error) {
+        throw new Error(`Failed to update tag ${tag_id}: ${error.message}`);
+    }
+}
+
+async function getTag(tag_id: string): Promise<Tag> {
+    const { data: tagData, error } = await supa.from("tags").select("*").eq("id", tag_id);
+
+    if (error) {
+        throw new Error(`Failed to get tag ${tag_id}: ${error.message}`);
+    }
+
+    if (!tagData || tagData.length !== 1) {
+        throw new NotFoundError(`Tag with id ${tag_id} not found`);
+    }
+
+    return tagData[0] as Tag;
+}

server/supabase/functions/courses/index.ts

@@ -1,6 +1,6 @@
 import { Context, Hono } from "jsr:@hono/hono";
 import { cors } from 'jsr:@hono/hono/cors';
-import { AccountStatusValue, ACCOUNT_STATUS_VALUES } from "@shared/mod.ts";
+import { AccountStatusValue, ACCOUNT_STATUS_VALUES, baseTagSchema } from "@shared/mod.ts";
 import { createCourse } from "./controller/create_course_activity.ts";
 import { getCourse } from "./controller/get_course_activity.ts";
 import { addUserToCourse } from "./controller/add_course_member_activity.ts";
@@ -26,6 +26,12 @@ import {
   DefaultRoles,
   Permissions
 } from '../../../../shared/schema/course.ts';
+import { getAllTags } from "./controller/get_all_tags_activity.ts";
+import { NestedTag, Tag, tagPermissionsSchema, updateTagSchema } from "@shared/schema/tag.ts";
+import { getTag, getTagNested } from "../_shared/utils/tag_helper.ts";
+import { createTag } from "./controller/create_tag_activity.ts";
+import { updateTag } from "./controller/update_tag_activity.ts";
+import { deleteTag } from "./controller/delete_tag_activity.ts";
 
 const functionName = "courses";
 const app = new Hono().basePath(`/${functionName}`); 
@@ -148,7 +154,7 @@ app.put("/:course_id", async (c: Context<{ Variables: UserVariables}>) => {
 // Add user to course
 app.post("/:course_id/members/:user_id", async (c: Context<{ Variables: UserVariables}>) => {
   try {
-    const course_id= c.req.param("course_id");
+    const course_id = c.req.param("course_id");
     const user_id = c.req.param("user_id");
     const caller = c.var.user;
     let role = (await c.req.json()).role;
@@ -233,5 +239,137 @@ app.get("/:course_id/members", async (c: Context<{ Variables: UserVariables}>) =
   }
 });
 
+// Get all tags of course
+app.get("/:course_id/tags", async (c: Context<{ Variables: UserVariables }>) => {
+  try {
+    const course_id = c.req.param("course_id");
+    const user = c.var.user;
+
+    if (!(await isUserMemberOfCourse(user.id, course_id))) {
+      return c.json({ error: "Unauthorized" }, 401);
+    }
+
+    const tags = await getAllTags(course_id);
+    return c.json({ tags: tags }, 200);
+  } catch (error) {
+    console.error(error);
+    return c.json({ error: "Internal server error" }, 500);
+  }
+});
+
+// Get tag
+app.get("/:course_id/tags/:tag_id", async (c: Context<{ Variables: UserVariables }>) => {
+  try {
+    const { course_id, tag_id } = c.req.param();
+    const nested = c.req.query("nested");
+    const user = c.var.user;
+
+    if (!(await isUserMemberOfCourse(user.id, course_id))) {
+      return c.json({ error: "Unauthorized" }, 401);
+    }
+
+    const tag: Tag | NestedTag = nested ? await getTagNested(tag_id) : await getTag(tag_id);
+    return c.json({ tag: tag }, 200);
+  } catch (error) {
+    console.error(error);
+    if (error instanceof NotFoundError) {
+      return c.json({ error: error.message }, 404);
+    }
+    return c.json({ error: "Internal server error" }, 500);
+  }
+});
+
+// Create a tag
+app.post("/:course_id/tags", async (c: Context<{ Variables: UserVariables }>) => {
+  try {
+    const course_id = c.req.param("course_id");
+    const user = c.var.user;
+    const newTagData = await c.req.json();
+
+    if (!newTagData.permissions) {
+      newTagData.permissions = tagPermissionsSchema.parse({});
+    }
+
+    const validationResult = baseTagSchema.safeParse(newTagData);
+    if (!validationResult.success) {
+      return c.json({
+        error: "Validation failed",
+        details: validationResult.error.errors,
+      }, 400);
+    }
+
+    const completeNewTagData = validationResult.data;
+
+    const permissions = await getUserPermissionsInCourse(user.id, course_id);
+    if (!permissions.can_create_tags) {
+      return c.json({ error: "Unauthorized" }, 401);
+    }
+
+    const tag = await createTag(completeNewTagData, course_id);
+    return c.json({ tag: tag }, 200);
+  } catch (error) {
+    console.error(error);
+    if (error instanceof NotFoundError) {
+      return c.json({ error: error.message }, 404);
+    }
+    return c.json({ error: "Internal server error"}, 500);
+  }
+});
+
+// Update tag
+// Note that if user wants to update permission or can_use_tag, they must pass the whole permission/can_use_tag object
+app.put("/:course_id/tags/:tag_id", async (c: Context<{ Variables: UserVariables }>) => {
+  try {
+    const course_id = c.req.param("course_id");
+    const tag_id = c.req.param("tag_id");
+    const user = c.var.user;
+    const updateTagData = await c.req.json();
+
+    const validationResult = updateTagSchema.safeParse(updateTagData);
+    if (!validationResult.success) {
+      return c.json({
+        error: "Validation failed",
+        details: validationResult.error.errors,
+      }, 400);
+    }
+
+    const completeUpdateTagData = validationResult.data;
+
+    const permissions = await getUserPermissionsInCourse(user.id, course_id);
+    if (!permissions.can_edit_tags) {
+      return c.json({ error: "Unauthorized" }, 401);
+    }
+
+    await updateTag(completeUpdateTagData, tag_id);
+    return c.json(200);
+  } catch (error) {
+    console.error(error);
+    if (error instanceof NotFoundError) {
+      return c.json({ error: error.message }, 404);
+    }
+    return c.json({ error: "Internal server error"}, 500);
+  }
+});
+
+// Delete tag
+app.delete("/:course_id/tags/:tag_id", async (c: Context<{ Variables: UserVariables }>) => {
+  try {
+    const course_id = c.req.param("course_id");
+    const tag_id = c.req.param("tag_id");
+    const user = c.var.user;
+
+    const permissions = await getUserPermissionsInCourse(user.id, course_id);
+    if (!permissions.can_delete_tags) {
+      return c.json({ error: "Unauthorized" }, 401);
+    }
+
+    await deleteTag(tag_id, course_id);
+    return c.json(200);
+  } catch (error) {
+    console.error(error);
+    return c.json({ error: "Internal server error" }, 500);
+  }
+});
+
 export { app };
 Deno.serve(app.fetch);