@bernierllc/email-domain-verification 1.0.3 → 1.0.6

package/CHANGELOG.md

@@ -1,5 +1,42 @@
+# Change Log
+
+All notable changes to this project will be documented in this file.
+See [Conventional Commits](https://conventionalcommits.org) for commit guidelines.
+
+## 1.0.6 (2025-12-25)
+
+
+### Bug Fixes
+
+* **ci:** add lerna version step before publish ([3d20300](https://github.com/bernierllc/tools/commit/3d203002143bf353fffafe4f8a78a99009567347))
+* **ci:** fix release workflow + convert internal deps to workspace:* ([01c078b](https://github.com/bernierllc/tools/commit/01c078b49d6025f7eef750f79207a1c71c8d85dc))
+* update neverhub-adapter deps to workspace:* and publish 0.1.2 ([f0e3d04](https://github.com/bernierllc/tools/commit/f0e3d04d8d4f094e3bb899ddf81e93243d16e2c2))
+
+
+
+
+
+## 1.0.5 (2025-12-25)
+
+
+### Bug Fixes
+
+* **ci:** fix release workflow + convert internal deps to workspace:* ([01c078b](https://github.com/bernierllc/tools/commit/01c078b49d6025f7eef750f79207a1c71c8d85dc))
+* update neverhub-adapter deps to workspace:* and publish 0.1.2 ([f0e3d04](https://github.com/bernierllc/tools/commit/f0e3d04d8d4f094e3bb899ddf81e93243d16e2c2))
+
+
+
+
+
 # @bernierllc/email-domain-verification
 
+## 1.0.4
+
+### Patch Changes
+
+- Updated dependencies [[`73c1d1e`](https://github.com/bernierllc/tools/commit/73c1d1e46114cf2ccfd5b74b83743361247f4502)]:
+  - @bernierllc/logger@1.1.0
+
 ## 1.0.3
 
 ### Patch Changes

package/__tests__/coverage-gaps.test.ts

@@ -0,0 +1,566 @@
+/*
+Copyright (c) 2025 Bernier LLC
+
+This file is licensed to the client under a limited-use license.
+The client may use and modify this code *only within the scope of the project it was delivered for*.
+Redistribution or use in other products or commercial offerings is not permitted without written consent from Bernier LLC.
+*/
+
+import { EmailDomainVerificationService } from '../src/EmailDomainVerificationService';
+import {
+  DomainVerificationError,
+  DNSPropagationError,
+  ProviderAPIError,
+  InvalidDomainError,
+  successResult,
+  errorResult,
+} from '../src/errors';
+
+// Create mock logger directly
+const createMockLogger = () => ({
+  debug: jest.fn(),
+  info: jest.fn(),
+  warn: jest.fn(),
+  error: jest.fn(),
+  fatal: jest.fn()
+});
+
+// Mock external dependencies
+jest.mock('dns2', () => ({
+  Resolver: jest.fn().mockImplementation(() => ({
+    resolve: jest.fn().mockResolvedValue({
+      answers: [
+        { type: 'TXT', data: 'v=spf1 include:sendgrid.net -all' },
+        { ns: '8.8.8.8' }
+      ]
+    })
+  }))
+}));
+
+jest.mock('axios', () => ({
+  create: jest.fn(() => ({
+    post: jest.fn().mockResolvedValue({
+      data: {
+        id: 'domain-123',
+        dns: [],
+        domain: {
+          name: 'example.com',
+          state: 'active'
+        },
+        receiving_dns_records: [],
+        sending_dns_records: []
+      }
+    }),
+    get: jest.fn().mockResolvedValue({
+      data: [{
+        domain: 'example.com',
+        id: 'domain-123'
+      }]
+    })
+  }))
+}));
+
+jest.mock('cron', () => ({
+  CronJob: jest.fn().mockImplementation((_schedule: string, callback: () => void) => {
+    const job = {
+      start: jest.fn(),
+      stop: jest.fn(),
+      callback
+    };
+    return job;
+  })
+}));
+
+describe('Coverage Gap Tests - EmailDomainVerificationService', () => {
+  let service: EmailDomainVerificationService;
+  let logger: ReturnType<typeof createMockLogger>;
+
+  beforeEach(() => {
+    logger = createMockLogger();
+    service = new EmailDomainVerificationService({ logger: logger as any });
+  });
+
+  afterEach(async () => {
+    await service.shutdown();
+    jest.clearAllMocks();
+  });
+
+  describe('Initialize method', () => {
+    it('should initialize the service', async () => {
+      await service.initialize();
+      expect(logger.info).toHaveBeenCalledWith(
+        'Email Domain Verification Service initialized',
+        expect.any(Object)
+      );
+    });
+  });
+
+  describe('SPF Record Generation - provider variations', () => {
+    it('should generate SPF record for mailgun provider', async () => {
+      const result = await service.setupDomain({
+        domain: 'example.com',
+        provider: 'mailgun',
+        providerCredentials: { apiKey: 'test-key' },
+        dkim: { enabled: false },
+        spf: { enabled: true, strict: true },
+        dmarc: { enabled: false }
+      });
+
+      expect(result.success).toBe(true);
+      const spfRecord = result.dnsRecords.find(r => r.type === 'SPF');
+      expect(spfRecord?.value).toContain('include:mailgun.org');
+    });
+
+    it('should generate SPF record for SES provider', async () => {
+      const result = await service.setupDomain({
+        domain: 'example.com',
+        provider: 'ses',
+        providerCredentials: { apiKey: 'test-key' },
+        dkim: { enabled: false },
+        spf: { enabled: true, strict: true },
+        dmarc: { enabled: false }
+      });
+
+      expect(result.success).toBe(true);
+      const spfRecord = result.dnsRecords.find(r => r.type === 'SPF');
+      expect(spfRecord?.value).toContain('include:amazonses.com');
+    });
+
+    it('should generate SPF with custom includes', async () => {
+      const result = await service.setupDomain({
+        domain: 'example.com',
+        provider: 'sendgrid',
+        providerCredentials: { apiKey: 'test-key' },
+        dkim: { enabled: false },
+        spf: { 
+          enabled: true, 
+          strict: true,
+          includes: ['include:custom.com']
+        },
+        dmarc: { enabled: false }
+      });
+
+      expect(result.success).toBe(true);
+      const spfRecord = result.dnsRecords.find(r => r.type === 'SPF');
+      expect(spfRecord?.value).toContain('include:custom.com');
+    });
+
+    it('should generate SPF with IPv4 addresses', async () => {
+      const result = await service.setupDomain({
+        domain: 'example.com',
+        provider: 'sendgrid',
+        providerCredentials: { apiKey: 'test-key' },
+        dkim: { enabled: false },
+        spf: { 
+          enabled: true, 
+          strict: true,
+          ipv4Addresses: ['192.168.1.1', '10.0.0.1']
+        },
+        dmarc: { enabled: false }
+      });
+
+      expect(result.success).toBe(true);
+      const spfRecord = result.dnsRecords.find(r => r.type === 'SPF');
+      expect(spfRecord?.value).toContain('ip4:192.168.1.1');
+      expect(spfRecord?.value).toContain('ip4:10.0.0.1');
+    });
+
+    it('should generate SPF with IPv6 addresses', async () => {
+      const result = await service.setupDomain({
+        domain: 'example.com',
+        provider: 'sendgrid',
+        providerCredentials: { apiKey: 'test-key' },
+        dkim: { enabled: false },
+        spf: { 
+          enabled: true, 
+          strict: true,
+          ipv6Addresses: ['2001:db8::1']
+        },
+        dmarc: { enabled: false }
+      });
+
+      expect(result.success).toBe(true);
+      const spfRecord = result.dnsRecords.find(r => r.type === 'SPF');
+      expect(spfRecord?.value).toContain('ip6:2001:db8::1');
+    });
+
+    it('should generate SPF with non-strict mode (~all)', async () => {
+      const result = await service.setupDomain({
+        domain: 'example.com',
+        provider: 'sendgrid',
+        providerCredentials: { apiKey: 'test-key' },
+        dkim: { enabled: false },
+        spf: { enabled: true, strict: false },
+        dmarc: { enabled: false }
+      });
+
+      expect(result.success).toBe(true);
+      const spfRecord = result.dnsRecords.find(r => r.type === 'SPF');
+      expect(spfRecord?.value).toContain('~all');
+    });
+  });
+
+  describe('DMARC Record Generation - variations', () => {
+    it('should generate DMARC with aggregateEmail', async () => {
+      const result = await service.setupDomain({
+        domain: 'example.com',
+        provider: 'sendgrid',
+        providerCredentials: { apiKey: 'test-key' },
+        dkim: { enabled: false },
+        spf: { enabled: false },
+        dmarc: { 
+          enabled: true,
+          policy: 'quarantine',
+          aggregateEmail: 'forensic@example.com'
+        }
+      });
+
+      expect(result.success).toBe(true);
+      const dmarcRecord = result.dnsRecords.find(r => r.type === 'DMARC');
+      expect(dmarcRecord?.value).toContain('ruf=mailto:forensic@example.com');
+    });
+
+    it('should generate DMARC with reportEmail', async () => {
+      const result = await service.setupDomain({
+        domain: 'example.com',
+        provider: 'sendgrid',
+        providerCredentials: { apiKey: 'test-key' },
+        dkim: { enabled: false },
+        spf: { enabled: false },
+        dmarc: { 
+          enabled: true,
+          policy: 'reject',
+          reportEmail: 'dmarc@example.com'
+        }
+      });
+
+      expect(result.success).toBe(true);
+      const dmarcRecord = result.dnsRecords.find(r => r.type === 'DMARC');
+      expect(dmarcRecord?.value).toContain('rua=mailto:dmarc@example.com');
+    });
+
+    it('should generate DMARC with all options', async () => {
+      const result = await service.setupDomain({
+        domain: 'example.com',
+        provider: 'sendgrid',
+        providerCredentials: { apiKey: 'test-key' },
+        dkim: { enabled: false },
+        spf: { enabled: false },
+        dmarc: { 
+          enabled: true,
+          policy: 'reject',
+          percentage: 50,
+          subdomain: 'quarantine',
+          reportEmail: 'dmarc@example.com',
+          aggregateEmail: 'forensic@example.com'
+        }
+      });
+
+      expect(result.success).toBe(true);
+      const dmarcRecord = result.dnsRecords.find(r => r.type === 'DMARC');
+      expect(dmarcRecord?.value).toContain('p=reject');
+      expect(dmarcRecord?.value).toContain('pct=50');
+      expect(dmarcRecord?.value).toContain('sp=quarantine');
+      expect(dmarcRecord?.value).toContain('rua=');
+      expect(dmarcRecord?.value).toContain('ruf=');
+    });
+  });
+
+  describe('Provider-specific records', () => {
+    it('should generate records for postmark provider (default case)', async () => {
+      const result = await service.setupDomain({
+        domain: 'example.com',
+        provider: 'postmark' as any,
+        providerCredentials: { apiKey: 'test-key' },
+        dkim: { enabled: false },
+        spf: { enabled: true, strict: true },
+        dmarc: { enabled: false }
+      });
+
+      expect(result.success).toBe(true);
+    });
+  });
+
+  describe('Error Handling', () => {
+    it('should handle verifyDomain error catch block', async () => {
+      // Create a service that will throw during verification
+      const errorService = new EmailDomainVerificationService({ logger: logger as any });
+      
+      // Mock the verifyWithProvider to throw
+      (errorService as any).verifyWithProvider = jest.fn().mockRejectedValue(
+        new Error('Provider API failed')
+      );
+
+      const result = await errorService.verifyDomain('example.com', 'sendgrid', { apiKey: 'key' });
+
+      expect(result.success).toBe(false);
+      expect(result.errors).toContain('Provider API failed');
+      expect(logger.error).toHaveBeenCalled();
+
+      await errorService.shutdown();
+    });
+
+    it('should handle verifyDomain with non-Error exception', async () => {
+      const errorService = new EmailDomainVerificationService({ logger: logger as any });
+      
+      // Mock to throw non-Error
+      (errorService as any).verifyWithProvider = jest.fn().mockRejectedValue('String error');
+
+      const result = await errorService.verifyDomain('example.com', 'sendgrid', { apiKey: 'key' });
+
+      expect(result.success).toBe(false);
+      expect(result.errors).toContain('Unknown error');
+
+      await errorService.shutdown();
+    });
+
+    it('should handle setupDomain with invalid domain', async () => {
+      const result = await service.setupDomain({
+        domain: '', // Invalid empty domain
+        provider: 'sendgrid',
+        providerCredentials: { apiKey: 'test-key' },
+        dkim: { enabled: false },
+        spf: { enabled: true },
+        dmarc: { enabled: false }
+      });
+
+      expect(result.success).toBe(false);
+      expect(result.errors).toBeDefined();
+    });
+  });
+
+  describe('DNS Propagation', () => {
+    it('should check propagation for DNS records', async () => {
+      const records = [
+        {
+          type: 'SPF' as const,
+          host: 'example.com',
+          value: 'v=spf1 include:sendgrid.net -all',
+          ttl: 3600,
+          provider: 'sendgrid' as const,
+          required: true,
+          instructions: 'Add this TXT record to your domain'
+        }
+      ];
+
+      const results = await service.checkPropagation('example.com', records);
+
+      expect(Array.isArray(results)).toBe(true);
+      expect(results.length).toBe(1);
+    });
+  });
+
+  describe('Domain Health', () => {
+    it('should get domain health status', async () => {
+      const health = await service.getDomainHealth('example.com');
+
+      expect(health.domain).toBe('example.com');
+      expect(health).toHaveProperty('healthy');
+      expect(health).toHaveProperty('lastChecked');
+    });
+  });
+
+  describe('Verification History', () => {
+    it('should return empty history for new domain', () => {
+      const history = service.getVerificationHistory('newdomain.com');
+      expect(Array.isArray(history)).toBe(true);
+    });
+
+    it('should return history after domain setup', async () => {
+      await service.setupDomain({
+        domain: 'test-history.com',
+        provider: 'sendgrid',
+        providerCredentials: { apiKey: 'test-key' },
+        dkim: { enabled: false },
+        spf: { enabled: true },
+        dmarc: { enabled: false }
+      });
+
+      const history = service.getVerificationHistory('test-history.com');
+      expect(history.length).toBeGreaterThan(0);
+    });
+
+    it('should respect limit parameter', async () => {
+      await service.setupDomain({
+        domain: 'test-limit.com',
+        provider: 'sendgrid',
+        providerCredentials: { apiKey: 'test-key' },
+        dkim: { enabled: false },
+        spf: { enabled: true },
+        dmarc: { enabled: false }
+      });
+
+      const history = service.getVerificationHistory('test-limit.com', 1);
+      expect(history.length).toBeLessThanOrEqual(1);
+    });
+  });
+
+  describe('Health Monitoring', () => {
+    it('should start and stop health monitoring', async () => {
+      // First verify a domain to start monitoring
+      const verifyService = new EmailDomainVerificationService({ logger: logger as any });
+      
+      // Mock successful verification
+      (verifyService as any).verifyWithProvider = jest.fn().mockResolvedValue({
+        verified: true,
+        message: 'Domain verified'
+      });
+
+      await verifyService.verifyDomain('test.com', 'sendgrid', { apiKey: 'key' });
+
+      // Stop monitoring explicitly
+      verifyService.stopHealthMonitoring('test.com');
+      
+      expect(logger.info).toHaveBeenCalledWith('Health monitoring stopped', { domain: 'test.com' });
+
+      await verifyService.shutdown();
+    });
+
+    it('should handle stopping monitoring for non-existent domain', () => {
+      // Should not throw when stopping non-existent domain
+      expect(() => service.stopHealthMonitoring('nonexistent.com')).not.toThrow();
+    });
+  });
+
+  describe('Domain Verification', () => {
+    it('should verify domain with sendgrid provider', async () => {
+      const result = await service.verifyDomain('example.com', 'sendgrid', { apiKey: 'test-key' });
+      
+      // The mock returns valid: undefined which maps to not verified
+      expect(result).toHaveProperty('success');
+      expect(result).toHaveProperty('domain', 'example.com');
+    });
+
+    it('should verify domain with mailgun provider', async () => {
+      const result = await service.verifyDomain('example.com', 'mailgun', { apiKey: 'test-key' });
+      
+      expect(result).toHaveProperty('success');
+      expect(result).toHaveProperty('domain', 'example.com');
+    });
+
+    it('should verify domain with SES provider', async () => {
+      const result = await service.verifyDomain('example.com', 'ses', { apiKey: 'test-key' });
+      
+      expect(result.success).toBe(false); // SES returns not implemented
+      expect(result.domain).toBe('example.com');
+    });
+
+    it('should handle verified domain status correctly', async () => {
+      const verifyService = new EmailDomainVerificationService({ logger: logger as any });
+      
+      // Mock successful verification
+      (verifyService as any).verifyWithProvider = jest.fn().mockResolvedValue({
+        verified: true,
+        message: 'Domain verified successfully'
+      });
+
+      const result = await verifyService.verifyDomain('verified.com', 'sendgrid', { apiKey: 'key' });
+
+      expect(result.success).toBe(true);
+      expect(result.status).toBe('verified');
+      
+      await verifyService.shutdown();
+    });
+
+    it('should handle failed domain verification', async () => {
+      const verifyService = new EmailDomainVerificationService({ logger: logger as any });
+      
+      // Mock failed verification
+      (verifyService as any).verifyWithProvider = jest.fn().mockResolvedValue({
+        verified: false,
+        message: 'DNS records not found'
+      });
+
+      const result = await verifyService.verifyDomain('failed.com', 'sendgrid', { apiKey: 'key' });
+
+      expect(result.success).toBe(false);
+      expect(result.status).toBe('failed');
+      expect(result.errors).toBeDefined();
+      
+      await verifyService.shutdown();
+    });
+
+    it('should handle unsupported provider in verification', async () => {
+      const verifyService = new EmailDomainVerificationService({ logger: logger as any });
+      
+      const result = await verifyService.verifyDomain('example.com', 'unknown' as any, { apiKey: 'key' });
+
+      expect(result.success).toBe(false);
+      
+      await verifyService.shutdown();
+    });
+  });
+});
+
+describe('Error Classes', () => {
+  describe('DomainVerificationError', () => {
+    it('should create error with all properties', () => {
+      const error = new DomainVerificationError('Test error', 'TEST_CODE', true, { key: 'value' });
+      
+      expect(error.message).toBe('Test error');
+      expect(error.code).toBe('TEST_CODE');
+      expect(error.retryable).toBe(true);
+      expect(error.details).toEqual({ key: 'value' });
+      expect(error.name).toBe('DomainVerificationError');
+    });
+
+    it('should default retryable to false', () => {
+      const error = new DomainVerificationError('Test error', 'TEST_CODE');
+      expect(error.retryable).toBe(false);
+    });
+  });
+
+  describe('DNSPropagationError', () => {
+    it('should create with correct code and retryable flag', () => {
+      const error = new DNSPropagationError('DNS not propagated', { domain: 'test.com' });
+      
+      expect(error.code).toBe('DNS_PROPAGATION_ERROR');
+      expect(error.retryable).toBe(true);
+      expect(error.name).toBe('DNSPropagationError');
+      expect(error.details).toEqual({ domain: 'test.com' });
+    });
+  });
+
+  describe('ProviderAPIError', () => {
+    it('should create with correct code and retryable flag', () => {
+      const error = new ProviderAPIError('API failed', { status: 500 });
+      
+      expect(error.code).toBe('PROVIDER_API_ERROR');
+      expect(error.retryable).toBe(true);
+      expect(error.name).toBe('ProviderAPIError');
+    });
+  });
+
+  describe('InvalidDomainError', () => {
+    it('should create with correct code and non-retryable flag', () => {
+      const error = new InvalidDomainError('Invalid domain format');
+      
+      expect(error.code).toBe('INVALID_DOMAIN');
+      expect(error.retryable).toBe(false);
+      expect(error.name).toBe('InvalidDomainError');
+    });
+  });
+
+  describe('Result Helpers', () => {
+    it('successResult should create success result', () => {
+      const result = successResult({ domain: 'test.com' });
+      
+      expect(result.success).toBe(true);
+      expect(result.data).toEqual({ domain: 'test.com' });
+    });
+
+    it('errorResult should create error result from DomainVerificationError', () => {
+      const error = new DomainVerificationError('Test error', 'TEST', true, { key: 'value' });
+      const result = errorResult(error);
+      
+      expect(result.success).toBe(false);
+      expect(result.error).toEqual({
+        code: 'TEST',
+        message: 'Test error',
+        retryable: true,
+        details: { key: 'value' }
+      });
+    });
+  });
+});
+

package/jest.config.cjs

@@ -17,10 +17,10 @@ module.exports = {
   ],
   coverageThreshold: {
     global: {
-      branches: 50,  // TODO: Increase to 85% - current: 50.92%
-      functions: 74,  // TODO: Increase to 85% - current: 74.07%
-      lines: 72,      // TODO: Increase to 85% - current: 72.9%
-      statements: 72  // TODO: Increase to 85% - current: 72.37%
+      branches: 65,
+      functions: 85,
+      lines: 85,
+      statements: 85
     }
   },
   testMatch: [

package/package.json

@@ -1,9 +1,18 @@
 {
   "name": "@bernierllc/email-domain-verification",
-  "version": "1.0.3",
+  "version": "1.0.6",
   "description": "Programmatic domain setup and DNS management for production email sending with multi-provider support",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
+  "scripts": {
+    "build": "tsc",
+    "test": "jest --watch",
+    "test:run": "jest",
+    "test:coverage": "jest --coverage",
+    "lint": "eslint src --ext .ts,.tsx",
+    "clean": "rm -rf dist",
+    "prepublishOnly": "npm run clean && npm run build"
+  },
   "keywords": [
     "email",
     "domain",
@@ -21,29 +30,29 @@
   "author": "Bernier LLC",
   "license": "SEE LICENSE IN LICENSE",
   "dependencies": {
-    "dns2": "^2.1.0",
-    "dns-packet": "^5.6.1",
+    "@bernierllc/crypto-utils": "1.0.6",
+    "@bernierllc/email-sender-manager": "1.2.0",
+    "@bernierllc/logger": "1.3.0",
+    "@bernierllc/neverhub-adapter": "0.1.4",
     "axios": "^1.6.0",
     "cron": "^3.1.6",
-    "@bernierllc/email-sender-manager": "1.0.2",
-    "@bernierllc/crypto-utils": "1.0.4",
-    "@bernierllc/logger": "1.0.4",
-    "@bernierllc/neverhub-adapter": "0.1.2"
+    "dns-packet": "^5.6.1",
+    "dns2": "^2.1.0"
   },
   "devDependencies": {
-    "@types/jest": "^29.0.0",
-    "@types/node": "^20.0.0",
     "@types/cron": "^2.0.1",
     "@types/dns2": "^2.0.0",
+    "@types/jest": "^29.0.0",
+    "@types/node": "^20.0.0",
+    "@types/react": "^18.0.0",
     "@typescript-eslint/eslint-plugin": "^6.0.0",
     "@typescript-eslint/parser": "^6.0.0",
     "eslint": "^8.0.0",
     "jest": "^29.0.0",
-    "ts-jest": "^29.0.0",
-    "typescript": "^5.0.0",
     "react": "^18.0.0",
     "react-dom": "^18.0.0",
-    "@types/react": "^18.0.0"
+    "ts-jest": "^29.0.0",
+    "typescript": "^5.0.0"
   },
   "peerDependencies": {
     "react": ">=18.0.0",
@@ -62,12 +71,5 @@
     "category": "service",
     "priority": "critical"
   },
-  "scripts": {
-    "build": "tsc",
-    "test": "jest --watch",
-    "test:run": "jest",
-    "test:coverage": "jest --coverage",
-    "lint": "eslint src --ext .ts,.tsx",
-    "clean": "rm -rf dist"
-  }
-}
+  "gitHead": "af7e74b3715d56d3a193e1bb6743b337c2b0df6d"
+}