Merge pull request #34 from xtr-dev/dev

Add fromName field support to emails collection
Fix security vulnerabilities in fromName field handling
2025-12-10 08:13:23 +00:00 · 2025-09-14 00:10:22 +02:00 · 2025-09-14 00:07:53 +02:00 · 2025-09-14 00:06:14 +02:00 · 2025-09-14 00:03:04 +02:00 · 2025-09-13 23:53:56 +02:00
22 changed files with 1564 additions and 950 deletions
--- a/README.md
+++ b/README.md
@@ -6,12 +6,19 @@
 ## Features
-✅ **Template System**: Create reusable email templates with Handlebars syntax  
+✅ **Template System**: Create reusable email templates with LiquidJS, Mustache, or simple variables
-✅ **Outbox Scheduling**: Schedule emails for future delivery  
+
-✅ **Job Integration**: Automatic processing via PayloadCMS jobs queue  
+✅ **Type Safety**: Full TypeScript support using your generated Payload types
-✅ **Retry Failed Sends**: Automatic retry mechanism for failed emails  
+
-✅ **Template Variables**: Dynamic content with validation  
+✅ **Flexible Template Engines**: LiquidJS, Mustache, or bring your own template renderer
-✅ **Developer API**: Simple methods for sending emails programmatically
+
 ✅ **Email Scheduling**: Schedule emails for future delivery using Payload collections
 ✅ **Job Integration**: Automatic processing via PayloadCMS jobs queue
 ✅ **Retry Failed Sends**: Automatic retry mechanism for failed emails
 ✅ **Payload Native**: Uses Payload collections directly - no custom APIs to learn
 ## Installation
@@ -49,29 +56,51 @@ export default buildConfig({
 })
 ```
-### 2. Send emails in your code
+### 2. Send emails with type-safe helper
 ```typescript
-import { sendEmail, scheduleEmail } from '@xtr-dev/payload-mailing'
+// sendEmail is a primary export for easy access
 import { sendEmail } from '@xtr-dev/payload-mailing'
 import { Email } from './payload-types' // Your generated types
-// Send immediately using template slug
+// Option 1: Using templates with full type safety
-const emailId = await sendEmail(payload, {
+const email = await sendEmail<Email>(payload, {
-  templateSlug: 'welcome-email',
+  template: {
-  to: 'user@example.com',
+    slug: 'welcome-email',
-  variables: {
+    variables: {
-    firstName: 'John',
+      firstName: 'John',
-    welcomeUrl: 'https://yoursite.com/welcome'
+      welcomeUrl: 'https://yoursite.com/welcome'
    }
  },
  data: {
    to: 'user@example.com',
    // Schedule for later (optional)
    scheduledAt: new Date(Date.now() + 24 * 60 * 60 * 1000),
    priority: 1,
    // Your custom fields are type-safe!
    customField: 'your-value',
  }
 })
-// Schedule for later
+// Option 2: Direct HTML email (no template)
-const scheduledId = await scheduleEmail(payload, {
+const directEmail = await sendEmail<Email>(payload, {
-  templateSlug: 'reminder-email',
+  data: {
-  to: 'user@example.com',
+    to: ['user@example.com', 'another@example.com'],
-  scheduledAt: new Date(Date.now() + 24 * 60 * 60 * 1000), // 24 hours
+    subject: 'Welcome!',
-  variables: {
+    html: '<h1>Welcome John!</h1><p>Thanks for joining!</p>',
-    eventName: 'Product Launch',
+    text: 'Welcome John! Thanks for joining!',
-    eventDate: new Date('2024-01-15')
+    // All your custom fields work with TypeScript autocomplete!
    customField: 'value',
  }
 })
 // Option 3: Use payload.create() directly for full control
 const manualEmail = await payload.create({
  collection: 'emails',
  data: {
    to: ['user@example.com'],
    subject: 'Hello',
    html: '<p>Hello World</p>',
  }
 })
 ```
@@ -81,21 +110,68 @@ const scheduledId = await scheduleEmail(payload, {
 ### Plugin Options
 ```typescript
-interface MailingPluginConfig {
+mailingPlugin({
-  collections?: {
+  // Template engine (optional)
-    templates?: string    // default: 'email-templates'
+  templateEngine: 'liquidjs',  // 'liquidjs' | 'mustache' | 'simple'
-    emails?: string      // default: 'emails'
+
  // Custom template renderer (optional)
  templateRenderer: async (template: string, variables: Record<string, any>) => {
    return yourCustomEngine.render(template, variables)
  },
  // Email transport
  transport: {
    host: 'smtp.gmail.com',
    port: 587,
    auth: { user: '...', pass: '...' }
  },
  // Collection names (optional)
  collections: {
    templates: 'email-templates',  // default
    emails: 'emails'              // default
  },
  // Sending options
  defaultFrom: 'noreply@yoursite.com',
  defaultFromName: 'Your Site',
  retryAttempts: 3,              // default
  retryDelay: 300000,            // 5 minutes (default)
  // Advanced options
  richTextEditor: lexicalEditor(),  // optional custom editor
  onReady: async (payload) => {     // optional initialization hook
    console.log('Mailing plugin ready!')
  }
-  defaultFrom?: string
+})
-  transport?: Transporter | MailingTransportConfig
+```
-  queue?: string         // default: 'default'
+
-  retryAttempts?: number // default: 3
+### Template Engine Options
-  retryDelay?: number    // default: 300000 (5 minutes)
+
-  emailWrapper?: EmailWrapperHook // optional email layout wrapper
+Choose your preferred template engine:
-  richTextEditor?: RichTextField['editor'] // optional custom rich text editor
+
-  onReady?: (payload: any) => Promise<void> // optional callback after plugin initialization
+```typescript
-  initOrder?: 'before' | 'after' // default: 'before'
+// LiquidJS (default) - Modern syntax with logic
-}
+mailingPlugin({
  templateEngine: 'liquidjs'  // {% if user.isPremium %}Premium!{% endif %}
 })
 // Mustache - Logic-less templates
 mailingPlugin({
  templateEngine: 'mustache'  // {{#user.isPremium}}Premium!{{/user.isPremium}}
 })
 // Simple variable replacement
 mailingPlugin({
  templateEngine: 'simple'    // Just {{variable}} replacement
 })
 // Custom template renderer
 mailingPlugin({
  templateRenderer: async (template, variables) => {
    return handlebars.compile(template)(variables)  // Bring your own!
  }
 })
 ```
 ### Transport Configuration
@@ -147,7 +223,7 @@ Thanks for joining {{siteName}}. We're excited to have you!
 **What you can do:**
 • Create beautiful emails with rich text formatting
-• Use the emailWrapper hook to add custom layouts  
+  
 • Queue and schedule emails effortlessly
 Your account was created on {{formatDate createdAt "long"}}.
@@ -158,282 +234,6 @@ The {{siteName}} Team
 ## Advanced Features
 ### Custom HTML Layouts with Email Wrapper Hook
 The `emailWrapper` hook allows you to apply consistent HTML layouts and styling to all emails sent through the plugin. This is perfect for adding company branding, headers, footers, and responsive styling.
 #### Basic Email Wrapper
 ```typescript
 mailingPlugin({
  // ... other config
  emailWrapper: (email) => {
    const wrappedHtml = `
      <!DOCTYPE html>
      <html>
      <head>
        <meta charset="utf-8">
        <meta name="viewport" content="width=device-width, initial-scale=1">
        <title>${email.subject}</title>
        <style>
          body { font-family: Arial, sans-serif; margin: 0; padding: 20px; background-color: #f4f4f4; }
          .container { max-width: 600px; margin: 0 auto; background: white; border-radius: 8px; overflow: hidden; }
          .header { background: #007bff; color: white; padding: 20px; text-align: center; }
          .content { padding: 30px; line-height: 1.6; }
          .footer { background: #f8f9fa; padding: 15px; text-align: center; color: #6c757d; font-size: 14px; }
          /* Responsive styles */
          @media only screen and (max-width: 600px) {
            .container { margin: 0 10px; }
            .content { padding: 20px; }
          }
        </style>
      </head>
      <body>
        <div class="container">
          <div class="header">
            <h1>My Company</h1>
          </div>
          <div class="content">
            ${email.html}
          </div>
          <div class="footer">
            © 2024 My Company. All rights reserved.<br>
            <a href="#" style="color: #007bff;">Unsubscribe</a> |
            <a href="#" style="color: #007bff;">Contact Support</a>
          </div>
        </div>
      </body>
      </html>
    `
    return {
      ...email,
      html: wrappedHtml,
      text: `MY COMPANY\n\n${email.text}\n\n© 2024 My Company\nUnsubscribe: [link] | Contact Support: [link]`
    }
  }
 })
 ```
 #### Advanced Email Wrapper with Dynamic Content
 ```typescript
 mailingPlugin({
  // ... other config
  emailWrapper: (email) => {
    // You can access email properties and customize based on content
    const isTransactional = email.subject?.includes('Receipt') || email.subject?.includes('Confirmation');
    const headerColor = isTransactional ? '#28a745' : '#007bff';
    const headerText = isTransactional ? 'Order Confirmation' : 'My Company';
    const wrappedHtml = `
      <!DOCTYPE html>
      <html lang="en">
      <head>
        <meta charset="utf-8">
        <meta name="viewport" content="width=device-width, initial-scale=1">
        <meta http-equiv="X-UA-Compatible" content="IE=edge">
        <title>${email.subject}</title>
        <!--[if mso]>
        <noscript>
          <xml>
            <o:OfficeDocumentSettings>
              <o:PixelsPerInch>96</o:PixelsPerInch>
            </o:OfficeDocumentSettings>
          </xml>
        </noscript>
        <![endif]-->
        <style>
          /* Reset styles */
          body, table, td, a { -webkit-text-size-adjust: 100%; -ms-text-size-adjust: 100%; }
          table, td { mso-table-lspace: 0pt; mso-table-rspace: 0pt; }
          img { -ms-interpolation-mode: bicubic; border: 0; outline: none; text-decoration: none; }
          /* Base styles */
          body {
            margin: 0 !important;
            padding: 0 !important;
            background-color: #f4f4f4;
            font-family: 'Segoe UI', Tahoma, Geneva, Verdana, sans-serif;
          }
          .email-container {
            max-width: 600px;
            margin: 0 auto;
            background-color: #ffffff;
            border-radius: 8px;
            overflow: hidden;
            box-shadow: 0 2px 10px rgba(0,0,0,0.1);
          }
          .email-header {
            background: linear-gradient(135deg, ${headerColor}, ${headerColor}dd);
            color: white;
            padding: 30px 20px;
            text-align: center;
          }
          .email-content {
            padding: 30px;
            color: #333333;
            line-height: 1.6;
          }
          .email-footer {
            background-color: #f8f9fa;
            padding: 20px;
            text-align: center;
            color: #6c757d;
            font-size: 14px;
            border-top: 1px solid #e9ecef;
          }
          .email-footer a {
            color: ${headerColor};
            text-decoration: none;
          }
          /* Responsive */
          @media only screen and (max-width: 600px) {
            .email-container {
              margin: 0 10px !important;
            }
            .email-header, .email-content {
              padding: 20px !important;
            }
          }
        </style>
      </head>
      <body>
        <div class="email-container">
          <div class="email-header">
            <h1 style="margin: 0; font-size: 24px;">${headerText}</h1>
          </div>
          <div class="email-content">
            ${email.html}
          </div>
          <div class="email-footer">
            <p style="margin: 0 0 10px;">© ${new Date().getFullYear()} My Company. All rights reserved.</p>
            <p style="margin: 0;">
              <a href="mailto:support@mycompany.com">Contact Support</a> |
              <a href="#">Privacy Policy</a> |
              <a href="#">Unsubscribe</a>
            </p>
          </div>
        </div>
      </body>
      </html>
    `
    // Also enhance the plain text version
    const wrappedText = `
 ${headerText.toUpperCase()}
 ${'='.repeat(headerText.length)}
 ${email.text || email.html?.replace(/<[^>]*>/g, '')}
 ---
 © ${new Date().getFullYear()} My Company. All rights reserved.
 Contact Support: support@mycompany.com
 Privacy Policy: [link]
 Unsubscribe: [link]
    `.trim();
    return {
      ...email,
      html: wrappedHtml,
      text: wrappedText
    }
  }
 })
 ```
 #### External CSS and Assets
 You can also reference external stylesheets and assets:
 ```typescript
 mailingPlugin({
  emailWrapper: (email) => {
    const wrappedHtml = `
      <!DOCTYPE html>
      <html>
      <head>
        <meta charset="utf-8">
        <meta name="viewport" content="width=device-width, initial-scale=1">
        <title>${email.subject}</title>
        <!-- External CSS -->
        <link href="https://fonts.googleapis.com/css2?family=Inter:wght@400;600&display=swap" rel="stylesheet">
        <style>
          body { font-family: 'Inter', sans-serif; }
          /* Your custom styles here */
        </style>
      </head>
      <body>
        <div style="max-width: 600px; margin: 0 auto;">
          <img src="https://mycompany.com/email-header.png" alt="My Company" style="width: 100%; height: auto;">
          <div style="padding: 20px;">
            ${email.html}
          </div>
          <img src="https://mycompany.com/email-footer.png" alt="Footer" style="width: 100%; height: auto;">
        </div>
      </body>
      </html>
    `;
    return { ...email, html: wrappedHtml };
  }
 })
 ```
 #### Template-Specific Layouts
 You can customize layouts based on email templates:
 ```typescript
 mailingPlugin({
  emailWrapper: (email, context) => {
    // Access template information if available
    const templateSlug = context?.templateSlug;
    let layoutClass = 'default-layout';
    let headerColor = '#007bff';
    if (templateSlug === 'welcome-email') {
      layoutClass = 'welcome-layout';
      headerColor = '#28a745';
    } else if (templateSlug === 'invoice-email') {
      layoutClass = 'invoice-layout';
      headerColor = '#dc3545';
    }
    const wrappedHtml = `
      <!DOCTYPE html>
      <html>
      <head>
        <meta charset="utf-8">
        <title>${email.subject}</title>
        <style>
          .${layoutClass} { /* template-specific styles */ }
          .header { background-color: ${headerColor}; }
        </style>
      </head>
      <body>
        <div class="${layoutClass}">
          ${email.html}
        </div>
      </body>
      </html>
    `;
    return { ...email, html: wrappedHtml };
  }
 })
 ```
 The `emailWrapper` hook receives the email object with `html`, `text`, and `subject` properties, and should return the modified email object with your custom layout applied.
 ### Custom Rich Text Editor
 Override the rich text editor used for templates:
@@ -473,73 +273,127 @@ mailingPlugin({
 })
 ```
-## Handlebars Helpers
+## Template Syntax Reference
-The plugin includes several built-in helpers:
+Depending on your chosen template engine, you can use different syntax:
- `{{formatDate date 'short'}}` - Format dates (short, long, or default)
+### LiquidJS (Default)
- `{{formatCurrency amount 'USD'}}` - Format currency
+- Variables: `{{ user.name }}`
- `{{capitalize string}}` - Capitalize first letter
+- Logic: `{% if user.isPremium %}Premium content{% endif %}`
- `{{#ifEquals value1 value2}}...{{/ifEquals}}` - Conditional equality
+- Loops: `{% for item in items %}{{ item.name }}{% endfor %}`
 - Filters: `{{ amount | formatCurrency }}`, `{{ date | formatDate: "short" }}`
-## API Methods
+### Mustache
 - Variables: `{{ user.name }}`
 - Logic: `{{#user.isPremium}}Premium content{{/user.isPremium}}`
 - Loops: `{{#items}}{{ name }}{{/items}}`
 - No built-in filters (use variables with pre-formatted data)
-### sendEmail(payload, options)
+### Simple
 - Variables only: `{{ user.name }}`, `{{ amount }}`, `{{ date }}`
-Send an email immediately:
+### Built-in Filters (LiquidJS only)
 - `formatDate` - Format dates: `{{ createdAt | formatDate: "short" }}`
 - `formatCurrency` - Format currency: `{{ amount | formatCurrency: "USD" }}`
 - `capitalize` - Capitalize first letter: `{{ name | capitalize }}`
 ## Available Helper Functions
 ```typescript
-const emailId = await sendEmail(payload, {
+import {
-  templateSlug: 'order-confirmation', // optional - use template slug
+  renderTemplate,    // Render email templates with variables
-  to: ['customer@example.com'],       // string or array of emails
+  processEmails,     // Process pending emails manually
-  cc: ['manager@example.com'],        // optional - array of emails
+  retryFailedEmails, // Retry failed emails
-  bcc: ['archive@example.com'],       // optional - array of emails  
+  getMailing        // Get mailing service instance
-  from: 'orders@yoursite.com',        // optional, uses default
+} from '@xtr-dev/payload-mailing'
-  replyTo: 'support@yoursite.com',    // optional
+
-  subject: 'Custom subject',          // required if no template
+// Render a template
-  html: '<h1>Custom HTML</h1>',       // required if no template
+const { html, text, subject } = await renderTemplate(payload, 'welcome', {
-  text: 'Custom text version',        // optional
+  name: 'John',
-  variables: {                        // template variables
+  activationUrl: 'https://example.com/activate'
    orderNumber: '12345',
    customerName: 'John Doe'
  },
  priority: 1                         // optional, 1-10 (1 = highest)
 })
 // Process emails manually
 await processEmails(payload)
 // Retry failed emails
 await retryFailedEmails(payload)
 ```
-### scheduleEmail(payload, options)
+## PayloadCMS Task Integration
-Schedule an email for later delivery:
+The plugin provides a ready-to-use PayloadCMS task for queuing template emails:
 ### 1. Add the task to your Payload config
 ```typescript
-const emailId = await scheduleEmail(payload, {
+import { buildConfig } from 'payload/config'
-  templateSlug: 'newsletter',
+import { sendTemplateEmailTask } from '@xtr-dev/payload-mailing'
-  to: ['user1@example.com', 'user2@example.com'],
+
-  scheduledAt: new Date('2024-01-15T10:00:00Z'),
+export default buildConfig({
-  variables: {
+  // ... your config
-    month: 'January',
+  jobs: {
-    highlights: ['Feature A', 'Feature B']
+    tasks: [
      sendTemplateEmailTask,
      // ... your other tasks
    ]
  }
 })
 ```
-### processEmails(payload)
+### 2. Queue emails from your code
 Manually process pending emails:
 ```typescript
-import { processEmails } from '@xtr-dev/payload-mailing'
+import type { SendTemplateEmailInput } from '@xtr-dev/payload-mailing'
-await processEmails(payload)
+
 // Queue a template email
 const result = await payload.jobs.queue({
  task: 'send-template-email',
  input: {
    templateSlug: 'welcome-email',
    to: ['user@example.com'],
    cc: ['manager@example.com'],
    variables: {
      firstName: 'John',
      activationUrl: 'https://example.com/activate/123'
    },
    priority: 1,
    // Add any custom fields from your email collection
    customField: 'value'
  } as SendTemplateEmailInput
 })
 // Queue a scheduled email
 await payload.jobs.queue({
  task: 'send-template-email',
  input: {
    templateSlug: 'reminder-email',
    to: ['user@example.com'],
    variables: { eventName: 'Product Launch' },
    scheduledAt: new Date('2024-01-15T10:00:00Z').toISOString(),
    priority: 3
  }
 })
 ```
-### retryFailedEmails(payload)
+### 3. Use in admin panel workflows
-Manually retry failed emails:
+The task can also be triggered from the Payload admin panel with a user-friendly form interface that includes:
 - Template slug selection
 - Email recipients (to, cc, bcc)
 - Template variables as JSON
 - Optional scheduling
 - Priority setting
 - Any custom fields you've added to your email collection
-```typescript
+### Task Benefits
-import { retryFailedEmails } from '@xtr-dev/payload-mailing'
+
-await retryFailedEmails(payload)
+- ✅ **Easy Integration**: Just add to your tasks array
-```
+- ✅ **Type Safety**: Full TypeScript support with `SendTemplateEmailInput`
 - ✅ **Admin UI**: Ready-to-use form interface
 - ✅ **Flexible**: Supports all your custom email collection fields
 - ✅ **Error Handling**: Comprehensive error reporting
 - ✅ **Queue Management**: Leverage Payload's job queue system
 ## Job Processing
@@ -716,35 +570,134 @@ import {
 } from '@xtr-dev/payload-mailing'
 ```
 ## API Reference
 ### `sendEmail<T>(payload, options)`
 Type-safe email sending with automatic template rendering and validation.
 ```typescript
 import { sendEmail } from '@xtr-dev/payload-mailing'
 import { Email } from './payload-types'
 const email = await sendEmail<Email>(payload, {
  template: {
    slug: 'template-slug',
    variables: { /* template variables */ }
  },
  data: {
    to: 'user@example.com',
    // Your custom fields are type-safe here!
  }
 })
 ```
 **Type Parameters:**
 - `T extends BaseEmailData` - Your generated Email type for full type safety
 **Options:**
 - `template.slug` - Template slug to render
 - `template.variables` - Variables to pass to template
 - `data` - Email data (merged with template output)
 - `collectionSlug` - Custom collection name (defaults to 'emails')
 ### `renderTemplate(payload, slug, variables)`
 Render an email template without sending.
 ```typescript
 const { html, text, subject } = await renderTemplate(
  payload,
  'welcome-email',
  { name: 'John' }
 )
 ```
 ### Helper Functions
 - `getMailing(payload)` - Get mailing context
 - `processEmails(payload)` - Manually trigger email processing
 - `retryFailedEmails(payload)` - Manually retry failed emails
 ## Migration Guide (v0.0.x → v0.1.0)
 **🚨 BREAKING CHANGES**: The API has been simplified to use Payload collections directly.
 ### Before (v0.0.x)
 ```typescript
 import { sendEmail, scheduleEmail } from '@xtr-dev/payload-mailing'
 // Old way
 const emailId = await sendEmail(payload, {
  templateSlug: 'welcome',
  to: 'user@example.com',
  variables: { name: 'John' }
 })
 const scheduledId = await scheduleEmail(payload, {
  templateSlug: 'reminder',
  to: 'user@example.com',
  scheduledAt: new Date('2024-01-15T10:00:00Z'),
  variables: { eventName: 'Launch' }
 })
 ```
 ### After (v0.1.0+)
 ```typescript
 import { renderTemplate } from '@xtr-dev/payload-mailing'
 // New way - render template first
 const { html, text, subject } = await renderTemplate(payload, 'welcome', {
  name: 'John'
 })
 // Then create email using Payload collections (full type safety!)
 const email = await payload.create({
  collection: 'emails',
  data: {
    to: ['user@example.com'],
    subject,
    html,
    text,
    // For scheduling
    scheduledAt: new Date('2024-01-15T10:00:00Z'),
    // Add any custom fields from your collection
    customField: 'value',
  }
 })
 ```
 ### Benefits of Migration
 - ✅ **Full TypeScript support** with your generated Payload types
 - ✅ **Use any custom fields** you add to your email collection
 - ✅ **Leverage Payload's features**: validation, hooks, access control
 - ✅ **One consistent API** - just use `payload.create()`
 - ✅ **No wrapper methods** - direct access to Payload's power
 ## Recent Changes
-### v0.0.x (Latest)
+### v0.1.0 (Latest - Breaking Changes)
-**🔄 Breaking Changes:**
+**🚀 Major API Simplification:**
- Removed email layouts system in favor of `emailWrapper` hook for better flexibility
+- **REMOVED**: `sendEmail()` and `scheduleEmail()` wrapper methods
- Email fields (`to`, `cc`, `bcc`) now use `hasMany: true` for proper array handling  
+- **REMOVED**: `SendEmailOptions` custom types
- Templates now use slug-based lookup instead of ID-based for developer-friendly API
+- **ADDED**: Direct Payload collection usage with full type safety
- Email collection renamed from "outbox" to "emails"
+- **ADDED**: `renderTemplate()` helper for template rendering
- Unified job processing: single `process-email-queue` job handles both pending and failed emails
+- **ADDED**: Support for LiquidJS, Mustache, and custom template engines
 - **IMPROVED**: Webpack compatibility with proper dynamic imports
-**✨ New Features:**
+**Template Engine Enhancements:**
- Rich text editor with automatic HTML/text conversion
+- **NEW**: LiquidJS support (default) with modern syntax and logic
- Template slugs for easier template reference
+- **NEW**: Mustache support for logic-less templates
- `emailWrapper` hook for consistent email layouts
+- **NEW**: Custom template renderer hook for maximum flexibility
- Custom rich text editor configuration support
+- **NEW**: Simple variable replacement as fallback
- Initialization hooks (`onReady`, `initOrder`) for better plugin lifecycle control
+- **FIXED**: All webpack compatibility issues resolved
 - Improved Handlebars variable interpolation with defensive programming
-**🐛 Bug Fixes:**
+**Developer Experience:**
- Fixed text version uppercase conversion in headings
+- **IMPROVED**: Full TypeScript inference using generated Payload types
- Fixed Handlebars interpolation issues in text version
+- **IMPROVED**: Comprehensive migration guide and documentation
- Improved plugin initialization order to prevent timing issues
+- **IMPROVED**: Better error handling and async patterns
-
+- **SIMPLIFIED**: Cleaner codebase with fewer abstractions
 **💡 Improvements:**
 - Better admin UI with proper array input controls
 - More robust error handling and logging
 - Enhanced TypeScript definitions
 - Simplified template creation workflow
 ## License
--- a/dev/README.md
+++ b/dev/README.md
@@ -184,25 +184,43 @@ The plugin automatically processes the outbox every 5 minutes and retries failed
 ## Plugin API Usage
 ```javascript
-import { sendEmail, scheduleEmail } from '@xtr-dev/payload-mailing'
+import { sendEmail } from '@xtr-dev/payload-mailing'
-// Send immediate email
+// Send immediate email with template
-const emailId = await sendEmail(payload, {
+const email = await sendEmail(payload, {
-  templateId: 'welcome-template-id',
+  template: {
-  to: 'user@example.com',
+    slug: 'welcome-email',
-  variables: {
+    variables: {
-    firstName: 'John',
+      firstName: 'John',
-    siteName: 'My App'
+      siteName: 'My App'
    }
  },
  data: {
    to: 'user@example.com',
  }
 })
-// Schedule email
+// Schedule email for later
-const scheduledId = await scheduleEmail(payload, {
+const scheduledEmail = await sendEmail(payload, {
-  templateId: 'reminder-template-id', 
+  template: {
-  to: 'user@example.com',
+    slug: 'reminder',
-  scheduledAt: new Date(Date.now() + 24 * 60 * 60 * 1000), // 24 hours
+    variables: {
-  variables: {
+      eventName: 'Product Launch'
-    eventName: 'Product Launch'
+    }
  },
  data: {
    to: 'user@example.com',
    scheduledAt: new Date(Date.now() + 24 * 60 * 60 * 1000), // 24 hours
  }
 })
 // Send direct HTML email (no template)
 const directEmail = await sendEmail(payload, {
  data: {
    to: 'user@example.com',
    subject: 'Direct Email',
    html: '<h1>Hello World</h1>',
    text: 'Hello World'
  }
 })
 ```
--- a/dev/app/api/test-email/route.ts
+++ b/dev/app/api/test-email/route.ts
@@ -1,37 +1,50 @@
 import { getPayload } from 'payload'
 import config from '@payload-config'
-import { sendEmail, scheduleEmail } from '@xtr-dev/payload-mailing'
+import { sendEmail } from '@xtr-dev/payload-mailing'
 export async function POST(request: Request) {
  try {
    const payload = await getPayload({ config })
    const body = await request.json()
-    const { type = 'send', templateSlug, to, variables, scheduledAt } = body
+    const { type = 'send', templateSlug, to, variables, scheduledAt, subject, html, text } = body
-    let result
+    // Use the new sendEmail API
-    if (type === 'send') {
+    const emailOptions: any = {
-      // Send immediately
+      data: {
      result = await sendEmail(payload, {
        templateSlug,
        to,
-        variables,
+      }
      })
    } else if (type === 'schedule') {
      // Schedule for later
      result = await scheduleEmail(payload, {
        templateSlug,
        to,
        variables,
        scheduledAt: scheduledAt ? new Date(scheduledAt) : new Date(Date.now() + 60000), // Default to 1 minute
      })
    } else {
      return Response.json({ error: 'Invalid type. Use "send" or "schedule"' }, { status: 400 })
    }
    // Add template if provided
    if (templateSlug) {
      emailOptions.template = {
        slug: templateSlug,
        variables: variables || {}
      }
    } else if (subject && html) {
      // Direct email without template
      emailOptions.data.subject = subject
      emailOptions.data.html = html
      if (text) {
        emailOptions.data.text = text
      }
    } else {
      return Response.json({
        error: 'Either templateSlug or subject+html must be provided'
      }, { status: 400 })
    }
    // Add scheduling if needed
    if (type === 'schedule' || scheduledAt) {
      emailOptions.data.scheduledAt = scheduledAt ? new Date(scheduledAt) : new Date(Date.now() + 60000)
    }
    const result = await sendEmail(payload, emailOptions)
    return Response.json({
      success: true,
-      emailId: result,
+      emailId: result.id,
-      message: type === 'send' ? 'Email sent successfully' : 'Email scheduled successfully',
+      message: scheduledAt ? 'Email scheduled successfully' : 'Email queued successfully',
    })
  } catch (error) {
    console.error('Test email error:', error)
--- a/dev/payload-types.ts
+++ b/dev/payload-types.ts
@@ -100,7 +100,8 @@ export interface Config {
  };
  jobs: {
    tasks: {
-      'process-email-queue': ProcessEmailQueueJob;
+      processEmails: ProcessEmailsJob;
      'send-email': TaskSendEmail;
      inline: {
        input: unknown;
        output: unknown;
@@ -232,21 +233,17 @@ export interface Email {
   */
  template?: (string | null) | EmailTemplate;
  /**
-   * Template slug used for this email
+   * Recipient email addresses
   */
-  templateSlug?: string | null;
+  to: string[];
  /**
-   * Recipient email address(es), comma-separated
+   * CC email addresses
   */
-  to: string;
+  cc?: string[] | null;
  /**
-   * CC email address(es), comma-separated
+   * BCC email addresses
   */
-  cc?: string | null;
+  bcc?: string[] | null;
  /**
   * BCC email address(es), comma-separated
   */
  bcc?: string | null;
  /**
   * Sender email address (optional, uses default if not provided)
   */
@@ -362,7 +359,7 @@ export interface PayloadJob {
    | {
        executedAt: string;
        completedAt: string;
-        taskSlug: 'inline' | 'process-email-queue';
+        taskSlug: 'inline' | 'processEmails' | 'send-email';
        taskID: string;
        input?:
          | {
@@ -395,7 +392,7 @@ export interface PayloadJob {
        id?: string | null;
      }[]
    | null;
-  taskSlug?: ('inline' | 'process-email-queue') | null;
+  taskSlug?: ('inline' | 'processEmails' | 'send-email') | null;
  queue?: string | null;
  waitUntil?: string | null;
  processing?: boolean | null;
@@ -542,7 +539,6 @@ export interface EmailTemplatesSelect<T extends boolean = true> {
 */
 export interface EmailsSelect<T extends boolean = true> {
  template?: T;
  templateSlug?: T;
  to?: T;
  cc?: T;
  bcc?: T;
@@ -627,12 +623,69 @@ export interface PayloadMigrationsSelect<T extends boolean = true> {
 }
 /**
 * This interface was referenced by `Config`'s JSON-Schema
- * via the `definition` "ProcessEmailQueueJob".
+ * via the `definition` "ProcessEmailsJob".
 */
-export interface ProcessEmailQueueJob {
+export interface ProcessEmailsJob {
  input?: unknown;
  output?: unknown;
 }
 /**
 * This interface was referenced by `Config`'s JSON-Schema
 * via the `definition` "TaskSend-email".
 */
 export interface TaskSendEmail {
  input: {
    /**
     * Use a template (leave empty for direct email)
     */
    templateSlug?: string | null;
    /**
     * JSON object with variables for template rendering
     */
    variables?:
      | {
          [k: string]: unknown;
        }
      | unknown[]
      | string
      | number
      | boolean
      | null;
    /**
     * Email subject (required if not using template)
     */
    subject?: string | null;
    /**
     * HTML email content (required if not using template)
     */
    html?: string | null;
    /**
     * Plain text email content (optional)
     */
    text?: string | null;
    /**
     * Comma-separated list of email addresses
     */
    to: string;
    /**
     * Optional comma-separated list of CC email addresses
     */
    cc?: string | null;
    /**
     * Optional comma-separated list of BCC email addresses
     */
    bcc?: string | null;
    /**
     * Optional date/time to schedule email for future delivery
     */
    scheduledAt?: string | null;
    /**
     * Email priority (1 = highest, 10 = lowest)
     */
    priority?: number | null;
  };
  output?: unknown;
 }
 /**
 * This interface was referenced by `Config`'s JSON-Schema
 * via the `definition` "auth".
--- a/dev/payload.config.ts
+++ b/dev/payload.config.ts
@@ -1,12 +1,10 @@
 import { mongooseAdapter } from '@payloadcms/db-mongodb'
 import { lexicalEditor } from '@payloadcms/richtext-lexical'
 import {
  BlocksFeature,
  FixedToolbarFeature,
  HeadingFeature,
  HorizontalRuleFeature,
  InlineToolbarFeature,
  lexicalHTML,
 } from '@payloadcms/richtext-lexical'
 import { MongoMemoryReplSet } from 'mongodb-memory-server'
 import path from 'path'
@@ -17,7 +15,7 @@ import { fileURLToPath } from 'url'
 import { testEmailAdapter } from './helpers/testEmailAdapter.js'
 import { seed, seedUser } from './seed.js'
 import mailingPlugin from "../src/plugin.js"
-import { sendEmail } from "../src/utils/helpers.js"
+import {sendEmail} from "@xtr-dev/payload-mailing"
 const filename = fileURLToPath(import.meta.url)
 const dirname = path.dirname(filename)
@@ -85,15 +83,19 @@ const buildConfigWithMemoryDB = async () => {
                  // Queue the welcome email using template slug
                  const emailId = await sendEmail(req.payload, {
-                    templateSlug: 'welcome-email',
+                    template: {
-                    to: doc.email,
+                      slug: 'welcome-email',
-                    variables: {
+                      variables: {
-                      firstName: doc.firstName || doc.email?.split('@')?.[0],
+                        firstName: doc.firstName || doc.email?.split('@')?.[0],
-                      siteName: 'PayloadCMS Mailing Demo',
+                        siteName: 'PayloadCMS Mailing Demo',
-                      createdAt: new Date().toISOString(),
+                        createdAt: new Date().toISOString(),
-                      isPremium: false,
+                        isPremium: false,
-                      dashboardUrl: 'http://localhost:3000/admin',
+                        dashboardUrl: 'http://localhost:3000/admin',
                      },
                    },
                    data: {
                      to: doc.email,
                    }
                  })
                  console.log('✅ Welcome email queued successfully. Email ID:', emailId)
@@ -280,56 +282,6 @@ const buildConfigWithMemoryDB = async () => {
          ],
        }),
        emailWrapper: (email) => {
          // Example: wrap email content in a custom layout
          const wrappedHtml = `
            <!DOCTYPE html>
            <html>
            <head>
              <meta charset="utf-8">
              <meta name="viewport" content="width=device-width, initial-scale=1">
              <title>${email.subject}</title>
              <style>
                body { font-family: Arial, sans-serif; margin: 0; padding: 20px; background-color: #f5f5f5; }
                .container { max-width: 600px; margin: 0 auto; background: white; border-radius: 8px; overflow: hidden; }
                .header { background: #007bff; color: white; padding: 20px; text-align: center; }
                .content { padding: 30px; }
                .footer { background: #f8f9fa; padding: 15px; text-align: center; font-size: 12px; color: #6c757d; }
              </style>
            </head>
            <body>
              <div class="container">
                <div class="header">
                  <h1>My Company</h1>
                </div>
                <div class="content">
                  ${email.html}
                </div>
                <div class="footer">
                  This email was sent from My Company. If you have questions, contact support@mycompany.com
                </div>
              </div>
            </body>
            </html>
          `
          const wrappedText = `
 MY COMPANY
 ==========
 ${email.text || email.html?.replace(/<[^>]*>/g, '')}
 ---
 This email was sent from My Company.
 If you have questions, contact support@mycompany.com
          `
          return {
            ...email,
            html: wrappedHtml,
            text: wrappedText.trim(),
          }
        },
        // Called after mailing plugin is fully initialized
        onReady: async (payload) => {
--- a/dev/seed.ts
+++ b/dev/seed.ts
@@ -102,7 +102,7 @@ export const seed = async (payload: Payload) => {
                        format: 0,
                        mode: 'normal',
                        style: '',
-                        text: 'Use the emailWrapper hook to add custom layouts',
+                        text: 'Create beautiful emails with rich text formatting',
                        type: 'text',
                        version: 1,
                      },
--- a/dev/test-plugin.mjs
+++ b/dev/test-plugin.mjs
@@ -1,10 +1,10 @@
 // Simple test to verify plugin can be imported and initialized
-import { mailingPlugin, sendEmail, scheduleEmail } from '@xtr-dev/payload-mailing'
+import { mailingPlugin, sendEmail, renderTemplate } from '@xtr-dev/payload-mailing'
 console.log('✅ Plugin imports successfully')
 console.log('✅ mailingPlugin:', typeof mailingPlugin)
-console.log('✅ sendEmail:', typeof sendEmail) 
+console.log('✅ sendEmail:', typeof sendEmail)
-console.log('✅ scheduleEmail:', typeof scheduleEmail)
+console.log('✅ renderTemplate:', typeof renderTemplate)
 // Test plugin configuration
 try {
--- a/dev/tsconfig.json
+++ b/dev/tsconfig.json
@@ -19,13 +19,13 @@
      "@payload-config": [
        "./payload.config.ts"
      ],
-      "temp-project": [
+      "@xtr-dev/payload-mailing": [
        "../src/index.ts"
      ],
-      "temp-project/client": [
+      "@xtr-dev/payload-mailing/client": [
        "../src/exports/client.ts"
      ],
-      "temp-project/rsc": [
+      "@xtr-dev/payload-mailing/rsc": [
        "../src/exports/rsc.ts"
      ]
    },
--- a/package.json
+++ b/package.json
@@ -1,6 +1,6 @@
 {
  "name": "@xtr-dev/payload-mailing",
-  "version": "0.0.12",
+  "version": "0.1.18",
  "description": "Template-based email system with scheduling and job processing for PayloadCMS",
  "type": "module",
  "main": "dist/index.js",
@@ -23,8 +23,9 @@
    "dev:generate-importmap": "npm run dev:payload generate:importmap",
    "dev:generate-types": "npm run dev:payload generate:types",
    "dev:payload": "cross-env PAYLOAD_CONFIG_PATH=./dev/payload.config.ts payload",
-    "generate:importmap": "npm run dev:generate-importmap",
+    "payload": "cross-env NODE_OPTIONS=--no-deprecation payload",
-    "generate:types": "npm run dev:generate-types",
+    "generate:importmap": "npm run payload generate:importmap",
    "generate:types": "npm run payload generate:types",
    "lint": "eslint",
    "lint:fix": "eslint ./src --fix",
    "prepublishOnly": "npm run clean && npm run build",
--- a/payload.config.ts
+++ b/payload.config.ts
@@ -0,0 +1,31 @@
 /**
 * This config is only used to generate types.
 */
 import { BaseDatabaseAdapter, buildConfig, Payload} from 'payload'
 import Emails from "./src/collections/Emails.js"
 import {createEmailTemplatesCollection} from "./src/collections/EmailTemplates.js"
 import path from "path"
 import { fileURLToPath } from 'url'
 const __filename = fileURLToPath(import.meta.url)
 const __dirname = path.dirname(__filename)
 export default buildConfig({
  collections: [
    Emails,
    createEmailTemplatesCollection()
  ],
  db: {
    allowIDOnCreate: undefined,
    defaultIDType: 'number',
    init: function (args: { payload: Payload; }): BaseDatabaseAdapter {
      throw new Error('Function not implemented.');
    },
    name: undefined
  },
  secret: '',
  typescript: {
    outputFile: path.resolve(__dirname, 'src/payload-types.ts'),
  }
 });
--- a/src/collections/Emails.ts
+++ b/src/collections/Emails.ts
@@ -49,6 +49,13 @@ const Emails: CollectionConfig = {
        description: 'Sender email address (optional, uses default if not provided)',
      },
    },
    {
      name: 'fromName',
      type: 'text',
      admin: {
        description: 'Sender display name (optional, e.g., "John Doe" for "John Doe <john@example.com>")',
      },
    },
    {
      name: 'replyTo',
      type: 'text',
--- a/src/index.ts
+++ b/src/index.ts
@@ -11,13 +11,19 @@ export { MailingService } from './services/MailingService.js'
 export { default as EmailTemplates, createEmailTemplatesCollection } from './collections/EmailTemplates.js'
 export { default as Emails } from './collections/Emails.js'
-// Jobs are integrated into the plugin configuration
+// Jobs (includes the send email task)
 export { mailingJobs, sendEmailJob } from './jobs/index.js'
 export type { SendEmailTaskInput } from './jobs/sendEmailTask.js'
 // Main email sending function
 export { sendEmail, type SendEmailOptions } from './sendEmail.js'
 export { default as sendEmailDefault } from './sendEmail.js'
 // Utility functions for developers
 export {
  getMailing,
-  sendEmail,
+  renderTemplate,
  scheduleEmail,
  processEmails,
  retryFailedEmails,
  parseAndValidateEmails,
 } from './utils/helpers.js'
--- a/src/jobs/index.ts
+++ b/src/jobs/index.ts
@@ -1,19 +1,35 @@
 import { processEmailsJob, ProcessEmailsJobData } from './processEmailsJob.js'
 import { sendEmailJob } from './sendEmailTask.js'
 import { MailingService } from '../services/MailingService.js'
-export const createMailingJobs = (mailingService: MailingService): any[] => {
+export const mailingJobs = [
-  return [
+  {
-    {
+    slug: 'processEmails',
-      slug: 'processEmails',
+    handler: async ({ job, req }: { job: any; req: any }) => {
-      handler: async ({ job, req }: { job: any; req: any }) => {
+      // Get mailing context from payload
-        return processEmailsJob(
+      const payload = (req as any).payload
-          job as { data: ProcessEmailsJobData },
+      const mailingContext = payload.mailing
-          { req, mailingService }
+      if (!mailingContext) {
-        )
+        throw new Error('Mailing plugin not properly initialized')
-      },
+      }
      interfaceName: 'ProcessEmailsJob',
    },
  ]
 }
-export * from './processEmailsJob.js'
+      // Use the existing mailing service from context
      await processEmailsJob(
        job as { data: ProcessEmailsJobData },
        { req, mailingService: mailingContext.service }
      )
      return {
        output: {
          success: true,
          message: 'Email queue processing completed successfully'
        }
      }
    },
    interfaceName: 'ProcessEmailsJob',
  },
  sendEmailJob,
 ]
 export * from './processEmailsJob.js'
 export * from './sendEmailTask.js'
--- a/src/jobs/processEmailsJob.ts
+++ b/src/jobs/processEmailsJob.ts
@@ -2,7 +2,7 @@ import type { PayloadRequest } from 'payload'
 import { MailingService } from '../services/MailingService.js'
 export interface ProcessEmailsJobData {
-  type: 'process-emails' | 'retry-failed'
+  // No type needed - always processes both pending and failed emails
 }
 export const processEmailsJob = async (
@@ -10,18 +10,19 @@ export const processEmailsJob = async (
  context: { req: PayloadRequest; mailingService: MailingService }
 ) => {
  const { mailingService } = context
  const { type } = job.data
  try {
-    if (type === 'process-emails') {
+    console.log('🔄 Processing email queue (pending + failed emails)...')
-      await mailingService.processEmails()
+
-      console.log('Email processing completed successfully')
+    // Process pending emails first
-    } else if (type === 'retry-failed') {
+    await mailingService.processEmails()
-      await mailingService.retryFailedEmails()
+
-      console.log('Failed email retry completed successfully')
+    // Then retry failed emails
-    }
+    await mailingService.retryFailedEmails()
    console.log('✅ Email queue processing completed successfully (pending and failed emails)')
  } catch (error) {
-    console.error(`${type} job failed:`, error)
+    console.error('❌ Email queue processing failed:', error)
    throw error
  }
 }
@@ -29,7 +30,6 @@ export const processEmailsJob = async (
 export const scheduleEmailsJob = async (
  payload: any,
  queueName: string,
  jobType: 'process-emails' | 'retry-failed',
  delay?: number
 ) => {
  if (!payload.jobs) {
@@ -41,10 +41,10 @@ export const scheduleEmailsJob = async (
    await payload.jobs.queue({
      queue: queueName,
      task: 'processEmails',
-      input: { type: jobType },
+      input: {},
      waitUntil: delay ? new Date(Date.now() + delay) : undefined,
    })
  } catch (error) {
-    console.error(`Failed to schedule ${jobType} job:`, error)
+    console.error('Failed to schedule email processing job:', error)
  }
 }
--- a/src/jobs/sendEmailTask.ts
+++ b/src/jobs/sendEmailTask.ts
@@ -0,0 +1,223 @@
 import { sendEmail } from '../sendEmail.js'
 import { BaseEmailDocument } from '../types/index.js'
 export interface SendEmailTaskInput {
  // Template mode fields
  templateSlug?: string
  variables?: Record<string, any>
  // Direct email mode fields
  subject?: string
  html?: string
  text?: string
  // Common fields
  to: string | string[]
  cc?: string | string[]
  bcc?: string | string[]
  from?: string
  fromName?: string
  replyTo?: string
  scheduledAt?: string | Date // ISO date string or Date object
  priority?: number
  // Allow any additional fields that users might have in their email collection
  [key: string]: any
 }
 /**
 * Transforms task input into sendEmail options by separating template and data fields
 */
 function transformTaskInputToSendEmailOptions(taskInput: SendEmailTaskInput) {
  const sendEmailOptions: any = {
    data: {}
  }
  // If using template mode, set template options
  if (taskInput.templateSlug) {
    sendEmailOptions.template = {
      slug: taskInput.templateSlug,
      variables: taskInput.variables || {}
    }
  }
  // Standard email fields that should be copied to data
  const standardFields = ['to', 'cc', 'bcc', 'from', 'fromName', 'replyTo', 'subject', 'html', 'text', 'scheduledAt', 'priority']
  // Template-specific fields that should not be copied to data
  const templateFields = ['templateSlug', 'variables']
  // Copy standard fields to data
  standardFields.forEach(field => {
    if (taskInput[field] !== undefined) {
      sendEmailOptions.data[field] = taskInput[field]
    }
  })
  // Copy any additional custom fields that aren't template or standard fields
  Object.keys(taskInput).forEach(key => {
    if (!templateFields.includes(key) && !standardFields.includes(key)) {
      sendEmailOptions.data[key] = taskInput[key]
    }
  })
  return sendEmailOptions
 }
 export const sendEmailJob = {
  slug: 'send-email',
  label: 'Send Email',
  inputSchema: [
    {
      name: 'templateSlug',
      type: 'text' as const,
      label: 'Template Slug',
      admin: {
        description: 'Use a template (leave empty for direct email)',
        condition: (data: any) => !data.subject && !data.html
      }
    },
    {
      name: 'variables',
      type: 'json' as const,
      label: 'Template Variables',
      admin: {
        description: 'JSON object with variables for template rendering',
        condition: (data: any) => Boolean(data.templateSlug)
      }
    },
    {
      name: 'subject',
      type: 'text' as const,
      label: 'Subject',
      admin: {
        description: 'Email subject (required if not using template)',
        condition: (data: any) => !data.templateSlug
      }
    },
    {
      name: 'html',
      type: 'textarea' as const,
      label: 'HTML Content',
      admin: {
        description: 'HTML email content (required if not using template)',
        condition: (data: any) => !data.templateSlug
      }
    },
    {
      name: 'text',
      type: 'textarea' as const,
      label: 'Text Content',
      admin: {
        description: 'Plain text email content (optional)',
        condition: (data: any) => !data.templateSlug
      }
    },
    {
      name: 'to',
      type: 'text' as const,
      required: true,
      label: 'To (Email Recipients)',
      admin: {
        description: 'Comma-separated list of email addresses'
      }
    },
    {
      name: 'cc',
      type: 'text' as const,
      label: 'CC (Carbon Copy)',
      admin: {
        description: 'Optional comma-separated list of CC email addresses'
      }
    },
    {
      name: 'bcc',
      type: 'text' as const,
      label: 'BCC (Blind Carbon Copy)',
      admin: {
        description: 'Optional comma-separated list of BCC email addresses'
      }
    },
    {
      name: 'from',
      type: 'text' as const,
      label: 'From Email',
      admin: {
        description: 'Optional sender email address (uses default if not provided)'
      }
    },
    {
      name: 'fromName',
      type: 'text' as const,
      label: 'From Name',
      admin: {
        description: 'Optional sender display name (e.g., "John Doe")'
      }
    },
    {
      name: 'replyTo',
      type: 'text' as const,
      label: 'Reply To',
      admin: {
        description: 'Optional reply-to email address'
      }
    },
    {
      name: 'scheduledAt',
      type: 'date' as const,
      label: 'Schedule For',
      admin: {
        description: 'Optional date/time to schedule email for future delivery'
      }
    },
    {
      name: 'priority',
      type: 'number' as const,
      label: 'Priority',
      min: 1,
      max: 10,
      defaultValue: 5,
      admin: {
        description: 'Email priority (1 = highest, 10 = lowest)'
      }
    }
  ],
  outputSchema: [
    {
      name: 'id',
      type: 'text' as const
    }
  ],
  handler: async ({ input, payload }: any) => {
    // Cast input to our expected type
    const taskInput = input as SendEmailTaskInput
    try {
      // Transform task input into sendEmail options using helper function
      const sendEmailOptions = transformTaskInputToSendEmailOptions(taskInput)
      // Use the sendEmail helper to create the email
      const email = await sendEmail<BaseEmailDocument>(payload, sendEmailOptions)
      return {
        output: {
          success: true,
          id: email.id,
        }
      }
    } catch (error) {
      if (error instanceof Error) {
        // Preserve original error and stack trace
        const wrappedError = new Error(`Failed to queue email: ${error.message}`)
        wrappedError.stack = error.stack
        wrappedError.cause = error
        throw wrappedError
      } else {
        throw new Error(`Failed to queue email: ${String(error)}`)
      }
    }
  }
 }
 export default sendEmailJob
--- a/src/payload-types.ts
+++ b/src/payload-types.ts
@@ -0,0 +1,431 @@
 /* tslint:disable */
 /* eslint-disable */
 /**
 * This file was automatically generated by Payload.
 * DO NOT MODIFY IT BY HAND. Instead, modify your source Payload config,
 * and re-run `payload generate:types` to regenerate this file.
 */
 /**
 * Supported timezones in IANA format.
 *
 * This interface was referenced by `Config`'s JSON-Schema
 * via the `definition` "supportedTimezones".
 */
 export type SupportedTimezones =
  | 'Pacific/Midway'
  | 'Pacific/Niue'
  | 'Pacific/Honolulu'
  | 'Pacific/Rarotonga'
  | 'America/Anchorage'
  | 'Pacific/Gambier'
  | 'America/Los_Angeles'
  | 'America/Tijuana'
  | 'America/Denver'
  | 'America/Phoenix'
  | 'America/Chicago'
  | 'America/Guatemala'
  | 'America/New_York'
  | 'America/Bogota'
  | 'America/Caracas'
  | 'America/Santiago'
  | 'America/Buenos_Aires'
  | 'America/Sao_Paulo'
  | 'Atlantic/South_Georgia'
  | 'Atlantic/Azores'
  | 'Atlantic/Cape_Verde'
  | 'Europe/London'
  | 'Europe/Berlin'
  | 'Africa/Lagos'
  | 'Europe/Athens'
  | 'Africa/Cairo'
  | 'Europe/Moscow'
  | 'Asia/Riyadh'
  | 'Asia/Dubai'
  | 'Asia/Baku'
  | 'Asia/Karachi'
  | 'Asia/Tashkent'
  | 'Asia/Calcutta'
  | 'Asia/Dhaka'
  | 'Asia/Almaty'
  | 'Asia/Jakarta'
  | 'Asia/Bangkok'
  | 'Asia/Shanghai'
  | 'Asia/Singapore'
  | 'Asia/Tokyo'
  | 'Asia/Seoul'
  | 'Australia/Brisbane'
  | 'Australia/Sydney'
  | 'Pacific/Guam'
  | 'Pacific/Noumea'
  | 'Pacific/Auckland'
  | 'Pacific/Fiji';
 export interface Config {
  auth: {
    users: UserAuthOperations;
  };
  blocks: {};
  collections: {
    emails: Email;
    'email-templates': EmailTemplate;
    users: User;
    'payload-locked-documents': PayloadLockedDocument;
    'payload-preferences': PayloadPreference;
    'payload-migrations': PayloadMigration;
  };
  collectionsJoins: {};
  collectionsSelect: {
    emails: EmailsSelect<false> | EmailsSelect<true>;
    'email-templates': EmailTemplatesSelect<false> | EmailTemplatesSelect<true>;
    users: UsersSelect<false> | UsersSelect<true>;
    'payload-locked-documents': PayloadLockedDocumentsSelect<false> | PayloadLockedDocumentsSelect<true>;
    'payload-preferences': PayloadPreferencesSelect<false> | PayloadPreferencesSelect<true>;
    'payload-migrations': PayloadMigrationsSelect<false> | PayloadMigrationsSelect<true>;
  };
  db: {
    defaultIDType: number;
  };
  globals: {};
  globalsSelect: {};
  locale: null;
  user: User & {
    collection: 'users';
  };
  jobs: {
    tasks: unknown;
    workflows: unknown;
  };
 }
 export interface UserAuthOperations {
  forgotPassword: {
    email: string;
    password: string;
  };
  login: {
    email: string;
    password: string;
  };
  registerFirstUser: {
    email: string;
    password: string;
  };
  unlock: {
    email: string;
    password: string;
  };
 }
 /**
 * Email delivery and status tracking
 *
 * This interface was referenced by `Config`'s JSON-Schema
 * via the `definition` "emails".
 */
 export interface Email {
  id: number;
  /**
   * Email template used (optional if custom content provided)
   */
  template?: (number | null) | EmailTemplate;
  /**
   * Recipient email addresses
   */
  to: string[];
  /**
   * CC email addresses
   */
  cc?: string[] | null;
  /**
   * BCC email addresses
   */
  bcc?: string[] | null;
  /**
   * Sender email address (optional, uses default if not provided)
   */
  from?: string | null;
  /**
   * Reply-to email address
   */
  replyTo?: string | null;
  /**
   * Email subject line
   */
  subject: string;
  /**
   * Rendered HTML content of the email
   */
  html: string;
  /**
   * Plain text version of the email
   */
  text?: string | null;
  /**
   * Template variables used to render this email
   */
  variables?:
    | {
        [k: string]: unknown;
      }
    | unknown[]
    | string
    | number
    | boolean
    | null;
  /**
   * When this email should be sent (leave empty for immediate)
   */
  scheduledAt?: string | null;
  /**
   * When this email was actually sent
   */
  sentAt?: string | null;
  /**
   * Current status of this email
   */
  status: 'pending' | 'processing' | 'sent' | 'failed';
  /**
   * Number of send attempts made
   */
  attempts?: number | null;
  /**
   * When the last send attempt was made
   */
  lastAttemptAt?: string | null;
  /**
   * Last error message if send failed
   */
  error?: string | null;
  /**
   * Email priority (1=highest, 10=lowest)
   */
  priority?: number | null;
  updatedAt: string;
  createdAt: string;
 }
 /**
 * This interface was referenced by `Config`'s JSON-Schema
 * via the `definition` "email-templates".
 */
 export interface EmailTemplate {
  id: number;
  /**
   * A descriptive name for this email template
   */
  name: string;
  /**
   * Unique identifier for this template (e.g., "welcome-email", "password-reset")
   */
  slug: string;
  /**
   * Email subject line. You can use Handlebars variables like {{firstName}} or {{siteName}}.
   */
  subject: string;
  /**
   * Email content with rich text formatting. Supports Handlebars variables like {{firstName}} and helpers like {{formatDate createdAt "long"}}. Content is converted to HTML and plain text automatically.
   */
  content: {
    root: {
      type: string;
      children: {
        type: string;
        version: number;
        [k: string]: unknown;
      }[];
      direction: ('ltr' | 'rtl') | null;
      format: 'left' | 'start' | 'center' | 'right' | 'end' | 'justify' | '';
      indent: number;
      version: number;
    };
    [k: string]: unknown;
  };
  updatedAt: string;
  createdAt: string;
 }
 /**
 * This interface was referenced by `Config`'s JSON-Schema
 * via the `definition` "users".
 */
 export interface User {
  id: number;
  updatedAt: string;
  createdAt: string;
  email: string;
  resetPasswordToken?: string | null;
  resetPasswordExpiration?: string | null;
  salt?: string | null;
  hash?: string | null;
  loginAttempts?: number | null;
  lockUntil?: string | null;
  sessions?:
    | {
        id: string;
        createdAt?: string | null;
        expiresAt: string;
      }[]
    | null;
  password?: string | null;
 }
 /**
 * This interface was referenced by `Config`'s JSON-Schema
 * via the `definition` "payload-locked-documents".
 */
 export interface PayloadLockedDocument {
  id: number;
  document?:
    | ({
        relationTo: 'emails';
        value: number | Email;
      } | null)
    | ({
        relationTo: 'email-templates';
        value: number | EmailTemplate;
      } | null)
    | ({
        relationTo: 'users';
        value: number | User;
      } | null);
  globalSlug?: string | null;
  user: {
    relationTo: 'users';
    value: number | User;
  };
  updatedAt: string;
  createdAt: string;
 }
 /**
 * This interface was referenced by `Config`'s JSON-Schema
 * via the `definition` "payload-preferences".
 */
 export interface PayloadPreference {
  id: number;
  user: {
    relationTo: 'users';
    value: number | User;
  };
  key?: string | null;
  value?:
    | {
        [k: string]: unknown;
      }
    | unknown[]
    | string
    | number
    | boolean
    | null;
  updatedAt: string;
  createdAt: string;
 }
 /**
 * This interface was referenced by `Config`'s JSON-Schema
 * via the `definition` "payload-migrations".
 */
 export interface PayloadMigration {
  id: number;
  name?: string | null;
  batch?: number | null;
  updatedAt: string;
  createdAt: string;
 }
 /**
 * This interface was referenced by `Config`'s JSON-Schema
 * via the `definition` "emails_select".
 */
 export interface EmailsSelect<T extends boolean = true> {
  template?: T;
  to?: T;
  cc?: T;
  bcc?: T;
  from?: T;
  replyTo?: T;
  subject?: T;
  html?: T;
  text?: T;
  variables?: T;
  scheduledAt?: T;
  sentAt?: T;
  status?: T;
  attempts?: T;
  lastAttemptAt?: T;
  error?: T;
  priority?: T;
  updatedAt?: T;
  createdAt?: T;
 }
 /**
 * This interface was referenced by `Config`'s JSON-Schema
 * via the `definition` "email-templates_select".
 */
 export interface EmailTemplatesSelect<T extends boolean = true> {
  name?: T;
  slug?: T;
  subject?: T;
  content?: T;
  updatedAt?: T;
  createdAt?: T;
 }
 /**
 * This interface was referenced by `Config`'s JSON-Schema
 * via the `definition` "users_select".
 */
 export interface UsersSelect<T extends boolean = true> {
  updatedAt?: T;
  createdAt?: T;
  email?: T;
  resetPasswordToken?: T;
  resetPasswordExpiration?: T;
  salt?: T;
  hash?: T;
  loginAttempts?: T;
  lockUntil?: T;
  sessions?:
    | T
    | {
        id?: T;
        createdAt?: T;
        expiresAt?: T;
      };
 }
 /**
 * This interface was referenced by `Config`'s JSON-Schema
 * via the `definition` "payload-locked-documents_select".
 */
 export interface PayloadLockedDocumentsSelect<T extends boolean = true> {
  document?: T;
  globalSlug?: T;
  user?: T;
  updatedAt?: T;
  createdAt?: T;
 }
 /**
 * This interface was referenced by `Config`'s JSON-Schema
 * via the `definition` "payload-preferences_select".
 */
 export interface PayloadPreferencesSelect<T extends boolean = true> {
  user?: T;
  key?: T;
  value?: T;
  updatedAt?: T;
  createdAt?: T;
 }
 /**
 * This interface was referenced by `Config`'s JSON-Schema
 * via the `definition` "payload-migrations_select".
 */
 export interface PayloadMigrationsSelect<T extends boolean = true> {
  name?: T;
  batch?: T;
  updatedAt?: T;
  createdAt?: T;
 }
 /**
 * This interface was referenced by `Config`'s JSON-Schema
 * via the `definition` "auth".
 */
 export interface Auth {
  [k: string]: unknown;
 }
 declare module 'payload' {
  export interface GeneratedTypes extends Config {}
 }
--- a/src/plugin.ts
+++ b/src/plugin.ts
@@ -3,53 +3,8 @@ import { MailingPluginConfig, MailingContext } from './types/index.js'
 import { MailingService } from './services/MailingService.js'
 import { createEmailTemplatesCollection } from './collections/EmailTemplates.js'
 import Emails from './collections/Emails.js'
 import { mailingJobs, scheduleEmailsJob } from './jobs/index.js'
 // Helper function to schedule the email processing job
 async function scheduleEmailProcessingJob(payload: any, queueName: string, delayMs: number = 60000): Promise<boolean> {
  if (!queueName || typeof queueName !== 'string') {
    throw new Error('Invalid queueName: must be a non-empty string')
  }
  const jobSlug = 'process-email-queue'
  // Check if there's already a scheduled job for this task
  const existingJobs = await payload.find({
    collection: 'payload-jobs',
    where: {
      and: [
        {
          taskSlug: {
            equals: jobSlug,
          },
        },
        {
          hasCompleted: {
            equals: false,
          },
        },
      ],
    },
    limit: 1,
  })
  // If no existing job, schedule a new one
  if (existingJobs.docs.length === 0) {
    await payload.create({
      collection: 'payload-jobs',
      data: {
        taskSlug: jobSlug,
        input: {},
        queue: queueName,
        waitUntil: new Date(Date.now() + delayMs),
      },
    })
    console.log(`🔄 Scheduled email processing job in queue: ${queueName}`)
    return true
  } else {
    console.log(`✅ Email processing job already scheduled in queue: ${queueName}`)
    return false
  }
 }
 export const mailingPlugin = (pluginConfig: MailingPluginConfig) => (config: Config): Config => {
  const queueName = pluginConfig.queue || 'default'
@@ -59,6 +14,7 @@ export const mailingPlugin = (pluginConfig: MailingPluginConfig) => (config: Con
    throw new Error('Invalid queue configuration: queue must be a non-empty string')
  }
  // Handle templates collection configuration
  const templatesConfig = pluginConfig.collections?.templates
  const templatesSlug = typeof templatesConfig === 'string' ? templatesConfig : 'email-templates'
@@ -129,61 +85,7 @@ export const mailingPlugin = (pluginConfig: MailingPluginConfig) => (config: Con
      ...(config.jobs || {}),
      tasks: [
        ...(config.jobs?.tasks || []),
-        {
+        ...mailingJobs,
          slug: 'process-email-queue',
          handler: async ({ job, req }: { job: any; req: any }) => {
            const payload = (req as any).payload
            let jobResult = null
            try {
              const mailingService = new MailingService(payload, pluginConfig)
              console.log('🔄 Processing email queue (pending + failed emails)...')
              // Process pending emails first
              await mailingService.processEmails()
              // Then retry failed emails
              await mailingService.retryFailedEmails()
              jobResult = {
                output: {
                  success: true,
                  message: 'Email queue processed successfully (pending and failed emails)'
                }
              }
              console.log('✅ Email queue processing completed successfully')
            } catch (error) {
              console.error('❌ Error processing email queue:', error)
              const errorMessage = error instanceof Error ? error.message : 'Unknown error'
              jobResult = new Error(`Email queue processing failed: ${errorMessage}`)
            }
            // Always reschedule the next job (success or failure) using duplicate prevention
            let rescheduled = false
            try {
              rescheduled = await scheduleEmailProcessingJob(payload, queueName, 300000) // Reschedule in 5 minutes
              if (rescheduled) {
                console.log(`🔄 Rescheduled next email processing job in ${queueName} queue`)
              }
            } catch (rescheduleError) {
              console.error('❌ Failed to reschedule email processing job:', rescheduleError)
              // If rescheduling fails, we should warn but not fail the current job
              // since the email processing itself may have succeeded
              console.warn('⚠️  Email processing completed but next job could not be scheduled')
            }
            // Return the original result or throw the error
            if (jobResult instanceof Error) {
              throw jobResult
            }
            return jobResult
          },
          interfaceName: 'ProcessEmailQueueJob',
        },
      ],
    },
    onInit: async (payload: any) => {
@@ -191,7 +93,7 @@ export const mailingPlugin = (pluginConfig: MailingPluginConfig) => (config: Con
        await config.onInit(payload)
      }
-      // Initialize mailing service
+      // Initialize mailing service with proper payload instance
      const mailingService = new MailingService(payload, pluginConfig)
      // Add mailing context to payload for developer access
@@ -207,9 +109,10 @@ export const mailingPlugin = (pluginConfig: MailingPluginConfig) => (config: Con
      console.log('PayloadCMS Mailing Plugin initialized successfully')
-      // Schedule the email processing job if not already scheduled
+      // Schedule the initial email processing job
      try {
-        await scheduleEmailProcessingJob(payload, queueName)
+        await scheduleEmailsJob(payload, queueName, 60000) // Schedule in 1 minute
        console.log(`🔄 Scheduled initial email processing job in queue: ${queueName}`)
      } catch (error) {
        console.error('Failed to schedule email processing job:', error)
      }
--- a/src/sendEmail.ts
+++ b/src/sendEmail.ts
@@ -0,0 +1,145 @@
 import { Payload } from 'payload'
 import { getMailing, renderTemplate, parseAndValidateEmails } from './utils/helpers.js'
 import { BaseEmailDocument } from './types/index.js'
 // Options for sending emails
 export interface SendEmailOptions<T extends BaseEmailDocument = BaseEmailDocument> {
  // Template-based email
  template?: {
    slug: string
    variables?: Record<string, any>
  }
  // Direct email data
  data?: Partial<T>
  // Common options
  collectionSlug?: string // defaults to 'emails'
 }
 /**
 * Send an email with full type safety
 *
 * @example
 * ```typescript
 * // With your generated Email type
 * import { Email } from './payload-types'
 *
 * const email = await sendEmail<Email>(payload, {
 *   template: {
 *     slug: 'welcome',
 *     variables: { name: 'John' }
 *   },
 *   data: {
 *     to: 'user@example.com',
 *     customField: 'value' // Your custom fields are type-safe!
 *   }
 * })
 * ```
 */
 export const sendEmail = async <TEmail extends BaseEmailDocument = BaseEmailDocument>(
  payload: Payload,
  options: SendEmailOptions<TEmail>
 ): Promise<TEmail> => {
  const mailing = getMailing(payload)
  const collectionSlug = options.collectionSlug || mailing.collections.emails || 'emails'
  let emailData: Partial<TEmail> = { ...options.data } as Partial<TEmail>
  // If using a template, render it first
  if (options.template) {
    const { html, text, subject } = await renderTemplate(
      payload,
      options.template.slug,
      options.template.variables || {}
    )
    // Template values take precedence over data values
    emailData = {
      ...emailData,
      subject,
      html,
      text,
    } as Partial<TEmail>
  }
  // Validate required fields
  if (!emailData.to) {
    throw new Error('Field "to" is required for sending emails')
  }
  // Validate required fields based on whether template was used
  if (options.template) {
    // When using template, subject and html should have been set by renderTemplate
    if (!emailData.subject || !emailData.html) {
      throw new Error(`Template rendering failed: template "${options.template.slug}" did not provide required subject and html content`)
    }
  } else {
    // When not using template, user must provide subject and html directly
    if (!emailData.subject || !emailData.html) {
      throw new Error('Fields "subject" and "html" are required when sending direct emails without a template')
    }
  }
  // Process email addresses using shared validation (handle null values)
  if (emailData.to) {
    emailData.to = parseAndValidateEmails(emailData.to as string | string[])
  }
  if (emailData.cc && emailData.cc !== null) {
    emailData.cc = parseAndValidateEmails(emailData.cc as string | string[])
  }
  if (emailData.bcc && emailData.bcc !== null) {
    emailData.bcc = parseAndValidateEmails(emailData.bcc as string | string[])
  }
  if (emailData.replyTo && emailData.replyTo !== null) {
    const validated = parseAndValidateEmails(emailData.replyTo as string | string[])
    // replyTo should be a single email, so take the first one if array
    emailData.replyTo = validated && validated.length > 0 ? validated[0] : undefined
  }
  if (emailData.from && emailData.from !== null) {
    const validated = parseAndValidateEmails(emailData.from as string | string[])
    // from should be a single email, so take the first one if array
    emailData.from = validated && validated.length > 0 ? validated[0] : undefined
  }
  // Sanitize fromName to prevent header injection
  if (emailData.fromName && emailData.fromName !== null) {
    emailData.fromName = emailData.fromName
      .trim()
      // Remove/replace newlines and carriage returns to prevent header injection
      .replace(/[\r\n]/g, ' ')
      // Remove control characters (except space and printable characters)
      .replace(/[\x00-\x1F\x7F-\x9F]/g, '')
      // Note: We don't escape quotes here as that's handled in MailingService
  }
  // Normalize Date objects to ISO strings for consistent database storage
  if (emailData.scheduledAt instanceof Date) {
    emailData.scheduledAt = emailData.scheduledAt.toISOString()
  }
  if (emailData.sentAt instanceof Date) {
    emailData.sentAt = emailData.sentAt.toISOString()
  }
  if (emailData.lastAttemptAt instanceof Date) {
    emailData.lastAttemptAt = emailData.lastAttemptAt.toISOString()
  }
  if (emailData.createdAt instanceof Date) {
    emailData.createdAt = emailData.createdAt.toISOString()
  }
  if (emailData.updatedAt instanceof Date) {
    emailData.updatedAt = emailData.updatedAt.toISOString()
  }
  // Create the email in the collection with proper typing
  const email = await payload.create({
    collection: collectionSlug,
    data: emailData
  })
  // Validate that the created email has the expected structure
  if (!email || typeof email !== 'object' || !email.id) {
    throw new Error('Failed to create email: invalid response from database')
  }
  return email as TEmail
 }
 export default sendEmail
--- a/src/services/MailingService.ts
+++ b/src/services/MailingService.ts
@@ -3,22 +3,21 @@ import { Liquid } from 'liquidjs'
 import nodemailer, { Transporter } from 'nodemailer'
 import {
  MailingPluginConfig,
-  SendEmailOptions,
+  TemplateVariables,
  MailingService as IMailingService,
  EmailTemplate,
  QueuedEmail,
  MailingTransportConfig,
-  EmailObject
+  BaseEmail, BaseEmailTemplate, BaseEmailDocument, BaseEmailTemplateDocument
 } from '../types/index.js'
 import { serializeRichTextToHTML, serializeRichTextToText } from '../utils/richTextSerializer.js'
 export class MailingService implements IMailingService {
-  private payload: Payload
+  public payload: Payload
  private config: MailingPluginConfig
  private transporter!: Transporter | any
  private templatesCollection: string
  private emailsCollection: string
  private liquid: Liquid | null | false = null
  private transporterInitialized = false
  constructor(payload: Payload, config: MailingPluginConfig) {
    this.payload = payload
@@ -30,10 +29,15 @@ export class MailingService implements IMailingService {
    const emailsConfig = config.collections?.emails
    this.emailsCollection = typeof emailsConfig === 'string' ? emailsConfig : 'emails'
-    this.initializeTransporter()
+    // Only initialize transporter if payload is properly set
    if (payload && payload.db) {
      this.initializeTransporter()
    }
  }
  private initializeTransporter(): void {
    if (this.transporterInitialized) return
    if (this.config.transport) {
      if ('sendMail' in this.config.transport) {
        this.transporter = this.config.transport
@@ -46,6 +50,43 @@ export class MailingService implements IMailingService {
    } else {
      throw new Error('Email transport configuration is required either in plugin config or Payload config')
    }
    this.transporterInitialized = true
  }
  private ensureInitialized(): void {
    if (!this.payload || !this.payload.db) {
      throw new Error('MailingService payload not properly initialized')
    }
    if (!this.transporterInitialized) {
      this.initializeTransporter()
    }
  }
  /**
   * Sanitizes a display name for use in email headers to prevent header injection
   * and ensure proper formatting
   */
  private sanitizeDisplayName(name: string): string {
    return name
      .trim()
      // Remove/replace newlines and carriage returns to prevent header injection
      .replace(/[\r\n]/g, ' ')
      // Remove control characters (except space and printable characters)
      .replace(/[\x00-\x1F\x7F-\x9F]/g, '')
      // Escape quotes to prevent malformed headers
      .replace(/"/g, '\\"')
  }
  /**
   * Formats an email address with optional display name
   */
  private formatEmailAddress(email: string, displayName?: string | null): string {
    if (displayName && displayName.trim()) {
      const sanitizedName = this.sanitizeDisplayName(displayName)
      return `"${sanitizedName}" <${email}>`
    }
    return email
  }
  private getDefaultFrom(): string {
@@ -54,9 +95,7 @@ export class MailingService implements IMailingService {
    // Check if fromName exists, is not empty after trimming, and fromEmail exists
    if (fromName && fromName.trim() && fromEmail) {
-      // Escape quotes in the display name to prevent malformed headers
+      return this.formatEmailAddress(fromEmail, fromName)
      const escapedName = fromName.replace(/"/g, '\\"')
      return `"${escapedName}" <${fromEmail}>`
    }
    return fromEmail || ''
@@ -107,72 +146,26 @@ export class MailingService implements IMailingService {
    }
  }
-  async sendEmail(options: SendEmailOptions): Promise<string> {
+  async renderTemplate(templateSlug: string, variables: TemplateVariables): Promise<{ html: string; text: string; subject: string }> {
-    const emailId = await this.scheduleEmail({
+    this.ensureInitialized()
-      ...options,
+    const template = await this.getTemplateBySlug(templateSlug)
      scheduledAt: new Date()
    })
-    await this.processEmailItem(emailId)
+    if (!template) {
-
+      throw new Error(`Email template not found: ${templateSlug}`)
    return emailId
  }
  async scheduleEmail(options: SendEmailOptions): Promise<string> {
    let html = options.html || ''
    let text = options.text || ''
    let subject = options.subject || ''
    let templateId: string | undefined = undefined
    if (options.templateSlug) {
      const template = await this.getTemplateBySlug(options.templateSlug)
      if (template) {
        templateId = template.id
        const variables = options.variables || {}
        const renderedContent = await this.renderEmailTemplate(template, variables)
        html = renderedContent.html
        text = renderedContent.text
        subject = await this.renderTemplate(template.subject, variables)
      } else {
        throw new Error(`Email template not found: ${options.templateSlug}`)
      }
    }
-    if (!subject && !options.subject) {
+    const emailContent = await this.renderEmailTemplate(template, variables)
-      throw new Error('Email subject is required')
+    const subject = await this.renderTemplateString(template.subject || '', variables)
    return {
      html: emailContent.html,
      text: emailContent.text,
      subject
    }
    if (!html && !options.html) {
      throw new Error('Email HTML content is required')
    }
    const queueData = {
      template: templateId,
      to: Array.isArray(options.to) ? options.to : [options.to],
      cc: options.cc ? (Array.isArray(options.cc) ? options.cc : [options.cc]) : undefined,
      bcc: options.bcc ? (Array.isArray(options.bcc) ? options.bcc : [options.bcc]) : undefined,
      from: options.from || this.getDefaultFrom(),
      replyTo: options.replyTo,
      subject: subject || options.subject,
      html,
      text,
      variables: options.variables,
      scheduledAt: options.scheduledAt?.toISOString(),
      status: 'pending' as const,
      attempts: 0,
      priority: options.priority || 5,
    }
    const result = await this.payload.create({
      collection: this.emailsCollection as any,
      data: queueData,
    })
    return result.id as string
  }
  async processEmails(): Promise<void> {
    this.ensureInitialized()
    const currentTime = new Date().toISOString()
    const { docs: pendingEmails } = await this.payload.find({
@@ -210,6 +203,7 @@ export class MailingService implements IMailingService {
  }
  async retryFailedEmails(): Promise<void> {
    this.ensureInitialized()
    const maxAttempts = this.config.retryAttempts || 3
    const retryDelay = this.config.retryDelay || 300000 // 5 minutes
    const retryTime = new Date(Date.now() - retryDelay).toISOString()
@@ -266,10 +260,18 @@ export class MailingService implements IMailingService {
      const email = await this.payload.findByID({
        collection: this.emailsCollection as any,
        id: emailId,
-      }) as QueuedEmail
+      }) as BaseEmailDocument
-      let emailObject: EmailObject = {
+      // Combine from and fromName for nodemailer using proper sanitization
-        from: email.from || this.getDefaultFrom(),
+      let fromField: string
      if (email.from) {
        fromField = this.formatEmailAddress(email.from, email.fromName)
      } else {
        fromField = this.getDefaultFrom()
      }
      const mailOptions = {
        from: fromField,
        to: email.to,
        cc: email.cc || undefined,
        bcc: email.bcc || undefined,
@@ -277,23 +279,6 @@ export class MailingService implements IMailingService {
        subject: email.subject,
        html: email.html,
        text: email.text || undefined,
        variables: email.variables,
      }
      // Apply emailWrapper hook if configured
      if (this.config.emailWrapper) {
        emailObject = await this.config.emailWrapper(emailObject)
      }
      const mailOptions = {
        from: emailObject.from,
        to: emailObject.to,
        cc: emailObject.cc || undefined,
        bcc: emailObject.bcc || undefined,
        replyTo: emailObject.replyTo || undefined,
        subject: emailObject.subject,
        html: emailObject.html,
        text: emailObject.text || undefined,
      }
      await this.transporter.sendMail(mailOptions)
@@ -332,7 +317,7 @@ export class MailingService implements IMailingService {
    const email = await this.payload.findByID({
      collection: this.emailsCollection as any,
      id: emailId,
-    }) as QueuedEmail
+    }) as BaseEmail
    const newAttempts = (email.attempts || 0) + 1
@@ -347,7 +332,7 @@ export class MailingService implements IMailingService {
    return newAttempts
  }
-  private async getTemplateBySlug(templateSlug: string): Promise<EmailTemplate | null> {
+  private async getTemplateBySlug(templateSlug: string): Promise<BaseEmailTemplateDocument | null> {
    try {
      const { docs } = await this.payload.find({
        collection: this.templatesCollection as any,
@@ -359,14 +344,14 @@ export class MailingService implements IMailingService {
        limit: 1,
      })
-      return docs.length > 0 ? docs[0] as EmailTemplate : null
+      return docs.length > 0 ? docs[0] as BaseEmailTemplateDocument : null
    } catch (error) {
      console.error(`Template with slug '${templateSlug}' not found:`, error)
      return null
    }
  }
-  private async renderTemplate(template: string, variables: Record<string, any>): Promise<string> {
+  private async renderTemplateString(template: string, variables: Record<string, any>): Promise<string> {
    // Use custom template renderer if provided
    if (this.config.templateRenderer) {
      try {
@@ -424,7 +409,7 @@ export class MailingService implements IMailingService {
    })
  }
-  private async renderEmailTemplate(template: EmailTemplate, variables: Record<string, any> = {}): Promise<{ html: string; text: string }> {
+  private async renderEmailTemplate(template: BaseEmailTemplateDocument, variables: Record<string, any> = {}): Promise<{ html: string; text: string }> {
    if (!template.content) {
      return { html: '', text: '' }
    }
@@ -434,8 +419,8 @@ export class MailingService implements IMailingService {
    let text = serializeRichTextToText(template.content)
    // Apply template variables to the rendered content
-    html = await this.renderTemplate(html, variables)
+    html = await this.renderTemplateString(html, variables)
-    text = await this.renderTemplate(text, variables)
+    text = await this.renderTemplateString(text, variables)
    return { html, text }
  }
--- a/src/types/index.ts
+++ b/src/types/index.ts
@@ -2,19 +2,47 @@ import { Payload } from 'payload'
 import type { CollectionConfig, RichTextField } from 'payload'
 import { Transporter } from 'nodemailer'
-export interface EmailObject {
+// JSON value type that matches Payload's JSON field type
-  to: string | string[]
+export type JSONValue = string | number | boolean | { [k: string]: unknown } | unknown[] | null | undefined
-  cc?: string | string[]
+
-  bcc?: string | string[]
+// Generic base interfaces that work with any ID type and null values
-  from?: string
+export interface BaseEmailDocument {
-  replyTo?: string
+  id: string | number
  template?: any
  to: string[]
  cc?: string[] | null
  bcc?: string[] | null
  from?: string | null
  fromName?: string | null
  replyTo?: string | null
  subject: string
  html: string
-  text?: string
+  text?: string | null
-  variables?: Record<string, any>
+  variables?: JSONValue
  scheduledAt?: string | Date | null
  sentAt?: string | Date | null
  status?: 'pending' | 'processing' | 'sent' | 'failed' | null
  attempts?: number | null
  lastAttemptAt?: string | Date | null
  error?: string | null
  priority?: number | null
  createdAt?: string | Date | null
  updatedAt?: string | Date | null
 }
-export type EmailWrapperHook = (email: EmailObject) => EmailObject | Promise<EmailObject>
+export interface BaseEmailTemplateDocument {
  id: string | number
  name: string
  slug: string
  subject?: string | null
  content?: any
  createdAt?: string | Date | null
  updatedAt?: string | Date | null
 }
 export type BaseEmail<TEmail extends BaseEmailDocument = BaseEmailDocument, TEmailTemplate extends BaseEmailTemplateDocument = BaseEmailTemplateDocument> = Omit<TEmail, 'id' | 'template'> & {template: Omit<TEmailTemplate, 'id'> | TEmailTemplate['id'] | undefined | null}
 export type BaseEmailTemplate<TEmailTemplate extends BaseEmailTemplateDocument = BaseEmailTemplateDocument> = Omit<TEmailTemplate, 'id'>
 export type TemplateRendererHook = (template: string, variables: Record<string, any>) => string | Promise<string>
@@ -31,7 +59,6 @@ export interface MailingPluginConfig {
  queue?: string
  retryAttempts?: number
  retryDelay?: number
  emailWrapper?: EmailWrapperHook
  templateRenderer?: TemplateRendererHook
  templateEngine?: TemplateEngine
  richTextEditor?: RichTextField['editor']
@@ -49,60 +76,40 @@ export interface MailingTransportConfig {
  }
 }
 export interface EmailTemplate {
  id: string
  name: string
  slug: string
  subject: string
  content: any // Lexical editor state
  createdAt: string
  updatedAt: string
 }
 export interface QueuedEmail {
  id: string
-  template?: string
+  template?: string | null
  to: string[]
-  cc?: string[]
+  cc?: string[] | null
-  bcc?: string[]
+  bcc?: string[] | null
-  from?: string
+  from?: string | null
-  replyTo?: string
+  fromName?: string | null
  replyTo?: string | null
  subject: string
  html: string
-  text?: string
+  text?: string | null
-  variables?: Record<string, any>
+  variables?: JSONValue
-  scheduledAt?: string
+  scheduledAt?: string | Date | null
-  sentAt?: string
+  sentAt?: string | Date | null
  status: 'pending' | 'processing' | 'sent' | 'failed'
  attempts: number
-  lastAttemptAt?: string
+  lastAttemptAt?: string | Date | null
-  error?: string
+  error?: string | null
-  priority?: number
+  priority?: number | null
  createdAt: string
  updatedAt: string
 }
-export interface SendEmailOptions {
+// Simple helper type for template variables
-  templateSlug?: string
+export interface TemplateVariables {
-  to: string | string[]
+  [key: string]: any
  cc?: string | string[]
  bcc?: string | string[]
  from?: string
  replyTo?: string
  subject?: string
  html?: string
  text?: string
  variables?: Record<string, any>
  scheduledAt?: Date
  priority?: number
 }
 export interface MailingService {
  sendEmail(options: SendEmailOptions): Promise<string>
  scheduleEmail(options: SendEmailOptions): Promise<string>
  processEmails(): Promise<void>
  retryFailedEmails(): Promise<void>
  renderTemplate(templateSlug: string, variables: TemplateVariables): Promise<{ html: string; text: string; subject: string }>
 }
 export interface MailingContext {
--- a/src/utils/helpers.ts
+++ b/src/utils/helpers.ts
@@ -1,5 +1,40 @@
 import { Payload } from 'payload'
-import { SendEmailOptions } from '../types/index.js'
+import { TemplateVariables } from '../types/index.js'
 /**
 * Parse and validate email addresses
 * @internal
 */
 export const parseAndValidateEmails = (emails: string | string[] | null | undefined): string[] | undefined => {
  if (!emails || emails === null) return undefined
  let emailList: string[]
  if (Array.isArray(emails)) {
    emailList = emails
  } else {
    emailList = emails.split(',').map(email => email.trim()).filter(Boolean)
  }
  // RFC 5322 compliant email validation
  const emailRegex = /^[a-zA-Z0-9.!#$%&'*+/=?^_`{|}~-]+@[a-zA-Z0-9](?:[a-zA-Z0-9-]{0,61}[a-zA-Z0-9])?(?:\.[a-zA-Z0-9](?:[a-zA-Z0-9-]{0,61}[a-zA-Z0-9])?)*$/
  const invalidEmails = emailList.filter(email => {
    // Check basic format
    if (!emailRegex.test(email)) return true
    // Check for common invalid patterns
    if (email.includes('..') || email.startsWith('.') || email.endsWith('.')) return true
    if (email.includes('@.') || email.includes('.@')) return true
    // Check domain has at least one dot
    const parts = email.split('@')
    if (parts.length !== 2 || !parts[1].includes('.')) return true
    return false
  })
  if (invalidEmails.length > 0) {
    throw new Error(`Invalid email addresses: ${invalidEmails.join(', ')}`)
  }
  return emailList
 }
 export const getMailing = (payload: Payload) => {
  const mailing = (payload as any).mailing
@@ -9,14 +44,9 @@ export const getMailing = (payload: Payload) => {
  return mailing
 }
-export const sendEmail = async (payload: Payload, options: SendEmailOptions): Promise<string> => {
+export const renderTemplate = async (payload: Payload, templateSlug: string, variables: TemplateVariables): Promise<{ html: string; text: string; subject: string }> => {
  const mailing = getMailing(payload)
-  return mailing.service.sendEmail(options)
+  return mailing.service.renderTemplate(templateSlug, variables)
 }
 export const scheduleEmail = async (payload: Payload, options: SendEmailOptions): Promise<string> => {
  const mailing = getMailing(payload)
  return mailing.service.scheduleEmail(options)
 }
 export const processEmails = async (payload: Payload): Promise<void> => {
--- a/template-syntax-migration.md
+++ b/template-syntax-migration.md
@@ -1,160 +0,0 @@
 # Template Engine Options
 The plugin now supports flexible template rendering with multiple options:
 1. **String-based Configuration** (easy setup with built-in engines)
 2. **Custom Template Renderer Hook** (maximum flexibility)
 3. **Simple Variable Replacement** (fallback, no dependencies)
 ## Configuration Options
 ### String-based Template Engine Configuration
 Easy setup using built-in template engines:
 ```typescript
 // Using LiquidJS (default, requires: npm install liquidjs)
 mailingPlugin({
  templateEngine: 'liquidjs'
 })
 // Using Mustache (requires: npm install mustache)
 mailingPlugin({
  templateEngine: 'mustache'
 })
 // Using simple variable replacement (no dependencies)
 mailingPlugin({
  templateEngine: 'simple'
 })
 ```
 ### Custom Template Renderer Hook
 ```typescript
 // Example with Handlebars
 import Handlebars from 'handlebars'
 mailingPlugin({
  templateRenderer: async (template: string, variables: Record<string, any>) => {
    const compiled = Handlebars.compile(template)
    return compiled(variables)
  }
 })
 // Example with Mustache
 import Mustache from 'mustache'
 mailingPlugin({
  templateRenderer: async (template: string, variables: Record<string, any>) => {
    return Mustache.render(template, variables)
  }
 })
 // Example with Nunjucks
 import nunjucks from 'nunjucks'
 mailingPlugin({
  templateRenderer: async (template: string, variables: Record<string, any>) => {
    return nunjucks.renderString(template, variables)
  }
 })
 ```
 ### Using LiquidJS (Optional)
 Install the optional dependency:
 ```bash
 npm install liquidjs
 # or
 pnpm add liquidjs
 ```
 ### Fallback Mode
 If no custom renderer is provided and neither LiquidJS nor Mustache are installed, simple `{{variable}}` replacement is used.
 ## Template Syntax Reference
 ### Mustache Syntax (Logic-less)
 ```mustache
 Hello {{user.name}},
 {{#user.isPremium}}
  Welcome to premium! Your balance is {{balance}}.
 {{/user.isPremium}}
 {{#orders}}
  Order: {{id}} - {{date}}
 {{/orders}}
 ```
 ### LiquidJS Syntax (With Logic)
 ```liquid
 Hello {{user.name}},
 {% if user.isPremium %}
  Welcome to premium! Your balance is {{balance | formatCurrency}}.
 {% endif %}
 {% for order in orders %}
  Order: {{order.id}} - {{order.date | formatDate: "short"}}
 {% endfor %}
 ```
 ### Simple Variable Replacement
 ```
 Hello {{user.name}},
 Your balance is {{balance}}.
 ```
 ## Migration from Handlebars
 ### Variables
 - **Handlebars**: `{{variable}}`
 - **LiquidJS**: `{{variable}}` (same)
 ### Conditionals
 - **Handlebars**: `{{#if condition}}content{{/if}}`
 - **LiquidJS**: `{% if condition %}content{% endif %}`
 ### Loops
 - **Handlebars**: `{{#each items}}{{this}}{{/each}}`
 - **LiquidJS**: `{% for item in items %}{{item}}{% endfor %}`
 ### Filters/Helpers
 - **Handlebars**: `{{formatDate date "short"}}`
 - **LiquidJS**: `{{date | formatDate: "short"}}`
 ### Available Filters
 - `formatDate` - Format dates (short, long, or default)
 - `formatCurrency` - Format currency amounts
 - `capitalize` - Capitalize first letter
 ### Comparison Operations (LiquidJS Advantage)
 - **Handlebars**: Required `{{#ifEquals}}` helper
 - **LiquidJS**: Built-in: `{% if user.role == "admin" %}`
 ## Example Migration
 ### Before (Handlebars)
 ```handlebars
 Hello {{user.name}},
 {{#if user.isPremium}}
  Welcome to premium! Your balance is {{formatCurrency balance}}.
 {{/if}}
 {{#each orders}}
  Order: {{this.id}} - {{formatDate this.date "short"}}
 {{/each}}
 ```
 ### After (LiquidJS)
 ```liquid
 Hello {{user.name}},
 {% if user.isPremium %}
  Welcome to premium! Your balance is {{balance | formatCurrency}}.
 {% endif %}
 {% for order in orders %}
  Order: {{order.id}} - {{order.date | formatDate: "short"}}
 {% endfor %}
 ```