refactor: simplify getAllFrameworkInstancesWithControls function and enhance task computation

- Removed caching from the getAllFrameworkInstancesWithControls function for improved clarity and maintainability.
- Streamlined the mapping of framework instances to controls, ensuring better readability.
- Updated task computation logic in computeFrameworkStats to deduplicate tasks, preventing double counting and improving accuracy in task statistics.

Author: Marfuen

apps/app/src/app/(app)/[orgId]/frameworks/data/getAllFrameworkInstancesWithControls.ts

@@ -2,76 +2,73 @@
 
 import type { Control, PolicyStatus, RequirementMap } from '@db';
 import { db } from '@db';
-import { cache } from 'react';
 import type { FrameworkInstanceWithControls } from '../types';
 
-export const getAllFrameworkInstancesWithControls = cache(
-  async function getAllFrameworkInstancesWithControls({
-    organizationId,
-  }: {
-    organizationId: string;
-  }): Promise<FrameworkInstanceWithControls[]> {
-    const frameworkInstancesFromDb = await db.frameworkInstance.findMany({
-      where: {
-        organizationId,
-      },
-      include: {
-        framework: true,
-        requirementsMapped: {
-          include: {
-            control: {
-              include: {
-                policies: {
-                  select: {
-                    id: true,
-                    name: true,
-                    status: true,
-                  },
+export async function getAllFrameworkInstancesWithControls({
+  organizationId,
+}: {
+  organizationId: string;
+}): Promise<FrameworkInstanceWithControls[]> {
+  const frameworkInstancesFromDb = await db.frameworkInstance.findMany({
+    where: {
+      organizationId,
+    },
+    include: {
+      framework: true,
+      requirementsMapped: {
+        include: {
+          control: {
+            include: {
+              policies: {
+                select: {
+                  id: true,
+                  name: true,
+                  status: true,
                 },
-                requirementsMapped: true,
               },
+              requirementsMapped: true,
             },
           },
         },
       },
-    });
+    },
+  });
 
-    const frameworksWithControls: FrameworkInstanceWithControls[] = frameworkInstancesFromDb.map(
-      (fi) => {
-        const controlsMap = new Map<
-          string,
-          Control & {
-            policies: Array<{
-              id: string;
-              name: string;
-              status: PolicyStatus;
-            }>;
-            requirementsMapped: RequirementMap[];
-          }
-        >();
+  const frameworksWithControls: FrameworkInstanceWithControls[] = frameworkInstancesFromDb.map(
+    (fi) => {
+      const controlsMap = new Map<
+        string,
+        Control & {
+          policies: Array<{
+            id: string;
+            name: string;
+            status: PolicyStatus;
+          }>;
+          requirementsMapped: RequirementMap[];
+        }
+      >();
 
-        for (const rm of fi.requirementsMapped) {
-          if (rm.control) {
-            const { requirementsMapped: _, ...controlData } = rm.control;
-            if (!controlsMap.has(rm.control.id)) {
-              controlsMap.set(rm.control.id, {
-                ...controlData,
-                policies: rm.control.policies || [],
-                requirementsMapped: rm.control.requirementsMapped || [],
-              });
-            }
+      for (const rm of fi.requirementsMapped) {
+        if (rm.control) {
+          const { requirementsMapped: _, ...controlData } = rm.control;
+          if (!controlsMap.has(rm.control.id)) {
+            controlsMap.set(rm.control.id, {
+              ...controlData,
+              policies: rm.control.policies || [],
+              requirementsMapped: rm.control.requirementsMapped || [],
+            });
           }
         }
+      }
 
-        const { requirementsMapped, ...restOfFi } = fi;
+      const { requirementsMapped, ...restOfFi } = fi;
 
-        return {
-          ...restOfFi,
-          controls: Array.from(controlsMap.values()),
-        };
-      },
-    );
+      return {
+        ...restOfFi,
+        controls: Array.from(controlsMap.values()),
+      };
+    },
+  );
 
-    return frameworksWithControls;
-  },
-);
+  return frameworksWithControls;
+}

apps/app/src/app/(app)/[orgId]/frameworks/lib/compute.ts

@@ -29,8 +29,12 @@ export function computeFrameworkStats(
 
   const controlIds = controls.map((c) => c.id);
   const frameworkTasks = tasks.filter((t) => t.controls.some((c) => controlIds.includes(c.id)));
-  const totalTasks = frameworkTasks.length;
-  const doneTasks = frameworkTasks.filter((t) => t.status === 'done').length;
+  // Deduplicate tasks by id to avoid double counting across multiple controls
+  const uniqueTaskMap = new Map<string, Task & { controls: Control[] }>();
+  for (const t of frameworkTasks) uniqueTaskMap.set(t.id, t);
+  const uniqueTasks = Array.from(uniqueTaskMap.values());
+  const totalTasks = uniqueTasks.length;
+  const doneTasks = uniqueTasks.filter((t) => t.status === 'done').length;
   const taskRatio = totalTasks > 0 ? doneTasks / totalTasks : 1;
 
   const complianceScore = Math.round(((policyRatio + taskRatio) / 2) * 100);