Merge pull request #38 from xtr-dev/dev

Add debug log for email transporter configuration and bump version to…
Add debug log for email transporter configuration and bump version to 0.1.23
2025-12-10 08:13:23 +00:00 · 2025-09-14 16:15:41 +02:00 · 2025-09-14 16:14:56 +02:00 · 2025-09-14 13:53:32 +02:00 · 2025-09-14 13:52:49 +02:00 · 2025-09-14 12:37:38 +02:00
17 changed files with 1069 additions and 510 deletions
--- a/README.md
+++ b/README.md
@@ -139,13 +139,21 @@ mailingPlugin({
  retryDelay: 300000,            // 5 minutes (default)

  // Advanced options
-  emailWrapper: (email) => ({    // optional layout wrapper
-    ...email,
-    html: `<html><body>${email.html}</body></html>`
-  }),
  richTextEditor: lexicalEditor(),  // optional custom editor
  onReady: async (payload) => {     // optional initialization hook
    console.log('Mailing plugin ready!')
+  },
+
+  // beforeSend hook - modify emails before sending
+  beforeSend: async (options, email) => {
+    // Add attachments, modify headers, etc.
+    options.attachments = [
+      { filename: 'invoice.pdf', content: pdfBuffer }
+    ]
+    options.headers = {
+      'X-Campaign-ID': email.campaignId
+    }
+    return options
  }
 })
 ```
@@ -227,7 +235,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"}}.
@@ -238,282 +246,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:
@@ -535,6 +267,56 @@ mailingPlugin({
 })
 ```

+### beforeSend Hook
+
+Modify emails before they are sent to add attachments, custom headers, or make other changes:
+
+```typescript
+mailingPlugin({
+  // ... other config
+  beforeSend: async (options, email) => {
+    // Add attachments dynamically
+    if (email.invoiceId) {
+      const invoice = await generateInvoicePDF(email.invoiceId)
+      options.attachments = [
+        {
+          filename: `invoice-${email.invoiceId}.pdf`,
+          content: invoice.buffer,
+          contentType: 'application/pdf'
+        }
+      ]
+    }
+
+    // Add custom headers
+    options.headers = {
+      'X-Campaign-ID': email.campaignId,
+      'X-Customer-ID': email.customerId,
+      'X-Priority': email.priority === 1 ? 'High' : 'Normal'
+    }
+
+    // Modify recipients based on conditions
+    if (process.env.NODE_ENV === 'development') {
+      // Redirect all emails to test address in dev
+      options.to = ['test@example.com']
+      options.subject = `[TEST] ${options.subject}`
+    }
+
+    // Add BCC for compliance
+    if (email.requiresAudit) {
+      options.bcc = ['audit@company.com']
+    }
+
+    return options
+  }
+})
+```
+
+The `beforeSend` hook receives:
+- `options`: The nodemailer mail options that will be sent
+- `email`: The full email document from the database
+
+You must return the modified options object.
+
 ### Initialization Hooks

 Control plugin initialization order and add post-initialization logic:
--- 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,25 +233,25 @@ 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 email address(es), comma-separated
-   */
-  bcc?: string | null;
+  bcc?: string[] | null;
  /**
   * Sender email address (optional, uses default if not provided)
   */
  from?: string | null;
+  /**
+   * Sender display name (optional, e.g., "John Doe" for "John Doe <john@example.com>")
+   */
+  fromName?: string | null;
  /**
   * Reply-to email address
   */
@@ -362,7 +363,7 @@ export interface PayloadJob {
    | {
        executedAt: string;
        completedAt: string;
-        taskSlug: 'inline' | 'process-email-queue';
+        taskSlug: 'inline' | 'processEmails' | 'send-email';
        taskID: string;
        input?:
          | {
@@ -395,7 +396,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,11 +543,11 @@ export interface EmailTemplatesSelect<T extends boolean = true> {
 */
 export interface EmailsSelect<T extends boolean = true> {
  template?: T;
-  templateSlug?: T;
  to?: T;
  cc?: T;
  bcc?: T;
  from?: T;
+  fromName?: T;
  replyTo?: T;
  subject?: T;
  html?: T;
@@ -627,12 +628,83 @@ 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 sender email address (uses default if not provided)
+     */
+    from?: string | null;
+    /**
+     * Optional sender display name (e.g., "John Doe")
+     */
+    fromName?: string | null;
+    /**
+     * Optional reply-to email address
+     */
+    replyTo?: string | null;
+    /**
+     * Optional date/time to schedule email for future delivery
+     */
+    scheduledAt?: string | null;
+    /**
+     * Email priority (1 = highest, 10 = lowest)
+     */
+    priority?: number | null;
+  };
+  output: {
+    id?: string | null;
+  };
+}
 /**
 * 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',
-                    to: doc.email,
-                    variables: {
-                      firstName: doc.firstName || doc.email?.split('@')?.[0],
-                      siteName: 'PayloadCMS Mailing Demo',
-                      createdAt: new Date().toISOString(),
-                      isPremium: false,
-                      dashboardUrl: 'http://localhost:3000/admin',
+                    template: {
+                      slug: 'welcome-email',
+                      variables: {
+                        firstName: doc.firstName || doc.email?.split('@')?.[0],
+                        siteName: 'PayloadCMS Mailing Demo',
+                        createdAt: new Date().toISOString(),
+                        isPremium: false,
+                        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-hook-validation.ts
+++ b/dev/test-hook-validation.ts
@@ -0,0 +1,113 @@
+// Test hook validation in the dev environment
+import { getPayload } from 'payload'
+import config from './payload.config.js'
+
+async function testHookValidation() {
+  const payload = await getPayload({ config: await config })
+
+  console.log('\n🧪 Testing beforeSend hook validation...\n')
+
+  // Test 1: Create an email to process
+  const email = await payload.create({
+    collection: 'emails',
+    data: {
+      to: ['test@example.com'],
+      subject: 'Test Email for Validation',
+      html: '<p>Testing hook validation</p>',
+      text: 'Testing hook validation',
+      status: 'pending'
+    }
+  })
+
+  console.log('✅ Test email created:', email.id)
+
+  // Get the mailing service
+  const mailingService = (payload as any).mailing.service
+
+  // Test 2: Temporarily replace the config with a bad hook
+  const originalBeforeSend = mailingService.config.beforeSend
+
+  console.log('\n📝 Test: Hook that removes "from" field...')
+  mailingService.config.beforeSend = async (options: any, email: any) => {
+    delete options.from
+    return options
+  }
+
+  try {
+    await mailingService.processEmails()
+    console.log('❌ Should have thrown error for missing "from"')
+  } catch (error: any) {
+    if (error.message.includes('must not remove the "from" property')) {
+      console.log('✅ Correctly caught missing "from" field')
+    } else {
+      console.log('❌ Unexpected error:', error.message)
+    }
+  }
+
+  console.log('\n📝 Test: Hook that empties "to" array...')
+  mailingService.config.beforeSend = async (options: any, email: any) => {
+    options.to = []
+    return options
+  }
+
+  try {
+    await mailingService.processEmails()
+    console.log('❌ Should have thrown error for empty "to"')
+  } catch (error: any) {
+    if (error.message.includes('must not remove or empty the "to" property')) {
+      console.log('✅ Correctly caught empty "to" array')
+    } else {
+      console.log('❌ Unexpected error:', error.message)
+    }
+  }
+
+  console.log('\n📝 Test: Hook that removes "subject"...')
+  mailingService.config.beforeSend = async (options: any, email: any) => {
+    delete options.subject
+    return options
+  }
+
+  try {
+    await mailingService.processEmails()
+    console.log('❌ Should have thrown error for missing "subject"')
+  } catch (error: any) {
+    if (error.message.includes('must not remove the "subject" property')) {
+      console.log('✅ Correctly caught missing "subject" field')
+    } else {
+      console.log('❌ Unexpected error:', error.message)
+    }
+  }
+
+  console.log('\n📝 Test: Hook that removes both "html" and "text"...')
+  mailingService.config.beforeSend = async (options: any, email: any) => {
+    delete options.html
+    delete options.text
+    return options
+  }
+
+  try {
+    await mailingService.processEmails()
+    console.log('❌ Should have thrown error for missing content')
+  } catch (error: any) {
+    if (error.message.includes('must not remove both "html" and "text" properties')) {
+      console.log('✅ Correctly caught missing content fields')
+    } else {
+      console.log('❌ Unexpected error:', error.message)
+    }
+  }
+
+  // Restore original hook
+  mailingService.config.beforeSend = originalBeforeSend
+
+  console.log('\n✅ All validation tests completed!\n')
+
+  // Clean up
+  await payload.delete({
+    collection: 'emails',
+    id: email.id
+  })
+
+  process.exit(0)
+}
+
+testHookValidation().catch(console.error)
--- 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.1.6",
+  "version": "0.1.23",
  "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",
-    "generate:types": "npm run dev:generate-types",
+    "payload": "cross-env NODE_OPTIONS=--no-deprecation payload",
+    "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
@@ -16,7 +16,7 @@ export { mailingJobs, sendEmailJob } from './jobs/index.js'
 export type { SendEmailTaskInput } from './jobs/sendEmailTask.js'

 // Main email sending function
-export { sendEmail, type BaseEmailData, type SendEmailOptions } from './sendEmail.js'
+export { sendEmail, type SendEmailOptions } from './sendEmail.js'
 export { default as sendEmailDefault } from './sendEmail.js'

 // Utility functions for developers
--- a/src/jobs/sendEmailTask.ts
+++ b/src/jobs/sendEmailTask.ts
@@ -1,4 +1,5 @@
-import { sendEmail, type BaseEmailData } from '../sendEmail.js'
+import { sendEmail } from '../sendEmail.js'
+import { BaseEmailDocument } from '../types/index.js'

 export interface SendEmailTaskInput {
  // Template mode fields
@@ -14,13 +15,55 @@ export interface SendEmailTaskInput {
  to: string | string[]
  cc?: string | string[]
  bcc?: string | string[]
-  scheduledAt?: string // ISO date 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',
@@ -95,6 +138,30 @@ export const sendEmailJob = {
        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,
@@ -115,62 +182,40 @@ export const sendEmailJob = {
      }
    }
  ],
+  outputSchema: [
+    {
+      name: 'id',
+      type: 'text' as const
+    }
+  ],
  handler: async ({ input, payload }: any) => {
    // Cast input to our expected type
    const taskInput = input as SendEmailTaskInput

    try {
-      // Prepare options for sendEmail based on task input
-      const sendEmailOptions: any = {
-        data: {}
-      }
-
-      // If using template mode
-      if (taskInput.templateSlug) {
-        sendEmailOptions.template = {
-          slug: taskInput.templateSlug,
-          variables: taskInput.variables || {}
-        }
-      }
-
-      // Build data object from task input
-      const dataFields = ['to', 'cc', 'bcc', 'subject', 'html', 'text', 'scheduledAt', 'priority']
-      const additionalFields: string[] = []
-
-      // Copy standard fields
-      dataFields.forEach(field => {
-        if (taskInput[field] !== undefined) {
-          sendEmailOptions.data[field] = taskInput[field]
-        }
-      })
-
-      // Copy any additional custom fields
-      Object.keys(taskInput).forEach(key => {
-        if (!['templateSlug', 'variables', ...dataFields].includes(key)) {
-          sendEmailOptions.data[key] = taskInput[key]
-          additionalFields.push(key)
-        }
-      })
+      // 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<BaseEmailData>(payload, sendEmailOptions)
+      const email = await sendEmail<BaseEmailDocument>(payload, sendEmailOptions)

      return {
        output: {
          success: true,
-          emailId: email.id,
-          message: `Email queued successfully with ID: ${email.id}`,
-          mode: taskInput.templateSlug ? 'template' : 'direct',
-          templateSlug: taskInput.templateSlug || null,
-          subject: email.subject,
-          recipients: Array.isArray(email.to) ? email.to.length : 1,
-          scheduledAt: email.scheduledAt || null
+          id: email.id,
        }
      }

    } catch (error) {
-      const errorMessage = error instanceof Error ? error.message : 'Unknown error'
-      throw new Error(`Failed to queue email: ${errorMessage}`)
+      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)}`)
+      }
    }
  }
 }
--- a/src/payload-types.ts
+++ b/src/payload-types.ts
@@ -0,0 +1,436 @@
+/* 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;
+  /**
+   * Sender display name (optional, e.g., "John Doe" for "John Doe <john@example.com>")
+   */
+  fromName?: 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;
+  fromName?: 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
@@ -74,10 +74,15 @@ export const mailingPlugin = (pluginConfig: MailingPluginConfig) => (config: Con
    }),
  } satisfies CollectionConfig

+  // Filter out any existing collections with the same slugs to prevent duplicates
+  const existingCollections = (config.collections || []).filter(
+    (collection) => collection.slug !== templatesSlug && collection.slug !== emailsSlug
+  )
+
  return {
    ...config,
    collections: [
-      ...(config.collections || []),
+      ...existingCollections,
      templatesCollection,
      emailsCollection,
    ],
--- a/src/sendEmail.ts
+++ b/src/sendEmail.ts
@@ -1,21 +1,9 @@
 import { Payload } from 'payload'
 import { getMailing, renderTemplate, parseAndValidateEmails } from './utils/helpers.js'
-
-// Base type for email data that all emails must have
-export interface BaseEmailData {
-  to: string | string[]
-  cc?: string | string[]
-  bcc?: string | string[]
-  subject?: string
-  html?: string
-  text?: string
-  scheduledAt?: string | Date
-  priority?: number
-  [key: string]: any
-}
+import { BaseEmailDocument } from './types/index.js'

 // Options for sending emails
-export interface SendEmailOptions<T extends BaseEmailData = BaseEmailData> {
+export interface SendEmailOptions<T extends BaseEmailDocument = BaseEmailDocument> {
  // Template-based email
  template?: {
    slug: string
@@ -47,14 +35,14 @@ export interface SendEmailOptions<T extends BaseEmailData = BaseEmailData> {
 * })
 * ```
 */
-export const sendEmail = async <T extends BaseEmailData = BaseEmailData>(
+export const sendEmail = async <TEmail extends BaseEmailDocument = BaseEmailDocument>(
  payload: Payload,
-  options: SendEmailOptions<T>
-): Promise<T> => {
+  options: SendEmailOptions<TEmail>
+): Promise<TEmail> => {
  const mailing = getMailing(payload)
  const collectionSlug = options.collectionSlug || mailing.collections.emails || 'emails'

-  let emailData: Partial<T> = { ...options.data } as Partial<T>
+  let emailData: Partial<TEmail> = { ...options.data } as Partial<TEmail>

  // If using a template, render it first
  if (options.template) {
@@ -70,7 +58,7 @@ export const sendEmail = async <T extends BaseEmailData = BaseEmailData>(
      subject,
      html,
      text,
-    } as Partial<T>
+    } as Partial<TEmail>
  }

  // Validate required fields
@@ -78,11 +66,20 @@ export const sendEmail = async <T extends BaseEmailData = BaseEmailData>(
    throw new Error('Field "to" is required for sending emails')
  }

-  if (!emailData.subject || !emailData.html) {
-    throw new Error('Fields "subject" and "html" are required when not using a template')
+  // 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
+  // Process email addresses using shared validation (handle null values)
  if (emailData.to) {
    emailData.to = parseAndValidateEmails(emailData.to as string | string[])
  }
@@ -92,19 +89,57 @@ export const sendEmail = async <T extends BaseEmailData = BaseEmailData>(
  if (emailData.bcc) {
    emailData.bcc = parseAndValidateEmails(emailData.bcc as string | string[])
  }
+  if (emailData.replyTo) {
+    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) {
+    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
+  }

-  // Convert scheduledAt to ISO string if it's a Date
+  // Sanitize fromName to prevent header injection
+  if (emailData.fromName) {
+    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
+  // Create the email in the collection with proper typing
  const email = await payload.create({
-    collection: collectionSlug as any,
-    data: emailData as any
+    collection: collectionSlug,
+    data: emailData
  })

-  return email as unknown as T
+  // 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
@@ -5,10 +5,8 @@ import {
  MailingPluginConfig,
  TemplateVariables,
  MailingService as IMailingService,
-  EmailTemplate,
-  QueuedEmail,
  MailingTransportConfig,
-  EmailObject
+  BaseEmail, BaseEmailTemplate, BaseEmailDocument, BaseEmailTemplateDocument
 } from '../types/index.js'
 import { serializeRichTextToHTML, serializeRichTextToText } from '../utils/richTextSerializer.js'

@@ -31,10 +29,7 @@ export class MailingService implements IMailingService {
    const emailsConfig = config.collections?.emails
    this.emailsCollection = typeof emailsConfig === 'string' ? emailsConfig : 'emails'

-    // Only initialize transporter if payload is properly set
-    if (payload && payload.db) {
-      this.initializeTransporter()
-    }
+    this.initializeTransporter()
  }

  private initializeTransporter(): void {
@@ -50,6 +45,7 @@ export class MailingService implements IMailingService {
      // Use Payload's configured mailer (cast to any to handle different adapter types)
      this.transporter = this.payload.email as any
    } else {
+      console.log('[DEBUG] email: ', this.payload.email);
      throw new Error('Email transport configuration is required either in plugin config or Payload config')
    }

@@ -65,15 +61,39 @@ export class MailingService implements IMailingService {
    }
  }

+  /**
+   * 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 {
    const fromEmail = this.config.defaultFrom
    const fromName = this.config.defaultFromName

    // 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
-      const escapedName = fromName.replace(/"/g, '\\"')
-      return `"${escapedName}" <${fromEmail}>`
+      return this.formatEmailAddress(fromEmail, fromName)
    }

    return fromEmail || ''
@@ -133,7 +153,7 @@ export class MailingService implements IMailingService {
    }

    const emailContent = await this.renderEmailTemplate(template, variables)
-    const subject = await this.renderTemplateString(template.subject, variables)
+    const subject = await this.renderTemplateString(template.subject || '', variables)

    return {
      html: emailContent.html,
@@ -238,10 +258,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 = {
-        from: email.from || this.getDefaultFrom(),
+      // Combine from and fromName for nodemailer using proper sanitization
+      let fromField: string
+      if (email.from) {
+        fromField = this.formatEmailAddress(email.from, email.fromName)
+      } else {
+        fromField = this.getDefaultFrom()
+      }
+
+      let mailOptions: any = {
+        from: fromField,
        to: email.to,
        cc: email.cc || undefined,
        bcc: email.bcc || undefined,
@@ -249,23 +277,30 @@ 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)
-      }
+      // Call beforeSend hook if configured
+      if (this.config.beforeSend) {
+        try {
+          mailOptions = await this.config.beforeSend(mailOptions, email)

-      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,
+          // Validate required properties remain intact after hook execution
+          if (!mailOptions.from) {
+            throw new Error('beforeSend hook must not remove the "from" property')
+          }
+          if (!mailOptions.to || (Array.isArray(mailOptions.to) && mailOptions.to.length === 0)) {
+            throw new Error('beforeSend hook must not remove or empty the "to" property')
+          }
+          if (!mailOptions.subject) {
+            throw new Error('beforeSend hook must not remove the "subject" property')
+          }
+          if (!mailOptions.html && !mailOptions.text) {
+            throw new Error('beforeSend hook must not remove both "html" and "text" properties')
+          }
+        } catch (error) {
+          console.error('Error in beforeSend hook:', error)
+          throw new Error(`beforeSend hook failed: ${error instanceof Error ? error.message : 'Unknown error'}`)
+        }
      }

      await this.transporter.sendMail(mailOptions)
@@ -304,7 +339,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

@@ -319,7 +354,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,
@@ -331,7 +366,7 @@ 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
@@ -396,7 +431,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: '' }
    }
--- a/src/types/index.ts
+++ b/src/types/index.ts
@@ -1,25 +1,68 @@
 import { Payload } from 'payload'
-import type { CollectionConfig, RichTextField, TypedCollection } from 'payload'
+import type { CollectionConfig, RichTextField } from 'payload'
 import { Transporter } from 'nodemailer'

-export interface EmailObject {
-  to: string | string[]
-  cc?: string | string[]
-  bcc?: string | string[]
-  from?: string
-  replyTo?: string
+// JSON value type that matches Payload's JSON field type
+export type JSONValue = string | number | boolean | { [k: string]: unknown } | unknown[] | null | undefined
+
+// Generic base interfaces that work with any ID type and null values
+export interface BaseEmailDocument {
+  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
-  variables?: Record<string, any>
+  text?: string | null
+  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>

 export type TemplateEngine = 'liquidjs' | 'mustache' | 'simple'

+export interface BeforeSendMailOptions {
+  from: string
+  to: string[]
+  cc?: string[]
+  bcc?: string[]
+  replyTo?: string
+  subject: string
+  html: string
+  text?: string
+  attachments?: any[]
+  [key: string]: any
+}
+
+export type BeforeSendHook = (options: BeforeSendMailOptions, email: BaseEmailDocument) => BeforeSendMailOptions | Promise<BeforeSendMailOptions>
+
 export interface MailingPluginConfig {
  collections?: {
    templates?: string | Partial<CollectionConfig>
@@ -31,10 +74,10 @@ export interface MailingPluginConfig {
  queue?: string
  retryAttempts?: number
  retryDelay?: number
-  emailWrapper?: EmailWrapperHook
  templateRenderer?: TemplateRendererHook
  templateEngine?: TemplateEngine
  richTextEditor?: RichTextField['editor']
+  beforeSend?: BeforeSendHook
  onReady?: (payload: any) => Promise<void>
  initOrder?: 'before' | 'after'
 }
@@ -49,36 +92,27 @@ 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[]
-  bcc?: string[]
-  from?: string
-  replyTo?: string
+  cc?: string[] | null
+  bcc?: string[] | null
+  from?: string | null
+  fromName?: string | null
+  replyTo?: string | null
  subject: string
  html: string
-  text?: string
-  variables?: Record<string, any>
-  scheduledAt?: string
-  sentAt?: string
+  text?: string | null
+  variables?: JSONValue
+  scheduledAt?: string | Date | null
+  sentAt?: string | Date | null
  status: 'pending' | 'processing' | 'sent' | 'failed'
  attempts: number
-  lastAttemptAt?: string
-  error?: string
-  priority?: number
+  lastAttemptAt?: string | Date | null
+  error?: string | null
+  priority?: number | null
  createdAt: string
  updatedAt: string
 }
--- a/src/utils/helpers.ts
+++ b/src/utils/helpers.ts
@@ -5,8 +5,8 @@ import { TemplateVariables } from '../types/index.js'
 * Parse and validate email addresses
 * @internal
 */
-export const parseAndValidateEmails = (emails: string | string[] | undefined): string[] | undefined => {
-  if (!emails) return undefined
+export const parseAndValidateEmails = (emails: string | string[] | null | undefined): string[] | undefined => {
+  if (!emails || emails === null) return undefined

  let emailList: string[]
  if (Array.isArray(emails)) {
@@ -15,9 +15,20 @@ export const parseAndValidateEmails = (emails: string | string[] | undefined): s
    emailList = emails.split(',').map(email => email.trim()).filter(Boolean)
  }

-  // Basic email validation
-  const emailRegex = /^[^\s@]+@[^\s@]+\.[^\s@]+$/
-  const invalidEmails = emailList.filter(email => !emailRegex.test(email))
+  // 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(', ')}`)
  }
Author	SHA1	Message	Date
Bas	6cf055178b	Merge pull request #38 from xtr-dev/dev Add debug log for email transporter configuration and bump version to…	2025-09-14 16:15:41 +02:00
Bas van den Aakster	aa978090fa	Add debug log for email transporter configuration and bump version to 0.1.23	2025-09-14 16:14:56 +02:00
Bas	556d910e30	Merge pull request #37 from xtr-dev/dev Remove conditional transporter initialization and bump version to 0.1.22	2025-09-14 13:53:32 +02:00
Bas van den Aakster	b4bad70634	Remove conditional transporter initialization and bump version to 0.1.22	2025-09-14 13:52:49 +02:00
Bas	efdfaf5889	Merge pull request #36 from xtr-dev/dev Add beforeSend hook for email customization	2025-09-14 12:37:38 +02:00
Bas van den Aakster	ea7d8dfdd5	Add validation for beforeSend hook to ensure required properties remain intact - Validate that 'from' field is not removed - Validate that 'to' field is not removed or emptied - Validate that 'subject' field is not removed - Validate that at least 'html' or 'text' content exists - Throw clear error messages if validation fails - Bump version to 0.1.21	2025-09-14 12:27:43 +02:00
Bas van den Aakster	0d6d07de85	Add beforeSend hook for email customization - Add BeforeSendHook type and BeforeSendMailOptions interface - Implement hook execution in MailingService before sending emails - Hook allows adding attachments, headers, and modifying email options - Add comprehensive documentation with examples - Bump version to 0.1.20	2025-09-14 12:19:52 +02:00
Bas	f12ac8172e	Merge pull request #35 from xtr-dev/dev Fix model overwrite error when plugin is initialized multiple times	2025-09-14 10:24:58 +02:00
Bas van den Aakster	347cd33e13	Fix model overwrite error when plugin is initialized multiple times - Filter out existing collections with same slugs before adding plugin collections - Prevents 'Cannot overwrite model once compiled' errors in Next.js apps - Fixes issue during hot reload and multiple getPayload() calls - Bump version to 0.1.19	2025-09-14 10:22:34 +02:00
Bas	672ab3236a	Merge pull request #34 from xtr-dev/dev Add fromName field support to emails collection	2025-09-14 00:10:22 +02:00
Bas van den Aakster	c7db65980a	Fix security vulnerabilities in fromName field handling - Add sanitizeDisplayName() method to prevent header injection attacks - Remove newlines, carriage returns, and control characters from display names - Fix quote escaping inconsistency between getDefaultFrom() and processEmailItem() - Create formatEmailAddress() helper method for consistent email formatting - Add fromName sanitization in sendEmail() function for input validation - Prevent malformed email headers and potential security issues Security improvements: - Header injection prevention (removes \r\n and control characters) - Consistent quote escaping across all display name usage - Proper sanitization at both input and output stages 🤖 Generated with [Claude Code](https://claude.ai/code) Co-Authored-By: Claude <noreply@anthropic.com>	2025-09-14 00:07:53 +02:00
Bas van den Aakster	624dc12471	Bump package version to 0.1.18 in `package.json`.	2025-09-14 00:06:14 +02:00
Bas van den Aakster	e20ebe27bf	Add fromName field support to emails collection - Add fromName field to Emails collection schema for sender display name - Update BaseEmailDocument and QueuedEmail interfaces to include fromName - Add SendEmailTaskInput support for fromName field in job tasks - Update MailingService to combine fromName and from into proper "Name <email>" format - Add fromName, from, and replyTo fields to job input schema for admin UI - Update field copying logic to handle new sender-related fields Users can now specify a display name for emails (e.g., "John Doe <john@example.com>"). 🤖 Generated with [Claude Code](https://claude.ai/code) Co-Authored-By: Claude <noreply@anthropic.com>	2025-09-14 00:03:04 +02:00
Bas	7f04275d39	Merge pull request #33 from xtr-dev/dev Dev	2025-09-13 23:53:56 +02:00
Bas van den Aakster	20afe30e88	Fix scheduledAt type in SendEmailTaskInput and add Date normalization - Update SendEmailTaskInput.scheduledAt to support string \| Date types - Add Date object normalization to ISO strings in sendEmail processing - Ensure consistent database storage format for all timestamp fields - Convert Date objects to ISO strings before database operations Resolves remaining "Type Date is not assignable to type string" error for scheduledAt field in job task input. 🤖 Generated with [Claude Code](https://claude.ai/code) Co-Authored-By: Claude <noreply@anthropic.com>	2025-09-13 23:53:25 +02:00
Bas van den Aakster	02b3fecadf	Bump package version to 0.1.17 in `package.json`.	2025-09-13 23:52:53 +02:00
Bas	ea87f14308	Merge pull request #32 from xtr-dev/dev Dev	2025-09-13 23:48:28 +02:00
Bas van den Aakster	6886027727	Bump package version to 0.1.16 in `package.json`.	2025-09-13 23:45:39 +02:00
Bas van den Aakster	965569be06	Add Date type support for timestamp fields - Update scheduledAt, sentAt, lastAttemptAt, createdAt, updatedAt fields to support Date \| string \| null - Support both Date objects and ISO string formats for all timestamp fields - Update BaseEmailDocument, BaseEmailTemplateDocument, and QueuedEmail interfaces consistently - Update documentation to reflect Date object compatibility Fixes type constraint error where customer timestamp fields use Date objects but plugin interfaces only supported string formats. 🤖 Generated with [Claude Code](https://claude.ai/code) Co-Authored-By: Claude <noreply@anthropic.com>	2025-09-13 23:44:57 +02:00
Bas	ff788c1ecf	Merge pull request #31 from xtr-dev/dev Fix variables field type to support all JSON-compatible values	2025-09-13 23:41:43 +02:00
Bas van den Aakster	c12438aaa2	Bump package version to 0.1.15 in `package.json`.	2025-09-13 23:40:31 +02:00
Bas van den Aakster	4dcbc1446a	Fix variables field type to support all JSON-compatible values - Replace restrictive Record<string, any> with flexible JSONValue type for variables field - Add JSONValue type alias that matches Payload's JSON field type specification - Support string, number, boolean, objects, arrays, null, and undefined for variables - Update both BaseEmailDocument and QueuedEmail interfaces consistently - Update documentation to reflect JSONValue support Fixes type constraint error where customer Email.variables field type (string \| number \| boolean \| {...} \| unknown[] \| null \| undefined) was not assignable to Record<string, any>. 🤖 Generated with [Claude Code](https://claude.ai/code) Co-Authored-By: Claude <noreply@anthropic.com>	2025-09-13 23:38:46 +02:00
Bas	72f3d7f66d	Merge pull request #30 from xtr-dev/dev Add null value support to BaseEmailDocument interface	2025-09-13 23:35:25 +02:00
Bas van den Aakster	ecc0b0a73e	Fix type inconsistencies and missing null checks - Update QueuedEmail interface to include `\| null` for optional fields to match BaseEmailDocument - Add missing null checks for replyTo and from fields in sendEmail processing - Add proper email validation for replyTo and from fields (single email addresses) - Ensure type consistency across all email-related interfaces Fixes potential type conflicts between QueuedEmail and BaseEmailDocument, and ensures all nullable email fields are properly validated. 🤖 Generated with [Claude Code](https://claude.ai/code) Co-Authored-By: Claude <noreply@anthropic.com>	2025-09-13 23:32:44 +02:00
Bas van den Aakster	a959673fc1	Bump package version to 0.1.14 in `package.json`.	2025-09-13 23:31:23 +02:00
Bas van den Aakster	8809db6aff	Add null value support to BaseEmailDocument interface - Update BaseEmailDocument to support `\| null` for optional fields (cc, bcc, from, replyTo, text, etc.) - Update BaseEmailTemplateDocument to support `\| null` for optional fields - Add explicit null checks in sendEmail processing to handle null values properly - Update CUSTOM-TYPES.md documentation to reflect null value compatibility Fixes type constraint error where customer Email types had `cc?: string[] \| null` but BaseEmailDocument only supported `cc?: string[]`. 🤖 Generated with [Claude Code](https://claude.ai/code) Co-Authored-By: Claude <noreply@anthropic.com>	2025-09-13 23:27:53 +02:00
Bas	5905f732de	Merge pull request #29 from xtr-dev/dev Support custom ID types (string/number) for improved compatibility	2025-09-13 23:24:55 +02:00
Bas van den Aakster	4c495a72b0	Remove duplicate BaseEmailDocument definition - Remove duplicate BaseEmailDocument interface from sendEmail.ts - Import BaseEmailDocument from types/index.ts instead - Update sendEmailTask.ts to import from types/index.ts - Maintain single source of truth for BaseEmailDocument type definition 🤖 Generated with [Claude Code](https://claude.ai/code) Co-Authored-By: Claude <noreply@anthropic.com>	2025-09-13 23:22:23 +02:00
Bas van den Aakster	8518c716e8	Bump package version to 0.1.13 in `package.json`.	2025-09-13 23:21:33 +02:00
Bas van den Aakster	570190be01	Support custom ID types (string/number) for improved compatibility - Replace hardcoded payload-types imports with generic BaseEmailDocument interface - Update sendEmail and sendEmailTask to work with both string and number IDs - Refactor MailingService to use generic document types instead of specific ones - Add BaseEmailDocument and BaseEmailTemplateDocument interfaces supporting id: string \| number - Export BaseEmailDocument for users to extend with their custom fields - Fix TypeScript compilation error in template subject handling - Add CUSTOM-TYPES.md documentation for users with different ID types Fixes compatibility issue where plugin required number IDs but user projects used string IDs. 🤖 Generated with [Claude Code](https://claude.ai/code) Co-Authored-By: Claude <noreply@anthropic.com>	2025-09-13 23:18:37 +02:00
Bas	685875d1b9	Merge pull request #28 from xtr-dev/dev Dev	2025-09-13 23:11:16 +02:00
Bas van den Aakster	79044b7bc3	Remove unused BaseEmail imports - Remove BaseEmail import from sendEmail.ts (no longer used after type refactoring) - Remove BaseEmail import from sendEmailTask.ts (no longer used after type refactoring) - BaseEmail types are still used in MailingService.ts for proper type casting 🤖 Generated with [Claude Code](https://claude.ai/code) Co-Authored-By: Claude <noreply@anthropic.com>	2025-09-13 23:10:20 +02:00
Bas van den Aakster	e7304fe1a2	Improve type safety, error handling, and code maintainability - Simplify sendEmail generic constraints for better type safety - Add validation before type assertions in sendEmail - Preserve error stack traces in sendEmailTask error handling - Extract field copying logic into reusable helper function - Improve code documentation and separation of concerns 🤖 Generated with [Claude Code](https://claude.ai/code) Co-Authored-By: Claude <noreply@anthropic.com>	2025-09-13 23:06:02 +02:00
Bas van den Aakster	790eedfee7	Bump package version to 0.1.12 in `package.json`.	2025-09-13 23:01:06 +02:00
Bas van den Aakster	9520ec5ed1	Refactor email types for enhanced consistency and type safety - Replace `EmailTemplate` with `BaseEmailTemplate` for stricter type validation. - Update `sendEmail` and `sendEmailTask` to utilize refined `BaseEmail` structure. - Simplify type definitions in `MailingService` and related modules.	2025-09-13 23:00:41 +02:00
Bas	768b70a003	Merge pull request #27 from xtr-dev/dev Align `sendEmail` and `sendEmailTask` with updated `BaseEmail` typing	2025-09-13 22:49:05 +02:00
Bas van den Aakster	e91ab7e54e	Bump package version to 0.1.11 in `package.json`.	2025-09-13 22:48:55 +02:00
Bas van den Aakster	06f9c2cb5b	Align `sendEmail` and `sendEmailTask` with updated `BaseEmail` typing - Refactor `sendEmail` to return extended type with `id` for better type inference. - Update `sendEmailTask` to use `BaseEmail` instead of `Email`. - Add `outputSchema` in `sendEmailTask` for consistent output structure.	2025-09-13 22:46:30 +02:00
Bas	21b22a033a	Merge pull request #26 from xtr-dev/dev Refactor `sendEmail` to improve type safety and align with `BaseEmail…	2025-09-13 22:41:28 +02:00
Bas van den Aakster	6ad90874cf	Refactor `sendEmail` to improve type safety and align with `BaseEmail` interface - Replace `Email` with `BaseEmail` for stricter type validation. - Update `SendEmailOptions` and `sendEmail` typing for improved extensibility.	2025-09-13 22:39:28 +02:00
Bas	03f1f62fbf	Merge pull request #25 from xtr-dev/dev Remove `emailWrapper` hook and all associated references.	2025-09-13 22:34:48 +02:00
Bas van den Aakster	e55e4197d3	Bump package version to 0.1.9 in `package.json`.	2025-09-13 22:32:19 +02:00
Bas van den Aakster	2e6feccf54	Remove `emailWrapper` hook and all associated references. - Simplified email sending logic by dropping custom layout wrapping. - Updated service, config, types, and readme to remove `emailWrapper` usage. - Retained focus on core email functionality while ensuring consistent formatting.	2025-09-13 22:31:05 +02:00
Bas	e38b63d814	Merge pull request #24 from xtr-dev/dev Dev	2025-09-13 22:00:51 +02:00
Bas van den Aakster	31721dc110	Add comment to clarify purpose of `payload.config.ts`	2025-09-13 22:00:29 +02:00
Bas van den Aakster	6e4f754306	Fix critical type safety and validation issues Issue 2 - Type Safety: - Remove dangerous 'as any' casts in sendEmail function - Use proper typing for payload.create() calls - Maintain type safety throughout email creation process Issue 3 - Email Validation: - Implement RFC 5322 compliant email regex - Add comprehensive validation for common invalid patterns - Check for consecutive dots, invalid domain formats - Prevent emails like 'test@.com' and 'test@domain.' Issue 4 - Error Message Logic: - Add contextual error messages for template vs direct email modes - Distinguish between template rendering failures and missing direct email content - Provide clearer guidance to developers on what went wrong Additional fixes: - Update imports to use generated Email type instead of BaseEmailData - Maintain compatibility with updated sendEmail interface 🤖 Generated with [Claude Code](https://claude.ai/code) Co-Authored-By: Claude <noreply@anthropic.com>	2025-09-13 21:57:02 +02:00
Bas van den Aakster	45559804b0	Refactor email handling for improved type safety and extensibility - Replace `BaseEmailData` with `Email` type for stricter type validation - Update `sendEmail` API to support new typed structure and template integration - Migrate to `@xtr-dev/payload-mailing` for enhanced email sending capabilities - Remove unnecessary null checks and redundant code in email scheduling logic - Regenerate PayloadCMS types for aligning with revised schema changes - Update dev scripts and imports for seamless compatibility with the new email module	2025-09-13 21:51:52 +02:00
Bas van den Aakster	934b7c2de7	Fix ES module __dirname error in payload config Resolves: ReferenceError: __dirname is not defined in ES module scope - Import fileURLToPath from 'url' module - Create __filename and __dirname using ES module pattern - Maintains compatibility with TypeScript output file path resolution 🤖 Generated with [Claude Code](https://claude.ai/code) Co-Authored-By: Claude <noreply@anthropic.com>	2025-09-13 21:50:05 +02:00
Bas	c78a8c2480	Merge pull request #23 from xtr-dev/dev Fix TypeScript compatibility with PayloadCMS generated types	2025-09-13 21:10:09 +02:00
Bas van den Aakster	a27481c818	Bump package version to 0.1.7 in `package.json`.	2025-09-13 21:07:22 +02:00
Bas van den Aakster	b342f32d97	Simplify null checks in sendEmail validation logic	2025-09-13 21:06:54 +02:00
Bas van den Aakster	e1800f5a6e	Fix TypeScript compatibility with PayloadCMS generated types Resolves: TS2344: Type Email does not satisfy the constraint BaseEmailData - Add null support to BaseEmailData interface for all optional fields - Update parseAndValidateEmails to handle null values - Update sendEmail validation to properly check for null values - Maintain compatibility with PayloadCMS generated types that include null Generated Email types like cc?: string[] \| null \| undefined now work correctly. 🤖 Generated with [Claude Code](https://claude.ai/code) Co-Authored-By: Claude <noreply@anthropic.com>	2025-09-13 21:03:21 +02:00