Merge pull request #52 from xtr-dev/dev

Dev
Fix critical race conditions and error handling inconsistencies
2025-12-10 16:23:23 +00:00 · 2025-09-14 22:05:08 +02:00 · 2025-09-14 21:57:52 +02:00 · 2025-09-14 21:52:55 +02:00 · 2025-09-14 21:41:29 +02:00 · 2025-09-14 21:35:27 +02:00
31 changed files with 1533 additions and 1006 deletions
--- a/.gitignore
+++ b/.gitignore
@@ -4,4 +4,6 @@ node_modules/
 payload-docs
 dist/
 /dev/payload.db
 /dev/dev.db
 dev.db
 tsconfig.tsbuildinfo
--- a/DEVELOPMENT.md
+++ b/DEVELOPMENT.md
@@ -126,9 +126,10 @@ When you start the dev server, look for these messages:
 🎯 Test interface will be available at: /mailing-test
 ✅ Example email templates created successfully
 PayloadCMS Mailing Plugin initialized successfully
 ```
 **Note**: The plugin initializes silently on success (no "initialized successfully" message). If you see no errors, the plugin loaded correctly.
 ## Troubleshooting
 ### Server won't start
--- a/README.md
+++ b/README.md
@@ -28,26 +28,31 @@ npm install @xtr-dev/payload-mailing
 ## Quick Start
-### 1. Add the plugin to your Payload config
+### 1. Configure email in your Payload config and add the plugin
 ```typescript
 import { buildConfig } from 'payload/config'
 import { mailingPlugin } from '@xtr-dev/payload-mailing'
 import { nodemailerAdapter } from '@payloadcms/email-nodemailer'
 export default buildConfig({
  // ... your config
  email: nodemailerAdapter({
    defaultFromAddress: 'noreply@yoursite.com',
    defaultFromName: 'Your Site',
    transport: {
      host: 'smtp.gmail.com',
      port: 587,
      auth: {
        user: process.env.EMAIL_USER,
        pass: process.env.EMAIL_PASS,
      },
    },
  }),
  plugins: [
    mailingPlugin({
      defaultFrom: 'noreply@yoursite.com',
-      transport: {
+      defaultFromName: 'Your Site Name',
        host: 'smtp.gmail.com',
        port: 587,
        secure: false,
        auth: {
          user: process.env.EMAIL_USER,
          pass: process.env.EMAIL_PASS,
        },
      },
      retryAttempts: 3,
      retryDelay: 300000, // 5 minutes
      queue: 'email-queue', // optional
@@ -119,13 +124,6 @@ mailingPlugin({
    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
@@ -142,6 +140,18 @@ mailingPlugin({
  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
  }
 })
 ```
@@ -255,6 +265,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:
@@ -266,7 +326,7 @@ mailingPlugin({
  onReady: async (payload) => {
    // Called after plugin is fully initialized
    console.log('Mailing plugin ready!')
-    
+
    // Custom initialization logic here
    await setupCustomEmailSettings(payload)
  }
@@ -320,9 +380,9 @@ await processEmails(payload)
 await retryFailedEmails(payload)
 ```
-## PayloadCMS Task Integration
+## PayloadCMS Integration
-The plugin provides a ready-to-use PayloadCMS task for queuing template emails:
+The plugin provides PayloadCMS tasks for email processing:
 ### 1. Add the task to your Payload config
@@ -395,6 +455,27 @@ The task can also be triggered from the Payload admin panel with a user-friendly
 - ✅ **Error Handling**: Comprehensive error reporting
 - ✅ **Queue Management**: Leverage Payload's job queue system
 ### Immediate Processing
 The send email task now supports immediate processing. Enable the `processImmediately` option to send emails instantly:
 ```typescript
 await payload.jobs.queue({
  task: 'send-email',
  input: {
    processImmediately: true, // Send immediately (default: false)
    templateSlug: 'welcome-email',
    to: ['user@example.com'],
    variables: { name: 'John' }
  }
 })
 ```
 **Benefits**:
 - No separate workflow needed
 - Unified task interface
 - Optional immediate processing when needed
 ## Job Processing
 The plugin automatically adds a unified email processing job to PayloadCMS:
--- a/dev/.env.local
+++ b/dev/.env.local
@@ -0,0 +1,2 @@
 USE_MEMORY_DB=true
 PAYLOAD_SECRET=YOUR_SECRET_HERE
--- a/dev/app/(frontend)/dashboard/page.tsx
+++ b/dev/app/(frontend)/dashboard/page.tsx
@@ -0,0 +1,310 @@
 'use client'
 import { useState, useEffect } from 'react'
 import Link from 'next/link'
 interface EmailStats {
  total: number
  sent: number
  pending: number
  failed: number
  processing: number
 }
 export default function HomePage() {
  const [emailStats, setEmailStats] = useState<EmailStats>({
    total: 0,
    sent: 0,
    pending: 0,
    failed: 0,
    processing: 0
  })
  const [loading, setLoading] = useState<boolean>(true)
  useEffect(() => {
    fetchEmailStats()
  }, [])
  const fetchEmailStats = async () => {
    try {
      const response = await fetch('/api/test-email')
      const data = await response.json()
      if (data.outbox?.emails) {
        const emails = data.outbox.emails
        const stats: EmailStats = {
          total: emails.length,
          sent: emails.filter((email: any) => email.status === 'sent').length,
          pending: emails.filter((email: any) => email.status === 'pending').length,
          failed: emails.filter((email: any) => email.status === 'failed').length,
          processing: emails.filter((email: any) => email.status === 'processing').length
        }
        setEmailStats(stats)
      }
    } catch (error) {
      console.error('Error fetching email statistics:', error)
    } finally {
      setLoading(false)
    }
  }
  const StatCard = ({ label, value, color, description }: { label: string; value: number; color: string; description: string }) => (
    <div style={{
      backgroundColor: 'white',
      border: '1px solid #e5e7eb',
      borderRadius: '12px',
      padding: '24px',
      textAlign: 'center',
      boxShadow: '0 1px 3px rgba(0, 0, 0, 0.1)',
    }}>
      <div style={{
        fontSize: '3rem',
        fontWeight: 'bold',
        color: color,
        marginBottom: '8px'
      }}>
        {value}
      </div>
      <div style={{
        fontSize: '1.1rem',
        fontWeight: '600',
        color: '#374151',
        marginBottom: '4px'
      }}>
        {label}
      </div>
      <div style={{
        fontSize: '0.875rem',
        color: '#6b7280'
      }}>
        {description}
      </div>
    </div>
  )
  return (
    <div style={{
      backgroundColor: '#f9fafb',
      padding: '40px 20px',
      minHeight: 'calc(100vh - 80px)'
    }}>
      <div style={{
        maxWidth: '1200px',
        margin: '0 auto'
      }}>
        {/* Header */}
        <div style={{ textAlign: 'center', marginBottom: '48px' }}>
          <h1 style={{
            fontSize: '3rem',
            fontWeight: 'bold',
            color: '#1f2937',
            marginBottom: '16px'
          }}>
            📧 PayloadCMS Mailing Plugin
          </h1>
          <p style={{
            fontSize: '1.25rem',
            color: '#6b7280',
            marginBottom: '24px'
          }}>
            Development Dashboard
          </p>
          <div style={{ display: 'flex', gap: '16px', justifyContent: 'center', flexWrap: 'wrap' }}>
            <Link
              href="/admin"
              style={{
                backgroundColor: '#3b82f6',
                color: 'white',
                padding: '12px 24px',
                borderRadius: '8px',
                textDecoration: 'none',
                fontWeight: '500',
                transition: 'background-color 0.2s'
              }}
            >
              📊 Admin Panel
            </Link>
            <Link
              href="/mailing-test"
              style={{
                backgroundColor: '#10b981',
                color: 'white',
                padding: '12px 24px',
                borderRadius: '8px',
                textDecoration: 'none',
                fontWeight: '500',
                transition: 'background-color 0.2s'
              }}
            >
              🧪 Test Interface
            </Link>
          </div>
        </div>
        {/* Email Statistics */}
        <div style={{ marginBottom: '48px' }}>
          <div style={{
            display: 'flex',
            justifyContent: 'space-between',
            alignItems: 'center',
            marginBottom: '24px'
          }}>
            <h2 style={{
              fontSize: '2rem',
              fontWeight: 'bold',
              color: '#1f2937'
            }}>
              Email Statistics
            </h2>
            <button
              onClick={fetchEmailStats}
              disabled={loading}
              style={{
                backgroundColor: loading ? '#9ca3af' : '#6b7280',
                color: 'white',
                padding: '8px 16px',
                borderRadius: '6px',
                border: 'none',
                cursor: loading ? 'not-allowed' : 'pointer',
                fontWeight: '500'
              }}
            >
              {loading ? 'Loading...' : 'Refresh'}
            </button>
          </div>
          {loading ? (
            <div style={{ textAlign: 'center', padding: '48px' }}>
              <div style={{ color: '#6b7280', fontSize: '1.1rem' }}>Loading email statistics...</div>
            </div>
          ) : (
            <div style={{
              display: 'grid',
              gridTemplateColumns: 'repeat(auto-fit, minmax(250px, 1fr))',
              gap: '24px'
            }}>
              <StatCard
                label="Total Emails"
                value={emailStats.total}
                color="#1f2937"
                description="All emails in the system"
              />
              <StatCard
                label="Successfully Sent"
                value={emailStats.sent}
                color="#10b981"
                description="Delivered successfully"
              />
              <StatCard
                label="Pending"
                value={emailStats.pending}
                color="#f59e0b"
                description="Waiting to be sent"
              />
              <StatCard
                label="Failed"
                value={emailStats.failed}
                color="#ef4444"
                description="Failed to send"
              />
              {emailStats.processing > 0 && (
                <StatCard
                  label="Processing"
                  value={emailStats.processing}
                  color="#3b82f6"
                  description="Currently being sent"
                />
              )}
            </div>
          )}
        </div>
        {/* Quick Actions */}
        <div style={{
          backgroundColor: 'white',
          borderRadius: '12px',
          padding: '32px',
          border: '1px solid #e5e7eb',
          boxShadow: '0 1px 3px rgba(0, 0, 0, 0.1)'
        }}>
          <h3 style={{
            fontSize: '1.5rem',
            fontWeight: 'bold',
            color: '#1f2937',
            marginBottom: '16px'
          }}>
            Quick Actions
          </h3>
          <div style={{
            display: 'grid',
            gridTemplateColumns: 'repeat(auto-fit, minmax(300px, 1fr))',
            gap: '16px'
          }}>
            <div style={{ padding: '16px', backgroundColor: '#f9fafb', borderRadius: '8px' }}>
              <h4 style={{ marginBottom: '8px', color: '#1f2937' }}>🎯 Test Email Sending</h4>
              <p style={{ color: '#6b7280', marginBottom: '12px', fontSize: '0.9rem' }}>
                Send test emails using templates with the interactive testing interface.
              </p>
              <Link
                href="/mailing-test"
                style={{
                  color: '#3b82f6',
                  textDecoration: 'none',
                  fontWeight: '500'
                }}
              >
                Open Test Interface →
              </Link>
            </div>
            <div style={{ padding: '16px', backgroundColor: '#f9fafb', borderRadius: '8px' }}>
              <h4 style={{ marginBottom: '8px', color: '#1f2937' }}>📝 Manage Templates</h4>
              <p style={{ color: '#6b7280', marginBottom: '12px', fontSize: '0.9rem' }}>
                Create and edit email templates in the Payload admin interface.
              </p>
              <Link
                href="/admin/collections/email-templates"
                style={{
                  color: '#3b82f6',
                  textDecoration: 'none',
                  fontWeight: '500'
                }}
              >
                Manage Templates →
              </Link>
            </div>
            <div style={{ padding: '16px', backgroundColor: '#f9fafb', borderRadius: '8px' }}>
              <h4 style={{ marginBottom: '8px', color: '#1f2937' }}>📬 Email Queue</h4>
              <p style={{ color: '#6b7280', marginBottom: '12px', fontSize: '0.9rem' }}>
                View and manage the email outbox and delivery status.
              </p>
              <Link
                href="/admin/collections/emails"
                style={{
                  color: '#3b82f6',
                  textDecoration: 'none',
                  fontWeight: '500'
                }}
              >
                View Email Queue →
              </Link>
            </div>
          </div>
        </div>
        {/* Footer */}
        <div style={{
          textAlign: 'center',
          marginTop: '48px',
          padding: '24px',
          color: '#6b7280',
          fontSize: '0.875rem'
        }}>
          PayloadCMS Mailing Plugin Development Environment
        </div>
      </div>
    </div>
  )
 }
--- a/dev/app/(frontend)/layout.tsx
+++ b/dev/app/(frontend)/layout.tsx
@@ -0,0 +1,24 @@
 import type { Metadata } from 'next'
 export const metadata: Metadata = {
  title: 'PayloadCMS Mailing Plugin - Development',
  description: 'Development environment for PayloadCMS Mailing Plugin',
 }
 export default function FrontendLayout({
  children,
 }: {
  children: React.ReactNode
 }) {
  return (
    <html lang="en">
      <body style={{
        margin: 0,
        padding: 0,
        fontFamily: '-apple-system, BlinkMacSystemFont, "Segoe UI", Roboto, sans-serif'
      }}>
        {children}
      </body>
    </html>
  )
 }
--- a/dev/app/(frontend)/mailing-test/page.tsx
+++ b/dev/app/(frontend)/mailing-test/page.tsx
@@ -33,6 +33,8 @@ export default function MailingTestPage() {
  const [selectedTemplate, setSelectedTemplate] = useState<string>('')
  const [toEmail, setToEmail] = useState<string>('test@example.com')
  const [variables, setVariables] = useState<Record<string, any>>({})
  const [jsonVariables, setJsonVariables] = useState<string>('{}')
  const [jsonError, setJsonError] = useState<string>('')
  const [emailType, setEmailType] = useState<'send' | 'schedule'>('send')
  const [scheduleDate, setScheduleDate] = useState<string>('')
  const [loading, setLoading] = useState<boolean>(false)
@@ -58,6 +60,23 @@ export default function MailingTestPage() {
    const template = templates.find(t => t.slug === templateSlug)
    if (template?.previewData) {
      setVariables(template.previewData)
      setJsonVariables(JSON.stringify(template.previewData, null, 2))
    } else {
      setVariables({})
      setJsonVariables('{}')
    }
    setJsonError('')
  }
  const handleJsonVariablesChange = (jsonString: string) => {
    setJsonVariables(jsonString)
    setJsonError('')
    try {
      const parsed = JSON.parse(jsonString)
      setVariables(parsed)
    } catch (error) {
      setJsonError(error instanceof Error ? error.message : 'Invalid JSON')
    }
  }
@@ -67,6 +86,11 @@ export default function MailingTestPage() {
      return
    }
    if (jsonError) {
      setMessage('Please fix the JSON syntax error before sending')
      return
    }
    setLoading(true)
    setMessage('')
@@ -88,7 +112,8 @@ export default function MailingTestPage() {
      const result = await response.json()
      if (result.success) {
-        setMessage(`✅ ${result.message} (ID: ${result.emailId})`)
+        const statusIcon = result.status === 'sent' ? '📧' : '📫'
        setMessage(`✅ ${statusIcon} ${result.message} (ID: ${result.emailId})`)
        fetchData() // Refresh email queue
      } else {
        setMessage(`❌ Error: ${result.error}`)
@@ -204,28 +229,43 @@ export default function MailingTestPage() {
            </div>
          )}
-          {selectedTemplateData?.variables && (
+          {selectedTemplate && (
            <div style={{ marginBottom: '15px' }}>
-              <h3>Template Variables:</h3>
+              <label style={{ display: 'block', marginBottom: '5px' }}>
-              {selectedTemplateData.variables.map(variable => (
+                <strong>Template Variables (JSON):</strong>
-                <div key={variable.name} style={{ marginBottom: '10px' }}>
+                {selectedTemplateData?.variables && (
-                  <label style={{ display: 'block', marginBottom: '5px' }}>
+                  <small style={{ color: '#666', marginLeft: '8px' }}>
-                    {variable.name} {variable.required && <span style={{ color: 'red' }}>*</span>}
+                    Available variables: {selectedTemplateData.variables.map(v => v.name).join(', ')}
-                    {variable.description && <small style={{ color: '#666' }}> - {variable.description}</small>}
+                  </small>
-                  </label>
+                )}
-                  <input
+              </label>
-                    type={variable.type === 'number' ? 'number' : variable.type === 'date' ? 'datetime-local' : 'text'}
+              <textarea
-                    value={variables[variable.name] || ''}
+                value={jsonVariables}
-                    onChange={(e) => setVariables({
+                onChange={(e) => handleJsonVariablesChange(e.target.value)}
-                      ...variables,
+                placeholder='{\n  "firstName": "John",\n  "siteName": "MyApp",\n  "createdAt": "2023-01-01T00:00:00Z"\n}'
-                      [variable.name]: variable.type === 'number' ? Number(e.target.value) : 
+                style={{
-                                     variable.type === 'boolean' ? e.target.checked : 
+                  width: '100%',
-                                     e.target.value
+                  height: '150px',
-                    })}
+                  padding: '8px',
-                    style={{ width: '100%', padding: '8px', borderRadius: '4px', border: '1px solid #ddd' }}
+                  borderRadius: '4px',
-                  />
+                  border: jsonError ? '2px solid #dc3545' : '1px solid #ddd',
                  fontFamily: 'monaco, "Courier New", monospace',
                  fontSize: '13px',
                  resize: 'vertical'
                }}
              />
              {jsonError && (
                <div style={{
                  color: '#dc3545',
                  fontSize: '12px',
                  marginTop: '5px',
                  padding: '5px',
                  backgroundColor: '#f8d7da',
                  borderRadius: '4px'
                }}>
                  Invalid JSON: {jsonError}
                </div>
-              ))}
+              )}
            </div>
          )}
--- a/dev/app/api/process-emails/route.ts
+++ b/dev/app/api/process-emails/route.ts
@@ -4,24 +4,25 @@ import config from '@payload-config'
 export async function POST(request: Request) {
  try {
    const payload = await getPayload({ config })
-    
+
-    // Queue the combined email queue processing job
+    // Run jobs in the default queue (the plugin already schedules email processing on init)
-    const job = await payload.jobs.queue({
+    const results = await payload.jobs.run({
-      task: 'process-email-queue',
+      queue: 'default',
      input: {},
    })
-    
+
    const processedCount = Array.isArray(results) ? results.length : (results ? 1 : 0)
    return Response.json({
      success: true,
-      message: 'Email queue processing job queued successfully (will process both pending and failed emails)',
+      message: `Email queue processing completed. Processed ${processedCount} jobs.`,
-      jobId: job.id,
+      processedJobs: processedCount,
    })
  } catch (error) {
    console.error('Process emails error:', error)
    return Response.json(
-      { 
+      {
        error: 'Failed to process emails',
-        details: error instanceof Error ? error.message : 'Unknown error' 
+        details: error instanceof Error ? error.message : 'Unknown error'
      },
      { status: 500 }
    )
--- a/dev/app/api/test-email/route.ts
+++ b/dev/app/api/test-email/route.ts
@@ -8,6 +8,22 @@ export async function POST(request: Request) {
    const body = await request.json()
    const { type = 'send', templateSlug, to, variables, scheduledAt, subject, html, text } = body
    // Validate required fields
    if (!to) {
      return Response.json(
        { error: 'Recipient email address (to) is required' },
        { status: 400 }
      )
    }
    // Validate email has either template or direct content
    if (!templateSlug && (!subject || !html)) {
      return Response.json(
        { error: 'Either templateSlug or both subject and html must be provided' },
        { status: 400 }
      )
    }
    // Use the new sendEmail API
    const emailOptions: any = {
      data: {
@@ -39,12 +55,21 @@ export async function POST(request: Request) {
      emailOptions.data.scheduledAt = scheduledAt ? new Date(scheduledAt) : new Date(Date.now() + 60000)
    }
    // Set processImmediately for "send now" type
    const processImmediately = (type === 'send' && !scheduledAt)
    emailOptions.processImmediately = processImmediately
    const result = await sendEmail(payload, emailOptions)
    return Response.json({
      success: true,
      emailId: result.id,
-      message: scheduledAt ? 'Email scheduled successfully' : 'Email queued successfully',
+      message: processImmediately ? 'Email sent successfully' :
               scheduledAt ? 'Email scheduled successfully' :
               'Email queued successfully',
      status: processImmediately ? 'sent' :
              scheduledAt ? 'scheduled' :
              'queued'
    })
  } catch (error) {
    console.error('Test email error:', error)
@@ -82,8 +107,8 @@ export async function GET() {
        total: totalDocs,
      },
      mailing: {
-        pluginActive: !!(payload as any).mailing,
+        pluginActive: 'mailing' in payload && !!payload.mailing,
-        service: !!(payload as any).mailing?.service,
+        service: 'mailing' in payload && payload.mailing && 'service' in payload.mailing && !!payload.mailing.service,
      },
    })
  } catch (error) {
--- a/dev/app/page.tsx
+++ b/dev/app/page.tsx
@@ -0,0 +1,11 @@
 import { Metadata } from 'next'
 import {redirect} from "next/navigation.js"
 export const metadata: Metadata = {
  title: 'PayloadCMS Mailing Plugin - Development',
  description: 'Development environment for PayloadCMS Mailing Plugin',
 }
 export default function HomePage() {
  redirect('/dashboard')
 }
--- a/dev/payload-types.ts
+++ b/dev/payload-types.ts
@@ -90,7 +90,7 @@ export interface Config {
    'payload-migrations': PayloadMigrationsSelect<false> | PayloadMigrationsSelect<true>;
  };
  db: {
-    defaultIDType: string;
+    defaultIDType: number;
  };
  globals: {};
  globalsSelect: {};
@@ -100,7 +100,7 @@ export interface Config {
  };
  jobs: {
    tasks: {
-      processEmails: ProcessEmailsJob;
+      'process-emails': ProcessEmailsTask;
      'send-email': TaskSendEmail;
      inline: {
        input: unknown;
@@ -133,7 +133,7 @@ export interface UserAuthOperations {
 * via the `definition` "users".
 */
 export interface User {
-  id: string;
+  id: number;
  firstName?: string | null;
  lastName?: string | null;
  updatedAt: string;
@@ -159,7 +159,7 @@ export interface User {
 * via the `definition` "posts".
 */
 export interface Post {
-  id: string;
+  id: number;
  updatedAt: string;
  createdAt: string;
 }
@@ -168,7 +168,7 @@ export interface Post {
 * via the `definition` "media".
 */
 export interface Media {
-  id: string;
+  id: number;
  updatedAt: string;
  createdAt: string;
  url?: string | null;
@@ -186,7 +186,7 @@ export interface Media {
 * via the `definition` "email-templates".
 */
 export interface EmailTemplate {
-  id: string;
+  id: number;
  /**
   * A descriptive name for this email template
   */
@@ -227,11 +227,11 @@ export interface EmailTemplate {
 * via the `definition` "emails".
 */
 export interface Email {
-  id: string;
+  id: number;
  /**
   * Email template used (optional if custom content provided)
   */
-  template?: (string | null) | EmailTemplate;
+  template?: (number | null) | EmailTemplate;
  /**
   * Recipient email addresses
   */
@@ -248,6 +248,10 @@ export interface Email {
   * 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
   */
@@ -312,7 +316,7 @@ export interface Email {
 * via the `definition` "payload-jobs".
 */
 export interface PayloadJob {
-  id: string;
+  id: number;
  /**
   * Input data provided to the job
   */
@@ -359,7 +363,7 @@ export interface PayloadJob {
    | {
        executedAt: string;
        completedAt: string;
-        taskSlug: 'inline' | 'processEmails' | 'send-email';
+        taskSlug: 'inline' | 'process-emails' | 'send-email';
        taskID: string;
        input?:
          | {
@@ -392,7 +396,7 @@ export interface PayloadJob {
        id?: string | null;
      }[]
    | null;
-  taskSlug?: ('inline' | 'processEmails' | 'send-email') | null;
+  taskSlug?: ('inline' | 'process-emails' | 'send-email') | null;
  queue?: string | null;
  waitUntil?: string | null;
  processing?: boolean | null;
@@ -404,36 +408,36 @@ export interface PayloadJob {
 * via the `definition` "payload-locked-documents".
 */
 export interface PayloadLockedDocument {
-  id: string;
+  id: number;
  document?:
    | ({
        relationTo: 'users';
-        value: string | User;
+        value: number | User;
      } | null)
    | ({
        relationTo: 'posts';
-        value: string | Post;
+        value: number | Post;
      } | null)
    | ({
        relationTo: 'media';
-        value: string | Media;
+        value: number | Media;
      } | null)
    | ({
        relationTo: 'email-templates';
-        value: string | EmailTemplate;
+        value: number | EmailTemplate;
      } | null)
    | ({
        relationTo: 'emails';
-        value: string | Email;
+        value: number | Email;
      } | null)
    | ({
        relationTo: 'payload-jobs';
-        value: string | PayloadJob;
+        value: number | PayloadJob;
      } | null);
  globalSlug?: string | null;
  user: {
    relationTo: 'users';
-    value: string | User;
+    value: number | User;
  };
  updatedAt: string;
  createdAt: string;
@@ -443,10 +447,10 @@ export interface PayloadLockedDocument {
 * via the `definition` "payload-preferences".
 */
 export interface PayloadPreference {
-  id: string;
+  id: number;
  user: {
    relationTo: 'users';
-    value: string | User;
+    value: number | User;
  };
  key?: string | null;
  value?:
@@ -466,7 +470,7 @@ export interface PayloadPreference {
 * via the `definition` "payload-migrations".
 */
 export interface PayloadMigration {
-  id: string;
+  id: number;
  name?: string | null;
  batch?: number | null;
  updatedAt: string;
@@ -543,6 +547,7 @@ export interface EmailsSelect<T extends boolean = true> {
  cc?: T;
  bcc?: T;
  from?: T;
  fromName?: T;
  replyTo?: T;
  subject?: T;
  html?: T;
@@ -623,9 +628,9 @@ export interface PayloadMigrationsSelect<T extends boolean = true> {
 }
 /**
 * This interface was referenced by `Config`'s JSON-Schema
- * via the `definition` "ProcessEmailsJob".
+ * via the `definition` "ProcessEmailsTask".
 */
-export interface ProcessEmailsJob {
+export interface ProcessEmailsTask {
  input?: unknown;
  output?: unknown;
 }
@@ -635,6 +640,10 @@ export interface ProcessEmailsJob {
 */
 export interface TaskSendEmail {
  input: {
    /**
     * Process and send the email immediately instead of waiting for the queue processor
     */
    processImmediately?: boolean | null;
    /**
     * Use a template (leave empty for direct email)
     */
@@ -675,6 +684,18 @@ export interface TaskSendEmail {
     * 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
     */
@@ -684,7 +705,9 @@ export interface TaskSendEmail {
     */
    priority?: number | null;
  };
-  output?: unknown;
+  output: {
    id?: string | null;
  };
 }
 /**
 * This interface was referenced by `Config`'s JSON-Schema
--- a/dev/payload.config.ts
+++ b/dev/payload.config.ts
@@ -1,4 +1,4 @@
-import { mongooseAdapter } from '@payloadcms/db-mongodb'
+import { sqliteAdapter } from '@payloadcms/db-sqlite'
 import { lexicalEditor } from '@payloadcms/richtext-lexical'
 import {
  FixedToolbarFeature,
@@ -6,7 +6,6 @@ import {
  HorizontalRuleFeature,
  InlineToolbarFeature,
 } from '@payloadcms/richtext-lexical'
 import { MongoMemoryReplSet } from 'mongodb-memory-server'
 import path from 'path'
 import { buildConfig } from 'payload'
 import sharp from 'sharp'
@@ -24,36 +23,7 @@ if (!process.env.ROOT_DIR) {
  process.env.ROOT_DIR = dirname
 }
-const buildConfigWithMemoryDB = async () => {
+export default buildConfig({
  // Use in-memory MongoDB for development and testing
  if (process.env.NODE_ENV === 'test' || process.env.USE_MEMORY_DB === 'true' || !process.env.DATABASE_URI) {
    console.log('🚀 Starting MongoDB in-memory database...')
    const memoryDB = await MongoMemoryReplSet.create({
      replSet: {
        count: 1, // Single instance for dev (faster startup)
        dbName: process.env.NODE_ENV === 'test' ? 'payloadmemory' : 'payload-mailing-dev',
        storageEngine: 'wiredTiger',
      },
    })
    const uri = `${memoryDB.getUri()}&retryWrites=true`
    process.env.DATABASE_URI = uri
    console.log('✅ MongoDB in-memory database started')
    console.log(`📊 Database URI: ${uri.replace(/mongodb:\/\/[^@]*@/, 'mongodb://***@')}`)
    // Graceful shutdown
    process.on('SIGINT', async () => {
      console.log('🛑 Stopping MongoDB in-memory database...')
      await memoryDB.stop()
      process.exit(0)
    })
  } else {
    console.log(`🔗 Using external MongoDB: ${process.env.DATABASE_URI?.replace(/mongodb:\/\/[^@]*@/, 'mongodb://***@')}`)
  }
  return buildConfig({
    admin: {
      importMap: {
        baseDir: path.resolve(dirname),
@@ -122,31 +92,36 @@ const buildConfigWithMemoryDB = async () => {
        },
      },
    ],
-    db: mongooseAdapter({
+    db: sqliteAdapter({
-      ensureIndexes: true,
+      client: {
-      url: process.env.DATABASE_URI || '',
+        url: process.env.DATABASE_URI || 'file:./dev.db',
      },
    }),
    editor: lexicalEditor(),
    email: testEmailAdapter,
    onInit: async (payload) => {
      await seed(payload)
    },
    jobs: {
      jobsCollectionOverrides: c => {
        if (c.defaultJobsCollection.admin) c.defaultJobsCollection.admin.hidden = false
        return c.defaultJobsCollection
      },
      autoRun: [
        {
          cron: '*/1 * * * *', // every minute
          limit: 10, // limit jobs to process each run
          queue: 'default', // name of the queue
        },
      ],
    },
    plugins: [
      mailingPlugin({
        defaultFrom: 'noreply@test.com',
        initOrder: 'after',
        transport: {
          host: 'localhost',
          port: 1025, // MailHog port for dev
          secure: false,
          auth: {
            user: 'test',
            pass: 'test',
          },
        },
        retryAttempts: 3,
        retryDelay: 60000, // 1 minute for dev
-        queue: 'email-queue',
+        queue: 'default',
        // Example: Collection overrides for customization
        // Uncomment and modify as needed for your use case
@@ -295,6 +270,3 @@ const buildConfigWithMemoryDB = async () => {
      outputFile: path.resolve(dirname, 'payload-types.ts'),
    },
  })
 }
 export default buildConfigWithMemoryDB()
--- a/dev/start-dev.js
+++ b/dev/start-dev.js
@@ -3,26 +3,14 @@
 // Development startup script for PayloadCMS Mailing Plugin
 // This ensures proper environment setup and provides helpful information
 console.log('🚀 PayloadCMS Mailing Plugin - Development Mode')
 console.log('=' .repeat(50))
 // Set development environment
 process.env.NODE_ENV = process.env.NODE_ENV || 'development'
-// Enable in-memory MongoDB by default for development
+// Set default SQLite database for development
 if (!process.env.DATABASE_URI) {
-  process.env.USE_MEMORY_DB = 'true'
+  process.env.DATABASE_URI = 'file:./dev.db'
  console.log('📦 Using in-memory MongoDB (no installation required)')
 } else {
  console.log(`🔗 Using external MongoDB: ${process.env.DATABASE_URI}`)
 }
 console.log('')
 console.log('🔧 Starting development server...')
 console.log('📧 Mailing plugin configured with test transport')
 console.log('🎯 Test interface will be available at: /mailing-test')
 console.log('')
 // Import and start Next.js
 import('next/dist/cli/next-dev.js')
  .then(({ nextDev }) => {
@@ -35,11 +23,9 @@ import('next/dist/cli/next-dev.js')
 // Handle graceful shutdown
 process.on('SIGTERM', () => {
  console.log('\n🛑 Shutting down development server...')
  process.exit(0)
 })
 process.on('SIGINT', () => {
  console.log('\n🛑 Shutting down development server...')
  process.exit(0)
 })
--- 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/package.json
+++ b/package.json
@@ -1,6 +1,6 @@
 {
  "name": "@xtr-dev/payload-mailing",
-  "version": "0.1.9",
+  "version": "0.4.8",
  "description": "Template-based email system with scheduling and job processing for PayloadCMS",
  "type": "module",
  "main": "dist/index.js",
@@ -23,9 +23,6 @@
    "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",
    "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
@@ -1,31 +0,0 @@
 /**
 * 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
@@ -1,10 +1,11 @@
 import type { CollectionConfig } from 'payload'
 import { findExistingJobs, ensureEmailJob, updateEmailJobRelationship } from '../utils/jobScheduler.js'
 const Emails: CollectionConfig = {
  slug: 'emails',
  admin: {
    useAsTitle: 'subject',
-    defaultColumns: ['subject', 'to', 'status', 'scheduledAt', 'sentAt'],
+    defaultColumns: ['subject', 'to', 'status', 'jobs', 'scheduledAt', 'sentAt'],
    group: 'Mailing',
    description: 'Email delivery and status tracking',
  },
@@ -49,6 +50,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',
@@ -157,22 +165,75 @@ const Emails: CollectionConfig = {
        description: 'Email priority (1=highest, 10=lowest)',
      },
    },
    {
      name: 'jobs',
      type: 'relationship',
      relationTo: 'payload-jobs',
      hasMany: true,
      admin: {
        description: 'Processing jobs associated with this email',
        allowCreate: false,
        readOnly: true,
      },
      filterOptions: ({ id }) => {
        return {
          'input.emailId': {
            equals: id,
          },
        }
      },
    },
  ],
  hooks: {
    // Simple approach: Only use afterChange hook for job management
    // This avoids complex interaction between hooks and ensures document ID is always available
    afterChange: [
      async ({ doc, previousDoc, req, operation }) => {
        // Skip if:
        // 1. Email is not pending status
        // 2. Jobs are not configured
        // 3. Email already has jobs (unless status just changed to pending)
        const shouldSkip =
          doc.status !== 'pending' ||
          !req.payload.jobs ||
          (doc.jobs?.length > 0 && previousDoc?.status === 'pending')
        if (shouldSkip) {
          return
        }
        try {
          // Ensure a job exists for this email
          // This function handles:
          // - Checking for existing jobs (duplicate prevention)
          // - Creating new job if needed
          // - Returning all job IDs
          const result = await ensureEmailJob(req.payload, doc.id, {
            scheduledAt: doc.scheduledAt,
          })
          // Update the email's job relationship if we have jobs
          // This handles both new jobs and existing jobs that weren't in the relationship
          if (result.jobIds.length > 0) {
            await updateEmailJobRelationship(req.payload, doc.id, result.jobIds, 'emails')
          }
        } catch (error) {
          // Log error but don't throw - we don't want to fail the email operation
          console.error(`Failed to ensure job for email ${doc.id}:`, error)
        }
      }
    ]
  },
  timestamps: true,
-  // indexes: [
+  indexes: [
-  //   {
+    {
-  //     fields: {
+      fields: ['status', 'scheduledAt'],
-  //       status: 1,
+    },
-  //       scheduledAt: 1,
+    {
-  //     },
+      fields: ['priority', 'createdAt'],
-  //   },
+    },
-  //   {
+  ],
  //     fields: {
  //       priority: -1,
  //       createdAt: 1,
  //     },
  //   },
  // ],
 }
 export default Emails
--- a/src/index.ts
+++ b/src/index.ts
@@ -11,9 +11,9 @@ export { MailingService } from './services/MailingService.js'
 export { default as EmailTemplates, createEmailTemplatesCollection } from './collections/EmailTemplates.js'
 export { default as Emails } from './collections/Emails.js'
-// Jobs (includes the send email task)
+// Jobs (includes the individual email processing job)
-export { mailingJobs, sendEmailJob } from './jobs/index.js'
+export { mailingJobs } from './jobs/index.js'
-export type { SendEmailTaskInput } from './jobs/sendEmailTask.js'
+export type { ProcessEmailJobInput } from './jobs/processEmailJob.js'
 // Main email sending function
 export { sendEmail, type SendEmailOptions } from './sendEmail.js'
@@ -26,4 +26,12 @@ export {
  processEmails,
  retryFailedEmails,
  parseAndValidateEmails,
-} from './utils/helpers.js'
+  sanitizeDisplayName,
  sanitizeFromName,
 } from './utils/helpers.js'
 // Email processing utilities
 export { processEmailById, processJobById, processAllEmails } from './utils/emailProcessor.js'
 // Job scheduling utilities
 export { findExistingJobs, ensureEmailJob, updateEmailJobRelationship } from './utils/jobScheduler.js'
--- a/src/jobs/index.ts
+++ b/src/jobs/index.ts
@@ -1,35 +1,16 @@
-import { processEmailsJob, ProcessEmailsJobData } from './processEmailsJob.js'
+import { processEmailsJob } from './processEmailsTask.js'
-import { sendEmailJob } from './sendEmailTask.js'
+import { processEmailJob } from './processEmailJob.js'
 import { MailingService } from '../services/MailingService.js'
 /**
 * All mailing-related jobs that get registered with Payload
 *
 * Note: The sendEmailJob has been removed as each email now gets its own individual processEmailJob
 */
 export const mailingJobs = [
-  {
+  processEmailsJob, // Kept for backward compatibility and batch processing if needed
-    slug: 'processEmails',
+  processEmailJob,  // New individual email processing job
    handler: async ({ job, req }: { job: any; req: any }) => {
      // Get mailing context from payload
      const payload = (req as any).payload
      const mailingContext = payload.mailing
      if (!mailingContext) {
        throw new Error('Mailing plugin not properly initialized')
      }
      // 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'
+// Re-export everything from individual job files
-export * from './sendEmailTask.js'
+export * from './processEmailsTask.js'
 export * from './processEmailJob.js'
--- a/src/jobs/processEmailJob.ts
+++ b/src/jobs/processEmailJob.ts
@@ -0,0 +1,72 @@
 import type { PayloadRequest } from 'payload'
 import { processEmailById } from '../utils/emailProcessor.js'
 /**
 * Data passed to the individual email processing job
 */
 export interface ProcessEmailJobInput {
  /**
   * The ID of the email to process
   */
  emailId: string | number
 }
 /**
 * Job definition for processing a single email
 * This replaces the batch processing approach with individual email jobs
 */
 export const processEmailJob = {
  slug: 'process-email',
  label: 'Process Individual Email',
  inputSchema: [
    {
      name: 'emailId',
      type: 'text' as const,
      required: true,
      label: 'Email ID',
      admin: {
        description: 'The ID of the email to process and send'
      }
    }
  ],
  outputSchema: [
    {
      name: 'success',
      type: 'checkbox' as const
    },
    {
      name: 'emailId',
      type: 'text' as const
    },
    {
      name: 'status',
      type: 'text' as const
    }
  ],
  handler: async ({ input, req }: { input: ProcessEmailJobInput; req: PayloadRequest }) => {
    const payload = (req as any).payload
    const { emailId } = input
    if (!emailId) {
      throw new Error('Email ID is required for processing')
    }
    try {
      // Process the individual email
      await processEmailById(payload, String(emailId))
      return {
        output: {
          success: true,
          emailId: String(emailId),
          status: 'sent',
          message: `Email ${emailId} processed successfully`
        }
      }
    } catch (error) {
      throw new Error(`Failed to process email ${emailId}: ${String(error)}`)
    }
  }
 }
 export default processEmailJob
--- a/src/jobs/processEmailsJob.ts
+++ b/src/jobs/processEmailsJob.ts
@@ -1,50 +0,0 @@
 import type { PayloadRequest } from 'payload'
 import { MailingService } from '../services/MailingService.js'
 export interface ProcessEmailsJobData {
  // No type needed - always processes both pending and failed emails
 }
 export const processEmailsJob = async (
  job: { data: ProcessEmailsJobData },
  context: { req: PayloadRequest; mailingService: MailingService }
 ) => {
  const { mailingService } = context
  try {
    console.log('🔄 Processing email queue (pending + failed emails)...')
    // Process pending emails first
    await mailingService.processEmails()
    // Then retry failed emails
    await mailingService.retryFailedEmails()
    console.log('✅ Email queue processing completed successfully (pending and failed emails)')
  } catch (error) {
    console.error('❌ Email queue processing failed:', error)
    throw error
  }
 }
 export const scheduleEmailsJob = async (
  payload: any,
  queueName: string,
  delay?: number
 ) => {
  if (!payload.jobs) {
    console.warn('PayloadCMS jobs not configured - emails will not be processed automatically')
    return
  }
  try {
    await payload.jobs.queue({
      queue: queueName,
      task: 'processEmails',
      input: {},
      waitUntil: delay ? new Date(Date.now() + delay) : undefined,
    })
  } catch (error) {
    console.error('Failed to schedule email processing job:', error)
  }
 }
--- a/src/jobs/processEmailsTask.ts
+++ b/src/jobs/processEmailsTask.ts
@@ -0,0 +1,84 @@
 import type { PayloadRequest, Payload } from 'payload'
 import { processAllEmails } from '../utils/emailProcessor.js'
 /**
 * Data passed to the process emails task
 */
 export interface ProcessEmailsTaskData {
  // Currently no data needed - always processes both pending and failed emails
 }
 /**
 * Handler function for processing emails
 * Used internally by the task definition
 */
 export const processEmailsTaskHandler = async (
  job: { data: ProcessEmailsTaskData },
  context: { req: PayloadRequest }
 ) => {
  const { req } = context
  const payload = (req as any).payload
  // Use the shared email processing logic
  await processAllEmails(payload)
 }
 /**
 * Task definition for processing emails
 * This is what gets registered with Payload's job system
 */
 export const processEmailsTask = {
  slug: 'process-emails',
  handler: async ({ job, req }: { job: any; req: any }) => {
    // Get mailing context from payload
    const payload = (req as any).payload
    const mailingContext = payload.mailing
    if (!mailingContext) {
      throw new Error('Mailing plugin not properly initialized')
    }
    // Use the task handler
    await processEmailsTaskHandler(
      job as { data: ProcessEmailsTaskData },
      { req }
    )
    return {
      output: {
        success: true,
        message: 'Email queue processing completed successfully'
      }
    }
  },
  interfaceName: 'ProcessEmailsTask',
 }
 // For backward compatibility, export as processEmailsJob
 export const processEmailsJob = processEmailsTask
 /**
 * Helper function to schedule an email processing job
 * Used by the plugin during initialization and can be used by developers
 */
 export const scheduleEmailsJob = async (
  payload: Payload,
  queueName: string,
  delay?: number
 ) => {
  if (!payload.jobs) {
    console.warn('PayloadCMS jobs not configured - emails will not be processed automatically')
    return
  }
  try {
    await payload.jobs.queue({
      queue: queueName,
      task: 'process-emails',
      input: {},
      waitUntil: delay ? new Date(Date.now() + delay) : undefined,
    } as any)
  } catch (error) {
    console.error('Failed to schedule email processing job:', error)
  }
 }
--- a/src/jobs/sendEmailTask.ts
+++ b/src/jobs/sendEmailTask.ts
@@ -1,179 +0,0 @@
 import { sendEmail } from '../sendEmail.js'
 import { Email } from '../payload-types.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[]
  scheduledAt?: string // ISO date string
  priority?: number
  // Allow any additional fields that users might have in their email collection
  [key: string]: any
 }
 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: '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)'
      }
    }
  ],
  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)
        }
      })
      // Use the sendEmail helper to create the email
      const email = await sendEmail<Email>(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
        }
      }
    } catch (error) {
      const errorMessage = error instanceof Error ? error.message : 'Unknown error'
      throw new Error(`Failed to queue email: ${errorMessage}`)
    }
  }
 }
 export default sendEmailJob
--- a/src/payload-types.ts
+++ b/src/payload-types.ts
@@ -1,431 +0,0 @@
 /* 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,18 +3,12 @@ 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'
+import { mailingJobs } from './jobs/index.js'
 export const mailingPlugin = (pluginConfig: MailingPluginConfig) => (config: Config): Config => {
  const queueName = pluginConfig.queue || 'default'
  // Validate queueName
  if (!queueName || typeof queueName !== 'string') {
    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'
@@ -74,10 +68,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,
    ],
@@ -107,21 +106,6 @@ export const mailingPlugin = (pluginConfig: MailingPluginConfig) => (config: Con
        },
      } as MailingContext
      console.log('PayloadCMS Mailing Plugin initialized successfully')
      // Schedule the initial email processing job
      try {
        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)
      }
      // Call onReady callback if provided
      if (pluginConfig.onReady) {
        await pluginConfig.onReady(payload)
      }
      if (pluginConfig.initOrder !== 'after' && config.onInit) {
        await config.onInit(payload)
      }
--- a/src/sendEmail.ts
+++ b/src/sendEmail.ts
@@ -1,9 +1,10 @@
 import { Payload } from 'payload'
-import { getMailing, renderTemplate, parseAndValidateEmails } from './utils/helpers.js'
+import { getMailing, renderTemplate, parseAndValidateEmails, sanitizeFromName } from './utils/helpers.js'
-import {Email} from "./payload-types.js"
+import { BaseEmailDocument } from './types/index.js'
 import { processJobById } from './utils/emailProcessor.js'
 // Options for sending emails
-export interface SendEmailOptions<T extends Email = Email> {
+export interface SendEmailOptions<T extends BaseEmailDocument = BaseEmailDocument> {
  // Template-based email
  template?: {
    slug: string
@@ -13,6 +14,8 @@ export interface SendEmailOptions<T extends Email = Email> {
  data?: Partial<T>
  // Common options
  collectionSlug?: string // defaults to 'emails'
  processImmediately?: boolean // if true, creates job and processes it immediately
  queue?: string // queue name for the job, defaults to mailing config queue
 }
 /**
@@ -35,14 +38,14 @@ export interface SendEmailOptions<T extends Email = Email> {
 * })
 * ```
 */
-export const sendEmail = async <T extends Email = Email>(
+export const sendEmail = async <TEmail extends BaseEmailDocument = BaseEmailDocument>(
  payload: Payload,
-  options: SendEmailOptions<T>
+  options: SendEmailOptions<TEmail>
-): Promise<T> => {
+): Promise<TEmail> => {
-  const mailing = getMailing(payload)
+  const mailingConfig = getMailing(payload)
-  const collectionSlug = options.collectionSlug || mailing.collections.emails || 'emails'
+  const collectionSlug = options.collectionSlug || mailingConfig.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) {
@@ -58,7 +61,7 @@ export const sendEmail = async <T extends Email = Email>(
      subject,
      html,
      text,
-    } as Partial<T>
+    } as Partial<TEmail>
  }
  // Validate required fields
@@ -89,14 +92,126 @@ export const sendEmail = async <T extends Email = Email>(
  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
  }
  // Sanitize fromName to prevent header injection
  emailData.fromName = sanitizeFromName(emailData.fromName as string)
  // 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
  // The hooks will automatically create and populate the job relationship
  const email = await payload.create({
    collection: collectionSlug,
    data: emailData
  })
-  return email 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')
  }
  // If processImmediately is true, get the job from the relationship and process it now
  if (options.processImmediately) {
    if (!payload.jobs) {
      throw new Error('PayloadCMS jobs not configured - cannot process email immediately')
    }
    // Poll for the job with optimized backoff and timeout protection
    // This handles the async nature of hooks and ensures we wait for job creation
    const maxAttempts = 5 // Reduced from 10 to minimize delay
    const initialDelay = 25 // Reduced from 50ms for faster response
    const maxTotalTime = 3000 // 3 second total timeout
    const startTime = Date.now()
    let jobId: string | undefined
    for (let attempt = 0; attempt < maxAttempts; attempt++) {
      // Check total timeout before continuing
      if (Date.now() - startTime > maxTotalTime) {
        throw new Error(
          `Job polling timed out after ${maxTotalTime}ms for email ${email.id}. ` +
          `The auto-scheduling may have failed or is taking longer than expected.`
        )
      }
      // Calculate delay with exponential backoff (25ms, 50ms, 100ms, 200ms, 400ms)
      // Cap at 400ms per attempt for better responsiveness
      const delay = Math.min(initialDelay * Math.pow(2, attempt), 400)
      if (attempt > 0) {
        await new Promise(resolve => setTimeout(resolve, delay))
      }
      // Refetch the email to check for jobs
      const emailWithJobs = await payload.findByID({
        collection: collectionSlug,
        id: email.id,
      })
      if (emailWithJobs.jobs && emailWithJobs.jobs.length > 0) {
        // Job found! Get the first job ID (should only be one for a new email)
        jobId = Array.isArray(emailWithJobs.jobs)
          ? String(emailWithJobs.jobs[0])
          : String(emailWithJobs.jobs)
        break
      }
      // Log on later attempts to help with debugging (reduced threshold)
      if (attempt >= 2) {
        console.log(`Waiting for job creation for email ${email.id}, attempt ${attempt + 1}/${maxAttempts}`)
      }
    }
    if (!jobId) {
      // Distinguish between different failure scenarios for better error handling
      const timeoutMsg = Date.now() - startTime >= maxTotalTime
      const errorType = timeoutMsg ? 'POLLING_TIMEOUT' : 'JOB_NOT_FOUND'
      const baseMessage = timeoutMsg
        ? `Job polling timed out after ${maxTotalTime}ms for email ${email.id}`
        : `No processing job found for email ${email.id} after ${maxAttempts} attempts (${Date.now() - startTime}ms)`
      throw new Error(
        `${errorType}: ${baseMessage}. ` +
        `This indicates the email was created but job auto-scheduling failed. ` +
        `The email exists in the database but immediate processing cannot proceed. ` +
        `You may need to: 1) Check job queue configuration, 2) Verify database hooks are working, ` +
        `3) Process the email later using processEmailById('${email.id}').`
      )
    }
    try {
      await processJobById(payload, jobId)
    } catch (error) {
      throw new Error(`Failed to process email ${email.id} immediately: ${String(error)}`)
    }
  }
  return email as TEmail
 }
 export default sendEmail
--- a/src/services/MailingService.ts
+++ b/src/services/MailingService.ts
@@ -1,25 +1,21 @@
 import { Payload } from 'payload'
 import { Liquid } from 'liquidjs'
 import nodemailer, { Transporter } from 'nodemailer'
 import {
  MailingPluginConfig,
  TemplateVariables,
  MailingService as IMailingService,
-  EmailTemplate,
+  BaseEmail, BaseEmailTemplate, BaseEmailDocument, BaseEmailTemplateDocument
  QueuedEmail,
  MailingTransportConfig,
  BaseEmail
 } from '../types/index.js'
 import { serializeRichTextToHTML, serializeRichTextToText } from '../utils/richTextSerializer.js'
 import { sanitizeDisplayName } from '../utils/helpers.js'
 export class MailingService implements IMailingService {
  public payload: Payload
  private config: MailingPluginConfig
-  private transporter!: Transporter | any
+  private emailAdapter: any
  private templatesCollection: string
  private emailsCollection: string
  private liquid: Liquid | null | false = null
  private transporterInitialized = false
  constructor(payload: Payload, config: MailingPluginConfig) {
    this.payload = payload
@@ -31,49 +27,48 @@ 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
+    // Use Payload's configured email adapter
-    if (payload && payload.db) {
+    if (!this.payload.email) {
-      this.initializeTransporter()
+      throw new Error('Payload email configuration is required. Please configure email in your Payload config.')
    }
-  }
+    this.emailAdapter = this.payload.email
  private initializeTransporter(): void {
    if (this.transporterInitialized) return
    if (this.config.transport) {
      if ('sendMail' in this.config.transport) {
        this.transporter = this.config.transport
      } else {
        this.transporter = nodemailer.createTransport(this.config.transport as MailingTransportConfig)
      }
    } else if (this.payload.email && 'sendMail' in this.payload.email) {
      // Use Payload's configured mailer (cast to any to handle different adapter types)
      this.transporter = this.payload.email as any
    } 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) {
+    if (!this.emailAdapter) {
-      this.initializeTransporter()
+      throw new Error('Email adapter not configured. Please ensure Payload has email configured.')
    }
  }
  /**
   * Sanitizes a display name for use in email headers to prevent header injection
   * Uses the centralized sanitization utility with quote escaping for headers
   */
  private sanitizeDisplayName(name: string): string {
    return sanitizeDisplayName(name, true) // escapeQuotes = true for email headers
  }
  /**
   * 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
+      return this.formatEmailAddress(fromEmail, fromName)
      const escapedName = fromName.replace(/"/g, '\\"')
      return `"${escapedName}" <${fromEmail}>`
    }
    return fromEmail || ''
@@ -133,7 +128,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,
@@ -224,7 +219,7 @@ export class MailingService implements IMailingService {
    }
  }
-  private async processEmailItem(emailId: string): Promise<void> {
+  async processEmailItem(emailId: string): Promise<void> {
    try {
      await this.payload.update({
        collection: this.emailsCollection as any,
@@ -238,10 +233,18 @@ export class MailingService implements IMailingService {
      const email = await this.payload.findByID({
        collection: this.emailsCollection as any,
        id: emailId,
-      }) as BaseEmail
+      }) as BaseEmailDocument
-      const mailOptions = {
+      // Combine from and fromName for nodemailer using proper sanitization
-        from: email.from,
+      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,
@@ -251,7 +254,32 @@ export class MailingService implements IMailingService {
        text: email.text || undefined,
      }
-      await this.transporter.sendMail(mailOptions)
+      // Call beforeSend hook if configured
      if (this.config.beforeSend) {
        try {
          mailOptions = await this.config.beforeSend(mailOptions, email)
          // 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'}`)
        }
      }
      // Send email using Payload's email adapter
      await this.emailAdapter.sendEmail(mailOptions)
      await this.payload.update({
        collection: this.emailsCollection as any,
@@ -287,9 +315,9 @@ export class MailingService implements IMailingService {
    const email = await this.payload.findByID({
      collection: this.emailsCollection as any,
      id: emailId,
-    }) as QueuedEmail
+    })
-    const newAttempts = (email.attempts || 0) + 1
+    const newAttempts = ((email as any).attempts || 0) + 1
    await this.payload.update({
      collection: this.emailsCollection as any,
@@ -302,7 +330,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,
@@ -314,7 +342,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
@@ -379,7 +407,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,14 +1,67 @@
 import { Payload } from 'payload'
 import type { CollectionConfig, RichTextField } from 'payload'
 import { Transporter } from 'nodemailer'
 import {Email} from "../payload-types.js"
-export type BaseEmail<TEmail = Email, TEmailTemplate = EmailTemplate> = Omit<TEmail, 'id' | 'template'> & {template: Omit<TEmailTemplate, 'id'>}
+// 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 | 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 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>
@@ -16,57 +69,36 @@ export interface MailingPluginConfig {
  }
  defaultFrom?: string
  defaultFromName?: string
  transport?: Transporter | MailingTransportConfig
  queue?: string
  retryAttempts?: number
  retryDelay?: number
  templateRenderer?: TemplateRendererHook
  templateEngine?: TemplateEngine
  richTextEditor?: RichTextField['editor']
-  onReady?: (payload: any) => Promise<void>
+  beforeSend?: BeforeSendHook
  initOrder?: 'before' | 'after'
 }
 export interface MailingTransportConfig {
  host: string
  port: number
  secure?: boolean
  auth?: {
    user: string
    pass: string
  }
 }
 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
 }
@@ -78,6 +110,7 @@ export interface TemplateVariables {
 export interface MailingService {
  processEmails(): Promise<void>
  processEmailItem(emailId: string): Promise<void>
  retryFailedEmails(): Promise<void>
  renderTemplate(templateSlug: string, variables: TemplateVariables): Promise<{ html: string; text: string; subject: string }>
 }
--- a/src/utils/emailProcessor.ts
+++ b/src/utils/emailProcessor.ts
@@ -0,0 +1,86 @@
 import type { Payload } from 'payload'
 /**
 * Processes a single email by ID using the mailing service
 * @param payload Payload instance
 * @param emailId The ID of the email to process
 * @returns Promise that resolves when email is processed
 */
 export async function processEmailById(payload: Payload, emailId: string): Promise<void> {
  // Get mailing context from payload
  const mailingContext = (payload as any).mailing
  if (!mailingContext) {
    throw new Error(
      'Mailing plugin not found on payload instance. ' +
      'Ensure the mailingPlugin is properly configured in your Payload config plugins array.'
    )
  }
  if (!mailingContext.service) {
    throw new Error(
      'Mailing service not available. ' +
      'The plugin may not have completed initialization. ' +
      'Check that email configuration is properly set up in your Payload config.'
    )
  }
  // Process the specific email
  await mailingContext.service.processEmailItem(emailId)
 }
 /**
 * Processes a job immediately by finding and executing it
 * @param payload Payload instance
 * @param jobId The ID of the job to run immediately
 * @returns Promise that resolves when job is processed
 */
 export async function processJobById(payload: Payload, jobId: string): Promise<void> {
  if (!payload.jobs) {
    throw new Error('PayloadCMS jobs not configured - cannot process job immediately')
  }
  try {
    // Run a specific job by its ID (using where clause to find the job)
    await payload.jobs.run({
      where: {
        id: {
          equals: jobId
        }
      }
    })
  } catch (error) {
    throw new Error(`Failed to process job ${jobId}: ${String(error)}`)
  }
 }
 /**
 * Processes all pending and failed emails using the mailing service
 * @param payload Payload instance
 * @returns Promise that resolves when all emails are processed
 */
 export async function processAllEmails(payload: Payload): Promise<void> {
  // Get mailing context from payload
  const mailingContext = (payload as any).mailing
  if (!mailingContext) {
    throw new Error(
      'Mailing plugin not found on payload instance. ' +
      'Ensure the mailingPlugin is properly configured in your Payload config plugins array.'
    )
  }
  if (!mailingContext.service) {
    throw new Error(
      'Mailing service not available. ' +
      'The plugin may not have completed initialization. ' +
      'Check that email configuration is properly set up in your Payload config.'
    )
  }
  // Process pending emails first
  await mailingContext.service.processEmails()
  // Then retry failed emails
  await mailingContext.service.retryFailedEmails()
 }
--- a/src/utils/helpers.ts
+++ b/src/utils/helpers.ts
@@ -36,6 +36,44 @@ export const parseAndValidateEmails = (emails: string | string[] | null | undefi
  return emailList
 }
 /**
 * Sanitize display names to prevent email header injection
 * Removes newlines, carriage returns, and control characters
 * @param displayName - The display name to sanitize
 * @param escapeQuotes - Whether to escape quotes (for email headers)
 * @returns Sanitized display name
 */
 export const sanitizeDisplayName = (displayName: string, escapeQuotes = false): string => {
  if (!displayName) return displayName
  let sanitized = displayName
    .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 if needed (for email headers)
  if (escapeQuotes) {
    sanitized = sanitized.replace(/"/g, '\\"')
  }
  return sanitized
 }
 /**
 * Sanitize and validate fromName for emails
 * Wrapper around sanitizeDisplayName for consistent fromName handling
 * @param fromName - The fromName to sanitize
 * @returns Sanitized fromName or undefined if empty after sanitization
 */
 export const sanitizeFromName = (fromName: string | null | undefined): string | undefined => {
  if (!fromName) return undefined
  const sanitized = sanitizeDisplayName(fromName, false)
  return sanitized.length > 0 ? sanitized : undefined
 }
 export const getMailing = (payload: Payload) => {
  const mailing = (payload as any).mailing
  if (!mailing) {
--- a/src/utils/jobScheduler.ts
+++ b/src/utils/jobScheduler.ts
@@ -0,0 +1,140 @@
 import type { Payload } from 'payload'
 /**
 * Finds existing processing jobs for an email
 */
 export async function findExistingJobs(
  payload: Payload,
  emailId: string | number
 ): Promise<{ docs: any[], totalDocs: number }> {
  return await payload.find({
    collection: 'payload-jobs',
    where: {
      'input.emailId': {
        equals: String(emailId),
      },
      task: {
        equals: 'process-email',
      },
    },
    limit: 10,
  })
 }
 /**
 * Ensures a processing job exists for an email
 * Creates one if it doesn't exist, or returns existing job IDs
 *
 * This function is idempotent and safe for concurrent calls:
 * - Uses atomic check-and-create pattern with retry logic
 * - Multiple concurrent calls will only create one job
 * - Database-level uniqueness prevents duplicate jobs
 * - Race conditions are handled with exponential backoff retry
 */
 export async function ensureEmailJob(
  payload: Payload,
  emailId: string | number,
  options?: {
    scheduledAt?: string | Date
    queueName?: string
  }
 ): Promise<{ jobIds: (string | number)[], created: boolean }> {
  if (!payload.jobs) {
    throw new Error('PayloadCMS jobs not configured - cannot create email job')
  }
  const normalizedEmailId = String(emailId)
  const mailingContext = (payload as any).mailing
  const queueName = options?.queueName || mailingContext?.config?.queue || 'default'
  // First, optimistically try to create the job
  // If it fails due to uniqueness constraint, then check for existing jobs
  // This approach minimizes the race condition window
  try {
    // Attempt to create job - rely on database constraints for duplicate prevention
    const job = await payload.jobs.queue({
      queue: queueName,
      task: 'process-email',
      input: {
        emailId: normalizedEmailId
      },
      waitUntil: options?.scheduledAt ? new Date(options.scheduledAt) : undefined
    })
    console.log(`Auto-scheduled processing job ${job.id} for email ${normalizedEmailId}`)
    return {
      jobIds: [job.id],
      created: true
    }
  } catch (createError) {
    // Job creation failed - likely due to duplicate constraint or system issue
    // Check if duplicate jobs exist (handles race condition where another process created job)
    const existingJobs = await findExistingJobs(payload, normalizedEmailId)
    if (existingJobs.totalDocs > 0) {
      // Found existing jobs - return them (race condition handled successfully)
      console.log(`Found existing jobs for email ${normalizedEmailId}: ${existingJobs.docs.map(j => j.id).join(', ')}`)
      return {
        jobIds: existingJobs.docs.map(job => job.id),
        created: false
      }
    }
    // No existing jobs found - this is a genuine error
    // Enhanced error context for better debugging
    const errorMessage = String(createError)
    const isLikelyUniqueConstraint = errorMessage.toLowerCase().includes('duplicate') ||
                                     errorMessage.toLowerCase().includes('unique') ||
                                     errorMessage.toLowerCase().includes('constraint')
    if (isLikelyUniqueConstraint) {
      // This should not happen if our check above worked, but provide a clear error
      throw new Error(
        `Database uniqueness constraint violation for email ${normalizedEmailId}, but no existing jobs found. ` +
        `This indicates a potential data consistency issue. Original error: ${errorMessage}`
      )
    }
    // Non-constraint related error
    throw new Error(`Failed to create job for email ${normalizedEmailId}: ${errorMessage}`)
  }
 }
 /**
 * Updates an email document to include job IDs in the relationship field
 */
 export async function updateEmailJobRelationship(
  payload: Payload,
  emailId: string | number,
  jobIds: (string | number)[],
  collectionSlug: string = 'emails'
 ): Promise<void> {
  try {
    const normalizedEmailId = String(emailId)
    const normalizedJobIds = jobIds.map(id => String(id))
    // Get current jobs to avoid overwriting
    const currentEmail = await payload.findByID({
      collection: collectionSlug,
      id: normalizedEmailId,
    })
    const currentJobs = (currentEmail.jobs || []).map((job: any) => String(job))
    const allJobs = [...new Set([...currentJobs, ...normalizedJobIds])] // Deduplicate with normalized strings
    await payload.update({
      collection: collectionSlug,
      id: normalizedEmailId,
      data: {
        jobs: allJobs
      }
    })
  } catch (error) {
    const normalizedEmailId = String(emailId)
    console.error(`Failed to update email ${normalizedEmailId} with job relationship:`, error)
    throw error
  }
 }
		`@@ -0,0 +1,2 @@`
							`USE_MEMORY_DB=true`
							`PAYLOAD_SECRET=YOUR_SECRET_HERE`