Merge pull request #43 from xtr-dev/dev

Remove verbose initialization logs

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

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
-  plugins: [
+  email: nodemailerAdapter({
-    mailingPlugin({
+    defaultFromAddress: 'noreply@yoursite.com',
-      defaultFrom: 'noreply@yoursite.com',
+    defaultFromName: 'Your Site',
     transport: {
       host: 'smtp.gmail.com',
       port: 587,
-        secure: false,
       auth: {
         user: process.env.EMAIL_USER,
         pass: process.env.EMAIL_PASS,
       },
     },
+  }),
+  plugins: [
+    mailingPlugin({
+      defaultFrom: 'noreply@yoursite.com',
+      defaultFromName: 'Your Site Name',
       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:
@@ -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:

dev/payload-types.ts

@@ -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
    */
@@ -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;
@@ -675,6 +680,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 +701,9 @@ export interface TaskSendEmail {
      */
     priority?: number | null;
   };
-  output?: unknown;
+  output: {
+    id?: string | null;
+  };
 }
 /**
  * This interface was referenced by `Config`'s JSON-Schema

dev/payload.config.ts

@@ -135,15 +135,6 @@ const buildConfigWithMemoryDB = async () => {
       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',

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)

package.json

@@ -1,6 +1,6 @@
 {
   "name": "@xtr-dev/payload-mailing",
-  "version": "0.1.18",
+  "version": "0.4.3",
   "description": "Template-based email system with scheduling and job processing for PayloadCMS",
   "type": "module",
   "main": "dist/index.js",

src/index.ts

@@ -27,3 +27,6 @@ export {
   retryFailedEmails,
   parseAndValidateEmails,
 } from './utils/helpers.js'
+
+// Email processing utilities
+export { processEmailById, processAllEmails } from './utils/emailProcessor.js'

src/jobs/index.ts

@@ -1,35 +1,14 @@
-import { processEmailsJob, ProcessEmailsJobData } from './processEmailsJob.js'
+import { processEmailsJob } from './processEmailsTask.js'
 import { sendEmailJob } from './sendEmailTask.js'
-import { MailingService } from '../services/MailingService.js'
 
+/**
+ * All mailing-related jobs that get registered with Payload
+ */
 export const mailingJobs = [
-  {
+  processEmailsJob,
-    slug: 'processEmails',
-    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 './processEmailsTask.js'
 export * from './sendEmailTask.js'

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)
-  }
-}

src/jobs/processEmailsTask.ts

@@ -0,0 +1,93 @@
+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
+
+  try {
+    console.log('🔄 Processing email queue (pending + failed emails)...')
+
+    // Use the shared email processing logic
+    await processAllEmails(payload)
+
+    console.log('✅ Email queue processing completed successfully')
+  } catch (error) {
+    console.error('❌ Email queue processing failed:', error)
+    throw error
+  }
+}
+
+/**
+ * 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)
+  }
+}

src/jobs/sendEmailTask.ts

@@ -1,5 +1,6 @@
 import { sendEmail } from '../sendEmail.js'
 import { BaseEmailDocument } from '../types/index.js'
+import { processEmailById } from '../utils/emailProcessor.js'
 
 export interface SendEmailTaskInput {
   // Template mode fields
@@ -20,6 +21,7 @@ export interface SendEmailTaskInput {
   replyTo?: string
   scheduledAt?: string | Date // ISO date string or Date object
   priority?: number
+  processImmediately?: boolean // If true, process the email immediately instead of waiting for the queue
 
   // Allow any additional fields that users might have in their email collection
   [key: string]: any
@@ -44,8 +46,8 @@ function transformTaskInputToSendEmailOptions(taskInput: SendEmailTaskInput) {
   // Standard email fields that should be copied to data
   const standardFields = ['to', 'cc', 'bcc', 'from', 'fromName', 'replyTo', 'subject', 'html', 'text', 'scheduledAt', 'priority']
 
-  // Template-specific fields that should not be copied to data
+  // Fields that should not be copied to data
-  const templateFields = ['templateSlug', 'variables']
+  const excludedFields = ['templateSlug', 'variables', 'processImmediately']
 
   // Copy standard fields to data
   standardFields.forEach(field => {
@@ -54,9 +56,9 @@ function transformTaskInputToSendEmailOptions(taskInput: SendEmailTaskInput) {
     }
   })
 
-  // Copy any additional custom fields that aren't template or standard fields
+  // Copy any additional custom fields that aren't excluded or standard fields
   Object.keys(taskInput).forEach(key => {
-    if (!templateFields.includes(key) && !standardFields.includes(key)) {
+    if (!excludedFields.includes(key) && !standardFields.includes(key)) {
       sendEmailOptions.data[key] = taskInput[key]
     }
   })
@@ -64,10 +66,23 @@ function transformTaskInputToSendEmailOptions(taskInput: SendEmailTaskInput) {
   return sendEmailOptions
 }
 
+/**
+ * Job definition for sending emails
+ * Can be used through Payload's job queue system to send emails programmatically
+ */
 export const sendEmailJob = {
   slug: 'send-email',
   label: 'Send Email',
   inputSchema: [
+    {
+      name: 'processImmediately',
+      type: 'checkbox' as const,
+      label: 'Process Immediately',
+      defaultValue: false,
+      admin: {
+        description: 'Process and send the email immediately instead of waiting for the queue processor'
+      }
+    },
     {
       name: 'templateSlug',
       type: 'text' as const,
@@ -167,7 +182,8 @@ export const sendEmailJob = {
       type: 'date' as const,
       label: 'Schedule For',
       admin: {
-        description: 'Optional date/time to schedule email for future delivery'
+        description: 'Optional date/time to schedule email for future delivery',
+        condition: (data: any) => !data.processImmediately
       }
     },
     {
@@ -191,6 +207,7 @@ export const sendEmailJob = {
   handler: async ({ input, payload }: any) => {
     // Cast input to our expected type
     const taskInput = input as SendEmailTaskInput
+    const shouldProcessImmediately = taskInput.processImmediately || false
 
     try {
       // Transform task input into sendEmail options using helper function
@@ -199,22 +216,38 @@ export const sendEmailJob = {
       // Use the sendEmail helper to create the email
       const email = await sendEmail<BaseEmailDocument>(payload, sendEmailOptions)
 
+      // If processImmediately is true, process the email now
+      if (shouldProcessImmediately) {
+        console.log(`⚡ Processing email ${email.id} immediately...`)
+        await processEmailById(payload, String(email.id))
+        console.log(`✅ Email ${email.id} processed and sent immediately`)
+
         return {
           output: {
             success: true,
             id: email.id,
+            status: 'sent',
+            processedImmediately: true
+          }
+        }
+      }
+
+      return {
+        output: {
+          success: true,
+          id: email.id,
+          status: 'queued',
+          processedImmediately: false
         }
       }
 
     } catch (error) {
+      // Re-throw Error instances to preserve stack trace and error context
       if (error instanceof Error) {
-        // Preserve original error and stack trace
+        throw error
-        const wrappedError = new Error(`Failed to queue email: ${error.message}`)
-        wrappedError.stack = error.stack
-        wrappedError.cause = error
-        throw wrappedError
       } else {
-        throw new Error(`Failed to queue email: ${String(error)}`)
+        // Only wrap non-Error values
+        throw new Error(`Failed to process email: ${String(error)}`)
       }
     }
   }

src/payload-types.ts

@@ -143,6 +143,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
    */
@@ -336,6 +340,7 @@ export interface EmailsSelect<T extends boolean = true> {
   cc?: T;
   bcc?: T;
   from?: T;
+  fromName?: T;
   replyTo?: T;
   subject?: T;
   html?: T;

src/plugin.ts

@@ -9,12 +9,6 @@ import { mailingJobs, scheduleEmailsJob } 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,12 +106,9 @@ 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)
       }

src/sendEmail.ts

@@ -83,25 +83,25 @@ export const sendEmail = async <TEmail extends BaseEmailDocument = BaseEmailDocu
   if (emailData.to) {
     emailData.to = parseAndValidateEmails(emailData.to as string | string[])
   }
-  if (emailData.cc && emailData.cc !== null) {
+  if (emailData.cc) {
     emailData.cc = parseAndValidateEmails(emailData.cc as string | string[])
   }
-  if (emailData.bcc && emailData.bcc !== null) {
+  if (emailData.bcc) {
     emailData.bcc = parseAndValidateEmails(emailData.bcc as string | string[])
   }
-  if (emailData.replyTo && emailData.replyTo !== null) {
+  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 && emailData.from !== null) {
+  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
-  if (emailData.fromName && emailData.fromName !== null) {
+  if (emailData.fromName) {
     emailData.fromName = emailData.fromName
       .trim()
       // Remove/replace newlines and carriage returns to prevent header injection

src/services/MailingService.ts

@@ -1,11 +1,9 @@
 import { Payload } from 'payload'
 import { Liquid } from 'liquidjs'
-import nodemailer, { Transporter } from 'nodemailer'
 import {
   MailingPluginConfig,
   TemplateVariables,
   MailingService as IMailingService,
-  MailingTransportConfig,
   BaseEmail, BaseEmailTemplate, BaseEmailDocument, BaseEmailTemplateDocument
 } from '../types/index.js'
 import { serializeRichTextToHTML, serializeRichTextToText } from '../utils/richTextSerializer.js'
@@ -13,11 +11,10 @@ import { serializeRichTextToHTML, serializeRichTextToText } from '../utils/richT
 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
@@ -29,37 +26,19 @@ 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.')
     }
   }
 
@@ -246,7 +225,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,
@@ -270,7 +249,7 @@ export class MailingService implements IMailingService {
         fromField = this.getDefaultFrom()
       }
 
-      const mailOptions = {
+      let mailOptions: any = {
         from: fromField,
         to: email.to,
         cc: email.cc || undefined,
@@ -281,7 +260,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,

src/types/index.ts

@@ -1,6 +1,5 @@
 import { Payload } from 'payload'
 import type { CollectionConfig, RichTextField } from 'payload'
-import { Transporter } from 'nodemailer'
 
 // JSON value type that matches Payload's JSON field type
 export type JSONValue = string | number | boolean | { [k: string]: unknown } | unknown[] | null | undefined
@@ -48,6 +47,21 @@ export type TemplateRendererHook = (template: string, variables: Record<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>
@@ -55,28 +69,17 @@ export interface MailingPluginConfig {
   }
   defaultFrom?: string
   defaultFromName?: string
-  transport?: Transporter | MailingTransportConfig
   queue?: string
   retryAttempts?: number
   retryDelay?: number
   templateRenderer?: TemplateRendererHook
   templateEngine?: TemplateEngine
   richTextEditor?: RichTextField['editor']
+  beforeSend?: BeforeSendHook
   onReady?: (payload: any) => Promise<void>
   initOrder?: 'before' | 'after'
 }
 
-export interface MailingTransportConfig {
-  host: string
-  port: number
-  secure?: boolean
-  auth?: {
-    user: string
-    pass: string
-  }
-}
-
-
 export interface QueuedEmail {
   id: string
   template?: string | null
@@ -108,6 +111,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 }>
 }

src/utils/emailProcessor.ts

@@ -0,0 +1,61 @@
+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 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()
+}