@tuturuuu/utils 0.0.3 → 0.6.0

package/src/email/__tests__/client.test.ts

@@ -0,0 +1,141 @@
+import { describe, expect, it } from 'vitest';
+
+import {
+  formatEmailAddresses,
+  isEmail,
+  isExactTuturuuuDotComEmail,
+  isIncompleteEmail,
+  isValidTuturuuuEmail,
+  suggestEmails,
+} from '../client';
+
+describe('formatEmailAddresses', () => {
+  it('parses name and email from formatted string', () => {
+    const result = formatEmailAddresses('Jane Doe <jane@tuturuuu.com>');
+
+    expect(result).toEqual([
+      {
+        name: 'Jane Doe',
+        email: 'jane@tuturuuu.com',
+        raw: 'Jane Doe <jane@tuturuuu.com>',
+      },
+    ]);
+  });
+
+  it('handles simple email without display name', () => {
+    const result = formatEmailAddresses('user@example.com');
+
+    expect(result).toEqual([
+      {
+        name: '',
+        email: 'user@example.com',
+        raw: 'user@example.com',
+      },
+    ]);
+  });
+
+  it('returns fallback object when value is not an email', () => {
+    const result = formatEmailAddresses('not-an-email');
+
+    expect(result).toEqual([
+      {
+        name: '',
+        email: '',
+        raw: 'not-an-email',
+      },
+    ]);
+  });
+
+  it('filters out non-string values when provided in an array', () => {
+    const result = formatEmailAddresses([
+      'Alice <alice@example.com>',
+      123 as unknown as string,
+    ]);
+
+    expect(result).toEqual([
+      {
+        name: 'Alice',
+        email: 'alice@example.com',
+        raw: 'Alice <alice@example.com>',
+      },
+    ]);
+  });
+
+  it('returns an empty array for falsy input', () => {
+    expect(formatEmailAddresses(undefined)).toEqual([]);
+  });
+});
+
+describe('isValidTuturuuuEmail', () => {
+  it('accepts first-party tuturuuu domains', () => {
+    expect(isValidTuturuuuEmail('member@tuturuuu.com')).toBe(true);
+    expect(isValidTuturuuuEmail('member@xwf.tuturuuu.com')).toBe(true);
+  });
+
+  it('rejects other domains and falsy values', () => {
+    expect(isValidTuturuuuEmail('member@example.com')).toBe(false);
+    expect(isValidTuturuuuEmail('member@sub.tuturuuu.com')).toBe(false);
+    expect(isValidTuturuuuEmail(null)).toBe(false);
+    expect(isValidTuturuuuEmail(undefined)).toBe(false);
+  });
+});
+
+describe('isExactTuturuuuDotComEmail', () => {
+  it('accepts only exact tuturuuu.com accounts', () => {
+    expect(isExactTuturuuuDotComEmail('member@tuturuuu.com')).toBe(true);
+    expect(isExactTuturuuuDotComEmail('MEMBER@TUTURUUU.COM')).toBe(true);
+    expect(isExactTuturuuuDotComEmail('member@xwf.tuturuuu.com')).toBe(false);
+    expect(isExactTuturuuuDotComEmail('member@sub.tuturuuu.com')).toBe(false);
+    expect(isExactTuturuuuDotComEmail('member@example.com')).toBe(false);
+  });
+});
+
+describe('isEmail', () => {
+  it('validates complex email formats', () => {
+    expect(isEmail('user.name+alias@example.co.uk')).toBe(true);
+  });
+
+  it('rejects malformed values', () => {
+    expect(isEmail('missing-at-symbol.com')).toBe(false);
+    expect(isEmail(' user@example.com')).toBe(false);
+  });
+});
+
+describe('isIncompleteEmail', () => {
+  it('detects emails missing domain details', () => {
+    expect(isIncompleteEmail('user@domain')).toBe(true);
+    expect(isIncompleteEmail('user@domain c')).toBe(true);
+  });
+
+  it('rejects complete or invalid starts', () => {
+    expect(isIncompleteEmail('user@domain.com')).toBe(false);
+    expect(isIncompleteEmail('@domain.com')).toBe(false);
+    expect(isIncompleteEmail('')).toBe(false);
+  });
+});
+
+describe('suggestEmails', () => {
+  it('returns provider list when no handle provided', () => {
+    expect(suggestEmails('')).toEqual([
+      '@gmail.com',
+      '@yahoo.com',
+      '@outlook.com',
+      '@tuturuuu.com',
+    ]);
+  });
+
+  it('uses the provided handle when available', () => {
+    expect(suggestEmails('handle')).toEqual([
+      'handle@gmail.com',
+      'handle@yahoo.com',
+      'handle@outlook.com',
+      'handle@tuturuuu.com',
+    ]);
+    expect(suggestEmails('handle@existing.com')).toEqual([
+      'handle@gmail.com',
+      'handle@yahoo.com',
+      'handle@outlook.com',
+      'handle@tuturuuu.com',
+    ]);
+  });
+});

package/src/email/__tests__/validation.test.ts

@@ -0,0 +1,46 @@
+import { describe, expect, it } from 'vitest';
+import {
+  DOMAIN_BLACKLIST_REGEX,
+  EMAIL_BLACKLIST_REGEX,
+  isValidBlacklistDomain,
+  isValidBlacklistEmail,
+} from '../validation';
+
+describe('email blacklist validation utils', () => {
+  describe('isValidBlacklistEmail', () => {
+    it('accepts well-formed email addresses with TLD', () => {
+      expect(isValidBlacklistEmail('user@example.com')).toBe(true);
+      expect(isValidBlacklistEmail('first.last+tag@sub.domain.io')).toBe(true);
+    });
+
+    it('rejects email addresses without TLD', () => {
+      expect(isValidBlacklistEmail('user@example')).toBe(false);
+    });
+
+    it('mirrors EMAIL_BLACKLIST_REGEX', () => {
+      const sample = 'name+alias@sub.domain.com';
+      expect(isValidBlacklistEmail(sample)).toBe(
+        EMAIL_BLACKLIST_REGEX.test(sample)
+      );
+    });
+  });
+
+  describe('isValidBlacklistDomain', () => {
+    it('accepts well-formed domains', () => {
+      expect(isValidBlacklistDomain('example.com')).toBe(true);
+      expect(isValidBlacklistDomain('sub.domain.co')).toBe(true);
+    });
+
+    it('rejects malformed domains', () => {
+      expect(isValidBlacklistDomain('-example.com')).toBe(false);
+      expect(isValidBlacklistDomain('example')).toBe(false);
+    });
+
+    it('mirrors DOMAIN_BLACKLIST_REGEX', () => {
+      const sample = 'valid-domain.org';
+      expect(isValidBlacklistDomain(sample)).toBe(
+        DOMAIN_BLACKLIST_REGEX.test(sample)
+      );
+    });
+  });
+});

package/src/email/client.ts

@@ -0,0 +1,92 @@
+export function formatEmailAddresses(
+  addresses?: string | string[]
+): { name: string; email: string; raw: string }[] {
+  if (!addresses) return [];
+  const arr = Array.isArray(addresses) ? addresses : [addresses];
+  return arr
+    .filter((addr): addr is string => typeof addr === 'string')
+    .map((addr) => {
+      const match = addr.match(
+        /^(.+?)\s*<\s*([\w\-.+]+@[\w\-.]+\.[a-zA-Z]{2,})\s*>$/
+      );
+      if (match) {
+        return { name: match[1] ?? '', email: match[2] ?? '', raw: addr };
+      }
+      // If just an email
+      if (/^[\w\-.+]+@[\w\-.]+\.[a-zA-Z]{2,}$/.test(addr)) {
+        return { name: '', email: addr, raw: addr };
+      }
+      return { name: '', email: '', raw: addr };
+    });
+}
+
+export const isValidTuturuuuEmail = (email?: string | null): boolean => {
+  if (!email) return false;
+  const emailRegex = /^[^\s@]+@(tuturuuu\.com|xwf\.tuturuuu\.com)$/;
+  return emailRegex.test(email);
+};
+
+export const isExactTuturuuuDotComEmail = (email?: string | null): boolean => {
+  if (!email) return false;
+  return /^[^\s@]+@tuturuuu\.com$/i.test(email.trim());
+};
+
+export const isEmail = (text: string): boolean => {
+  const emailRegex =
+    /^(?:[^<>()[\]\\.,;:\s@"]+(?:\.[^<>()[\]\\.,;:\s@"]+)*|".+")@(?:\[[0-9]{1,3}\.[0-9]{1,3}\.[0-9]{1,3}\.[0-9]{1,3}]|(?:[a-zA-Z\-0-9]+\.)+[a-zA-Z]{2,})$/;
+  return emailRegex.test(text);
+};
+
+export const isIncompleteEmail = (text: string): boolean => {
+  if (!text) return false;
+
+  // Find the @ symbol
+  const atIndex = text.indexOf('@');
+  if (atIndex === -1) return false;
+
+  // Split into local and domain parts
+  const localPart = text.slice(0, atIndex);
+  const domainPart = text.slice(atIndex + 1);
+
+  // Return false for cases that are definitely not valid email starts
+  if (!localPart || localPart.endsWith(' ') || text.startsWith('@')) {
+    return false;
+  }
+
+  // Return true if domain part has spaces or is incomplete
+  if (domainPart.includes(' ') || !domainPart.includes('.')) {
+    return true;
+  }
+
+  // Return false if it has a valid domain part
+  if (/^[^.\s]+\.[^.\s]+$/.test(domainPart)) {
+    return false;
+  }
+
+  return true;
+};
+
+export const suggestEmails = (text: string): string[] => {
+  if (!text) {
+    return ['@gmail.com', '@yahoo.com', '@outlook.com', '@tuturuuu.com'];
+  }
+
+  const handle = text.split('@')[0];
+  const suggestions = [
+    `${handle}@gmail.com`,
+    `${handle}@yahoo.com`,
+    `${handle}@outlook.com`,
+    `${handle}@tuturuuu.com`,
+  ];
+
+  return suggestions;
+};
+
+export function generateEmailSubaddressing(email: string, wsId: string) {
+  const atIndex = email.indexOf('@');
+  if (atIndex === -1) return email; // Invalid email, return as is
+
+  const localPart = email.substring(0, atIndex);
+  const domainPart = email.substring(atIndex);
+  return `${localPart}+ws_${wsId}${domainPart}`;
+}

package/src/email/server.ts

@@ -0,0 +1,128 @@
+import { createAdminClient } from '@tuturuuu/supabase/next/server';
+import { hashEmail } from '../abuse-protection';
+
+export const validateEmail = async (email?: string | null) => {
+  if (!email) throw 'Email is required';
+
+  const regex = /\S+@\S+\.\S+/;
+  if (!regex.test(email)) throw 'Email is invalid';
+
+  return email.toLowerCase();
+};
+
+export interface EmailInfrastructureBlockResult {
+  isBlocked: boolean;
+  reason?: string;
+  blockType?: 'blacklist' | 'bounce' | 'complaint';
+}
+
+/**
+ * Check if an email is blocked by infrastructure.
+ * This checks both:
+ * 1. Email blacklist (blocked emails/domains)
+ * 2. Email bounce/complaint history (hard bounces, spam complaints)
+ *
+ * Use this before sending OTP or transactional emails to avoid
+ * sending to known-bad addresses and hurting sender reputation.
+ */
+export const checkEmailInfrastructureBlocked = async (
+  email: string
+): Promise<EmailInfrastructureBlockResult> => {
+  try {
+    const sbAdmin = await createAdminClient();
+    const normalizedEmail = email.toLowerCase();
+    const emailHash = hashEmail(normalizedEmail);
+
+    // Check email blacklist first (direct blocks)
+    const { data: isBlacklisted, error: blacklistError } = await sbAdmin.rpc(
+      'check_email_blocked',
+      { p_email: normalizedEmail }
+    );
+
+    if (blacklistError) {
+      console.error(
+        '[EmailInfrastructureCheck] Blacklist check error:',
+        blacklistError
+      );
+      // Fail open - don't block if we can't check
+    } else if (isBlacklisted) {
+      console.log(
+        `[EmailInfrastructureCheck] Email ${normalizedEmail} is blacklisted`
+      );
+      return {
+        isBlocked: true,
+        reason: 'Email address is blocked',
+        blockType: 'blacklist',
+      };
+    }
+
+    // Check bounce/complaint status
+    const { data: bounceStatus, error: bounceError } = await sbAdmin.rpc(
+      'check_email_bounce_status',
+      { p_email_hash: emailHash }
+    );
+
+    if (bounceError) {
+      console.error(
+        '[EmailInfrastructureCheck] Bounce check error:',
+        bounceError
+      );
+      // Fail open - don't block if we can't check
+    } else if (bounceStatus && bounceStatus.length > 0) {
+      const status = bounceStatus[0];
+      if (status?.is_blocked) {
+        console.log(
+          `[EmailInfrastructureCheck] Email ${normalizedEmail} blocked due to bounces/complaints`
+        );
+        return {
+          isBlocked: true,
+          reason: status.block_reason || 'Email has delivery issues',
+          blockType:
+            status.complaint_count && status.complaint_count > 0
+              ? 'complaint'
+              : 'bounce',
+        };
+      }
+    }
+
+    return { isBlocked: false };
+  } catch (error) {
+    console.error('[EmailInfrastructureCheck] Unexpected error:', error);
+    // Fail open - don't block if we can't check
+    return { isBlocked: false };
+  }
+};
+
+export const validateOtp = async (otp?: string | null) => {
+  if (!otp) throw 'OTP is required';
+
+  const regex = /^\d{6}$/;
+  if (!regex.test(otp)) throw 'OTP is invalid';
+
+  return otp;
+};
+
+export const checkIfUserExists = async ({ email }: { email: string }) => {
+  const sbAdmin = await createAdminClient();
+
+  const { data, error } = await sbAdmin
+    .from('user_private_details')
+    .select('id:user_id')
+    .eq('email', email)
+    .maybeSingle();
+
+  if (error) throw error.message;
+  return data?.id;
+};
+
+export const generateRandomPassword = () => {
+  const length = 16;
+  const charset =
+    'abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789!@#$%^&*()_+~`|}{[]:;?><,./-=';
+
+  let temp = '';
+  for (let i = 0, n = charset.length; i < length; ++i)
+    temp += charset.charAt(Math.floor(Math.random() * n));
+
+  return temp;
+};

package/src/email/validation.ts

@@ -0,0 +1,11 @@
+export const EMAIL_BLACKLIST_REGEX =
+  /^[a-zA-Z0-9._%+-]+@[a-zA-Z0-9](?:[a-zA-Z0-9-]{0,61}[a-zA-Z0-9])?(?:\.[a-zA-Z0-9](?:[a-zA-Z0-9-]{0,61}[a-zA-Z0-9])?)+$/;
+
+export const DOMAIN_BLACKLIST_REGEX =
+  /^(?:[a-zA-Z0-9](?:[a-zA-Z0-9-]{0,61}[a-zA-Z0-9])?\.)+[a-zA-Z]{2,}$/;
+
+export const isValidBlacklistEmail = (value: string): boolean =>
+  EMAIL_BLACKLIST_REGEX.test(value);
+
+export const isValidBlacklistDomain = (value: string): boolean =>
+  DOMAIN_BLACKLIST_REGEX.test(value);