Merge pull request #19 from digitalsolutiongroup/feat/management-aspect

Update API for management aspect

apps/backend/src/routes/managementAspect/route.ts

@@ -1,6 +1,6 @@
-import { and, eq, ilike, isNull, or, sql } from "drizzle-orm";
+import { and, eq, ilike, isNull, or, sql, inArray } from "drizzle-orm";
 import { Hono } from "hono";
-
+import { questions } from "../../drizzle/schema/questions";
 import { z } from "zod";
 import db from "../../drizzle";
 import { aspects } from "../../drizzle/schema/aspects";
@@ -33,14 +33,16 @@ export const aspectFormSchema = z.object({
     .optional(),
 });
 
-export const aspectUpdateSchema = aspectFormSchema.extend({
-  subAspects: z.string().optional().or(z.literal("")),
-});
-
 // Schema for creating and updating subAspects
 export const subAspectFormSchema = z.object({
+  id: z.string(),
   name: z.string().min(1).max(50),
-  aspectId: z.string().uuid(),
+  aspectId: z.string().optional(),
+});
+
+export const aspectUpdateSchema = z.object({
+  name: z.string(),
+  subAspects: z.array(subAspectFormSchema),
 });
 
 export const subAspectUpdateSchema = subAspectFormSchema.extend({});
@@ -55,140 +57,223 @@ const managementAspectRoute = new Hono<HonoEnv>()
      * - withMetadata: boolean
      */
 
-    // Get all aspects
+  // Get all aspects
-    .get(
+  .get(
-      "/",
+    "/",
-      checkPermission("managementAspect.readAll"),
+    checkPermission("managementAspect.readAll"),
-      requestValidator(
+    requestValidator(
-        "query",
+      "query",
-        z.object({
+      z.object({
-          includeTrashed: z
+        includeTrashed: z
-            .string()
+          .string()
-            .optional()
+          .optional()
-            .transform((v) => v?.toLowerCase() === "true"),
+          .transform((v) => v?.toLowerCase() === "true"),
-          withMetadata: z
+        withMetadata: z
-            .string()
+          .string()
-            .optional()
+          .optional()
-            .transform((v) => v?.toLowerCase() === "true"),
+          .transform((v) => v?.toLowerCase() === "true"),
-          page: z.coerce.number().int().min(0).default(0),
+        page: z.coerce.number().int().min(0).default(0),
-          limit: z.coerce.number().int().min(1).max(1000).default(10),
+        limit: z.coerce.number().int().min(1).max(1000).default(10),
-          q: z.string().default(""),
+        q: z.string().default(""),
+      })
+    ),
+    async (c) => {
+      const { includeTrashed, page, limit, q } = c.req.valid("query");
+  
+      const totalCountQuery = includeTrashed
+        ? sql<number>`(SELECT count(DISTINCT ${aspects.id}) FROM ${aspects})`
+        : sql<number>`(SELECT count(DISTINCT ${aspects.id}) FROM ${aspects} WHERE ${aspects.deletedAt} IS NULL)`;
+  
+      const aspectIdsQuery = await db
+        .select({
+          id: aspects.id,
         })
-      ),
+        .from(aspects)
-      async (c) => {
+        .where(
-        const { includeTrashed, page, limit, q } = c.req.valid("query");
+          and(
-
+            includeTrashed ? undefined : isNull(aspects.deletedAt),
-        const totalCountQuery = includeTrashed 
+            q ? or(ilike(aspects.name, q), eq(aspects.id, q)) : undefined
-          ? sql<number>`(SELECT count(*) FROM ${aspects})` 
-          : sql<number>`(SELECT count(*) FROM ${aspects} WHERE ${aspects.deletedAt} IS NULL)`;
-
-        const result = await db
-          .select({
-            id: aspects.id,
-            name: aspects.name,
-            createdAt: aspects.createdAt,
-            updatedAt: aspects.updatedAt,
-            ...(includeTrashed ? { deletedAt: aspects.deletedAt } : {}),
-            fullCount: totalCountQuery,
-          })
-          .from(aspects)
-          .where(
-            and(
-              includeTrashed ? undefined : isNull(aspects.deletedAt),
-              q ? or(ilike(aspects.name, q), eq(aspects.id, q)) : undefined
-            )
           )
-          .offset(page * limit)
+        )
-          .limit(limit);
+        .offset(page * limit)
-
+        .limit(limit);
+  
+      const aspectIds = aspectIdsQuery.map(a => a.id);
+  
+      if (aspectIds.length === 0) {
         return c.json({
-          data: result.map((d) => ({ ...d, fullCount: undefined })),
+          data: [],
           _metadata: {
             currentPage: page,
-            totalPages: Math.ceil((Number(result[0]?.fullCount) ?? 0) / limit),
+            totalPages: 0,
-            totalItems: Number(result[0]?.fullCount) ?? 0,
+            totalItems: 0,
             perPage: limit,
           },
         });
       }
-    )
+  
-
+      // Main query to get aspects, sub-aspects, and number of questions
-    // Get aspect by id
+      const result = await db
-    .get(
+        .select({
-      "/:id",
+          id: aspects.id,
-      checkPermission("managementAspect.readAll"),
+          name: aspects.name,
-      requestValidator(
+          createdAt: aspects.createdAt,
-        "query",
+          updatedAt: aspects.updatedAt,
-        z.object({
+          ...(includeTrashed ? { deletedAt: aspects.deletedAt } : {}),
-          includeTrashed: z.string().default("false"),
+          subAspectId: subAspects.id,
+          subAspectName: subAspects.name,
+          // Increase the number of questions related to sub aspects
+          questionCount: sql<number>`(
+            SELECT count(*) 
+            FROM ${questions}
+            WHERE ${questions.subAspectId} = ${subAspects.id}
+          )`.as('questionCount'),
+          fullCount: totalCountQuery,
         })
-      ),
+        .from(aspects)
-      async (c) => {
+        .leftJoin(subAspects, eq(subAspects.aspectId, aspects.id))
-        const aspectId = c.req.param("id");
+        .where(inArray(aspects.id, aspectIds));
+  
+      // Grouping sub aspects by aspect ID
+      const groupedResult = result.reduce((acc, curr) => {
+        const aspectId = curr.id;
+  
+        if (!acc[aspectId]) {
+          acc[aspectId] = {
+            id: curr.id,
+            name: curr.name,
+            createdAt: curr.createdAt ? new Date(curr.createdAt).toISOString() : null,
+            updatedAt: curr.updatedAt ? new Date(curr.updatedAt).toISOString() : null,
+            subAspects: curr.subAspectName
+              ? [{ id: curr.subAspectId!, name: curr.subAspectName, questionCount: curr.questionCount }]
+              : [],
+          };
+        } else {
+          if (curr.subAspectName) {
+            const exists = acc[aspectId].subAspects.some(sub => sub.id === curr.subAspectId);
+            if (!exists) {
+              acc[aspectId].subAspects.push({
+                id: curr.subAspectId!,
+                name: curr.subAspectName,
+                questionCount: curr.questionCount,
+              });
+            }
+          }
+        }
+  
+        return acc;
+      }, {} as Record<string, {
+        id: string;
+        name: string;
+        createdAt: string | null;
+        updatedAt: string | null;
+        subAspects: { id: string; name: string; questionCount: number }[];
+      }>);
+  
+      const groupedArray = Object.values(groupedResult);
+  
+      return c.json({
+        data: groupedArray,
+        _metadata: {
+          currentPage: page,
+          totalPages: Math.ceil((Number(result[0]?.fullCount) ?? 0) / limit),
+          totalItems: Number(result[0]?.fullCount) ?? 0,
+          perPage: limit,
+        },
+      });
+    }
+  )  
 
-        if (!aspectId)
+  // Get aspect by id
-          throw notFound({
+  .get(
-            message: "Missing id",
+    "/:id",
-          });
+    checkPermission("managementAspect.readAll"),
+    requestValidator(
+      "query",
+      z.object({
+        includeTrashed: z.string().default("false"),
+      })
+    ),
+    async (c) => {
+      const aspectId = c.req.param("id");
 
-        const includeTrashed = c.req.query("includeTrashed")?.toLowerCase() === "true";
+      if (!aspectId)
+        throw notFound({
+          message: "Missing id",
+        });
 
-        const queryResult = await db
+      const includeTrashed = c.req.query("includeTrashed")?.toLowerCase() === "true";
-          .select({
-            id: aspects.id,
-            name: aspects.name,
-            createdAt: aspects.createdAt,
-            updatedAt: aspects.updatedAt,
-            ...(includeTrashed ? { deletedAt: aspects.deletedAt } : {}),
-            subAspect: {
-              name: subAspects.name,
-              id: subAspects.id,
-            },
-          })
-          .from(aspects)
-          .leftJoin(subAspects, eq(aspects.id, subAspects.aspectId))
-          .where(and(eq(aspects.id, aspectId), !includeTrashed ? isNull(aspects.deletedAt) : undefined));
 
-        if (!queryResult.length)
+      const queryResult = await db
-          throw forbidden({
+        .select({
-            message: "The aspect does not exist",
+          id: aspects.id,
-          });
+          name: aspects.name,
+          createdAt: aspects.createdAt,
+          updatedAt: aspects.updatedAt,
+          ...(includeTrashed ? { deletedAt: aspects.deletedAt } : {}),
+          subAspect: {
+            name: subAspects.name,
+            id: subAspects.id,
+            questionCount: sql`COUNT(${questions.id})`.as("questionCount"),
+          },
+        })
+        .from(aspects)
+        .leftJoin(subAspects, eq(aspects.id, subAspects.aspectId))
+        .leftJoin(questions, eq(subAspects.id, questions.subAspectId))
+        .where(and(eq(aspects.id, aspectId), !includeTrashed ? isNull(aspects.deletedAt) : undefined))
+        .groupBy(aspects.id, aspects.name, aspects.createdAt, aspects.updatedAt, subAspects.id, subAspects.name);
 
-        const subAspectsList = queryResult.reduce((prev, curr) => {
+      if (!queryResult.length)
-          if (!curr.subAspect) return prev;
+        throw notFound({
-          prev.set(curr.subAspect.id, curr.subAspect.name);
+          message: "The aspect does not exist",
-          return prev;
+        });
-        }, new Map<string, string>()); // Map<id, name>
 
-        const aspectData = {
+      const subAspectsList = queryResult.reduce((prev, curr) => {
-          ...queryResult[0],
+        if (!curr.subAspect) return prev;
-          subAspect: undefined,
+        prev.set(curr.subAspect.id, {
-          subAspects: Array.from(subAspectsList, ([id, name]) => ({ id, name })),
+          name: curr.subAspect.name,
-        };
+          questionCount: Number(curr.subAspect.questionCount),
+        });
+        return prev;
+      }, new Map<string, { name: string; questionCount: number }>());
 
-        return c.json(aspectData);
+      const aspectData = {
-      }
+        ...queryResult[0],
-    )
+        subAspect: undefined,
+        subAspects: Array.from(subAspectsList, ([id, { name, questionCount }]) => ({ id, name, questionCount })),
+      };
 
-    // Create aspect
+      return c.json(aspectData);
-    .post("/", 
+    }
-      checkPermission("managementAspect.create"), 
+  )
-      requestValidator("json", aspectFormSchema), 
-      async (c) => {
-        const aspectData = c.req.valid("json");
 
-      // Validation to check if the aspect name already exists
+  // Create aspect
+  .post("/",
+    checkPermission("managementAspect.create"),
+    requestValidator("json", aspectFormSchema),
+    async (c) => {
+      const aspectData = c.req.valid("json");
+
+      // Check if aspect name already exists and is not deleted
       const existingAspect = await db
         .select()
         .from(aspects)
-        .where(eq(aspects.name, aspectData.name));
+        .where(
+          and(
+            eq(aspects.name, aspectData.name),
+            isNull(aspects.deletedAt)
+          )
+        );
 
       if (existingAspect.length > 0) {
-        throw forbidden({
+        // Return an error if the aspect name already exists
-          message: "Aspect name already exists",
+        return c.json(
-        });
+          { message: "Aspect name already exists" },
+          400 // Bad Request
+        );
       }
 
+      // If it doesn't exist, create a new aspect
       const aspect = await db
         .insert(aspects)
         .values({
@@ -196,56 +281,60 @@ const managementAspectRoute = new Hono<HonoEnv>()
         })
         .returning();
 
-      // if sub-aspects are available, parse them into a string array
+      const aspectId = aspect[0].id;
+
+      // If there is sub aspect data, parse and insert into the database.
       if (aspectData.subAspects) {
         const subAspectsArray = JSON.parse(aspectData.subAspects) as string[];
-        // if there are sub-aspects, insert them into the database
+
+        // Insert new sub aspects into the database without checking for sub aspect duplication
         if (subAspectsArray.length) {
           await db.insert(subAspects).values(
             subAspectsArray.map((subAspect) => ({
-              aspectId: aspect[0].id,
+              aspectId,
               name: subAspect,
             }))
           );
         }
       }
 
-        return c.json(
+      return c.json(
-          {
+        {
-            message: "Aspect created successfully",
+          message: "Aspect and sub aspects created successfully",
-          },
+        },
-          201
+        201
-        );
+      );
-      }
+    }
-    )
+  )  
 
-    // Update aspect
+  // Update aspect
-    .patch(
+  .patch(
-      "/:id", 
+    "/:id",
-      checkPermission("managementAspect.update"), 
+    checkPermission("managementAspect.update"),
-      requestValidator("json", aspectUpdateSchema), 
+    requestValidator("json", aspectUpdateSchema),
-      async (c) => {
+    async (c) => {
-        const aspectId = c.req.param("id");
+      const aspectId = c.req.param("id");
-        const aspectData = c.req.valid("json");
+      const aspectData = c.req.valid("json");
 
-      // Validation to check if the new aspect name already exists
+      // Check if new aspect name already exists
       const existingAspect = await db
         .select()
         .from(aspects)
         .where(
           and(
-          eq(aspects.name, aspectData.name), 
+            eq(aspects.name, aspectData.name),
-          isNull(aspects.deletedAt), 
+            isNull(aspects.deletedAt),
-          sql`${aspects.id} <> ${aspectId}`
+            sql`${aspects.id} <> ${aspectId}`
-        )
+          )
-      );
+        );
 
       if (existingAspect.length > 0) {
-        throw forbidden({
+        throw notFound({
           message: "Aspect name already exists",
         });
       }
 
+      // Check if the aspect in question exists
       const aspect = await db
         .select()
         .from(aspects)
@@ -253,240 +342,153 @@ const managementAspectRoute = new Hono<HonoEnv>()
 
       if (!aspect[0]) throw notFound();
 
+      // Update aspect name
       await db
         .update(aspects)
         .set({
-          ...aspectData,
+          name: aspectData.name,
           updatedAt: new Date(),
         })
         .where(eq(aspects.id, aspectId));
 
-      //Update for Sub-Aspects
+      // Get new sub aspect data from request
-      // if (aspectData.subAspects) {
+      const newSubAspects = aspectData.subAspects || [];
-      //   const subAspectsArray = JSON.parse(aspectData.subAspects) as string[];
 
-      //   await db.delete(subAspects).where(eq(subAspects.aspectId, aspectId));
+      // Take the existing sub aspects
+      const currentSubAspects = await db
+        .select({ id: subAspects.id, name: subAspects.name })
+        .from(subAspects)
+        .where(eq(subAspects.aspectId, aspectId));
 
-      //   if (subAspectsArray.length) {
+      const currentSubAspectMap = new Map(currentSubAspects.map(sub => [sub.id, sub.name]));
-      //     await db.insert(subAspects).values(
-      //       subAspectsArray.map((subAspect) => ({
-      //         aspectId: aspectId,
-      //         name: subAspect,
-      //       }))
-      //     );
-      //   }
-      // }
 
-        return c.json({
+      // Sub aspects to be removed
-          message: "Aspect updated successfully",
+      const subAspectsToDelete = currentSubAspects
-        });
+        .filter(sub => !newSubAspects.some(newSub => newSub.id === sub.id))
-      }
+        .map(sub => sub.id);
-    )
-
-    // Delete aspect
-    .delete(
-      "/:id",
-      checkPermission("managementAspect.delete"),
-      requestValidator(
-        "form",
-        z.object({
-          // skipTrash: z.string().default("false"),
-        })
-      ),
-      async (c) => {
-        const aspectId = c.req.param("id");
-
-        // const skipTrash = c.req.valid("form").skipTrash.toLowerCase() === "true";
-
-        const aspect = await db
-          .select()
-          .from(aspects)
-          .where(and(eq(aspects.id, aspectId), isNull(aspects.deletedAt)));
-
-        if (!aspect[0])
-          throw notFound({
-            message: "The aspect is not found",
-          });
 
+      // Delete sub aspects that do not exist in the new data
+      if (subAspectsToDelete.length) {
         await db
-            .update(aspects)
+          .delete(subAspects)
+          .where(
+            and(
+              eq(subAspects.aspectId, aspectId),
+              inArray(subAspects.id, subAspectsToDelete)
+            )
+          );
+      }
+
+      // Update or add new sub aspects
+      for (const subAspect of newSubAspects) {
+        const existingSubAspect = currentSubAspectMap.has(subAspect.id);
+
+        if (existingSubAspect) {
+          // Update if sub aspect already exists
+          await db
+            .update(subAspects)
             .set({
-              deletedAt: new Date(),
+              name: subAspect.name,
+              updatedAt: new Date(),
             })
-            .where(eq(aspects.id, aspectId));
+            .where(
-        
+              and(
-        return c.json({
+                eq(subAspects.id, subAspect.id),
-          message: "Aspect deleted successfully",
+                eq(subAspects.aspectId, aspectId)
-        });
+              )
-      }
+            );
-    )
+        } else {
-
+          // Add if new sub aspect
-    // Undo delete
+          await db
-    .patch(
+            .insert(subAspects)
-      "/restore/:id", 
+            .values({
-      checkPermission("managementAspect.restore"), 
+              id: subAspect.id,
-      async (c) => {
+              aspectId,
-        const aspectId = c.req.param("id");
+              name: subAspect.name,
-
+              createdAt: new Date(),
-        const aspect = (await db.select().from(aspects).where(eq(aspects.id, aspectId)))[0];
+            });
-
-        if (!aspect) throw notFound();
-
-        if (!aspect.deletedAt) {
-          throw forbidden({
-            message: "The aspect is not deleted",
-          });
         }
+      }
 
-        await db.update(aspects).set({ deletedAt: null }).where(eq(aspects.id, aspectId));
+      return c.json({
+        message: "Aspect and sub aspects updated successfully",
+      });
+    }
+  )
 
-        return c.json({
+  // Delete aspect
-          message: "Aspect restored successfully",
+  .delete(
+    "/:id",
+    checkPermission("managementAspect.delete"),
+    async (c) => {
+      const aspectId = c.req.param("id");
+
+      // Check if aspect exists before deleting
+      const aspect = await db
+        .select()
+        .from(aspects)
+        .where(and(eq(aspects.id, aspectId), isNull(aspects.deletedAt)));
+
+      if (!aspect[0])
+        throw notFound({
+          message: "The aspect is not found",
+        });
+
+      // Update deletedAt column on aspect (soft delete)
+      await db
+        .update(aspects)
+        .set({
+          deletedAt: new Date(),
+        })
+        .where(eq(aspects.id, aspectId));
+
+      // Soft delete related sub aspects (update deletedAt on the sub-aspect)
+      await db
+        .update(subAspects)
+        .set({
+          deletedAt: new Date(),
+        })
+        .where(eq(subAspects.aspectId, aspectId));
+
+      return c.json({
+        message: "Aspect and sub aspects soft deleted successfully",
+      });
+    }
+  )
+
+  // Undo delete
+  .patch(
+    "/restore/:id",
+    checkPermission("managementAspect.restore"),
+    async (c) => {
+      const aspectId = c.req.param("id");
+
+      // Check if the desired aspects are present
+      const aspect = (await db.select().from(aspects).where(eq(aspects.id, aspectId)))[0];
+
+      if (!aspect) {
+        throw notFound({
+          message: "The aspect is not found",
         });
       }
-    )
 
-    // Get sub aspects by aspect ID
+      // Make sure the aspect has been deleted (there is deletedAt)
-    .get(
+      if (!aspect.deletedAt) {
-      "/subAspects/:aspectId", 
+        throw notFound({
-      checkPermission("managementAspect.readAll"), 
+          message: "The aspect is not deleted",
-      async (c) => {
-        const aspectId = c.req.param("aspectId");
-
-        const aspect = await db
-          .select()
-          .from(aspects)
-          .where(and(
-            eq(aspects.id, aspectId), 
-            isNull(aspects.deletedAt)));
-
-        if (!aspect[0])
-          throw notFound({
-            message: "The aspect is not found",
-          });
-
-        const subAspectsData = await db
-          .select()
-          .from(subAspects)
-          .where(eq(subAspects.aspectId, aspectId));
-
-        return c.json({
-          subAspects: subAspectsData,
         });
       }
-    )
 
-    // Create sub aspect
+      // Restore aspects (remove deletedAt mark)
-    .post(
+      await db.update(aspects).set({ deletedAt: null }).where(eq(aspects.id, aspectId));
-      "/subAspect", 
-      checkPermission("managementAspect.create"), 
-      requestValidator("json", subAspectFormSchema), 
-      async (c) => {
-        const subAspectData = c.req.valid("json");
 
-        // Validation to check if the sub aspect name already exists
+      // Restore all related sub aspects that have also been deleted (if any)
-        const existingSubAspect = await db
+      await db.update(subAspects).set({ deletedAt: null }).where(eq(subAspects.aspectId, aspectId));
-          .select()
-          .from(subAspects)
-          .where(
-            and(
-              eq(subAspects.name, subAspectData.name), 
-              eq(subAspects.aspectId, subAspectData.aspectId)));
 
-        if (existingSubAspect.length > 0) {
+      return c.json({
-          throw forbidden({ message: "Nama Sub Aspek sudah tersedia!" });
+        message: "Aspect and sub aspects restored successfully",
-        }
+      });
+    }
+  )
 
-        const [aspect] = await db
+export default managementAspectRoute;
-          .select()
-          .from(aspects)
-          .where(
-            and(
-              eq(aspects.id, subAspectData.aspectId), 
-              isNull(aspects.deletedAt)));
-
-        if (!aspect)
-          throw forbidden({
-            message: "The aspect is not found",
-          });
-
-        await db.insert(subAspects).values(subAspectData);
-
-        return c.json(
-          {
-            message: "Sub aspect created successfully",
-          },
-          201
-        );
-      }
-    )
-
-    // Update sub aspect
-    .patch(
-      "/subAspect/:id", checkPermission("managementAspect.update"), 
-      requestValidator("json", subAspectUpdateSchema), 
-      async (c) => {
-        const subAspectId = c.req.param("id");
-        const subAspectData = c.req.valid("json");
-
-        // Validation to check if the new sub aspect name already exists
-        const existingSubAspect = await db
-          .select()
-          .from(subAspects)
-          .where(
-            eq(subAspects.aspectId, subAspectData.aspectId));
-
-        if (existingSubAspect.length > 0) {
-          throw forbidden({ message: "Name Sub Aspect already exists" });
-        }
-
-        if (!existingSubAspect[0])
-          throw notFound({
-            message: "The sub aspect is not found",
-          });
-
-        await db
-          .update(subAspects)
-          .set({
-            ...subAspectData,
-            updatedAt: new Date(),
-          })
-          .where(eq(subAspects.id, subAspectId));
-
-        return c.json({
-          message: "Sub aspect updated successfully",
-        });
-      })
-
-    // Delete sub aspect
-    .delete(
-      "/subAspect/:id", 
-      checkPermission("managementAspect.delete"), 
-      async (c) => {
-        const subAspectId = c.req.param("id");
-
-        const subAspect = await db
-          .select()
-          .from(subAspects)
-          .where(eq(subAspects.id, subAspectId));
-
-        if (!subAspect[0])
-          throw notFound({
-            message: "The sub aspect is not found",
-          });
-
-        await db
-          .update(subAspects)
-          .set({
-            deletedAt: new Date(),
-          })
-          .where(eq(subAspects.id, subAspectId));
-        // await db.delete(subAspects).where(eq(subAspects.id, subAspectId));
-
-        return c.json({
-          message: "Sub aspect deleted successfully",
-        });
-      }
-    );
-
-export default managementAspectRoute;