@bernierllc/email-sendgrid-plugin 1.0.1

package/__tests__/converters/sender-converter.test.ts

@@ -0,0 +1,148 @@
+/*
+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 { SenderConverter } from '../../src/converters/sender-converter';
+import { SendGridVerifiedSenderData } from '../../src/types/sendgrid-types';
+
+describe('SenderConverter', () => {
+  let converter: SenderConverter;
+
+  beforeEach(() => {
+    converter = new SenderConverter();
+  });
+
+  describe('convertToVerifiedSender', () => {
+    it('should convert SendGrid data to VerifiedSender', () => {
+      const sendgridData: SendGridVerifiedSenderData = {
+        id: 123,
+        nickname: 'Test Sender',
+        from_email: 'noreply@example.com',
+        from_name: 'Example Team',
+        reply_to: 'support@example.com',
+        reply_to_name: 'Support',
+        address: '123 Main St',
+        address2: '',
+        city: 'Anytown',
+        state: 'CA',
+        zip: '12345',
+        country: 'US',
+        verified: true,
+        locked: false
+      };
+
+      const result = converter.convertToVerifiedSender(sendgridData);
+
+      expect(result).toEqual({
+        id: '123',
+        email: 'noreply@example.com',
+        name: 'Example Team',
+        isVerified: true,
+        domain: 'example.com',
+        verificationStatus: 'verified',
+        createdAt: expect.any(Date),
+        lastVerifiedAt: expect.any(Date)
+      });
+    });
+
+    it('should handle unverified sender', () => {
+      const sendgridData: SendGridVerifiedSenderData = {
+        id: 456,
+        nickname: 'Unverified',
+        from_email: 'test@test.com',
+        from_name: 'Test',
+        reply_to: 'test@test.com',
+        reply_to_name: 'Test',
+        address: '',
+        address2: '',
+        city: '',
+        state: '',
+        zip: '',
+        country: 'US',
+        verified: false,
+        locked: false
+      };
+
+      const result = converter.convertToVerifiedSender(sendgridData);
+
+      expect(result.isVerified).toBe(false);
+      expect(result.verificationStatus).toBe('pending');
+      expect(result.lastVerifiedAt).toBeUndefined();
+    });
+
+    it('should use nickname when from_name is missing', () => {
+      const sendgridData: SendGridVerifiedSenderData = {
+        id: 789,
+        nickname: 'My Sender',
+        from_email: 'noreply@example.com',
+        from_name: '',
+        reply_to: 'noreply@example.com',
+        reply_to_name: '',
+        address: '',
+        address2: '',
+        city: '',
+        state: '',
+        zip: '',
+        country: 'US',
+        verified: true,
+        locked: false
+      };
+
+      const result = converter.convertToVerifiedSender(sendgridData);
+
+      expect(result.name).toBe('My Sender');
+    });
+  });
+
+  describe('extractDomain', () => {
+    it('should extract domain from email', () => {
+      expect(converter.extractDomain('user@example.com')).toBe('example.com');
+      expect(converter.extractDomain('admin@subdomain.example.com')).toBe('subdomain.example.com');
+    });
+
+    it('should handle invalid email formats', () => {
+      expect(converter.extractDomain('invalid')).toBe('');
+      expect(converter.extractDomain('')).toBe('');
+    });
+
+    it('should lowercase domain', () => {
+      expect(converter.extractDomain('user@EXAMPLE.COM')).toBe('example.com');
+    });
+  });
+
+  describe('isDomainMatch', () => {
+    it('should match exact domains', () => {
+      expect(converter.isDomainMatch('example.com', 'example.com')).toBe(true);
+    });
+
+    it('should match subdomain to parent domain', () => {
+      expect(converter.isDomainMatch('app.example.com', 'example.com')).toBe(true);
+      expect(converter.isDomainMatch('example.com', 'app.example.com')).toBe(true);
+    });
+
+    it('should match deep subdomains', () => {
+      expect(converter.isDomainMatch('api.v2.example.com', 'example.com')).toBe(true);
+      expect(converter.isDomainMatch('example.com', 'api.v2.example.com')).toBe(true);
+    });
+
+    it('should not match different domains', () => {
+      expect(converter.isDomainMatch('example.com', 'different.com')).toBe(false);
+      expect(converter.isDomainMatch('app.example.com', 'app.different.com')).toBe(false);
+    });
+
+    it('should not match partial domain strings', () => {
+      expect(converter.isDomainMatch('example.com', 'notexample.com')).toBe(false);
+      expect(converter.isDomainMatch('myexample.com', 'example.com')).toBe(false);
+    });
+
+    it('should handle empty strings', () => {
+      expect(converter.isDomainMatch('', '')).toBe(true);
+      expect(converter.isDomainMatch('example.com', '')).toBe(false);
+      expect(converter.isDomainMatch('', 'example.com')).toBe(false);
+    });
+  });
+});

package/__tests__/converters/template-converter.test.ts

@@ -0,0 +1,230 @@
+/*
+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 { TemplateConverter } from '../../src/converters/template-converter';
+import { PrefixEnforcer } from '../../src/safety/prefix-enforcer';
+import { SendGridTemplateData, SendGridTemplateVersion } from '../../src/types/sendgrid-types';
+
+describe('TemplateConverter', () => {
+  let converter: TemplateConverter;
+  let prefixEnforcer: PrefixEnforcer;
+
+  beforeEach(() => {
+    prefixEnforcer = new PrefixEnforcer('MyApp - ');
+    converter = new TemplateConverter(prefixEnforcer);
+  });
+
+  describe('convertToProviderTemplate', () => {
+    it('should convert SendGrid template to provider template', () => {
+      const activeVersion: SendGridTemplateVersion = {
+        id: 'ver-123',
+        template_id: 'template-123',
+        active: 1,
+        name: 'v1.0.0',
+        html_content: '<html>Hello {{name}}</html>',
+        plain_content: 'Hello {{name}}',
+        subject: 'Welcome {{name}}',
+        updated_at: '2024-01-01T00:00:00Z',
+        editor: 'code'
+      };
+
+      const sendgridData: SendGridTemplateData = {
+        id: 'template-123',
+        name: 'MyApp - Welcome Email',
+        generation: 'dynamic',
+        updated_at: '2024-01-01T00:00:00Z',
+        versions: [activeVersion]
+      };
+
+      const result = converter.convertToProviderTemplate(sendgridData, activeVersion);
+
+      expect(result).toEqual({
+        id: 'template-123',
+        name: 'Welcome Email',
+        subject: 'Welcome {{name}}',
+        htmlContent: '<html>Hello {{name}}</html>',
+        textContent: 'Hello {{name}}',
+        version: 'v1.0.0',
+        active: true,
+        createdAt: expect.any(Date),
+        updatedAt: expect.any(Date)
+      });
+    });
+
+    it('should handle template without active version', () => {
+      const sendgridData: SendGridTemplateData = {
+        id: 'template-456',
+        name: 'MyApp - Test',
+        generation: 'dynamic',
+        updated_at: '2024-01-01T00:00:00Z',
+        versions: []
+      };
+
+      const result = converter.convertToProviderTemplate(sendgridData);
+
+      expect(result.subject).toBe('');
+      expect(result.htmlContent).toBe('');
+      expect(result.version).toBe('1.0.0');
+    });
+
+    it('should find active version automatically', () => {
+      const versions: SendGridTemplateVersion[] = [
+        {
+          id: 'ver-1',
+          template_id: 'template-123',
+          active: 0,
+          name: 'v1.0.0',
+          html_content: '<html>Old</html>',
+          plain_content: 'Old',
+          subject: 'Old',
+          updated_at: '2024-01-01T00:00:00Z',
+          editor: 'code'
+        },
+        {
+          id: 'ver-2',
+          template_id: 'template-123',
+          active: 1,
+          name: 'v2.0.0',
+          html_content: '<html>New</html>',
+          plain_content: 'New',
+          subject: 'New',
+          updated_at: '2024-01-02T00:00:00Z',
+          editor: 'code'
+        }
+      ];
+
+      const sendgridData: SendGridTemplateData = {
+        id: 'template-123',
+        name: 'MyApp - Test',
+        generation: 'dynamic',
+        updated_at: '2024-01-02T00:00:00Z',
+        versions
+      };
+
+      const result = converter.convertToProviderTemplate(sendgridData);
+
+      expect(result.version).toBe('v2.0.0');
+      expect(result.subject).toBe('New');
+    });
+  });
+
+  describe('convertToLocalTemplate', () => {
+    it('should convert SendGrid template to local template', () => {
+      const activeVersion: SendGridTemplateVersion = {
+        id: 'ver-123',
+        template_id: 'template-123',
+        active: 1,
+        name: 'v1.0.0',
+        html_content: '<html>Content</html>',
+        plain_content: 'Content',
+        subject: 'Subject',
+        updated_at: '2024-01-01T00:00:00Z',
+        editor: 'code'
+      };
+
+      const sendgridData: SendGridTemplateData = {
+        id: 'template-123',
+        name: 'MyApp - Welcome',
+        generation: 'dynamic',
+        updated_at: '2024-01-01T00:00:00Z',
+        versions: [activeVersion]
+      };
+
+      const result = converter.convertToLocalTemplate(sendgridData, 'local-123', activeVersion);
+
+      expect(result).toEqual({
+        id: 'local-123',
+        name: 'Welcome',
+        subject: 'Subject',
+        htmlContent: '<html>Content</html>',
+        textContent: 'Content',
+        category: 'synced',
+        tags: ['sendgrid', 'synced'],
+        version: 'v1.0.0',
+        isActive: true,
+        requiredVariables: [],
+        providerTemplateIds: {
+          sendgrid: 'template-123'
+        },
+        lastSyncedAt: {
+          sendgrid: expect.any(Date)
+        },
+        syncStatus: {
+          sendgrid: 'success'
+        },
+        createdAt: expect.any(Date),
+        updatedAt: expect.any(Date),
+        createdBy: 'sendgrid-sync',
+        lastModifiedBy: 'sendgrid-sync'
+      });
+    });
+  });
+
+  describe('extractVariables', () => {
+    it('should extract Handlebars variables', () => {
+      const content = 'Hello {{name}}, your order {{orderId}} is ready!';
+
+      const result = converter.extractVariables(content);
+
+      expect(result).toEqual(expect.arrayContaining(['name', 'orderId']));
+      expect(result).toHaveLength(2);
+    });
+
+    it('should handle variables with whitespace', () => {
+      const content = 'Hello {{ firstName }}, welcome to {{ siteName }}!';
+
+      const result = converter.extractVariables(content);
+
+      expect(result).toEqual(expect.arrayContaining(['firstName', 'siteName']));
+    });
+
+    it('should filter out Handlebars helpers', () => {
+      const content = '{{#if condition}}{{variable}}{{/if}}';
+
+      const result = converter.extractVariables(content);
+
+      expect(result).toEqual(['variable']);
+      expect(result).not.toContain('#if');
+      expect(result).not.toContain('/if');
+    });
+
+    it('should deduplicate variables', () => {
+      const content = 'Hello {{name}}, {{name}} is a great name!';
+
+      const result = converter.extractVariables(content);
+
+      expect(result).toEqual(['name']);
+      expect(result).toHaveLength(1);
+    });
+
+    it('should return empty array for content without variables', () => {
+      const content = 'This is plain text with no variables';
+
+      const result = converter.extractVariables(content);
+
+      expect(result).toEqual([]);
+    });
+
+    it('should handle complex HTML with variables', () => {
+      const content = `
+        <html>
+          <body>
+            <h1>Hello {{userName}}</h1>
+            <p>Your account {{accountId}} is active</p>
+            <a href="{{confirmationUrl}}">Click here</a>
+          </body>
+        </html>
+      `;
+
+      const result = converter.extractVariables(content);
+
+      expect(result).toEqual(expect.arrayContaining(['userName', 'accountId', 'confirmationUrl']));
+      expect(result).toHaveLength(3);
+    });
+  });
+});

package/__tests__/plugin/sender-manager.test.ts

@@ -0,0 +1,135 @@
+/*
+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 { SenderManager } from '../../src/plugin/sender-manager';
+import { SendGridClient } from '../../src/api/sendgrid-client';
+import { SenderConverter } from '../../src/converters/sender-converter';
+
+describe('SenderManager', () => {
+  let manager: SenderManager;
+  let mockClient: jest.Mocked<SendGridClient>;
+  let converter: SenderConverter;
+
+  beforeEach(() => {
+    mockClient = {
+      request: jest.fn(),
+      isSuccessResponse: jest.fn(),
+      parseResponseBody: jest.fn()
+    } as any;
+
+    converter = new SenderConverter();
+    manager = new SenderManager(mockClient, converter);
+  });
+
+  describe('getVerifiedSenders', () => {
+    it('should fetch and cache verified senders', async () => {
+      const mockSenders = {
+        results: [
+          {
+            id: 123,
+            nickname: 'Test',
+            from_email: 'test@example.com',
+            from_name: 'Test',
+            reply_to: 'test@example.com',
+            reply_to_name: 'Test',
+            address: '',
+            address2: '',
+            city: '',
+            state: '',
+            zip: '',
+            country: 'US',
+            verified: true,
+            locked: false
+          }
+        ]
+      };
+
+      mockClient.request.mockResolvedValueOnce({
+        statusCode: 200,
+        headers: {},
+        body: JSON.stringify(mockSenders)
+      });
+
+      mockClient.isSuccessResponse.mockReturnValue(true);
+      mockClient.parseResponseBody.mockReturnValueOnce(mockSenders);
+
+      const result = await manager.getVerifiedSenders();
+
+      expect(result).toHaveLength(1);
+      expect(result[0].email).toBe('test@example.com');
+      expect(mockClient.request).toHaveBeenCalledTimes(1);
+
+      // Second call should use cache
+      const result2 = await manager.getVerifiedSenders();
+      expect(result2).toEqual(result);
+      expect(mockClient.request).toHaveBeenCalledTimes(1); // Still 1, used cache
+    });
+  });
+
+  describe('validateSender', () => {
+    beforeEach(() => {
+      const mockSenders = {
+        results: [
+          {
+            id: 123,
+            nickname: 'Test',
+            from_email: 'verified@example.com',
+            from_name: 'Test',
+            reply_to: 'verified@example.com',
+            reply_to_name: 'Test',
+            address: '',
+            address2: '',
+            city: '',
+            state: '',
+            zip: '',
+            country: 'US',
+            verified: true,
+            locked: false
+          }
+        ]
+      };
+
+      mockClient.request.mockResolvedValueOnce({
+        statusCode: 200,
+        headers: {},
+        body: JSON.stringify(mockSenders)
+      });
+
+      mockClient.isSuccessResponse.mockReturnValue(true);
+      mockClient.parseResponseBody.mockReturnValueOnce(mockSenders);
+    });
+
+    it('should validate exact match sender', async () => {
+      const result = await manager.validateSender('verified@example.com');
+
+      expect(result.isValid).toBe(true);
+      expect(result.verifiedSender).toBeDefined();
+      expect(result.errors).toEqual([]);
+    });
+
+    it('should validate sender with domain match', async () => {
+      const result = await manager.validateSender('unverified@example.com');
+
+      expect(result.isValid).toBe(true); // Domain match is valid
+      expect(result.domainMatches.length).toBeGreaterThan(0);
+    });
+
+    it('should reject sender with no domain match', async () => {
+      const result = await manager.validateSender('test@different.com');
+
+      expect(result.isValid).toBe(false);
+      expect(result.errors.length).toBeGreaterThan(0);
+    });
+  });
+
+  describe('clearCache', () => {
+    it('should clear the senders cache', () => {
+      expect(() => manager.clearCache()).not.toThrow();
+    });
+  });
+});