@tuturuuu/utils 0.0.3 → 0.6.0

package/src/__tests__/notification-service.test.ts

@@ -0,0 +1,210 @@
+import { describe, expect, it } from 'vitest';
+import { extractMentions } from '../notification-service';
+
+describe('extractMentions', () => {
+  describe('basic functionality', () => {
+    it('should return empty array for empty string', () => {
+      expect(extractMentions('')).toEqual([]);
+    });
+
+    it('should return empty array for null/undefined', () => {
+      expect(extractMentions(null as unknown as string)).toEqual([]);
+      expect(extractMentions(undefined as unknown as string)).toEqual([]);
+    });
+
+    it('should return empty array for text without mentions', () => {
+      expect(extractMentions('Hello World')).toEqual([]);
+      expect(extractMentions('No mentions here')).toEqual([]);
+    });
+  });
+
+  describe('UUID mention extraction', () => {
+    it('should extract a single UUID mention', () => {
+      const text =
+        'Hey @[550e8400-e29b-41d4-a716-446655440000], check this out';
+      const result = extractMentions(text);
+      expect(result).toEqual(['550e8400-e29b-41d4-a716-446655440000']);
+    });
+
+    it('should extract multiple UUID mentions', () => {
+      const text = `
+        @[550e8400-e29b-41d4-a716-446655440000] and
+        @[6ba7b810-9dad-11d1-80b4-00c04fd430c8] please review
+      `;
+      const result = extractMentions(text);
+      expect(result).toHaveLength(2);
+      expect(result).toContain('550e8400-e29b-41d4-a716-446655440000');
+      expect(result).toContain('6ba7b810-9dad-11d1-80b4-00c04fd430c8');
+    });
+
+    it('should deduplicate repeated mentions', () => {
+      const text = `
+        @[550e8400-e29b-41d4-a716-446655440000] first mention
+        @[550e8400-e29b-41d4-a716-446655440000] second mention
+        @[550e8400-e29b-41d4-a716-446655440000] third mention
+      `;
+      const result = extractMentions(text);
+      expect(result).toHaveLength(1);
+      expect(result).toEqual(['550e8400-e29b-41d4-a716-446655440000']);
+    });
+
+    it('should handle UUID with uppercase letters', () => {
+      const text = '@[550E8400-E29B-41D4-A716-446655440000] uppercase UUID';
+      const result = extractMentions(text);
+      expect(result).toHaveLength(1);
+      // UUIDs should be extracted as-is (case-insensitive matching)
+    });
+
+    it('should handle mixed case UUIDs', () => {
+      const text = '@[550e8400-E29B-41d4-A716-446655440000] mixed case';
+      const result = extractMentions(text);
+      expect(result).toHaveLength(1);
+    });
+  });
+
+  describe('edge cases', () => {
+    it('should not extract malformed UUIDs', () => {
+      // Missing segment
+      expect(extractMentions('@[550e8400-e29b-41d4-a716] incomplete')).toEqual(
+        []
+      );
+
+      // Too short
+      expect(extractMentions('@[550e8400] too short')).toEqual([]);
+
+      // Invalid characters
+      expect(
+        extractMentions('@[550e8400-e29b-41d4-a716-44665544000g] invalid char')
+      ).toEqual([]);
+    });
+
+    it('should not extract @ without brackets', () => {
+      expect(extractMentions('@username plain mention')).toEqual([]);
+      expect(extractMentions('email@example.com')).toEqual([]);
+    });
+
+    it('should not extract incomplete bracket syntax', () => {
+      expect(
+        extractMentions(
+          '@[550e8400-e29b-41d4-a716-446655440000 missing bracket'
+        )
+      ).toEqual([]);
+      expect(
+        extractMentions(
+          '@550e8400-e29b-41d4-a716-446655440000] missing bracket'
+        )
+      ).toEqual([]);
+    });
+
+    it('should handle mentions at start of text', () => {
+      const text = '@[550e8400-e29b-41d4-a716-446655440000] at the start';
+      expect(extractMentions(text)).toEqual([
+        '550e8400-e29b-41d4-a716-446655440000',
+      ]);
+    });
+
+    it('should handle mentions at end of text', () => {
+      const text = 'At the end @[550e8400-e29b-41d4-a716-446655440000]';
+      expect(extractMentions(text)).toEqual([
+        '550e8400-e29b-41d4-a716-446655440000',
+      ]);
+    });
+
+    it('should handle mentions with no surrounding space', () => {
+      const text = 'text@[550e8400-e29b-41d4-a716-446655440000]more';
+      expect(extractMentions(text)).toEqual([
+        '550e8400-e29b-41d4-a716-446655440000',
+      ]);
+    });
+
+    it('should handle consecutive mentions', () => {
+      const text =
+        '@[550e8400-e29b-41d4-a716-446655440000]@[6ba7b810-9dad-11d1-80b4-00c04fd430c8]';
+      const result = extractMentions(text);
+      expect(result).toHaveLength(2);
+    });
+
+    it('should handle mentions in multiline text', () => {
+      const text = `
+        Line 1: @[550e8400-e29b-41d4-a716-446655440000]
+        Line 2: some text
+        Line 3: @[6ba7b810-9dad-11d1-80b4-00c04fd430c8]
+      `;
+      const result = extractMentions(text);
+      expect(result).toHaveLength(2);
+    });
+
+    it('should handle HTML content with mentions', () => {
+      const text =
+        '<p>Hello @[550e8400-e29b-41d4-a716-446655440000]</p><br>Test';
+      expect(extractMentions(text)).toEqual([
+        '550e8400-e29b-41d4-a716-446655440000',
+      ]);
+    });
+
+    it('should handle JSON-like content with mentions', () => {
+      const text =
+        '{"message": "Hello @[550e8400-e29b-41d4-a716-446655440000]"}';
+      expect(extractMentions(text)).toEqual([
+        '550e8400-e29b-41d4-a716-446655440000',
+      ]);
+    });
+  });
+
+  describe('real-world scenarios', () => {
+    it('should handle task description with mentions', () => {
+      const text = `
+        Please review this PR:
+        - @[550e8400-e29b-41d4-a716-446655440000] for frontend changes
+        - @[6ba7b810-9dad-11d1-80b4-00c04fd430c8] for backend changes
+
+        CC: @[f47ac10b-58cc-4372-a567-0e02b2c3d479]
+      `;
+      const result = extractMentions(text);
+      expect(result).toHaveLength(3);
+    });
+
+    it('should handle comment with single mention', () => {
+      const text =
+        '@[550e8400-e29b-41d4-a716-446655440000] can you take a look at this?';
+      expect(extractMentions(text)).toEqual([
+        '550e8400-e29b-41d4-a716-446655440000',
+      ]);
+    });
+
+    it('should handle markdown-style content', () => {
+      const text = `
+        # Task Title
+
+        Assigned to: @[550e8400-e29b-41d4-a716-446655440000]
+
+        ## Description
+        - [x] Complete task
+        - [ ] Review with @[6ba7b810-9dad-11d1-80b4-00c04fd430c8]
+      `;
+      const result = extractMentions(text);
+      expect(result).toHaveLength(2);
+    });
+  });
+});
+
+describe('NotificationType', () => {
+  it('should have expected notification types', () => {
+    // Type checking test - these should compile without errors
+    const types = [
+      'task_assigned',
+      'task_updated',
+      'task_mention',
+      'workspace_invite',
+    ] as const;
+
+    expect(types).toHaveLength(4);
+  });
+});
+
+describe('NotificationChannel', () => {
+  it('should have expected notification channels', () => {
+    const channels = ['web', 'email', 'sms', 'push'] as const;
+    expect(channels).toHaveLength(4);
+  });
+});

package/src/__tests__/onboarding-helper.test.ts

@@ -0,0 +1,331 @@
+import { describe, expect, it } from 'vitest';
+
+// Re-define constants and types here to avoid importing from the module
+// that has server-side dependencies (@tuturuuu/supabase/next/client)
+const ONBOARDING_STEPS = {
+  WELCOME: 'welcome',
+  WORKSPACE_SETUP: 'workspace_setup',
+  PROFILE_COMPLETION: 'profile_completion',
+  FEATURE_TOUR: 'feature_tour',
+  DASHBOARD_REDIRECT: 'dashboard_redirect',
+} as const;
+
+type OnboardingStep = (typeof ONBOARDING_STEPS)[keyof typeof ONBOARDING_STEPS];
+
+interface OnboardingProgress {
+  user_id: string;
+  completed_steps: string[];
+  current_step: string;
+  workspace_name?: string | null;
+  workspace_description?: string | null;
+  workspace_avatar_url?: string | null;
+  profile_completed: boolean;
+  tour_completed: boolean;
+  completed_at?: string | null;
+  created_at: string;
+  updated_at: string;
+}
+
+interface WhitelistStatus {
+  is_whitelisted: boolean;
+  enabled: boolean;
+  allow_challenge_management: boolean;
+  allow_manage_all_challenges: boolean;
+  allow_role_management: boolean;
+}
+
+interface WorkspaceTemplate {
+  id: string;
+  name: string;
+  description?: string | null;
+  avatar_url?: string | null;
+  is_default: boolean;
+  created_at: string;
+}
+
+describe('ONBOARDING_STEPS', () => {
+  describe('step values', () => {
+    it('should have WELCOME step', () => {
+      expect(ONBOARDING_STEPS.WELCOME).toBe('welcome');
+    });
+
+    it('should have WORKSPACE_SETUP step', () => {
+      expect(ONBOARDING_STEPS.WORKSPACE_SETUP).toBe('workspace_setup');
+    });
+
+    it('should have PROFILE_COMPLETION step', () => {
+      expect(ONBOARDING_STEPS.PROFILE_COMPLETION).toBe('profile_completion');
+    });
+
+    it('should have FEATURE_TOUR step', () => {
+      expect(ONBOARDING_STEPS.FEATURE_TOUR).toBe('feature_tour');
+    });
+
+    it('should have DASHBOARD_REDIRECT step', () => {
+      expect(ONBOARDING_STEPS.DASHBOARD_REDIRECT).toBe('dashboard_redirect');
+    });
+  });
+
+  describe('step count', () => {
+    it('should have exactly 5 steps', () => {
+      const steps = Object.values(ONBOARDING_STEPS);
+      expect(steps).toHaveLength(5);
+    });
+
+    it('should have all unique values', () => {
+      const steps = Object.values(ONBOARDING_STEPS);
+      const uniqueSteps = new Set(steps);
+      expect(uniqueSteps.size).toBe(steps.length);
+    });
+  });
+
+  describe('step keys', () => {
+    it('should have expected keys', () => {
+      const keys = Object.keys(ONBOARDING_STEPS);
+      expect(keys).toContain('WELCOME');
+      expect(keys).toContain('WORKSPACE_SETUP');
+      expect(keys).toContain('PROFILE_COMPLETION');
+      expect(keys).toContain('FEATURE_TOUR');
+      expect(keys).toContain('DASHBOARD_REDIRECT');
+    });
+  });
+
+  describe('step order logic', () => {
+    it('welcome should be the first step (logically)', () => {
+      expect(ONBOARDING_STEPS.WELCOME).toBe('welcome');
+    });
+
+    it('dashboard_redirect should be the last step (logically)', () => {
+      expect(ONBOARDING_STEPS.DASHBOARD_REDIRECT).toBe('dashboard_redirect');
+    });
+  });
+});
+
+describe('OnboardingStep type', () => {
+  it('should accept valid step values', () => {
+    // Type checking tests - these should compile
+    const step1: OnboardingStep = 'welcome';
+    const step2: OnboardingStep = 'workspace_setup';
+    const step3: OnboardingStep = 'profile_completion';
+    const step4: OnboardingStep = 'feature_tour';
+    const step5: OnboardingStep = 'dashboard_redirect';
+
+    expect(step1).toBe('welcome');
+    expect(step2).toBe('workspace_setup');
+    expect(step3).toBe('profile_completion');
+    expect(step4).toBe('feature_tour');
+    expect(step5).toBe('dashboard_redirect');
+  });
+
+  it('should work with ONBOARDING_STEPS values', () => {
+    const step: OnboardingStep = ONBOARDING_STEPS.WELCOME;
+    expect(step).toBe('welcome');
+  });
+});
+
+describe('OnboardingProgress interface', () => {
+  it('should accept valid progress object', () => {
+    const progress: OnboardingProgress = {
+      user_id: 'user-123',
+      completed_steps: ['welcome', 'workspace_setup'],
+      current_step: 'profile_completion',
+      workspace_name: 'My Workspace',
+      workspace_description: 'A test workspace',
+      workspace_avatar_url: 'https://example.com/avatar.png',
+      profile_completed: true,
+      tour_completed: false,
+      completed_at: null,
+      created_at: '2024-01-01T00:00:00Z',
+      updated_at: '2024-01-02T00:00:00Z',
+    };
+
+    expect(progress.user_id).toBe('user-123');
+    expect(progress.completed_steps).toHaveLength(2);
+    expect(progress.current_step).toBe('profile_completion');
+  });
+
+  it('should accept progress with null optional fields', () => {
+    const progress: OnboardingProgress = {
+      user_id: 'user-123',
+      completed_steps: [],
+      current_step: 'welcome',
+      workspace_name: null,
+      workspace_description: null,
+      workspace_avatar_url: null,
+      profile_completed: false,
+      tour_completed: false,
+      completed_at: null,
+      created_at: '2024-01-01T00:00:00Z',
+      updated_at: '2024-01-01T00:00:00Z',
+    };
+
+    expect(progress.workspace_name).toBeNull();
+    expect(progress.completed_at).toBeNull();
+  });
+
+  it('should track completion with completed_at timestamp', () => {
+    const progress: OnboardingProgress = {
+      user_id: 'user-123',
+      completed_steps: Object.values(ONBOARDING_STEPS),
+      current_step: 'dashboard_redirect',
+      profile_completed: true,
+      tour_completed: true,
+      completed_at: '2024-01-15T12:00:00Z',
+      created_at: '2024-01-01T00:00:00Z',
+      updated_at: '2024-01-15T12:00:00Z',
+    };
+
+    expect(progress.completed_at).toBe('2024-01-15T12:00:00Z');
+    expect(progress.completed_steps).toHaveLength(5);
+  });
+});
+
+describe('WhitelistStatus interface', () => {
+  it('should accept valid whitelist status', () => {
+    const status: WhitelistStatus = {
+      is_whitelisted: true,
+      enabled: true,
+      allow_challenge_management: true,
+      allow_manage_all_challenges: false,
+      allow_role_management: true,
+    };
+
+    expect(status.is_whitelisted).toBe(true);
+    expect(status.enabled).toBe(true);
+  });
+
+  it('should represent non-whitelisted user', () => {
+    const status: WhitelistStatus = {
+      is_whitelisted: false,
+      enabled: false,
+      allow_challenge_management: false,
+      allow_manage_all_challenges: false,
+      allow_role_management: false,
+    };
+
+    expect(status.is_whitelisted).toBe(false);
+    expect(status.allow_challenge_management).toBe(false);
+  });
+
+  it('should represent partial permissions', () => {
+    const status: WhitelistStatus = {
+      is_whitelisted: true,
+      enabled: true,
+      allow_challenge_management: true,
+      allow_manage_all_challenges: false,
+      allow_role_management: false,
+    };
+
+    expect(status.is_whitelisted).toBe(true);
+    expect(status.allow_challenge_management).toBe(true);
+    expect(status.allow_manage_all_challenges).toBe(false);
+  });
+});
+
+describe('WorkspaceTemplate interface', () => {
+  it('should accept valid workspace template', () => {
+    const template: WorkspaceTemplate = {
+      id: 'template-123',
+      name: 'Business Template',
+      description: 'A template for business workspaces',
+      avatar_url: 'https://example.com/template.png',
+      is_default: true,
+      created_at: '2024-01-01T00:00:00Z',
+    };
+
+    expect(template.id).toBe('template-123');
+    expect(template.name).toBe('Business Template');
+    expect(template.is_default).toBe(true);
+  });
+
+  it('should accept template with null optional fields', () => {
+    const template: WorkspaceTemplate = {
+      id: 'template-456',
+      name: 'Minimal Template',
+      description: null,
+      avatar_url: null,
+      is_default: false,
+      created_at: '2024-01-01T00:00:00Z',
+    };
+
+    expect(template.description).toBeNull();
+    expect(template.avatar_url).toBeNull();
+  });
+
+  it('should handle default and non-default templates', () => {
+    const defaultTemplate: WorkspaceTemplate = {
+      id: 'default-1',
+      name: 'Default',
+      is_default: true,
+      created_at: '2024-01-01T00:00:00Z',
+    };
+
+    const customTemplate: WorkspaceTemplate = {
+      id: 'custom-1',
+      name: 'Custom',
+      is_default: false,
+      created_at: '2024-01-02T00:00:00Z',
+    };
+
+    expect(defaultTemplate.is_default).toBe(true);
+    expect(customTemplate.is_default).toBe(false);
+  });
+});
+
+describe('Onboarding flow logic', () => {
+  describe('step completion tracking', () => {
+    it('should be able to track incremental step completion', () => {
+      const completedSteps: OnboardingStep[] = [];
+
+      // Simulate completing steps
+      completedSteps.push(ONBOARDING_STEPS.WELCOME);
+      expect(completedSteps).toContain('welcome');
+
+      completedSteps.push(ONBOARDING_STEPS.WORKSPACE_SETUP);
+      expect(completedSteps).toHaveLength(2);
+
+      completedSteps.push(ONBOARDING_STEPS.PROFILE_COMPLETION);
+      completedSteps.push(ONBOARDING_STEPS.FEATURE_TOUR);
+      completedSteps.push(ONBOARDING_STEPS.DASHBOARD_REDIRECT);
+
+      expect(completedSteps).toHaveLength(5);
+    });
+
+    it('should be able to check if all steps are completed', () => {
+      const allSteps = Object.values(ONBOARDING_STEPS);
+      const completedSteps = [...allSteps];
+
+      const isCompleted = allSteps.every((step) =>
+        completedSteps.includes(step)
+      );
+      expect(isCompleted).toBe(true);
+    });
+
+    it('should detect incomplete onboarding', () => {
+      const allSteps = Object.values(ONBOARDING_STEPS);
+      const completedSteps: OnboardingStep[] = [
+        ONBOARDING_STEPS.WELCOME,
+        ONBOARDING_STEPS.WORKSPACE_SETUP,
+      ];
+
+      const isCompleted = allSteps.every((step) =>
+        completedSteps.includes(step)
+      );
+      expect(isCompleted).toBe(false);
+    });
+  });
+
+  describe('step deduplication', () => {
+    it('should handle duplicate step completion attempts', () => {
+      const completedSteps: OnboardingStep[] = [ONBOARDING_STEPS.WELCOME];
+
+      // Simulate adding same step again (should not duplicate)
+      const newStep = ONBOARDING_STEPS.WELCOME;
+      if (!completedSteps.includes(newStep)) {
+        completedSteps.push(newStep);
+      }
+
+      expect(completedSteps).toHaveLength(1);
+    });
+  });
+});

package/src/__tests__/path-helper.test.ts

@@ -0,0 +1,152 @@
+import { describe, expect, it } from 'vitest';
+import { joinPath, popPath } from '../path-helper';
+
+describe('Path Helper', () => {
+  describe('joinPath', () => {
+    it('returns "/" for empty input', () => {
+      expect(joinPath()).toBe('/');
+    });
+
+    it('returns "/" for empty strings', () => {
+      expect(joinPath('', '')).toBe('/');
+    });
+
+    it('joins two simple paths without leading slash', () => {
+      // When first path doesn't start with /, no leading slash is added
+      expect(joinPath('folder', 'subfolder')).toBe('folder/subfolder');
+    });
+
+    it('joins multiple path segments', () => {
+      expect(joinPath('a', 'b', 'c', 'd')).toBe('a/b/c/d');
+    });
+
+    it('handles paths with slashes', () => {
+      expect(joinPath('/folder/', '/subfolder/')).toBe('/folder/subfolder/');
+    });
+
+    it('preserves leading slash for absolute paths', () => {
+      expect(joinPath('/root', 'child')).toBe('/root/child');
+    });
+
+    it('preserves relative path prefix ./', () => {
+      expect(joinPath('./relative', 'path')).toBe('./relative/path');
+    });
+
+    it('preserves trailing slash when present', () => {
+      expect(joinPath('folder', 'subfolder/')).toBe('folder/subfolder/');
+    });
+
+    it('handles mixed slashes with absolute first path', () => {
+      expect(joinPath('/folder/', '/subfolder')).toBe('/folder/subfolder');
+    });
+
+    it('filters out empty segments', () => {
+      expect(joinPath('folder', '', 'subfolder')).toBe('folder/subfolder');
+    });
+
+    it('skips dot segments', () => {
+      expect(joinPath('folder', '.', 'subfolder')).toBe('folder/subfolder');
+    });
+
+    it('handles whitespace in paths', () => {
+      expect(joinPath('  folder  ', '  subfolder  ')).toBe('folder/subfolder');
+    });
+
+    it('handles multiple consecutive slashes in absolute path', () => {
+      expect(joinPath('/folder///', '///subfolder')).toBe('/folder/subfolder');
+    });
+
+    it('handles double slash protocol prefix', () => {
+      expect(joinPath('//server', 'share')).toBe('/server/share');
+    });
+
+    it('handles single segment', () => {
+      expect(joinPath('single')).toBe('single');
+    });
+
+    it('handles single absolute segment', () => {
+      expect(joinPath('/single')).toBe('/single');
+    });
+
+    it('handles path with numbers', () => {
+      expect(joinPath('2024', '01', '15')).toBe('2024/01/15');
+    });
+
+    it('handles absolute path with numbers', () => {
+      expect(joinPath('/2024', '01', '15')).toBe('/2024/01/15');
+    });
+
+    it('handles paths with hyphens and underscores', () => {
+      expect(joinPath('my-folder', 'sub_folder')).toBe('my-folder/sub_folder');
+    });
+
+    it('handles absolute path with special chars', () => {
+      expect(joinPath('/my-folder', 'sub_folder')).toBe(
+        '/my-folder/sub_folder'
+      );
+    });
+  });
+
+  describe('popPath', () => {
+    it('returns "/" for empty input', () => {
+      expect(popPath('')).toBe('/');
+    });
+
+    it('returns "/" for root path', () => {
+      expect(popPath('/')).toBe('/');
+    });
+
+    it('returns "/" for single dot', () => {
+      expect(popPath('.')).toBe('/');
+    });
+
+    it('returns parent directory for simple path', () => {
+      expect(popPath('/folder/subfolder')).toBe('/folder');
+    });
+
+    it('returns "/" for single segment absolute path', () => {
+      expect(popPath('/folder')).toBe('/');
+    });
+
+    it('handles paths with trailing slashes', () => {
+      expect(popPath('/folder/subfolder/')).toBe('/folder');
+    });
+
+    it('handles paths with multiple trailing slashes', () => {
+      expect(popPath('/folder/subfolder///')).toBe('/folder');
+    });
+
+    it('handles relative paths starting with ./', () => {
+      expect(popPath('./folder/subfolder')).toBe('./folder');
+    });
+
+    it('returns "./" prefix for relative path with single segment', () => {
+      expect(popPath('./folder')).toBe('./.');
+    });
+
+    it('handles paths without leading slash', () => {
+      expect(popPath('folder/subfolder')).toBe('/folder');
+    });
+
+    it('handles deep paths', () => {
+      expect(popPath('/a/b/c/d/e')).toBe('/a/b/c/d');
+    });
+
+    it('handles paths with consecutive slashes', () => {
+      expect(popPath('/folder//subfolder')).toBe('/folder');
+    });
+
+    it('handles paths with numbers', () => {
+      expect(popPath('/2024/01/15')).toBe('/2024/01');
+    });
+
+    it('handles whitespace in paths', () => {
+      expect(popPath('  /folder/subfolder  ')).toBe('/folder');
+    });
+
+    it('handles single segment without slash', () => {
+      // Function returns '/base' for non-relative single segment without slash
+      expect(popPath('folder')).toBe('/base');
+    });
+  });
+});