@bernierllc/email 1.0.1 → 1.1.1

package/packages/core/src/core/template-manager.ts

@@ -1,388 +0,0 @@
-/*
-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.
-*/
-
-/**
- * Email Template Manager - Core template management
- */
-
-import { Liquid } from 'liquidjs';
-import { EmailTemplate, RenderedTemplate, TemplateFilters, ValidationResult } from '../types/template';
-
-export interface DatabaseConfig {
-  type: 'memory' | 'supabase' | 'postgresql' | 'mysql';
-  connectionString?: string;
-  supabaseUrl?: string;
-  supabaseKey?: string;
-  tableName?: string;
-}
-
-export class EmailTemplateManager {
-  private templates: Map<string, EmailTemplate> = new Map();
-  private liquid: Liquid;
-  private dbConfig: DatabaseConfig;
-  private supabaseAdapter?: SupabaseEmailAdapter;
-
-  constructor(config: { database: DatabaseConfig }) {
-    this.dbConfig = config.database;
-    this.liquid = new Liquid({
-      strictFilters: false,
-      strictVariables: false,
-    });
-
-    // Initialize database connection
-    this.initializeDatabase();
-  }
-
-  private async initializeDatabase() {
-    if (this.dbConfig.type === 'memory') {
-      // Use in-memory storage for development/testing
-      return;
-    }
-
-    if (this.dbConfig.type === 'supabase') {
-      if (!this.dbConfig.supabaseUrl || !this.dbConfig.supabaseKey) {
-        throw new Error('Supabase URL and key are required for Supabase database type');
-      }
-
-      this.supabaseAdapter = new SupabaseEmailAdapter({
-        url: this.dbConfig.supabaseUrl,
-        key: this.dbConfig.supabaseKey,
-        templatesTable: this.dbConfig.tableName,
-      });
-    }
-
-    // For other database types, implement connection logic
-    // This will be extended based on the database type
-  }
-
-  /**
-   * Create a new email template
-   */
-  async createTemplate(template: Omit<EmailTemplate, 'id' | 'createdAt' | 'updatedAt'>): Promise<EmailTemplate> {
-    const newTemplate: EmailTemplate = {
-      ...template,
-      id: this.generateId(),
-      createdAt: new Date(),
-      updatedAt: new Date(),
-    };
-
-    // Validate template
-    const validation = this.validateTemplate(newTemplate);
-    if (!validation.isValid) {
-      throw new Error(`Template validation failed: ${validation.errors.map(e => e.message).join(', ')}`);
-    }
-
-    // Store template
-    if (this.dbConfig.type === 'memory') {
-      this.templates.set(newTemplate.id!, newTemplate);
-    } else {
-      await this.saveTemplateToDatabase(newTemplate);
-    }
-
-    return newTemplate;
-  }
-
-  /**
-   * Get template by ID
-   */
-  async getTemplate(id: string): Promise<EmailTemplate | null> {
-    if (this.dbConfig.type === 'memory') {
-      return this.templates.get(id) || null;
-    }
-
-    return await this.loadTemplateFromDatabase(id);
-  }
-
-  /**
-   * Get template by name
-   */
-  async getTemplateByName(name: string): Promise<EmailTemplate | null> {
-    if (this.dbConfig.type === 'memory') {
-      for (const template of this.templates.values()) {
-        if (template.name === name) {
-          return template;
-        }
-      }
-      return null;
-    }
-
-    return await this.loadTemplateFromDatabaseByName(name);
-  }
-
-  /**
-   * Update an existing template
-   */
-  async updateTemplate(id: string, updates: Partial<EmailTemplate>): Promise<EmailTemplate> {
-    const existingTemplate = await this.getTemplate(id);
-    if (!existingTemplate) {
-      throw new Error(`Template with id ${id} not found`);
-    }
-
-    const updatedTemplate: EmailTemplate = {
-      ...existingTemplate,
-      ...updates,
-      id: existingTemplate.id,
-      updatedAt: new Date(),
-    };
-
-    // Validate updated template
-    const validation = this.validateTemplate(updatedTemplate);
-    if (!validation.isValid) {
-      throw new Error(`Template validation failed: ${validation.errors.map(e => e.message).join(', ')}`);
-    }
-
-    // Store updated template
-    if (this.dbConfig.type === 'memory') {
-      this.templates.set(id, updatedTemplate);
-    } else {
-      await this.saveTemplateToDatabase(updatedTemplate);
-    }
-
-    return updatedTemplate;
-  }
-
-  /**
-   * Delete a template
-   */
-  async deleteTemplate(id: string): Promise<boolean> {
-    if (this.dbConfig.type === 'memory') {
-      return this.templates.delete(id);
-    }
-
-    return await this.deleteTemplateFromDatabase(id);
-  }
-
-  /**
-   * List templates with optional filtering
-   */
-  async listTemplates(filters?: TemplateFilters): Promise<EmailTemplate[]> {
-    let templates: EmailTemplate[];
-
-    if (this.dbConfig.type === 'memory') {
-      templates = Array.from(this.templates.values());
-    } else {
-      templates = await this.loadTemplatesFromDatabase(filters);
-    }
-
-    // Apply filters if provided
-    if (filters) {
-      templates = this.applyFilters(templates, filters);
-    }
-
-    return templates;
-  }
-
-  /**
-   * Render a template with variables
-   */
-  async renderTemplate(templateId: string, variables: Record<string, any>): Promise<RenderedTemplate> {
-    const template = await this.getTemplate(templateId);
-    if (!template) {
-      throw new Error(`Template with id ${templateId} not found`);
-    }
-
-    return this.renderTemplateObject(template, variables);
-  }
-
-  /**
-   * Render a template by name with variables
-   */
-  async renderTemplateByName(templateName: string, variables: Record<string, any>): Promise<RenderedTemplate> {
-    const template = await this.getTemplateByName(templateName);
-    if (!template) {
-      throw new Error(`Template with name ${templateName} not found`);
-    }
-
-    return this.renderTemplateObject(template, variables);
-  }
-
-  /**
-   * Render a template object with variables
-   */
-  private async renderTemplateObject(template: EmailTemplate, variables: Record<string, any>): Promise<RenderedTemplate> {
-    try {
-      // Validate required variables
-      const missingVariables = template.variables
-        .filter(v => v.required && !(v.name in variables))
-        .map(v => v.name);
-
-      if (missingVariables.length > 0) {
-        throw new Error(`Missing required variables: ${missingVariables.join(', ')}`);
-      }
-
-      // Render template parts
-      const subject = await this.liquid.parseAndRender(template.subject, variables);
-      const htmlContent = await this.liquid.parseAndRender(template.htmlBody, variables);
-      const textContent = await this.liquid.parseAndRender(template.textBody, variables);
-
-      return {
-        subject,
-        htmlContent,
-        textContent,
-        variables,
-        templateId: template.id!,
-      };
-    } catch (error) {
-      throw new Error(`Template rendering failed: ${error instanceof Error ? error.message : 'Unknown error'}`);
-    }
-  }
-
-  /**
-   * Validate a template
-   */
-  private validateTemplate(template: EmailTemplate): ValidationResult {
-    const errors: any[] = [];
-    const warnings: any[] = [];
-
-    // Required fields
-    if (!template.name) {
-      errors.push({ field: 'name', message: 'Template name is required', code: 'REQUIRED' });
-    }
-
-    if (!template.subject) {
-      errors.push({ field: 'subject', message: 'Template subject is required', code: 'REQUIRED' });
-    }
-
-    if (!template.htmlBody && !template.textBody) {
-      errors.push({ field: 'body', message: 'Template must have either HTML or text body', code: 'REQUIRED' });
-    }
-
-    // Variable validation
-    template.variables.forEach((variable, index) => {
-      if (!variable.name) {
-        errors.push({ 
-          field: `variables[${index}].name`, 
-          message: 'Variable name is required', 
-          code: 'REQUIRED' 
-        });
-      }
-
-      if (!variable.type) {
-        errors.push({ 
-          field: `variables[${index}].type`, 
-          message: 'Variable type is required', 
-          code: 'REQUIRED' 
-        });
-      }
-    });
-
-    // Check for duplicate variable names
-    const variableNames = template.variables.map(v => v.name).filter(Boolean);
-    const duplicates = variableNames.filter((name, index) => variableNames.indexOf(name) !== index);
-    if (duplicates.length > 0) {
-      errors.push({ 
-        field: 'variables', 
-        message: `Duplicate variable names: ${duplicates.join(', ')}`, 
-        code: 'DUPLICATE' 
-      });
-    }
-
-    return {
-      isValid: errors.length === 0,
-      errors,
-      warnings,
-    };
-  }
-
-  /**
-   * Apply filters to template list
-   */
-  private applyFilters(templates: EmailTemplate[], filters: TemplateFilters): EmailTemplate[] {
-    return templates.filter(template => {
-      if (filters.categoryId && template.categoryId !== filters.categoryId) {
-        return false;
-      }
-
-      if (filters.isActive !== undefined && template.isActive !== filters.isActive) {
-        return false;
-      }
-
-      if (filters.tags && filters.tags.length > 0) {
-        const hasMatchingTag = filters.tags.some(tag => template.tags.includes(tag));
-        if (!hasMatchingTag) {
-          return false;
-        }
-      }
-
-      if (filters.search) {
-        const searchLower = filters.search.toLowerCase();
-        const matchesSearch = 
-          template.name.toLowerCase().includes(searchLower) ||
-          template.subject.toLowerCase().includes(searchLower) ||
-          template.tags.some(tag => tag.toLowerCase().includes(searchLower));
-        
-        if (!matchesSearch) {
-          return false;
-        }
-      }
-
-      if (filters.createdBy && template.createdBy !== filters.createdBy) {
-        return false;
-      }
-
-      if (filters.createdAfter && template.createdAt && template.createdAt < filters.createdAfter) {
-        return false;
-      }
-
-      if (filters.createdBefore && template.createdAt && template.createdAt > filters.createdBefore) {
-        return false;
-      }
-
-      return true;
-    });
-  }
-
-  /**
-   * Generate a unique ID
-   */
-  private generateId(): string {
-    return `tpl_${Date.now()}_${Math.random().toString(36).substr(2, 9)}`;
-  }
-
-  // Database methods (to be implemented based on database type)
-  private async saveTemplateToDatabase(template: EmailTemplate): Promise<void> {
-    if (this.dbConfig.type === 'supabase' && this.supabaseAdapter) {
-      await this.supabaseAdapter.saveTemplate(template);
-      return;
-    }
-    
-    throw new Error(`Database operations not implemented for type: ${this.dbConfig.type}`);
-  }
-
-  private async loadTemplateFromDatabase(id: string): Promise<EmailTemplate | null> {
-    if (this.dbConfig.type === 'supabase' && this.supabaseAdapter) {
-      return await this.supabaseAdapter.loadTemplate(id);
-    }
-    
-    throw new Error(`Database operations not implemented for type: ${this.dbConfig.type}`);
-  }
-
-  private async loadTemplateFromDatabaseByName(name: string): Promise<EmailTemplate | null> {
-    if (this.dbConfig.type === 'supabase' && this.supabaseAdapter) {
-      return await this.supabaseAdapter.loadTemplateByName(name);
-    }
-    
-    throw new Error(`Database operations not implemented for type: ${this.dbConfig.type}`);
-  }
-
-  private async loadTemplatesFromDatabase(filters?: TemplateFilters): Promise<EmailTemplate[]> {
-    if (this.dbConfig.type === 'supabase' && this.supabaseAdapter) {
-      return await this.supabaseAdapter.loadTemplates(filters);
-    }
-    
-    throw new Error(`Database operations not implemented for type: ${this.dbConfig.type}`);
-  }
-
-  private async deleteTemplateFromDatabase(id: string): Promise<boolean> {
-    if (this.dbConfig.type === 'supabase' && this.supabaseAdapter) {
-      return await this.supabaseAdapter.deleteTemplate(id);
-    }
-    
-    throw new Error(`Database operations not implemented for type: ${this.dbConfig.type}`);
-  }
-} 

package/packages/core/src/index.ts

@@ -1,30 +0,0 @@
-/*
-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.
-*/
-
-/**
- * Email Template Manager - Core Library
- * Main entry point for the email template management system
- */
-
-// Core types
-export * from './types/provider';
-export * from './types/scheduled';
-export * from './types/template';
-
-// Core classes
-export { EmailScheduler } from './core/scheduler';
-export { EmailTemplateManager } from './core/template-manager';
-
-// Database adapters
-export { SupabaseEmailAdapter } from './adapters/supabase';
-
-// Base provider class and types
-export * from './providers/base';
-
-// SendGrid provider
-export { SendGridProvider } from './providers/sendgrid';

package/packages/core/src/providers/base.ts

@@ -1,104 +0,0 @@
-/*
-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.
-*/
-
-/**
- * Base EmailProvider abstract class
- */
-
-import { EmailMessage, SendResult, DeliveryStatus, WebhookEvent, EmailProviderCapabilities } from '../types/provider';
-
-// Re-export types for consumers
-export { EmailMessage, SendResult, DeliveryStatus, WebhookEvent, EmailProviderCapabilities };
-
-export abstract class EmailProvider {
-  protected config: Record<string, any>;
-
-  constructor(config: Record<string, any>) {
-    this.config = config;
-  }
-
-  /**
-   * Send a single email
-   */
-  abstract sendEmail(email: EmailMessage): Promise<SendResult>;
-
-  /**
-   * Send multiple emails
-   */
-  abstract sendBatch(emails: EmailMessage[]): Promise<SendResult[]>;
-
-  /**
-   * Get delivery status for a message
-   */
-  abstract getDeliveryStatus(messageId: string): Promise<DeliveryStatus | null>;
-
-  /**
-   * Process webhook events from the provider
-   */
-  abstract processWebhook(payload: any, signature: string): Promise<WebhookEvent[]>;
-
-  /**
-   * Validate provider configuration
-   */
-  validateConfiguration(): boolean {
-    return true;
-  }
-
-  /**
-   * Get provider name
-   */
-  getProviderName(): string {
-    return this.constructor.name.replace('Provider', '').toLowerCase();
-  }
-
-  /**
-   * Get provider capabilities
-   */
-  getCapabilities(): EmailProviderCapabilities {
-    return {
-      supportsBatch: true,
-      supportsTemplates: false,
-      supportsWebhooks: false,
-      supportsAttachments: true,
-      supportsDeliveryTracking: false,
-      maxBatchSize: 100,
-      maxAttachmentSize: 25 * 1024 * 1024 // 25MB
-    };
-  }
-
-  /**
-   * Create a template in the provider (if supported)
-   */
-  async createTemplate?(templateData: {
-    name: string;
-    subject: string;
-    htmlContent: string;
-    textContent?: string;
-  }): Promise<string>;
-
-  /**
-   * Send an email using a provider template (if supported)
-   */
-  async sendTemplateEmail?(
-    templateId: string,
-    toEmail: string,
-    templateData: Record<string, any>,
-    toName?: string
-  ): Promise<SendResult>;
-
-  /**
-   * Test the provider connection
-   */
-  async testConnection(): Promise<boolean> {
-    try {
-      return this.validateConfiguration();
-    } catch {
-      return false;
-    }
-  }
-}