fix(OUT-2055): realtime and cache issues for subtask count and subtask list.

- subtasks count cache issue : accessibleTask was use to calculate subtask count component for task card and task list. only implemented accessibleTask to be update from server on the first laod, rest of the time, its updated from realtime.
- subtasks list update issue : subtasks list were only refetched when no of subtasks in parent task was change, but while updating it doesnt change :
	- created a migration adding lastSubtaskUpdated timestamp in task schema.
	- formatted the timestamp for lastSubtaskUpdated in realtime response.
	- refetched subtasks according to the change in lastSubtaskUpdated.
	- updated lastSubtaskUpdated while creating, updating and deleted a sub task.
	- made sure we dont compromise on previously applied optimization by adding refetching check on mount and optimistic updates.

Author: arpandhakal

prisma/migrations/20250723060707_add_last_subtask_updated_timestamp/migration.sql

@@ -0,0 +1,2 @@
+-- AlterTable
+ALTER TABLE "Tasks" ADD COLUMN     "lastSubtaskUpdated" TIMESTAMP(3);

prisma/schema/task.prisma

@@ -32,6 +32,7 @@ model Task {
   completedAt              DateTime?
   dueDate                  String?                    @db.VarChar(10)
   lastActivityLogUpdated   DateTime?
+  lastSubtaskUpdated       DateTime?
   createdAt                DateTime                   @default(now())
   deletedAt                DateTime?
   ClientNotification       ClientNotification[]

src/app/api/tasks/tasks.service.ts

@@ -2,7 +2,7 @@ import { maxSubTaskDepth } from '@/constants/tasks'
 import { MAX_FETCH_ASSIGNEE_COUNT } from '@/constants/users'
 import { deleteTaskNotifications, sendTaskCreateNotifications, sendTaskUpdateNotifications } from '@/jobs/notifications'
 import { sendClientUpdateTaskNotifications } from '@/jobs/notifications/send-client-task-update-notifications'
-import { ClientResponse, CompanyResponse, InternalUsers } from '@/types/common'
+import { ClientResponse, CompanyResponse, InternalUsers, Uuid } from '@/types/common'
 import { TaskWithWorkflowState } from '@/types/db'
 import { AncestorTaskResponse, CreateTaskRequest, UpdateTaskRequest } from '@/types/dto/tasks.dto'
 import { DISPATCHABLE_EVENT } from '@/types/webhook'
@@ -247,7 +247,10 @@ export class TasksService extends BaseService {
         // Increment parent task's subtask count, if exists
         if (newTask.parentId) {
           const subtaskService = new SubtaskService(this.user)
-          await subtaskService.addSubtaskCount(newTask.parentId)
+          await Promise.all([
+            subtaskService.addSubtaskCount(newTask.parentId),
+            this.setNewLastSubtaskUpdated(newTask.parentId),
+          ])
         }
       } catch (e: unknown) {
         // Manually rollback task creation
@@ -415,6 +418,7 @@ export class TasksService extends BaseService {
       const isBodyChanged = prevTask.body !== updatedTask.body
       await Promise.all([
         activityLogger.logTaskUpdated(prevTask),
+        this.setNewLastSubtaskUpdated(updatedTask.parentId),
         sendTaskUpdateNotifications.trigger({ prevTask, updatedTask, user: this.user }),
         dispatchUpdatedWebhookEvent(this.user, prevTask, updatedTask, opts?.isPublicApi || false),
         isBodyChanged && opts?.isPublicApi ? queueBodyUpdatedWebhook(this.user, updatedTask) : undefined,
@@ -461,6 +465,7 @@ export class TasksService extends BaseService {
       subtaskService.setTransaction(tx as PrismaClient)
       if (task.parentId) {
         await subtaskService.decreaseSubtaskCount(task.parentId)
+        await this.setNewLastSubtaskUpdated(task.parentId)
       }
       await subtaskService.softDeleteAllSubtasks(task.id)
       return deletedTask
@@ -991,4 +996,20 @@ export class TasksService extends BaseService {
       assigneeType: null,
     }
   }
+
+  private async setNewLastSubtaskUpdated(parentId?: z.infer<typeof Uuid> | null) {
+    if (!parentId) {
+      return
+    }
+    try {
+      await this.db.task.update({
+        where: { id: parentId, workspaceId: this.user.workspaceId },
+        data: {
+          lastSubtaskUpdated: new Date(),
+        },
+      })
+    } catch (e) {
+      console.error('TaskService#setNewLastSubtaskUpdated::', e)
+    }
+  }
 }

src/app/detail/ui/ActivityWrapper.tsx

@@ -116,7 +116,7 @@ export const ActivityWrapper = ({
         {
           optimisticData: { data: optimisticData },
           rollbackOnError: true,
-          revalidate: false, // Make sure to revalidate after mutation
+          revalidate: false,
         },
       )
     } catch (error) {

src/app/detail/ui/Subtasks.tsx

@@ -6,6 +6,7 @@ import { NewTaskCard } from '@/app/detail/ui/NewTaskCard'
 import { TaskCardList } from '@/app/detail/ui/TaskCardList'
 import { AddBtn } from '@/components/buttons/AddBtn'
 import { GhostBtn } from '@/components/buttons/GhostBtn'
+import { useDebounce } from '@/hooks/useDebounce'
 import { GrayAddMediumIcon } from '@/icons'
 import { selectAuthDetails } from '@/redux/features/authDetailsSlice'
 import { selectTaskBoard } from '@/redux/features/taskBoardSlice'
@@ -40,7 +41,7 @@ export const Subtasks = ({
   const { workflowStates, assignee, activeTask } = useSelector(selectTaskBoard)
   const { tokenPayload } = useSelector(selectAuthDetails)
   const [optimisticUpdates, setOptimisticUpdates] = useState<OptimisticUpdate[]>([]) //might need this server-temp id maps in the future.
-
+  const [lastUpdated, setLastUpdated] = useState<string | null>()
   const handleFormCancel = () => setOpenTaskForm(false)
   const handleFormOpen = () => setOpenTaskForm(!openTaskForm)
 
@@ -53,18 +54,26 @@ export const Subtasks = ({
     revalidateOnFocus: false,
   })
   const didMount = useRef(false)
+  const shouldRefetchRef = useRef(true) //preventing double fetching from subtask update apis. Due to optimistic update revalidation, we are already fetching logs there. So no need to refetch in case for subtask update.
 
   const { mutate } = useSWRConfig()
 
-  useEffect(() => {
-    const taskListLength = subTasks?.tasks?.length
-
-    if (!activeTask || typeof taskListLength !== 'number') return
+  const _debounceMutate = async (cacheKey: string) => await mutate(cacheKey)
+  const debounceMutate = useDebounce(_debounceMutate, 200)
 
-    if (activeTask.subtaskCount !== taskListLength) {
-      mutate?.(cacheKey)
+  useEffect(() => {
+    if (!activeTask) return
+    if (!didMount.current || !shouldRefetchRef.current) {
+      didMount.current = true
+      shouldRefetchRef.current = true
+      setLastUpdated(activeTask?.lastSubtaskUpdated)
+      return //skip the refetch on first mount and shouldRefetch is false.
+    }
+    if (activeTask?.lastSubtaskUpdated && activeTask?.lastSubtaskUpdated !== lastUpdated) {
+      debounceMutate(cacheKey)
     }
-  }, [activeTask?.subtaskCount, activeTask?.isArchived, subTasks?.tasks?.length, activeTask, cacheKey, mutate])
+    setLastUpdated(activeTask?.lastSubtaskUpdated)
+  }, [activeTask?.lastSubtaskUpdated])
 
   const handleSubTaskCreation = (payload: CreateTaskRequest) => {
     const tempId = generateRandomString('temp-task')
@@ -115,13 +124,14 @@ export const Subtasks = ({
       await mutate(
         cacheKey,
         async () => {
+          shouldRefetchRef.current = false
           await updater()
           return await fetcher(cacheKey)
         },
         {
           optimisticData: { tasks: updatedTasks },
           rollbackOnError: true,
-          revalidate: true,
+          revalidate: false,
         },
       )
     } catch (error) {

src/cmd/load-testing/load-testing.service.ts

@@ -107,6 +107,7 @@ class LoadTester {
         | 'internalUserId'
         | 'clientId'
         | 'companyId'
+        | 'lastSubtaskUpdated'
       >[] = []
       const currentUser = await authenticateWithToken(this.token, this.apiKey)
       const labelsService = new LabelMappingService(currentUser, this.apiKey)

src/hoc/ClientSideStateUpdate.tsx

@@ -61,7 +61,7 @@ export const ClientSideStateUpdate = ({
   accesibleTaskIds?: string[]
   accessibleTasks?: TaskResponse[]
 }) => {
-  const { tasks: tasksInStore, viewSettingsTemp } = useSelector(selectTaskBoard)
+  const { tasks: tasksInStore, viewSettingsTemp, accessibleTasks: accessibleTaskInStore } = useSelector(selectTaskBoard)
   useEffect(() => {
     if (workflowStates) {
       store.dispatch(setWorkflowStates(workflowStates))
@@ -121,7 +121,8 @@ export const ClientSideStateUpdate = ({
     }
 
     if (accessibleTasks) {
-      store.dispatch(setAccessibleTasks(accessibleTasks))
+      const accessibleTaskData = accessibleTaskInStore.length ? accessibleTaskInStore : accessibleTasks
+      store.dispatch(setAccessibleTasks(accessibleTaskData))
     }
 
     return () => {

src/lib/realtime.ts

@@ -36,6 +36,7 @@ export class RealtimeHandler {
       createdAt: newTask.createdAt && new Date(newTask.createdAt + 'Z').toISOString(),
       updatedAt: newTask.updatedAt && new Date(newTask.updatedAt + 'Z').toISOString(),
       lastActivityLogUpdated: newTask.lastActivityLogUpdated && new Date(newTask.lastActivityLogUpdated + 'Z').toISOString(),
+      lastSubtaskUpdated: newTask.lastSubtaskUpdated && new Date(newTask.lastSubtaskUpdated + 'Z').toISOString(),
     }
   }
 

src/types/dto/tasks.dto.ts

@@ -78,6 +78,7 @@ export const TaskResponseSchema = z.object({
   updatedAt: z.string().datetime().nullish(),
   assignee: z.union([ClientResponseSchema, InternalUsersSchema, CompanyResponseSchema]).optional(),
   lastActivityLogUpdated: z.string().datetime().nullish(),
+  lastSubtaskUpdated: z.string().datetime().nullish(),
   isArchived: z.boolean().optional(),
   lastArchivedDate: z.string().datetime(),
   parentId: z.string().nullish(),