@bernierllc/sender-identity-verification 1.0.0

package/__tests__/service-coverage.test.ts

@@ -0,0 +1,412 @@
+/*
+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 { SenderIdentityVerification } from '../src/SenderIdentityVerification';
+import { SenderIdentityConfig } from '../src/config';
+import { EmailProvider, SenderStatus, IEmailDomainVerification, DomainVerificationStatus } from '../src/types';
+
+describe('Service Coverage Tests', () => {
+  let service: SenderIdentityVerification;
+  let config: SenderIdentityConfig;
+
+  beforeEach(() => {
+    config = {
+      emailSenderConfig: {
+        provider: 'smtp'
+      },
+      domainVerificationConfig: {},
+      verificationBaseUrl: 'https://example.com',
+      verificationFromEmail: 'verify@example.com',
+      verificationFromName: 'Verification Service'
+    };
+
+    service = new SenderIdentityVerification(config);
+  });
+
+  describe('Domain Verification Integration', () => {
+    it('should block sender creation when domain is not verified', async () => {
+      const mockDomainVerification: IEmailDomainVerification = {
+        getDomainStatus: async (domain: string): Promise<DomainVerificationStatus> => {
+          return {
+            isVerified: false,
+            domain
+          };
+        }
+      };
+
+      const configWithDomain: SenderIdentityConfig = {
+        ...config,
+        domainVerificationConfig: {
+          instance: mockDomainVerification
+        }
+      };
+
+      const serviceWithDomain = new SenderIdentityVerification(configWithDomain);
+
+      const result = await serviceWithDomain.createSender({
+        email: 'test@unverified-domain.com',
+        name: 'Test User',
+        provider: EmailProvider.SMTP
+      });
+
+      expect(result.success).toBe(false);
+      expect(result.error).toContain('not verified');
+      expect(result.errors).toContain('Domain verification required');
+    });
+
+    it('should allow sender creation when domain is verified', async () => {
+      const mockDomainVerification: IEmailDomainVerification = {
+        getDomainStatus: async (domain: string): Promise<DomainVerificationStatus> => {
+          return {
+            isVerified: true,
+            domain
+          };
+        }
+      };
+
+      const configWithDomain: SenderIdentityConfig = {
+        ...config,
+        domainVerificationConfig: {
+          instance: mockDomainVerification
+        }
+      };
+
+      const serviceWithDomain = new SenderIdentityVerification(configWithDomain);
+
+      const result = await serviceWithDomain.createSender({
+        email: 'test@verified-domain.com',
+        name: 'Test User',
+        provider: EmailProvider.SMTP
+      });
+
+      expect(result.success).toBe(true);
+      expect(result.data).toBeDefined();
+    });
+  });
+
+  describe('Duplicate Sender Detection', () => {
+    it('should prevent creating duplicate sender with same email', async () => {
+      const createResult1 = await service.createSender({
+        email: 'duplicate@example.com',
+        name: 'User One',
+        provider: EmailProvider.SMTP
+      });
+
+      expect(createResult1.success).toBe(true);
+
+      const createResult2 = await service.createSender({
+        email: 'duplicate@example.com',
+        name: 'User Two',
+        provider: EmailProvider.SMTP
+      });
+
+      expect(createResult2.success).toBe(false);
+      expect(createResult2.error).toContain('already exists');
+    });
+  });
+
+  describe('Token Expiration Handling', () => {
+    it('should handle expired verification tokens', async () => {
+      const createResult = await service.createSender({
+        email: 'expiry-test@example.com',
+        name: 'Test User',
+        provider: EmailProvider.SMTP
+      });
+
+      if (!createResult.success || !createResult.data) {
+        throw new Error('Setup failed');
+      }
+
+      const sender = createResult.data;
+
+      // Manually set expiration to past date
+      sender.verificationExpiresAt = new Date(Date.now() - 1000); // 1 second ago
+      sender.status = SenderStatus.VERIFICATION_SENT;
+
+      if (sender.verificationToken) {
+        const result = await service.verifySender(sender.verificationToken);
+
+        expect(result.success).toBe(false);
+        expect(result.status).toBe(SenderStatus.EXPIRED);
+        expect(result.errors).toContain('Token expired');
+      }
+    });
+  });
+
+  describe('Locked Sender Handling', () => {
+    it('should prevent verification of locked senders', async () => {
+      const createResult = await service.createSender({
+        email: 'locked-test@example.com',
+        name: 'Test User',
+        provider: EmailProvider.SMTP
+      });
+
+      if (!createResult.success || !createResult.data) {
+        throw new Error('Setup failed');
+      }
+
+      const sender = createResult.data;
+
+      // Manually lock the sender
+      sender.status = SenderStatus.LOCKED;
+
+      if (sender.verificationToken) {
+        const result = await service.verifySender(sender.verificationToken);
+
+        expect(result.success).toBe(false);
+        expect(result.status).toBe(SenderStatus.LOCKED);
+        expect(result.errors).toContain('Account locked');
+      }
+    });
+  });
+
+  describe('Soft Delete Functionality', () => {
+    it('should soft delete sender and set deletedAt', async () => {
+      const createResult = await service.createSender({
+        email: 'soft-delete@example.com',
+        name: 'Test User',
+        provider: EmailProvider.SMTP
+      });
+
+      if (!createResult.success || !createResult.data) {
+        throw new Error('Setup failed');
+      }
+
+      const senderId = createResult.data.id;
+
+      const deleteResult = await service.deleteSender(senderId);
+
+      expect(deleteResult.success).toBe(true);
+
+      // Verify sender was soft deleted by checking it's removed from map
+      const getResult = await service.getSender(senderId);
+      expect(getResult.success).toBe(false);
+    });
+  });
+
+  describe('Default Sender Management', () => {
+    it('should set sender as default', async () => {
+      const createResult = await service.createSender({
+        email: 'default-test@example.com',
+        name: 'Default User',
+        provider: EmailProvider.SMTP,
+        isDefault: true,
+        skipVerification: true
+      });
+
+      expect(createResult.success).toBe(true);
+      expect(createResult.data?.isDefault).toBe(true);
+
+      // Manually verify the sender (needed for getDefaultSender)
+      if (createResult.data) {
+        createResult.data.status = SenderStatus.VERIFIED;
+        createResult.data.verifiedAt = new Date();
+      }
+
+      const defaultResult = await service.getDefaultSender(EmailProvider.SMTP);
+
+      expect(defaultResult.success).toBe(true);
+      expect(defaultResult.data?.email).toBe('default-test@example.com');
+    });
+
+    it('should unset previous default when setting new default', async () => {
+      const oldResult = await service.createSender({
+        email: 'old-default@example.com',
+        name: 'Old Default',
+        provider: EmailProvider.SMTP,
+        isDefault: true,
+        skipVerification: true
+      });
+
+      if (oldResult.data) {
+        oldResult.data.status = SenderStatus.VERIFIED;
+        oldResult.data.verifiedAt = new Date();
+      }
+
+      const newResult = await service.createSender({
+        email: 'new-default@example.com',
+        name: 'New Default',
+        provider: EmailProvider.SMTP,
+        isDefault: true,
+        skipVerification: true
+      });
+
+      if (newResult.data) {
+        newResult.data.status = SenderStatus.VERIFIED;
+        newResult.data.verifiedAt = new Date();
+      }
+
+      const defaultResult = await service.getDefaultSender(EmailProvider.SMTP);
+
+      expect(defaultResult.success).toBe(true);
+      expect(defaultResult.data?.email).toBe('new-default@example.com');
+    });
+  });
+
+  describe('List Filtering', () => {
+    beforeEach(async () => {
+      await service.createSender({
+        email: 'active@example.com',
+        name: 'Active User',
+        provider: EmailProvider.SMTP
+      });
+
+      await service.createSender({
+        email: 'sendgrid@example.com',
+        name: 'SendGrid User',
+        provider: EmailProvider.SENDGRID
+      });
+
+      const createResult = await service.createSender({
+        email: 'verified@example.com',
+        name: 'Verified User',
+        provider: EmailProvider.SMTP
+      });
+
+      if (createResult.success && createResult.data) {
+        const sender = createResult.data;
+        sender.status = SenderStatus.VERIFIED;
+        sender.verifiedAt = new Date();
+      }
+    });
+
+    it('should filter by provider', async () => {
+      const result = await service.listSenders({ provider: EmailProvider.SMTP });
+
+      expect(result.success).toBe(true);
+      expect(result.data).toBeDefined();
+      expect(result.data!.length).toBeGreaterThan(0);
+      expect(result.data!.every(s => s.provider === EmailProvider.SMTP)).toBe(true);
+    });
+
+    it('should filter by status', async () => {
+      const result = await service.listSenders({ status: SenderStatus.VERIFIED });
+
+      expect(result.success).toBe(true);
+      expect(result.data).toBeDefined();
+      expect(result.data!.every(s => s.status === SenderStatus.VERIFIED)).toBe(true);
+    });
+
+    it('should filter by isActive', async () => {
+      const result = await service.listSenders({ isActive: true });
+
+      expect(result.success).toBe(true);
+      expect(result.data).toBeDefined();
+      expect(result.data!.every(s => s.isActive === true)).toBe(true);
+    });
+
+    it('should filter by domain', async () => {
+      const result = await service.listSenders({ domain: 'example.com' });
+
+      expect(result.success).toBe(true);
+      expect(result.data).toBeDefined();
+      expect(result.data!.every(s => s.domain === 'example.com')).toBe(true);
+    });
+
+    it('should apply limit and offset', async () => {
+      const result1 = await service.listSenders({ limit: 1 });
+      expect(result1.data!.length).toBeLessThanOrEqual(1);
+
+      const result2 = await service.listSenders({ offset: 1, limit: 10 });
+      expect(result2.success).toBe(true);
+    });
+  });
+
+  describe('Compliance Checking', () => {
+    it('should check compliance for verified sender', async () => {
+      const createResult = await service.createSender({
+        email: 'compliance@example.com',
+        name: 'Compliance User',
+        provider: EmailProvider.SMTP
+      });
+
+      if (!createResult.success || !createResult.data) {
+        throw new Error('Setup failed');
+      }
+
+      const sender = createResult.data;
+      sender.status = SenderStatus.VERIFIED;
+      sender.verifiedAt = new Date();
+
+      const result = await service.checkCompliance(sender.id);
+
+      expect(result.success).toBe(true);
+      expect(result.data).toBeDefined();
+    });
+  });
+
+  describe('Update Sender', () => {
+    it('should update sender name and reply-to', async () => {
+      const createResult = await service.createSender({
+        email: 'update-test@example.com',
+        name: 'Original Name',
+        provider: EmailProvider.SMTP
+      });
+
+      if (!createResult.success || !createResult.data) {
+        throw new Error('Setup failed');
+      }
+
+      const senderId = createResult.data.id;
+
+      const updateResult = await service.updateSender(senderId, {
+        name: 'Updated Name',
+        replyToEmail: 'reply@example.com',
+        replyToName: 'Reply Name'
+      });
+
+      expect(updateResult.success).toBe(true);
+      expect(updateResult.data?.name).toBe('Updated Name');
+      expect(updateResult.data?.replyToEmail).toBe('reply@example.com');
+      expect(updateResult.data?.replyToName).toBe('Reply Name');
+    });
+
+    it('should update isDefault flag', async () => {
+      const createResult = await service.createSender({
+        email: 'default-update@example.com',
+        name: 'Test User',
+        provider: EmailProvider.SMTP,
+        isDefault: false
+      });
+
+      if (!createResult.success || !createResult.data) {
+        throw new Error('Setup failed');
+      }
+
+      const senderId = createResult.data.id;
+
+      const updateResult = await service.updateSender(senderId, {
+        isDefault: true
+      });
+
+      expect(updateResult.success).toBe(true);
+      expect(updateResult.data?.isDefault).toBe(true);
+    });
+
+    it('should update isActive flag', async () => {
+      const createResult = await service.createSender({
+        email: 'active-update@example.com',
+        name: 'Test User',
+        provider: EmailProvider.SMTP
+      });
+
+      if (!createResult.success || !createResult.data) {
+        throw new Error('Setup failed');
+      }
+
+      const senderId = createResult.data.id;
+
+      const updateResult = await service.updateSender(senderId, {
+        isActive: false
+      });
+
+      expect(updateResult.success).toBe(true);
+      expect(updateResult.data?.isActive).toBe(false);
+    });
+  });
+});

package/dist/SenderIdentityVerification.d.ts

@@ -0,0 +1,72 @@
+import { SenderIdentity, EmailProvider, CreateSenderInput, UpdateSenderInput, VerificationResult, ComplianceCheckResult, ListSendersOptions, SenderIdentityResult } from './types.js';
+import { SenderIdentityConfig } from './config.js';
+/**
+ * Sender identity verification service
+ */
+export declare class SenderIdentityVerification {
+    private config;
+    private senders;
+    private emailSender?;
+    private domainVerification?;
+    private cryptoUtils?;
+    private logger?;
+    private emailValidator?;
+    private neverhub?;
+    constructor(config: SenderIdentityConfig);
+    /**
+     * Initialize service and register with NeverHub
+     */
+    initialize(): Promise<void>;
+    /**
+     * Create a new sender identity
+     */
+    createSender(input: CreateSenderInput): Promise<SenderIdentityResult<SenderIdentity>>;
+    /**
+     * Send verification email to sender
+     */
+    sendVerificationEmail(sender: SenderIdentity): Promise<SenderIdentityResult<void>>;
+    /**
+     * Verify sender email with token
+     */
+    verifySender(token: string): Promise<VerificationResult>;
+    /**
+     * Verify sender with email provider
+     */
+    private verifyWithProvider;
+    /**
+     * Get sender by ID
+     */
+    getSender(senderId: string): Promise<SenderIdentityResult<SenderIdentity>>;
+    /**
+     * List senders
+     */
+    listSenders(options?: ListSendersOptions): Promise<SenderIdentityResult<SenderIdentity[]>>;
+    /**
+     * Update sender
+     */
+    updateSender(senderId: string, input: UpdateSenderInput): Promise<SenderIdentityResult<SenderIdentity>>;
+    /**
+     * Delete sender
+     */
+    deleteSender(senderId: string): Promise<SenderIdentityResult<void>>;
+    /**
+     * Check provider compliance for sender
+     */
+    checkCompliance(senderId: string): Promise<SenderIdentityResult<ComplianceCheckResult>>;
+    /**
+     * Get default sender for provider
+     */
+    getDefaultSender(provider: EmailProvider): Promise<SenderIdentityResult<SenderIdentity>>;
+    /**
+     * Resend verification email
+     */
+    resendVerification(senderId: string): Promise<SenderIdentityResult<void>>;
+    private generateSenderId;
+    private fallbackGenerateToken;
+    private isValidEmail;
+    private findSenderByEmail;
+    private findSenderByToken;
+    private unsetOtherDefaults;
+    private loadSendersFromDatabase;
+    private saveSenderToDatabase;
+}