chore: import upstream snapshot with attribution

apps/sim/enrichments/email-verification/email-verification.test.ts

@@ -0,0 +1,59 @@
+/**
+ * @vitest-environment node
+ */
+import { describe, expect, it } from 'vitest'
+import { emailVerificationEnrichment } from '@/enrichments/email-verification/email-verification'
+import type { EnrichmentProvider } from '@/enrichments/types'
+
+function provider(id: string): EnrichmentProvider {
+  const p = emailVerificationEnrichment.providers.find((x) => x.id === id)
+  if (!p) throw new Error(`Provider ${id} not found in email-verification cascade`)
+  return p
+}
+
+const emailInput = { email: '  john@acme.com  ' }
+
+describe('email-verification enrichment cascade', () => {
+  it('chains the hosted verifiers in waterfall order', () => {
+    expect(emailVerificationEnrichment.providers.map((p) => p.id)).toEqual([
+      'zerobounce',
+      'neverbounce',
+      'millionverifier',
+      'enrow',
+    ])
+  })
+
+  describe('zerobounce', () => {
+    const p = provider('zerobounce')
+    it('trims the email and falls through on missing/unknown verdict', () => {
+      expect(p.toolId).toBe('zerobounce_verify_email')
+      expect(p.buildParams(emailInput)).toEqual({ email: 'john@acme.com' })
+      expect(p.buildParams({ email: '' })).toBeNull()
+      expect(p.mapOutput({ status: 'valid', deliverable: true })).toEqual({
+        status: 'valid',
+        deliverable: true,
+      })
+      expect(p.mapOutput({ status: 'unknown', deliverable: false })).toBeNull()
+      expect(p.mapOutput({})).toBeNull()
+    })
+  })
+
+  describe('enrow', () => {
+    const p = provider('enrow')
+    it('maps the valid/invalid qualifier and falls through otherwise', () => {
+      expect(p.toolId).toBe('enrow_verify_email')
+      expect(p.buildParams(emailInput)).toEqual({ email: 'john@acme.com' })
+      expect(p.buildParams({ email: '' })).toBeNull()
+      expect(p.mapOutput({ qualification: 'valid' })).toEqual({
+        status: 'valid',
+        deliverable: true,
+      })
+      expect(p.mapOutput({ qualification: 'invalid' })).toEqual({
+        status: 'invalid',
+        deliverable: false,
+      })
+      expect(p.mapOutput({ qualification: null })).toBeNull()
+      expect(p.mapOutput({})).toBeNull()
+    })
+  })
+})

apps/sim/enrichments/email-verification/email-verification.ts

@@ -0,0 +1,89 @@
+import { ShieldCheck } from '@sim/emcn/icons'
+import { str, toolProvider } from '@/enrichments/providers'
+import type { EnrichmentConfig } from '@/enrichments/types'
+
+/**
+ * Email Verification enrichment. Checks an email address's deliverability via a
+ * verifier waterfall — ZeroBounce first (highest coverage), then NeverBounce,
+ * then MillionVerifier, then Enrow. A provider that returns a
+ * definitive verdict (valid / invalid / catch_all / disposable / etc.) fills the
+ * cell; a provider that can only return `unknown` falls through to the next so
+ * the row gets the most confident answer available. All providers support hosted
+ * keys.
+ */
+export const emailVerificationEnrichment: EnrichmentConfig = {
+  id: 'email-verification',
+  name: 'Email Verification',
+  description: "Check an email address's deliverability and risk status.",
+  icon: ShieldCheck,
+  inputs: [{ id: 'email', name: 'Email', type: 'string', required: true }],
+  outputs: [
+    { id: 'status', name: 'status', type: 'string' },
+    { id: 'deliverable', name: 'deliverable', type: 'boolean' },
+  ],
+  providers: [
+    toolProvider({
+      id: 'zerobounce',
+      label: 'ZeroBounce',
+      toolId: 'zerobounce_verify_email',
+      buildParams: (inputs) => {
+        const email = str(inputs.email)
+        if (!email) return null
+        return { email }
+      },
+      mapOutput: (output) => {
+        const status = str(output.status)
+        // Fall through to the next verifier when the verdict is missing or inconclusive.
+        if (!status || status === 'unknown') return null
+        return { status, deliverable: output.deliverable === true }
+      },
+    }),
+    toolProvider({
+      id: 'neverbounce',
+      label: 'NeverBounce',
+      toolId: 'neverbounce_verify_email',
+      buildParams: (inputs) => {
+        const email = str(inputs.email)
+        if (!email) return null
+        return { email }
+      },
+      mapOutput: (output) => {
+        const status = str(output.status)
+        if (!status || status === 'unknown') return null
+        return { status, deliverable: output.deliverable === true }
+      },
+    }),
+    toolProvider({
+      id: 'millionverifier',
+      label: 'MillionVerifier',
+      toolId: 'millionverifier_verify_email',
+      buildParams: (inputs) => {
+        const email = str(inputs.email)
+        if (!email) return null
+        return { email }
+      },
+      mapOutput: (output) => {
+        const status = str(output.status)
+        if (!status || status === 'unknown') return null
+        return { status, deliverable: output.deliverable === true }
+      },
+    }),
+    toolProvider({
+      id: 'enrow',
+      label: 'Enrow',
+      toolId: 'enrow_verify_email',
+      buildParams: (inputs) => {
+        const email = str(inputs.email)
+        if (!email) return null
+        return { email }
+      },
+      mapOutput: (output) => {
+        // Enrow returns a "valid" / "invalid" qualifier; anything else is inconclusive.
+        const qualification = str(output.qualification).toLowerCase()
+        if (qualification === 'valid') return { status: 'valid', deliverable: true }
+        if (qualification === 'invalid') return { status: 'invalid', deliverable: false }
+        return null
+      },
+    }),
+  ],
+}

apps/sim/enrichments/email-verification/index.ts

@@ -0,0 +1 @@
+export { emailVerificationEnrichment } from './email-verification'