@tuturuuu/utils 0.0.2 → 0.6.0

package/src/notification-service.ts

@@ -0,0 +1,379 @@
+/**
+ * Notification Service Utilities
+ *
+ * Provides utilities for creating, managing, and querying notifications
+ * across web, email, SMS, and push notification channels.
+ */
+
+import { createClient } from '@tuturuuu/supabase/next/server';
+
+export type NotificationType =
+  | 'task_assigned'
+  | 'task_updated'
+  | 'task_mention'
+  | 'deadline_reminder'
+  | 'time_tracking_request_submitted'
+  | 'time_tracking_request_resubmitted'
+  | 'time_tracking_request_approved'
+  | 'time_tracking_request_rejected'
+  | 'time_tracking_request_needs_info'
+  | 'workspace_invite';
+
+export type NotificationChannel = 'web' | 'email' | 'sms' | 'push';
+
+export type NotificationStatus = 'pending' | 'sent' | 'failed';
+
+export interface CreateNotificationParams {
+  wsId: string;
+  userId: string;
+  type: NotificationType;
+  title: string;
+  description?: string;
+  data?: Record<string, any>;
+  entityType?: string;
+  entityId?: string;
+  createdBy?: string;
+}
+
+export interface GetNotificationsParams {
+  wsId: string;
+  userId: string;
+  limit?: number;
+  offset?: number;
+  unreadOnly?: boolean;
+  type?: NotificationType;
+}
+
+/**
+ * Creates a notification for a user
+ * Respects user preferences for web and email notifications
+ */
+export async function createNotification(
+  params: CreateNotificationParams
+): Promise<string | null> {
+  const supabase = await createClient();
+
+  const { data, error } = await supabase.rpc('create_notification', {
+    p_ws_id: params.wsId,
+    p_user_id: params.userId,
+    p_type: params.type,
+    p_title: params.title,
+    p_description: params.description ?? undefined,
+    p_data: params.data || {},
+    p_entity_type: params.entityType ?? undefined,
+    p_entity_id: params.entityId ?? undefined,
+    p_created_by: params.createdBy ?? undefined,
+  });
+
+  if (error) {
+    console.error('Error creating notification:', error);
+    return null;
+  }
+
+  return data as string | null;
+}
+
+/**
+ * Gets notifications for a user with pagination and filtering
+ */
+export async function getNotifications(params: GetNotificationsParams) {
+  const supabase = await createClient();
+
+  let query = supabase
+    .from('notifications')
+    .select('*', { count: 'exact' })
+    .eq('ws_id', params.wsId)
+    .eq('user_id', params.userId)
+    .order('created_at', { ascending: false });
+
+  if (params.unreadOnly) {
+    query = query.is('read_at', null);
+  }
+
+  if (params.type) {
+    query = query.eq('type', params.type);
+  }
+
+  if (params.limit) {
+    query = query.limit(params.limit);
+  }
+
+  if (params.offset) {
+    query = query.range(
+      params.offset,
+      params.offset + (params.limit || 10) - 1
+    );
+  }
+
+  const { data, error, count } = await query;
+
+  if (error) {
+    console.error('Error fetching notifications:', error);
+    return { notifications: [], count: 0 };
+  }
+
+  return {
+    notifications: data || [],
+    count: count || 0,
+  };
+}
+
+/**
+ * Gets the unread notification count for a user
+ */
+export async function getUnreadCount(
+  wsId: string,
+  userId: string
+): Promise<number> {
+  const supabase = await createClient();
+
+  const { count, error } = await supabase
+    .from('notifications')
+    .select('*', { count: 'exact', head: true })
+    .eq('ws_id', wsId)
+    .eq('user_id', userId)
+    .is('read_at', null);
+
+  if (error) {
+    console.error('Error fetching unread count:', error);
+    return 0;
+  }
+
+  return count || 0;
+}
+
+/**
+ * Marks a notification as read
+ */
+export async function markAsRead(notificationId: string): Promise<boolean> {
+  const supabase = await createClient();
+
+  const { error } = await supabase
+    .from('notifications')
+    .update({ read_at: new Date().toISOString() })
+    .eq('id', notificationId);
+
+  if (error) {
+    console.error('Error marking notification as read:', error);
+    return false;
+  }
+
+  return true;
+}
+
+/**
+ * Marks a notification as unread
+ */
+export async function markAsUnread(notificationId: string): Promise<boolean> {
+  const supabase = await createClient();
+
+  const { error } = await supabase
+    .from('notifications')
+    .update({ read_at: null })
+    .eq('id', notificationId);
+
+  if (error) {
+    console.error('Error marking notification as unread:', error);
+    return false;
+  }
+
+  return true;
+}
+
+/**
+ * Marks all notifications as read for a user in a workspace
+ */
+export async function markAllAsRead(
+  wsId: string,
+  userId: string
+): Promise<boolean> {
+  const supabase = await createClient();
+
+  const { error } = await supabase
+    .from('notifications')
+    .update({ read_at: new Date().toISOString() })
+    .eq('ws_id', wsId)
+    .eq('user_id', userId)
+    .is('read_at', null);
+
+  if (error) {
+    console.error('Error marking all notifications as read:', error);
+    return false;
+  }
+
+  return true;
+}
+
+/**
+ * Deletes a notification
+ */
+export async function deleteNotification(
+  notificationId: string
+): Promise<boolean> {
+  const supabase = await createClient();
+
+  const { error } = await supabase
+    .from('notifications')
+    .delete()
+    .eq('id', notificationId);
+
+  if (error) {
+    console.error('Error deleting notification:', error);
+    return false;
+  }
+
+  return true;
+}
+
+/**
+ * Gets notification preferences for a user
+ */
+export async function getNotificationPreferences(wsId: string, userId: string) {
+  const supabase = await createClient();
+
+  const { data, error } = await supabase
+    .from('notification_preferences')
+    .select('*')
+    .eq('ws_id', wsId)
+    .eq('user_id', userId);
+
+  if (error) {
+    console.error('Error fetching notification preferences:', error);
+    return [];
+  }
+
+  return data || [];
+}
+
+/**
+ * Sets notification preference for a specific event type and channel
+ */
+export async function setNotificationPreference(
+  wsId: string,
+  userId: string,
+  eventType: NotificationType,
+  channel: NotificationChannel,
+  enabled: boolean
+): Promise<boolean> {
+  const supabase = await createClient();
+
+  const { error } = await supabase.from('notification_preferences').upsert(
+    {
+      ws_id: wsId,
+      user_id: userId,
+      event_type: eventType,
+      channel,
+      enabled,
+    },
+    {
+      onConflict: 'ws_id,user_id,event_type,channel',
+    }
+  );
+
+  if (error) {
+    console.error('Error setting notification preference:', error);
+    return false;
+  }
+
+  return true;
+}
+
+/**
+ * Checks if a notification should be sent based on user preferences
+ * Defaults to true if no preference is set
+ */
+export async function shouldSendNotification(
+  wsId: string,
+  userId: string,
+  eventType: NotificationType,
+  channel: NotificationChannel
+): Promise<boolean> {
+  const supabase = await createClient();
+
+  const { data, error } = await supabase.rpc('should_send_notification', {
+    p_ws_id: wsId,
+    p_user_id: userId,
+    p_event_type: eventType,
+    p_channel: channel,
+  });
+
+  if (error) {
+    console.error('Error checking notification preference:', error);
+    // Default to true (enabled) if there's an error
+    return true;
+  }
+
+  return data as boolean;
+}
+
+/**
+ * Scans text for @mentions and returns user IDs
+ * Mentions format: @[userId] or @username
+ */
+export function extractMentions(text: string): string[] {
+  if (!text) return [];
+
+  // Match @[uuid] pattern
+  const uuidPattern =
+    /@\[([0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12})\]/gi;
+  const matches = text.matchAll(uuidPattern);
+
+  const userIds: string[] = [];
+  for (const match of matches) {
+    if (match[1]) {
+      userIds.push(match[1]);
+    }
+  }
+
+  return [...new Set(userIds)]; // Remove duplicates
+}
+
+/**
+ * Creates mention notifications for users mentioned in text
+ */
+export async function createMentionNotifications(
+  wsId: string,
+  text: string,
+  entityType: string,
+  entityId: string,
+  entityName: string,
+  createdBy: string
+): Promise<void> {
+  const mentionedUserIds = extractMentions(text);
+
+  if (mentionedUserIds.length === 0) return;
+
+  // Get creator name
+  const supabase = await createClient();
+  const { data: creator } = await supabase
+    .from('users')
+    .select('display_name')
+    .eq('id', createdBy)
+    .single();
+
+  const creatorName = creator?.display_name || 'Someone';
+
+  // Create notifications for each mentioned user
+  for (const userId of mentionedUserIds) {
+    // Don't notify the creator
+    if (userId === createdBy) continue;
+
+    await createNotification({
+      wsId,
+      userId,
+      type: 'task_mention',
+      title: 'You were mentioned',
+      description: `${creatorName} mentioned you in "${entityName}"`,
+      data: {
+        entity_type: entityType,
+        entity_id: entityId,
+        entity_name: entityName,
+        mentioned_by: createdBy,
+        mentioned_by_name: creatorName,
+      },
+      entityType,
+      entityId,
+      createdBy,
+    });
+  }
+}

package/src/nova/scores/__tests__/calculate.test.ts

@@ -0,0 +1,254 @@
+import { describe, expect, it } from 'vitest';
+import {
+  aggregateByChallenge,
+  calculateBestScores,
+  calculatePercentage,
+  calculateScore,
+  formatScore,
+  type ScoreInput,
+} from '../calculate';
+
+describe('calculateScore', () => {
+  it('should correctly calculate score with only tests', () => {
+    const input: ScoreInput = {
+      total_tests: 10,
+      passed_tests: 5,
+      total_criteria: 0,
+      sum_criterion_score: 0,
+    };
+
+    // With updated logic, only tests should get 100% weight
+    expect(calculateScore(input)).toBe(5); // (5/10) * 10 * 1.0 = 5
+  });
+
+  it('should correctly calculate score with only criteria', () => {
+    const input: ScoreInput = {
+      total_tests: 0,
+      passed_tests: 0,
+      total_criteria: 5,
+      sum_criterion_score: 25, // 5 criteria with average score of 5
+    };
+
+    expect(calculateScore(input)).toBe(5); // (25/(5*10)) * 10 * 1.0 = 5
+  });
+
+  it('should correctly calculate score with both tests and criteria', () => {
+    const input: ScoreInput = {
+      total_tests: 10,
+      passed_tests: 8,
+      total_criteria: 5,
+      sum_criterion_score: 40, // 5 criteria with average score of 8
+    };
+
+    // Test score: (8/10) * 10 * 0.5 = 4
+    // Criteria score: (40/(5*10)) * 10 * 0.5 = 4
+    // Total: 4 + 4 = 8
+    expect(calculateScore(input)).toBe(8);
+  });
+
+  it('should give full weight to tests when criteria do not exist', () => {
+    const input: ScoreInput = {
+      total_tests: 10,
+      passed_tests: 7,
+      total_criteria: 0,
+      sum_criterion_score: 0,
+    };
+
+    // No criteria, so tests get 100% weight
+    // Test score: (7/10) * 10 * 1.0 = 7
+    expect(calculateScore(input)).toBe(7);
+  });
+
+  it('should handle zero test cases with criteria', () => {
+    const input: ScoreInput = {
+      total_tests: 0,
+      passed_tests: 0,
+      total_criteria: 5,
+      sum_criterion_score: 25, // 5 criteria with average score of 5
+    };
+
+    // No tests, so criteria gets 100% weight
+    // Criteria score: (25/(5*10)) * 10 * 1.0 = 5
+    expect(calculateScore(input)).toBe(5);
+  });
+
+  it('should handle null values', () => {
+    const input: ScoreInput = {
+      total_tests: null,
+      passed_tests: null,
+      total_criteria: null,
+      sum_criterion_score: null,
+    };
+
+    expect(calculateScore(input)).toBe(0);
+  });
+
+  it('should handle undefined values', () => {
+    const input: ScoreInput = {};
+
+    expect(calculateScore(input)).toBe(0);
+  });
+});
+
+describe('calculateBestScores', () => {
+  it('should return the best score for each problem', () => {
+    const submissions = [
+      { problem_id: 'p1', total_tests: 10, passed_tests: 5 },
+      { problem_id: 'p1', total_tests: 10, passed_tests: 7 },
+      { problem_id: 'p2', total_tests: 10, passed_tests: 3 },
+      { problem_id: 'p2', total_tests: 10, passed_tests: 6 },
+    ];
+
+    const bestScores = calculateBestScores(submissions);
+
+    // With the updated logic: (passed/total) * 10 * 1.0 for tests only
+    expect(bestScores.get('p1')).toBe(7); // (7/10) * 10 * 1.0 = 7
+    expect(bestScores.get('p2')).toBe(6); // (6/10) * 10 * 1.0 = 6
+  });
+
+  it('should handle submissions with both tests and criteria', () => {
+    const submissions = [
+      {
+        problem_id: 'p1',
+        total_tests: 10,
+        passed_tests: 8,
+        total_criteria: 4,
+        sum_criterion_score: 32, // Average of 8 per criterion
+      },
+      {
+        problem_id: 'p1',
+        total_tests: 10,
+        passed_tests: 6,
+        total_criteria: 5,
+        sum_criterion_score: 45, // Average of 9 per criterion
+      },
+    ];
+
+    const bestScores = calculateBestScores(submissions);
+
+    // First submission:
+    // Tests: (8/10) * 10 * 0.5 = 4
+    // Criteria: (32/(4*10)) * 10 * 0.5 = 4
+    // Total: 8
+
+    // Second submission:
+    // Tests: (6/10) * 10 * 0.5 = 3
+    // Criteria: (45/(5*10)) * 10 * 0.5 = 4.5
+    // Total: 7.5
+
+    expect(bestScores.get('p1')).toBe(8);
+  });
+
+  it('should skip submissions without problem_id', () => {
+    const submissions = [
+      { problem_id: 'p1', total_tests: 10, passed_tests: 5 },
+      { problem_id: '', total_tests: 10, passed_tests: 7 },
+      { problem_id: undefined as any, total_tests: 10, passed_tests: 3 },
+    ];
+
+    const bestScores = calculateBestScores(submissions);
+
+    expect(bestScores.get('p1')).toBe(5); // (5/10) * 10 * 1.0 = 5
+    expect(bestScores.size).toBe(1);
+  });
+
+  it('should return an empty map when no valid submissions exist', () => {
+    const submissions: Array<ScoreInput & { problem_id: string }> = [];
+
+    const bestScores = calculateBestScores(submissions);
+
+    expect(bestScores.size).toBe(0);
+  });
+});
+
+describe('aggregateByChallenge', () => {
+  it('should correctly aggregate scores by challenge', () => {
+    const problemScores = new Map([
+      ['p1', 5],
+      ['p2', 7],
+      ['p3', 3],
+    ]);
+
+    const problemChallengeMap = new Map([
+      ['p1', 'c1'],
+      ['p2', 'c1'],
+      ['p3', 'c2'],
+    ]);
+
+    const challengeScores = aggregateByChallenge(
+      problemScores,
+      problemChallengeMap
+    );
+
+    expect(challengeScores.c1).toBe(12); // 5 + 7
+    expect(challengeScores.c2).toBe(3);
+  });
+
+  it('should ignore problems that are not in the challenge map', () => {
+    const problemScores = new Map([
+      ['p1', 5],
+      ['p2', 7],
+      ['p3', 3],
+    ]);
+
+    const problemChallengeMap = new Map([
+      ['p1', 'c1'],
+      ['p3', 'c2'],
+    ]);
+
+    const challengeScores = aggregateByChallenge(
+      problemScores,
+      problemChallengeMap
+    );
+
+    expect(challengeScores.c1).toBe(5);
+    expect(challengeScores.c2).toBe(3);
+    expect(Object.keys(challengeScores).length).toBe(2);
+  });
+
+  it('should return an empty object when no problems match challenges', () => {
+    const problemScores = new Map([
+      ['p1', 5],
+      ['p2', 7],
+    ]);
+
+    const problemChallengeMap = new Map([
+      ['p3', 'c1'],
+      ['p4', 'c2'],
+    ]);
+
+    const challengeScores = aggregateByChallenge(
+      problemScores,
+      problemChallengeMap
+    );
+
+    expect(Object.keys(challengeScores).length).toBe(0);
+  });
+});
+
+describe('formatScore', () => {
+  it('should format score with default decimal places (1)', () => {
+    expect(formatScore(5)).toBe('5.0');
+    expect(formatScore(5.678)).toBe('5.7');
+  });
+
+  it('should format score with specified decimal places', () => {
+    expect(formatScore(5, 0)).toBe('5');
+    expect(formatScore(5.678, 2)).toBe('5.68');
+    expect(formatScore(5.678, 3)).toBe('5.678');
+  });
+});
+
+describe('calculatePercentage', () => {
+  it('should correctly calculate percentage', () => {
+    expect(calculatePercentage(5, 10)).toBe(50);
+    expect(calculatePercentage(7.5, 10)).toBe(75);
+    expect(calculatePercentage(0, 10)).toBe(0);
+    expect(calculatePercentage(10, 10)).toBe(100);
+  });
+
+  it('should return 0 when maxScore is 0 or negative', () => {
+    expect(calculatePercentage(5, 0)).toBe(0);
+    expect(calculatePercentage(5, -10)).toBe(0);
+  });
+});