refactor(validation): remove dead validateEmail and checkMXRecord

Server-side disposable email blocking is now handled by
better-auth-harmony. The async validateEmail (with MX check) had no
remaining callers. Only quickValidateEmail remains for client-side
form feedback.

Co-Authored-By: Claude Sonnet 4.6 <noreply@anthropic.com>

Author: waleedlatif1

apps/sim/lib/messaging/email/validation.test.ts

@@ -1,228 +1,147 @@
-import { loggerMock } from '@sim/testing'
-import { describe, expect, it, vi } from 'vitest'
-import { quickValidateEmail, validateEmail } from '@/lib/messaging/email/validation'
-
-vi.mock('@sim/logger', () => loggerMock)
-
-vi.mock('dns', () => ({
-  resolveMx: (
-    _domain: string,
-    callback: (err: Error | null, addresses: { exchange: string; priority: number }[]) => void
-  ) => {
-    callback(null, [{ exchange: 'mail.example.com', priority: 10 }])
-  },
-}))
-
-describe('Email Validation', () => {
-  describe('validateEmail', () => {
-    it.concurrent('should validate a correct email', async () => {
-      const result = await validateEmail('user@example.com')
-      expect(result.isValid).toBe(true)
-      expect(result.checks.syntax).toBe(true)
-      expect(result.checks.disposable).toBe(true)
-    })
+import { describe, expect, it } from 'vitest'
+import { quickValidateEmail } from '@/lib/messaging/email/validation'
+
+describe('quickValidateEmail', () => {
+  it.concurrent('should validate a correct email', () => {
+    const result = quickValidateEmail('user@example.com')
+    expect(result.isValid).toBe(true)
+    expect(result.checks.syntax).toBe(true)
+    expect(result.checks.disposable).toBe(true)
+    expect(result.checks.mxRecord).toBe(true)
+    expect(result.confidence).toBe('medium')
+  })
 
-    it.concurrent('should reject invalid syntax', async () => {
-      const result = await validateEmail('invalid-email')
-      expect(result.isValid).toBe(false)
-      expect(result.reason).toBe('Invalid email format')
-      expect(result.checks.syntax).toBe(false)
-    })
+  it.concurrent('should reject invalid syntax', () => {
+    const result = quickValidateEmail('invalid-email')
+    expect(result.isValid).toBe(false)
+    expect(result.reason).toBe('Invalid email format')
+  })
 
-    it.concurrent('should reject disposable email addresses', async () => {
-      const result = await validateEmail('test@10minutemail.com')
+  it.concurrent('should reject disposable email addresses', () => {
+    const disposableDomains = [
+      'mailinator.com',
+      'yopmail.com',
+      'guerrillamail.com',
+      'temp-mail.org',
+      'throwaway.email',
+      'getnada.com',
+      'sharklasers.com',
+      'spam4.me',
+      'sharebot.net',
+      'oakon.com',
+      'catchmail.io',
+      'salt.email',
+      'mail.gw',
+      'tempmail.org',
+    ]
+
+    for (const domain of disposableDomains) {
+      const result = quickValidateEmail(`test@${domain}`)
       expect(result.isValid).toBe(false)
       expect(result.reason).toBe('Disposable email addresses are not allowed')
       expect(result.checks.disposable).toBe(false)
-    })
+    }
+  })
 
-    it.concurrent('should reject consecutive dots (RFC violation)', async () => {
-      const result = await validateEmail('user..name@example.com')
-      expect(result.isValid).toBe(false)
-      expect(result.reason).toBe('Email contains suspicious patterns')
-    })
+  it.concurrent('should reject consecutive dots (RFC violation)', () => {
+    const result = quickValidateEmail('user..name@example.com')
+    expect(result.isValid).toBe(false)
+    expect(result.reason).toBe('Email contains suspicious patterns')
+    expect(result.confidence).toBe('medium')
+  })
 
-    it.concurrent('should reject very long local parts (RFC violation)', async () => {
-      const longLocalPart = 'a'.repeat(65)
-      const result = await validateEmail(`${longLocalPart}@example.com`)
-      expect(result.isValid).toBe(false)
-      expect(result.reason).toBe('Email contains suspicious patterns')
-    })
+  it.concurrent('should reject very long local parts (RFC violation)', () => {
+    const longLocalPart = 'a'.repeat(65)
+    const result = quickValidateEmail(`${longLocalPart}@example.com`)
+    expect(result.isValid).toBe(false)
+    expect(result.reason).toBe('Email contains suspicious patterns')
+  })
 
-    it.concurrent('should reject email with missing domain', async () => {
-      const result = await validateEmail('user@')
-      expect(result.isValid).toBe(false)
-      expect(result.reason).toBe('Invalid email format')
-    })
+  it.concurrent('should reject email with missing domain', () => {
+    const result = quickValidateEmail('user@')
+    expect(result.isValid).toBe(false)
+    expect(result.reason).toBe('Invalid email format')
+  })
 
-    it.concurrent('should reject email with domain starting with dot', async () => {
-      const result = await validateEmail('user@.example.com')
-      expect(result.isValid).toBe(false)
-      expect(result.reason).toBe('Invalid email format')
-    })
+  it.concurrent('should reject email with domain starting with dot', () => {
+    const result = quickValidateEmail('user@.example.com')
+    expect(result.isValid).toBe(false)
+    expect(result.reason).toBe('Invalid email format')
+  })
 
-    it.concurrent('should reject email with domain ending with dot', async () => {
-      const result = await validateEmail('user@example.')
-      expect(result.isValid).toBe(false)
-      expect(result.reason).toBe('Invalid email format')
-    })
+  it.concurrent('should reject email with domain ending with dot', () => {
+    const result = quickValidateEmail('user@example.')
+    expect(result.isValid).toBe(false)
+    expect(result.reason).toBe('Invalid email format')
+  })
 
-    it.concurrent('should reject email with domain missing TLD', async () => {
-      const result = await validateEmail('user@localhost')
-      expect(result.isValid).toBe(false)
-      expect(result.reason).toBe('Invalid domain format')
-    })
+  it.concurrent('should reject email with domain missing TLD', () => {
+    const result = quickValidateEmail('user@localhost')
+    expect(result.isValid).toBe(false)
+    expect(result.reason).toBe('Invalid domain format')
+  })
 
-    it.concurrent('should reject email longer than 254 characters', async () => {
-      const longLocal = 'a'.repeat(64)
-      const longDomain = `${'b'.repeat(180)}.com`
-      const result = await validateEmail(`${longLocal}@${longDomain}`)
-      expect(result.isValid).toBe(false)
-    })
-
-    it.concurrent('should validate various known disposable email domains', async () => {
-      const disposableDomains = [
-        'mailinator.com',
-        'yopmail.com',
-        'guerrillamail.com',
-        'temp-mail.org',
-        'throwaway.email',
-        'getnada.com',
-        'sharklasers.com',
-        'spam4.me',
-        'sharebot.net',
-        'oakon.com',
-        'catchmail.io',
-        'salt.email',
-        'mail.gw',
-      ]
-
-      for (const domain of disposableDomains) {
-        const result = await validateEmail(`test@${domain}`)
-        expect(result.isValid).toBe(false)
-        expect(result.reason).toBe('Disposable email addresses are not allowed')
-        expect(result.checks.disposable).toBe(false)
-      }
-    })
-
-    it.concurrent('should accept valid email formats', async () => {
-      const validEmails = [
-        'simple@example.com',
-        'very.common@example.com',
-        'disposable.style.email.with+symbol@example.com',
-        'other.email-with-hyphen@example.com',
-        'fully-qualified-domain@example.com',
-        'user.name+tag+sorting@example.com',
-        'x@example.com',
-        'example-indeed@strange-example.com',
-        'example@s.example',
-      ]
-
-      for (const email of validEmails) {
-        const result = await validateEmail(email)
-        expect(result.checks.syntax).toBe(true)
-        expect(result.checks.disposable).toBe(true)
-      }
-    })
-
-    it.concurrent('should return high confidence for syntax failures', async () => {
-      const result = await validateEmail('not-an-email')
-      expect(result.confidence).toBe('high')
-    })
-
-    it.concurrent('should handle email with special characters in local part', async () => {
-      const result = await validateEmail("user!#$%&'*+/=?^_`{|}~@example.com")
-      expect(result.checks.syntax).toBe(true)
-    })
+  it.concurrent('should reject email longer than 254 characters', () => {
+    const longLocal = 'a'.repeat(64)
+    const longDomain = `${'b'.repeat(180)}.com`
+    const result = quickValidateEmail(`${longLocal}@${longDomain}`)
+    expect(result.isValid).toBe(false)
   })
 
-  describe('quickValidateEmail', () => {
-    it.concurrent('should validate quickly without MX check', () => {
-      const result = quickValidateEmail('user@example.com')
+  it.concurrent('should accept valid email formats', () => {
+    const validEmails = [
+      'simple@example.com',
+      'very.common@example.com',
+      'disposable.style.email.with+symbol@example.com',
+      'other.email-with-hyphen@example.com',
+      'user.name+tag+sorting@example.com',
+      'x@example.com',
+      'example-indeed@strange-example.com',
+      'example@s.example',
+    ]
+
+    for (const email of validEmails) {
+      const result = quickValidateEmail(email)
       expect(result.isValid).toBe(true)
-      expect(result.checks.mxRecord).toBe(true)
-      expect(result.confidence).toBe('medium')
-    })
-
-    it.concurrent('should reject invalid emails quickly', () => {
-      const result = quickValidateEmail('invalid-email')
-      expect(result.isValid).toBe(false)
-      expect(result.reason).toBe('Invalid email format')
-    })
-
-    it.concurrent('should reject disposable emails quickly', () => {
-      const result = quickValidateEmail('test@tempmail.org')
-      expect(result.isValid).toBe(false)
-      expect(result.reason).toBe('Disposable email addresses are not allowed')
-    })
-
-    it.concurrent('should reject email with missing domain', () => {
-      const result = quickValidateEmail('user@')
-      expect(result.isValid).toBe(false)
-      expect(result.reason).toBe('Invalid email format')
-    })
-
-    it.concurrent('should reject email with invalid domain format', () => {
-      const result = quickValidateEmail('user@.invalid')
-      expect(result.isValid).toBe(false)
-      expect(result.reason).toBe('Invalid email format')
-    })
-
-    it.concurrent('should return medium confidence for suspicious patterns', () => {
-      const result = quickValidateEmail('user..double@example.com')
-      expect(result.isValid).toBe(false)
-      expect(result.reason).toBe('Email contains suspicious patterns')
-      expect(result.confidence).toBe('medium')
-    })
+      expect(result.checks.syntax).toBe(true)
+      expect(result.checks.disposable).toBe(true)
+    }
+  })
 
-    it.concurrent('should return high confidence for syntax errors', () => {
-      const result = quickValidateEmail('not-valid-email')
-      expect(result.confidence).toBe('high')
-    })
+  it.concurrent('should return high confidence for syntax errors', () => {
+    const result = quickValidateEmail('not-valid-email')
+    expect(result.confidence).toBe('high')
+  })
 
-    it.concurrent('should handle empty string', () => {
-      const result = quickValidateEmail('')
-      expect(result.isValid).toBe(false)
-      expect(result.reason).toBe('Invalid email format')
-    })
+  it.concurrent('should handle special characters in local part', () => {
+    const result = quickValidateEmail("user!#$%&'*+/=?^_`{|}~@example.com")
+    expect(result.checks.syntax).toBe(true)
+  })
 
-    it.concurrent('should handle email with only @ symbol', () => {
-      const result = quickValidateEmail('@')
-      expect(result.isValid).toBe(false)
-      expect(result.reason).toBe('Invalid email format')
-    })
+  it.concurrent('should handle empty string', () => {
+    const result = quickValidateEmail('')
+    expect(result.isValid).toBe(false)
+    expect(result.reason).toBe('Invalid email format')
+  })
 
-    it.concurrent('should handle email with spaces', () => {
-      const result = quickValidateEmail('user name@example.com')
-      expect(result.isValid).toBe(false)
-      expect(result.reason).toBe('Invalid email format')
-    })
+  it.concurrent('should handle email with only @ symbol', () => {
+    const result = quickValidateEmail('@')
+    expect(result.isValid).toBe(false)
+  })
 
-    it.concurrent('should handle email with multiple @ symbols', () => {
-      const result = quickValidateEmail('user@domain@example.com')
-      expect(result.isValid).toBe(false)
-      expect(result.reason).toBe('Invalid email format')
-    })
+  it.concurrent('should handle email with spaces', () => {
+    const result = quickValidateEmail('user name@example.com')
+    expect(result.isValid).toBe(false)
+  })
 
-    it.concurrent('should validate complex but valid local parts', () => {
-      const result = quickValidateEmail('user+tag@example.com')
-      expect(result.isValid).toBe(true)
-      expect(result.checks.syntax).toBe(true)
-    })
+  it.concurrent('should handle email with multiple @ symbols', () => {
+    const result = quickValidateEmail('user@domain@example.com')
+    expect(result.isValid).toBe(false)
+  })
 
-    it.concurrent('should validate subdomains', () => {
-      const result = quickValidateEmail('user@mail.subdomain.example.com')
-      expect(result.isValid).toBe(true)
-      expect(result.checks.domain).toBe(true)
-    })
-
-    it.concurrent('should reject spam domains from the inline blocklist', () => {
-      const spamDomains = ['sharebot.net', 'oakon.com', 'catchmail.io', 'salt.email', 'mail.gw']
-      for (const domain of spamDomains) {
-        const result = quickValidateEmail(`user@${domain}`)
-        expect(result.isValid).toBe(false)
-        expect(result.reason).toBe('Disposable email addresses are not allowed')
-      }
-    })
+  it.concurrent('should validate subdomains', () => {
+    const result = quickValidateEmail('user@mail.subdomain.example.com')
+    expect(result.isValid).toBe(true)
+    expect(result.checks.domain).toBe(true)
   })
 })