@tuturuuu/ui 0.7.0 → 0.9.0

package/src/hooks/use-task-actions.ts

@@ -15,6 +15,7 @@ import {
 } from '@tuturuuu/utils/task-list-status';
 import { addDays } from 'date-fns';
 import { useCallback } from 'react';
+import { invalidateKanbanDeadlineTasks } from '../components/ui/tu-do/boards/boardId/kanban/data/kanban-deadline-query';
 import { useBoardBroadcast } from '../components/ui/tu-do/shared/board-broadcast-context';
 import {
   dispatchTaskSoundCue,
@@ -81,6 +82,9 @@ export function useTaskActions({
 }: UseTaskActionsProps) {
   const queryClient = useQueryClient();
   const broadcast = useBoardBroadcast();
+  const invalidateDeadlineTasks = useCallback(() => {
+    void invalidateKanbanDeadlineTasks(queryClient, boardId);
+  }, [boardId, queryClient]);
 
   const resolveWorkspaceIdForTask = useCallback(
     async (taskRecord?: Task) => {
@@ -272,6 +276,7 @@ export function useTaskActions({
           description: `Task marked as ${targetCompletionList.status === 'done' ? 'done' : 'closed'} and moved to ${targetCompletionList.name}`,
         });
         dispatchTaskActionSound('complete');
+        invalidateDeadlineTasks();
       } catch (error) {
         console.error('Failed to complete external task:', error);
         toast.error('Error', {
@@ -337,6 +342,7 @@ export function useTaskActions({
             closed_at: movedTask?.closed_at,
           },
         });
+        invalidateDeadlineTasks();
 
         toast.success('Task completed', {
           description: `Task marked as done and moved to ${targetCompletionList.name}`,
@@ -395,6 +401,7 @@ export function useTaskActions({
           },
         });
         dispatchTaskActionSound(newClosedState ? 'complete' : 'update');
+        invalidateDeadlineTasks();
       } catch (error) {
         // Rollback on error
         if (previousTasks) {
@@ -422,6 +429,7 @@ export function useTaskActions({
     getWorkspaceId,
     markLocallyMutatedTask,
     mergeLocallyMutatedTask,
+    invalidateDeadlineTasks,
   ]);
 
   const handleMoveToCompletion = useCallback(async () => {
@@ -452,6 +460,7 @@ export function useTaskActions({
           description: `Task marked as ${targetCompletionList.status === 'done' ? 'done' : 'closed'} and moved to ${targetCompletionList.name}`,
         });
         dispatchTaskActionSound('complete');
+        invalidateDeadlineTasks();
         return;
       }
 
@@ -514,6 +523,7 @@ export function useTaskActions({
         }
       }
       if (successCount === 0) throw new Error('Failed to move any tasks');
+      invalidateDeadlineTasks();
 
       if (failedTaskIds.length > 0) {
         toast.warning('Partial completion update', {
@@ -561,6 +571,7 @@ export function useTaskActions({
     getWorkspaceId,
     markLocallyMutatedTask,
     rollbackTaskIds,
+    invalidateDeadlineTasks,
   ]);
 
   const handleMoveToClose = useCallback(async () => {
@@ -590,6 +601,7 @@ export function useTaskActions({
           description: 'Task marked as closed',
         });
         dispatchTaskActionSound('complete');
+        invalidateDeadlineTasks();
         return;
       }
 
@@ -648,6 +660,7 @@ export function useTaskActions({
         }
       }
       if (successCount === 0) throw new Error('Failed to move any tasks');
+      invalidateDeadlineTasks();
 
       if (failedTaskIds.length > 0) {
         toast.warning('Partial close update', {
@@ -692,6 +705,7 @@ export function useTaskActions({
     getWorkspaceId,
     markLocallyMutatedTask,
     rollbackTaskIds,
+    invalidateDeadlineTasks,
   ]);
 
   const handleDelete = useCallback(async () => {
@@ -764,6 +778,7 @@ export function useTaskActions({
       }
 
       if (successCount === 0) throw new Error('Failed to delete any tasks');
+      invalidateDeadlineTasks();
 
       if (failedTaskIds.length > 0) {
         toast.warning('Partial delete update', {
@@ -812,6 +827,7 @@ export function useTaskActions({
     broadcast,
     getWorkspaceId,
     restoreDeletedTaskIds,
+    invalidateDeadlineTasks,
   ]);
 
   const handleRemoveAllAssignees = useCallback(async () => {
@@ -1010,6 +1026,7 @@ export function useTaskActions({
             description: `Task moved to ${targetList.name || 'selected list'}`,
           });
           dispatchTaskActionSound(getMoveSoundCue(targetList));
+          invalidateDeadlineTasks();
         } catch (error) {
           console.error('Failed to move external task:', error);
           toast.error('Error', {
@@ -1115,6 +1132,7 @@ export function useTaskActions({
           }
         }
         if (successCount === 0) throw new Error('Failed to move any tasks');
+        invalidateDeadlineTasks();
 
         if (failedTaskIds.length > 0) {
           toast.warning('Partial move update', {
@@ -1161,6 +1179,7 @@ export function useTaskActions({
       markLocallyMutatedTask,
       resolveWorkspaceIdForTask,
       rollbackTaskIds,
+      invalidateDeadlineTasks,
     ]
   );
 
@@ -1243,6 +1262,7 @@ export function useTaskActions({
             task: { id: tid, end_date: newDate },
           });
         }
+        invalidateDeadlineTasks();
 
         if (failedTaskIds.length > 0) {
           toast.warning('Partial due date update', {
@@ -1283,6 +1303,7 @@ export function useTaskActions({
       boardId,
       task,
       broadcast,
+      invalidateDeadlineTasks,
     ]
   );
 
@@ -1575,6 +1596,7 @@ export function useTaskActions({
         // Use the centralized bulk update function from useBulkOperations
         try {
           await bulkUpdateCustomDueDate(date || null);
+          invalidateDeadlineTasks();
         } catch (error) {
           console.error('Bulk custom date update failed', error);
           toast.error('Failed to update due date for selected tasks');
@@ -1610,6 +1632,7 @@ export function useTaskActions({
           broadcast?.('task:upsert', {
             task: { id: task.id, end_date: newDate },
           });
+          invalidateDeadlineTasks();
 
           toast.success('Due date updated', {
             description: newDate
@@ -1639,6 +1662,7 @@ export function useTaskActions({
       queryClient,
       boardId,
       broadcast,
+      invalidateDeadlineTasks,
     ]
   );
 

package/src/hooks/use-user-workspace-config.ts

@@ -0,0 +1,75 @@
+'use client';
+
+import { useMutation, useQuery, useQueryClient } from '@tanstack/react-query';
+import {
+  getUserWorkspaceConfig,
+  updateUserWorkspaceConfig,
+} from '@tuturuuu/internal-api/users';
+
+export function getUserWorkspaceConfigQueryKey(
+  workspaceId: string,
+  configId: string
+) {
+  return ['user-workspace-config', workspaceId, configId] as const;
+}
+
+export function useUserWorkspaceConfig(
+  workspaceId: string,
+  configId: string,
+  defaultValue: string | null = null,
+  options?: {
+    enabled?: boolean;
+    staleTime?: number;
+  }
+) {
+  return useQuery({
+    queryKey: getUserWorkspaceConfigQueryKey(workspaceId, configId),
+    queryFn: async () => {
+      const data = await getUserWorkspaceConfig(workspaceId, configId);
+      return data.value ?? defaultValue;
+    },
+    enabled: options?.enabled !== false && Boolean(workspaceId && configId),
+    staleTime: options?.staleTime ?? 5 * 60 * 1000,
+  });
+}
+
+export function useUpdateUserWorkspaceConfig() {
+  const queryClient = useQueryClient();
+
+  return useMutation({
+    mutationFn: async ({
+      configId,
+      value,
+      workspaceId,
+    }: {
+      configId: string;
+      value: string | null;
+      workspaceId: string;
+    }) => updateUserWorkspaceConfig(workspaceId, configId, value),
+    onMutate: async ({ configId, value, workspaceId }) => {
+      const queryKey = getUserWorkspaceConfigQueryKey(workspaceId, configId);
+      await queryClient.cancelQueries({ queryKey });
+
+      const previousValue = queryClient.getQueryData<string | null>(queryKey);
+      queryClient.setQueryData(queryKey, value);
+
+      return { configId, previousValue, workspaceId };
+    },
+    onError: (_error, _variables, context) => {
+      if (!context) return;
+
+      queryClient.setQueryData(
+        getUserWorkspaceConfigQueryKey(context.workspaceId, context.configId),
+        context.previousValue ?? null
+      );
+    },
+    onSettled: (_data, _error, variables) => {
+      queryClient.invalidateQueries({
+        queryKey: getUserWorkspaceConfigQueryKey(
+          variables.workspaceId,
+          variables.configId
+        ),
+      });
+    },
+  });
+}

package/src/hooks/use-workspace-currency.ts

@@ -1,5 +1,6 @@
 import {
   getCurrencyLocale,
+  resolveSupportedCurrency,
   type SupportedCurrency,
 } from '@tuturuuu/utils/currencies';
 
@@ -8,14 +9,18 @@ import { useWorkspaceConfig } from './use-workspace-config';
 // Re-export for convenience
 export type { SupportedCurrency } from '@tuturuuu/utils/currencies';
 
-export const useWorkspaceCurrency = (wsId: string) => {
+export const useWorkspaceCurrency = (
+  wsId: string,
+  fallbackCurrency = 'USD'
+) => {
+  const fallback = resolveSupportedCurrency(fallbackCurrency);
   const { data, isLoading, error } = useWorkspaceConfig<SupportedCurrency>(
     wsId,
     'DEFAULT_CURRENCY',
-    'USD'
+    fallback
   );
 
-  const currency = (data as SupportedCurrency) ?? 'USD';
+  const currency = resolveSupportedCurrency(data, fallback);
 
   return {
     currency,

package/src/hooks/useBoardRealtime.ts

@@ -10,8 +10,10 @@ import { toast } from './use-toast';
 import {
   type BoardRealtimePayload,
   createRealtimeClientId,
+  getBoardRealtimeChannelName,
   isBoardRealtimeEnvelope,
   LOCAL_BROADCAST_CHANNEL_PREFIX,
+  PRIVATE_TASK_REALTIME_CHANNEL_CONFIG,
   type RealtimeChannel,
   SEEN_REALTIME_EVENT_LIMIT,
 } from './useBoardRealtime.types';
@@ -205,9 +207,10 @@ export function useBoardRealtime(
       channelRef.current = null;
     }
 
-    const channel = supabase.channel(`board-realtime-${boardId}`, {
-      config: { broadcast: { self: false } },
-    });
+    const channel = supabase.channel(
+      getBoardRealtimeChannelName(boardId),
+      PRIVATE_TASK_REALTIME_CHANNEL_CONFIG
+    );
     channelRef.current = channel;
 
     channel

package/src/hooks/useBoardRealtime.types.ts

@@ -14,8 +14,19 @@ type BoardRealtimeEnvelope = {
   payload: BoardRealtimePayload;
 };
 
+export const BOARD_REALTIME_CHANNEL_PREFIX = 'board-realtime';
 export const LOCAL_BROADCAST_CHANNEL_PREFIX = 'tuturuuu:board-realtime';
 export const SEEN_REALTIME_EVENT_LIMIT = 500;
+export const PRIVATE_TASK_REALTIME_CHANNEL_CONFIG = {
+  config: {
+    broadcast: { self: false },
+    private: true,
+  },
+} as const;
+
+export function getBoardRealtimeChannelName(boardId: string) {
+  return `${BOARD_REALTIME_CHANNEL_PREFIX}-${boardId}`;
+}
 
 const isRecord = (value: unknown): value is Record<string, unknown> =>
   typeof value === 'object' && value !== null;

package/src/hooks/useBoardRealtimeEventHandler.ts

@@ -188,6 +188,16 @@ function invalidateTaskMembershipQueries(
   void queryClient.invalidateQueries({
     queryKey: ['task-list-counts', boardId],
   });
+  void queryClient.invalidateQueries({
+    predicate: (query) => {
+      const queryKey = query.queryKey;
+      return (
+        Array.isArray(queryKey) &&
+        queryKey[0] === 'kanban-deadline-tasks' &&
+        queryKey[2] === boardId
+      );
+    },
+  });
   void queryClient.invalidateQueries({ queryKey: ['my-tasks'] });
   void queryClient.invalidateQueries({ queryKey: ['my-completed-tasks'] });
 }
@@ -342,6 +352,7 @@ export function useBoardRealtimeEventHandler({
         patchMyTasksCaches(queryClient, taskData);
         if (
           'list_id' in taskData ||
+          'end_date' in taskData ||
           'completed' in taskData ||
           'completed_at' in taskData ||
           'closed_at' in taskData ||

package/src/hooks/useCursorTracking.ts

@@ -5,15 +5,79 @@ import { DEV_MODE } from '@tuturuuu/utils/constants';
 import type { RefObject } from 'react';
 import { useCallback, useEffect, useRef, useState } from 'react';
 import { usePageVisibility } from './use-page-visibility';
+import { PRIVATE_TASK_REALTIME_CHANNEL_CONFIG } from './useBoardRealtime.types';
+
+type CursorUser = Pick<User, 'avatar_url' | 'display_name' | 'id'> & {
+  id: string;
+};
 
 export interface CursorPosition {
   x: number;
   y: number;
-  user?: User;
+  user?: CursorUser;
   metadata?: { [key: string]: any };
   lastUpdatedAt: number;
 }
 
+type ParsedCursorPosition = CursorPosition & { user: CursorUser };
+
+function isRecord(value: unknown): value is Record<string, unknown> {
+  return typeof value === 'object' && value !== null;
+}
+
+function sanitizeCursorUser(user: User | undefined): CursorUser | null {
+  if (!user?.id) return null;
+
+  return {
+    avatar_url:
+      typeof user.avatar_url === 'string' && user.avatar_url.length > 0
+        ? user.avatar_url
+        : null,
+    display_name:
+      typeof user.display_name === 'string' && user.display_name.length > 0
+        ? user.display_name
+        : null,
+    id: user.id,
+  };
+}
+
+function sanitizeCursorMetadata(metadata: { [key: string]: any } | undefined) {
+  if (metadata == null || !isRecord(metadata) || Array.isArray(metadata)) {
+    return undefined;
+  }
+
+  return metadata;
+}
+
+function parseCursorMovePayload(payload: unknown): ParsedCursorPosition | null {
+  if (!isRecord(payload)) return null;
+
+  const { metadata, user, x, y } = payload;
+  if (typeof x !== 'number' || !Number.isFinite(x)) return null;
+  if (typeof y !== 'number' || !Number.isFinite(y)) return null;
+  if (!isRecord(user) || typeof user.id !== 'string' || user.id.length === 0) {
+    return null;
+  }
+
+  return {
+    lastUpdatedAt: Date.now(),
+    metadata: sanitizeCursorMetadata(metadata as { [key: string]: any }),
+    user: {
+      avatar_url:
+        typeof user.avatar_url === 'string' && user.avatar_url.length > 0
+          ? user.avatar_url
+          : null,
+      display_name:
+        typeof user.display_name === 'string' && user.display_name.length > 0
+          ? user.display_name
+          : null,
+      id: user.id,
+    },
+    x,
+    y,
+  };
+}
+
 export function useCursorTracking(
   channelName: string,
   containerRef?: RefObject<HTMLElement | null>,
@@ -59,6 +123,8 @@ export function useCursorTracking(
       metadata?: { [key: string]: any }
     ) => {
       if (!channelRef.current) return;
+      const cursorUser = sanitizeCursorUser(user);
+      if (cursorUser == null) return;
       // Check error count instead of state to avoid dependency
       if (errorCountRef.current >= MAX_ERROR_COUNT) return;
 
@@ -73,7 +139,12 @@ export function useCursorTracking(
                 await channelRef.current?.send({
                   type: 'broadcast',
                   event: 'cursor-move',
-                  payload: { x, y, user, metadata },
+                  payload: {
+                    metadata: sanitizeCursorMetadata(metadata),
+                    user: cursorUser,
+                    x,
+                    y,
+                  },
                 });
 
                 lastBroadcastTimeRef.current = Date.now();
@@ -90,7 +161,12 @@ export function useCursorTracking(
           await channelRef.current.send({
             type: 'broadcast',
             event: 'cursor-move',
-            payload: { x, y, user, metadata },
+            payload: {
+              metadata: sanitizeCursorMetadata(metadata),
+              user: cursorUser,
+              x,
+              y,
+            },
           });
 
           lastBroadcastTimeRef.current = now;
@@ -207,38 +283,25 @@ export function useCursorTracking(
           channelRef.current = null;
         }
 
-        const channel = supabase.channel(channelName, {
-          config: {
-            broadcast: {
-              self: false, // Don't receive own broadcasts
-            },
-          },
-        });
+        const channel = supabase.channel(
+          channelName,
+          PRIVATE_TASK_REALTIME_CHANNEL_CONFIG
+        );
 
         channelRef.current = channel;
         // Listen for cursor movements from other users
         channel
           .on('broadcast', { event: 'cursor-move' }, (payload) => {
             try {
-              const {
-                x,
-                y,
-                user: broadcastUser,
-                metadata: broadcastMetadata,
-              } = payload.payload;
+              const cursor = parseCursorMovePayload(payload.payload);
+              if (cursor == null) return;
 
               // Ignore own broadcasts (extra safety)
-              if (broadcastUser.id === user?.id) return;
+              if (cursor.user?.id === user?.id) return;
 
               setCursors((prev) => {
                 const updated = new Map(prev);
-                updated.set(broadcastUser.id || '', {
-                  x,
-                  y,
-                  user: broadcastUser,
-                  metadata: broadcastMetadata,
-                  lastUpdatedAt: Date.now(),
-                });
+                updated.set(cursor.user.id, cursor);
                 return updated;
               });
             } catch (err) {
@@ -289,16 +352,17 @@ export function useCursorTracking(
 
       // Broadcast cursor removal before unsubscribing (best effort)
       // This helps other users see the cursor disappear immediately
-      if (channelRef.current && user?.id) {
+      const cursorUser = sanitizeCursorUser(user);
+      if (channelRef.current && cursorUser != null) {
         try {
           channelRef.current.send({
             type: 'broadcast',
             event: 'cursor-move',
             payload: {
+              metadata: sanitizeCursorMetadata(metadata),
+              user: cursorUser,
               x: -1000,
               y: -1000,
-              user,
-              metadata,
             },
           });
         } catch (err) {

package/src/hooks/useTaskUserRealtime.ts

@@ -8,6 +8,7 @@ import { useCallback, useEffect, useRef } from 'react';
 import {
   type BoardRealtimePayload,
   createRealtimeClientId,
+  PRIVATE_TASK_REALTIME_CHANNEL_CONFIG,
   type RealtimeChannel,
   SEEN_REALTIME_EVENT_LIMIT,
 } from './useBoardRealtime.types';
@@ -255,9 +256,10 @@ export function useTaskUserRealtime(userId: string | null | undefined) {
       return;
     }
 
-    const channel = supabase.channel(getTaskUserRealtimeChannelName(userId), {
-      config: { broadcast: { self: false } },
-    });
+    const channel = supabase.channel(
+      getTaskUserRealtimeChannelName(userId),
+      PRIVATE_TASK_REALTIME_CHANNEL_CONFIG
+    );
     channelRef.current = channel;
 
     channel