@bernierllc/email-sendgrid-plugin 1.8.1 → 1.8.2

package/dist/plugin/sender-manager.js

@@ -1,129 +0,0 @@
-"use strict";
-/*
-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.
-*/
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.SenderManager = void 0;
-const errors_1 = require("../api/errors");
-class SenderManager {
-    client;
-    converter;
-    logger;
-    sendersCache;
-    cacheTimestamp;
-    cacheTTL = 300000; // 5 minutes
-    constructor(client, converter, logger) {
-        this.client = client;
-        this.converter = converter;
-        this.logger = logger;
-    }
-    async getVerifiedSenders(useCache = true) {
-        // Return cached data if valid
-        if (useCache &&
-            this.sendersCache &&
-            this.cacheTimestamp &&
-            Date.now() - this.cacheTimestamp < this.cacheTTL) {
-            this.logger?.debug('Returning cached verified senders');
-            return this.sendersCache;
-        }
-        const response = await this.client.request('/verified_senders', {
-            method: 'GET'
-        });
-        if (!this.client.isSuccessResponse(response)) {
-            throw new errors_1.SendGridApiError('Failed to fetch verified senders', response.statusCode, response.body);
-        }
-        const data = this.client.parseResponseBody(response);
-        const senders = data.results.map(sender => this.converter.convertToVerifiedSender(sender));
-        // Update cache
-        this.sendersCache = senders;
-        this.cacheTimestamp = Date.now();
-        this.logger?.info(`Fetched ${senders.length} verified senders from SendGrid`);
-        return senders;
-    }
-    async validateSender(email) {
-        const verifiedSenders = await this.getVerifiedSenders();
-        const emailDomain = this.converter.extractDomain(email);
-        // Check for exact match
-        const exactMatch = verifiedSenders.find(sender => sender.email.toLowerCase() === email.toLowerCase() && sender.isVerified);
-        if (exactMatch) {
-            return {
-                isValid: true,
-                verifiedSender: exactMatch,
-                domain: emailDomain,
-                domainMatches: [exactMatch],
-                errors: [],
-                suggestions: []
-            };
-        }
-        // Check for domain matches
-        const domainMatches = verifiedSenders.filter(sender => {
-            const senderDomain = this.converter.extractDomain(sender.email);
-            return this.converter.isDomainMatch(emailDomain, senderDomain) && sender.isVerified;
-        });
-        if (domainMatches.length > 0) {
-            return {
-                isValid: true,
-                domain: emailDomain,
-                domainMatches,
-                errors: [],
-                suggestions: domainMatches.map(sender => sender.email)
-            };
-        }
-        // No matches found
-        return {
-            isValid: false,
-            domain: emailDomain,
-            domainMatches: [],
-            errors: [`No verified sender found for email ${email} or domain ${emailDomain}`],
-            suggestions: this.getSenderSuggestions(email, verifiedSenders)
-        };
-    }
-    async selectBestSender(fromEmail) {
-        const validation = await this.validateSender(fromEmail);
-        if (!validation.isValid || validation.domainMatches.length === 0) {
-            return null;
-        }
-        // Prefer exact match
-        if (validation.verifiedSender) {
-            return validation.verifiedSender;
-        }
-        // Fall back to best domain match
-        // Priority: most recently verified, then alphabetical
-        return validation.domainMatches.sort((a, b) => {
-            if (a.lastVerifiedAt && b.lastVerifiedAt) {
-                return b.lastVerifiedAt.getTime() - a.lastVerifiedAt.getTime();
-            }
-            if (a.lastVerifiedAt && !b.lastVerifiedAt)
-                return -1;
-            if (!a.lastVerifiedAt && b.lastVerifiedAt)
-                return 1;
-            return a.email.localeCompare(b.email);
-        })[0];
-    }
-    clearCache() {
-        this.sendersCache = undefined;
-        this.cacheTimestamp = undefined;
-        this.logger?.debug('Cleared verified senders cache');
-    }
-    getSenderSuggestions(email, senders) {
-        const emailDomain = this.converter.extractDomain(email);
-        // Find senders with similar domains
-        const suggestions = [];
-        for (const sender of senders) {
-            if (!sender.isVerified)
-                continue;
-            const senderDomain = this.converter.extractDomain(sender.email);
-            // Check for partial domain matches
-            if (emailDomain.includes(senderDomain) ||
-                senderDomain.includes(emailDomain)) {
-                suggestions.push(sender.email);
-            }
-        }
-        return suggestions.slice(0, 5); // Limit to 5 suggestions
-    }
-}
-exports.SenderManager = SenderManager;

package/dist/plugin/sendgrid-plugin.d.ts

@@ -1,60 +0,0 @@
-import { SendGridPluginConfig } from '../types/config-types';
-import { PluginConfig, ProviderCapability, Template, ProviderTemplate, TemplateVersion, SyncResult, ValidationResult, DateRange, TemplateAnalytics, FeatureConfig } from '../types/plugin-types';
-import { VerifiedSender, SenderValidationResult } from '../types/sendgrid-types';
-export interface TemplateProviderPlugin {
-    readonly name: string;
-    readonly version: string;
-    readonly providerId: string;
-    initialize(config: PluginConfig): Promise<void>;
-    destroy(): Promise<void>;
-    createTemplate(template: Template): Promise<string>;
-    updateTemplate(providerTemplateId: string, template: Template): Promise<void>;
-    deleteTemplate(providerTemplateId: string): Promise<void>;
-    getTemplate(providerTemplateId: string): Promise<ProviderTemplate>;
-    listTemplates(): Promise<ProviderTemplate[]>;
-    syncToProvider(template: Template): Promise<SyncResult>;
-    syncFromProvider(providerTemplateId: string): Promise<Template>;
-    getCapabilities(): ProviderCapability[];
-    supportsFeature(feature: string): boolean;
-    getFeatureConfig(feature: string): FeatureConfig | null;
-}
-export declare class SendGridTemplatePlugin implements TemplateProviderPlugin {
-    readonly name = "sendgrid-templates";
-    readonly version = "1.0.0";
-    readonly providerId = "sendgrid";
-    private client;
-    private rateLimiter?;
-    private ownershipValidator;
-    private prefixEnforcer;
-    private templateConverter;
-    private senderConverter;
-    private templateManager;
-    private senderManager;
-    private syncManager;
-    private readonly config;
-    private readonly logger?;
-    private initialized;
-    constructor(config: SendGridPluginConfig);
-    initialize(__pluginConfig: PluginConfig): Promise<void>;
-    destroy(): Promise<void>;
-    createTemplate(template: Template): Promise<string>;
-    updateTemplate(providerTemplateId: string, template: Template): Promise<void>;
-    deleteTemplate(providerTemplateId: string): Promise<void>;
-    getTemplate(providerTemplateId: string): Promise<ProviderTemplate>;
-    listTemplates(): Promise<ProviderTemplate[]>;
-    syncToProvider(template: Template): Promise<SyncResult>;
-    syncFromProvider(providerTemplateId: string): Promise<Template>;
-    getVerifiedSenders(): Promise<VerifiedSender[]>;
-    validateSender(email: string): Promise<SenderValidationResult>;
-    selectBestSender(email: string): Promise<VerifiedSender | null>;
-    createTemplateVersion(templateId: string, version: TemplateVersion): Promise<string>;
-    activateTemplateVersion(templateId: string, versionId: string): Promise<void>;
-    getTemplateAnalytics(__templateId: string, __dateRange: DateRange): Promise<TemplateAnalytics>;
-    batchSyncTemplates(templates: Template[]): Promise<SyncResult[]>;
-    getCapabilities(): ProviderCapability[];
-    supportsFeature(feature: string): boolean;
-    getFeatureConfig(feature: string): FeatureConfig | null;
-    validateRoute(__route: unknown): ValidationResult;
-    private loadExistingTemplates;
-    private ensureInitialized;
-}

package/dist/plugin/sendgrid-plugin.js

@@ -1,215 +0,0 @@
-"use strict";
-/*
-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.
-*/
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.SendGridTemplatePlugin = void 0;
-const sendgrid_client_1 = require("../api/sendgrid-client");
-const rate_limiter_1 = require("../api/rate-limiter");
-const ownership_validator_1 = require("../safety/ownership-validator");
-const prefix_enforcer_1 = require("../safety/prefix-enforcer");
-const template_converter_1 = require("../converters/template-converter");
-const sender_converter_1 = require("../converters/sender-converter");
-const template_manager_1 = require("./template-manager");
-const sender_manager_1 = require("./sender-manager");
-const sync_manager_1 = require("./sync-manager");
-class SendGridTemplatePlugin {
-    name = 'sendgrid-templates';
-    version = '1.0.0';
-    providerId = 'sendgrid';
-    client;
-    rateLimiter;
-    ownershipValidator;
-    prefixEnforcer;
-    templateConverter;
-    senderConverter;
-    templateManager;
-    senderManager;
-    syncManager;
-    config;
-    logger;
-    initialized = false;
-    constructor(config) {
-        this.config = config;
-    }
-    async initialize(__pluginConfig) {
-        if (this.initialized) {
-            return;
-        }
-        // Initialize rate limiter if configured
-        if (this.config.rateLimits) {
-            this.rateLimiter = new rate_limiter_1.SimpleRateLimiter({
-                maxRequestsPerSecond: this.config.rateLimits.apiCallsPerSecond,
-                maxRequestsPerMinute: this.config.rateLimits.templatesPerMinute
-            });
-        }
-        // Initialize SendGrid client
-        this.client = new sendgrid_client_1.SendGridClient({
-            apiKey: this.config.apiKey,
-            rateLimiter: this.rateLimiter,
-            logger: this.logger
-        });
-        // Initialize safety components
-        this.ownershipValidator = new ownership_validator_1.OwnershipValidator(this.config.safetyMode, this.logger);
-        this.prefixEnforcer = new prefix_enforcer_1.PrefixEnforcer(this.config.templatePrefix);
-        // Initialize converters
-        this.templateConverter = new template_converter_1.TemplateConverter(this.prefixEnforcer);
-        this.senderConverter = new sender_converter_1.SenderConverter();
-        // Initialize managers
-        this.templateManager = new template_manager_1.TemplateManager(this.client, this.ownershipValidator, this.prefixEnforcer, this.templateConverter, this.logger);
-        this.senderManager = new sender_manager_1.SenderManager(this.client, this.senderConverter, this.logger);
-        this.syncManager = new sync_manager_1.SyncManager(this.templateManager, this.templateConverter, this.client, this.logger);
-        // Load existing templates
-        await this.loadExistingTemplates();
-        this.initialized = true;
-        this.logger?.info('SendGrid plugin initialized successfully');
-    }
-    async destroy() {
-        if (!this.initialized) {
-            return;
-        }
-        this.ownershipValidator.clearRegistrations();
-        this.senderManager.clearCache();
-        this.initialized = false;
-        this.logger?.info('SendGrid plugin destroyed');
-    }
-    // Template operations
-    async createTemplate(template) {
-        this.ensureInitialized();
-        return this.templateManager.createTemplate(template);
-    }
-    async updateTemplate(providerTemplateId, template) {
-        this.ensureInitialized();
-        return this.templateManager.updateTemplate(providerTemplateId, template);
-    }
-    async deleteTemplate(providerTemplateId) {
-        this.ensureInitialized();
-        return this.templateManager.deleteTemplate(providerTemplateId);
-    }
-    async getTemplate(providerTemplateId) {
-        this.ensureInitialized();
-        return this.templateManager.getTemplate(providerTemplateId);
-    }
-    async listTemplates() {
-        this.ensureInitialized();
-        return this.templateManager.listTemplates();
-    }
-    // Synchronization
-    async syncToProvider(template) {
-        this.ensureInitialized();
-        return this.syncManager.syncToProvider(template);
-    }
-    async syncFromProvider(providerTemplateId) {
-        this.ensureInitialized();
-        return this.syncManager.syncFromProvider(providerTemplateId);
-    }
-    // SendGrid-specific features
-    async getVerifiedSenders() {
-        this.ensureInitialized();
-        return this.senderManager.getVerifiedSenders();
-    }
-    async validateSender(email) {
-        this.ensureInitialized();
-        return this.senderManager.validateSender(email);
-    }
-    async selectBestSender(email) {
-        this.ensureInitialized();
-        return this.senderManager.selectBestSender(email);
-    }
-    async createTemplateVersion(templateId, version) {
-        this.ensureInitialized();
-        return this.templateManager.createTemplateVersion(templateId, version);
-    }
-    async activateTemplateVersion(templateId, versionId) {
-        this.ensureInitialized();
-        return this.templateManager.activateTemplateVersion(templateId, versionId);
-    }
-    async getTemplateAnalytics(__templateId, __dateRange) {
-        this.ensureInitialized();
-        // TODO: Implement analytics fetching from SendGrid
-        throw new Error('Template analytics not yet implemented');
-    }
-    async batchSyncTemplates(templates) {
-        this.ensureInitialized();
-        return this.syncManager.batchSync(templates);
-    }
-    // Capabilities
-    getCapabilities() {
-        return [
-            {
-                feature: 'template-management',
-                description: 'Full CRUD operations for SendGrid templates',
-                methods: ['createTemplate', 'updateTemplate', 'deleteTemplate', 'getTemplate', 'listTemplates'],
-                config: {
-                    supportsVersioning: true,
-                    supportsActivation: true,
-                    maxNameLength: 100,
-                    templatePrefix: this.config.templatePrefix
-                }
-            },
-            {
-                feature: 'sender-verification',
-                description: 'SendGrid verified sender management',
-                methods: ['getVerifiedSenders', 'validateSender', 'selectBestSender'],
-                config: {
-                    supportsDomainMatching: true,
-                    supportsAutoSelection: true
-                }
-            },
-            {
-                feature: 'template-analytics',
-                description: 'SendGrid template usage and performance analytics',
-                methods: ['getTemplateAnalytics'],
-                config: {
-                    supportsRealTime: false,
-                    historicalDataDays: 30,
-                    metricsAvailable: ['opens', 'clicks', 'bounces', 'deliveries']
-                }
-            },
-            {
-                feature: 'batch-operations',
-                description: 'Efficient bulk template operations',
-                methods: ['batchSyncTemplates'],
-                config: {
-                    maxBatchSize: 50,
-                    supportsTransactions: false
-                }
-            }
-        ];
-    }
-    supportsFeature(feature) {
-        return this.getCapabilities().some(cap => cap.feature === feature);
-    }
-    getFeatureConfig(feature) {
-        const capability = this.getCapabilities().find(cap => cap.feature === feature);
-        return capability?.config || null;
-    }
-    validateRoute(__route) {
-        // Placeholder validation
-        return {
-            isValid: true,
-            errors: []
-        };
-    }
-    // Private methods
-    async loadExistingTemplates() {
-        try {
-            const templates = await this.templateManager.listTemplates();
-            this.logger?.info(`Loaded ${templates.length} existing SendGrid templates`);
-        }
-        catch (error) {
-            const errorMessage = error instanceof Error ? error.message : 'Unknown error';
-            this.logger?.error(`Failed to load existing templates: ${errorMessage}`);
-        }
-    }
-    ensureInitialized() {
-        if (!this.initialized) {
-            throw new Error('SendGrid plugin not initialized. Call initialize() first.');
-        }
-    }
-}
-exports.SendGridTemplatePlugin = SendGridTemplatePlugin;

package/dist/plugin/sync-manager.d.ts

@@ -1,19 +0,0 @@
-import { TemplateManager } from './template-manager';
-import { TemplateConverter } from '../converters/template-converter';
-import { SendGridClient } from '../api/sendgrid-client';
-import { Template, SyncResult } from '../types/plugin-types';
-export declare class SyncManager {
-    private readonly templateManager;
-    private readonly converter;
-    private readonly client;
-    private readonly logger?;
-    constructor(templateManager: TemplateManager, converter: TemplateConverter, client: SendGridClient, logger?: {
-        info: (message: string) => void;
-        error: (message: string) => void;
-    } | undefined);
-    syncToProvider(template: Template): Promise<SyncResult>;
-    syncFromProvider(providerTemplateId: string): Promise<Template>;
-    batchSync(templates: Template[]): Promise<SyncResult[]>;
-    private generateLocalId;
-    private sleep;
-}

package/dist/plugin/sync-manager.js

@@ -1,98 +0,0 @@
-"use strict";
-/*
-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.
-*/
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.SyncManager = void 0;
-class SyncManager {
-    templateManager;
-    converter;
-    client;
-    logger;
-    constructor(templateManager, converter, client, logger) {
-        this.templateManager = templateManager;
-        this.converter = converter;
-        this.client = client;
-        this.logger = logger;
-    }
-    async syncToProvider(template) {
-        try {
-            const existingProviderId = template.providerTemplateIds?.sendgrid;
-            if (existingProviderId) {
-                // Update existing template
-                await this.templateManager.updateTemplate(existingProviderId, template);
-                return {
-                    success: true,
-                    action: 'updated',
-                    providerTemplateId: existingProviderId,
-                    localTemplateId: template.id,
-                    metadata: {
-                        newVersion: template.version
-                    }
-                };
-            }
-            else {
-                // Create new template
-                const newProviderId = await this.templateManager.createTemplate(template);
-                return {
-                    success: true,
-                    action: 'created',
-                    providerTemplateId: newProviderId,
-                    localTemplateId: template.id,
-                    metadata: {
-                        version: template.version
-                    }
-                };
-            }
-        }
-        catch (error) {
-            const errorMessage = error instanceof Error ? error.message : 'Unknown error';
-            this.logger?.error(`Template sync failed: ${errorMessage}`);
-            return {
-                success: false,
-                action: 'failed',
-                localTemplateId: template.id,
-                error: errorMessage,
-                metadata: {
-                    errorType: error instanceof Error ? error.constructor.name : 'UnknownError',
-                    timestamp: new Date()
-                }
-            };
-        }
-    }
-    async syncFromProvider(providerTemplateId) {
-        const response = await this.client.request(`/templates/${providerTemplateId}`, {
-            method: 'GET'
-        });
-        if (!this.client.isSuccessResponse(response)) {
-            throw new Error(`Failed to fetch template from SendGrid: ${response.statusCode}`);
-        }
-        const templateData = this.client.parseResponseBody(response);
-        const localId = this.generateLocalId();
-        return this.converter.convertToLocalTemplate(templateData, localId);
-    }
-    async batchSync(templates) {
-        this.logger?.info(`Starting batch sync of ${templates.length} templates`);
-        const results = [];
-        for (const template of templates) {
-            const result = await this.syncToProvider(template);
-            results.push(result);
-            // Add delay to respect rate limits
-            await this.sleep(100);
-        }
-        const successful = results.filter(r => r.success).length;
-        this.logger?.info(`Batch sync completed: ${successful}/${templates.length} successful`);
-        return results;
-    }
-    generateLocalId() {
-        return `local_${Date.now()}_${Math.random().toString(36).substring(2, 9)}`;
-    }
-    sleep(ms) {
-        return new Promise(resolve => setTimeout(resolve, ms));
-    }
-}
-exports.SyncManager = SyncManager;

package/dist/plugin/template-manager.d.ts

@@ -1,25 +0,0 @@
-import { SendGridClient } from '../api/sendgrid-client';
-import { OwnershipValidator } from '../safety/ownership-validator';
-import { PrefixEnforcer } from '../safety/prefix-enforcer';
-import { TemplateConverter } from '../converters/template-converter';
-import { Template, ProviderTemplate, TemplateVersion } from '../types/plugin-types';
-export declare class TemplateManager {
-    private readonly client;
-    private readonly ownershipValidator;
-    private readonly prefixEnforcer;
-    private readonly converter;
-    private readonly logger?;
-    constructor(client: SendGridClient, ownershipValidator: OwnershipValidator, prefixEnforcer: PrefixEnforcer, converter: TemplateConverter, logger?: {
-        info: (message: string) => void;
-        error: (message: string) => void;
-    } | undefined);
-    createTemplate(template: Template): Promise<string>;
-    updateTemplate(providerTemplateId: string, template: Template): Promise<void>;
-    deleteTemplate(providerTemplateId: string): Promise<void>;
-    getTemplate(providerTemplateId: string): Promise<ProviderTemplate>;
-    listTemplates(): Promise<ProviderTemplate[]>;
-    createTemplateVersion(templateId: string, version: TemplateVersion): Promise<string>;
-    activateTemplateVersion(templateId: string, versionId: string): Promise<void>;
-    private hasConflicts;
-    private detectConflicts;
-}