Merge pull request #38 from xtr-dev/dev

Add debug log for email transporter configuration and bump version to…

CUSTOM-TYPES.md

@@ -1,93 +0,0 @@
-# Using Custom ID Types
-
-The mailing plugin now supports both `string` and `number` ID types. By default, it works with the generic `BaseEmailDocument` interface, but you can provide your own types for full type safety.
-
-## Usage with Your Generated Types
-
-When you have your own generated Payload types (e.g., from `payload generate:types`), you can use them with the mailing plugin:
-
-```typescript
-import { sendEmail, BaseEmailDocument } from '@xtr-dev/payload-mailing'
-import { Email } from './payload-types' // Your generated types
-
-// Option 1: Use your specific Email type
-const email = await sendEmail<Email>(payload, {
-  template: {
-    slug: 'welcome',
-    variables: { name: 'John' }
-  },
-  data: {
-    to: 'user@example.com',
-    // All your custom fields are now type-safe
-  }
-})
-
-// Option 2: Extend BaseEmailDocument for custom fields
-interface MyEmail extends BaseEmailDocument {
-  customField: string
-  anotherField?: number
-}
-
-const customEmail = await sendEmail<MyEmail>(payload, {
-  data: {
-    to: 'user@example.com',
-    subject: 'Hello',
-    html: '<p>Hello World</p>',
-    customField: 'my value', // Type-safe!
-  }
-})
-```
-
-## Compatibility
-
-The plugin works with:
-- **String IDs**: `id: string`
-- **Number IDs**: `id: number`
-- **Nullable fields**: Fields can be `null`, `undefined`, or have values
-- **Generated types**: Works with `payload generate:types` output
-
-Your Payload configuration determines which types are used. The plugin automatically adapts to your setup.
-
-## Type Definitions
-
-The base interfaces provided by the plugin:
-
-```typescript
-// JSON value type that matches Payload's JSON field type
-type JSONValue = string | number | boolean | { [k: string]: unknown } | unknown[] | null | undefined
-
-interface BaseEmailDocument {
-  id: string | number
-  template?: any
-  to: string[]
-  cc?: string[] | null
-  bcc?: string[] | null
-  from?: string | null
-  replyTo?: string | null
-  subject: string
-  html: string
-  text?: string | null
-  variables?: JSONValue  // Supports any JSON-compatible value
-  scheduledAt?: string | null
-  sentAt?: string | null
-  status?: 'pending' | 'processing' | 'sent' | 'failed' | null
-  attempts?: number | null
-  lastAttemptAt?: string | null
-  error?: string | null
-  priority?: number | null
-  createdAt?: string | null
-  updatedAt?: string | null
-}
-
-interface BaseEmailTemplateDocument {
-  id: string | number
-  name: string
-  slug: string
-  subject?: string | null
-  content?: any
-  createdAt?: string | null
-  updatedAt?: string | null
-}
-```
-
-These provide a foundation that works with any ID type while maintaining type safety for the core email functionality.

README.md

@@ -142,6 +142,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 +267,56 @@ mailingPlugin({
 })
 ```
 
+### beforeSend Hook
+
+Modify emails before they are sent to add attachments, custom headers, or make other changes:
+
+```typescript
+mailingPlugin({
+  // ... other config
+  beforeSend: async (options, email) => {
+    // Add attachments dynamically
+    if (email.invoiceId) {
+      const invoice = await generateInvoicePDF(email.invoiceId)
+      options.attachments = [
+        {
+          filename: `invoice-${email.invoiceId}.pdf`,
+          content: invoice.buffer,
+          contentType: 'application/pdf'
+        }
+      ]
+    }
+
+    // Add custom headers
+    options.headers = {
+      'X-Campaign-ID': email.campaignId,
+      'X-Customer-ID': email.customerId,
+      'X-Priority': email.priority === 1 ? 'High' : 'Normal'
+    }
+
+    // Modify recipients based on conditions
+    if (process.env.NODE_ENV === 'development') {
+      // Redirect all emails to test address in dev
+      options.to = ['test@example.com']
+      options.subject = `[TEST] ${options.subject}`
+    }
+
+    // Add BCC for compliance
+    if (email.requiresAudit) {
+      options.bcc = ['audit@company.com']
+    }
+
+    return options
+  }
+})
+```
+
+The `beforeSend` hook receives:
+- `options`: The nodemailer mail options that will be sent
+- `email`: The full email document from the database
+
+You must return the modified options object.
+
 ### Initialization Hooks
 
 Control plugin initialization order and add post-initialization logic:
@@ -266,7 +328,7 @@ mailingPlugin({
   onReady: async (payload) => {
     // Called after plugin is fully initialized
     console.log('Mailing plugin ready!')
-    
+
     // Custom initialization logic here
     await setupCustomEmailSettings(payload)
   }

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/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.15",
+  "version": "0.1.23",
   "description": "Template-based email system with scheduling and job processing for PayloadCMS",
   "type": "module",
   "main": "dist/index.js",

src/collections/Emails.ts

@@ -49,6 +49,13 @@ const Emails: CollectionConfig = {
         description: 'Sender email address (optional, uses default if not provided)',
       },
     },
+    {
+      name: 'fromName',
+      type: 'text',
+      admin: {
+        description: 'Sender display name (optional, e.g., "John Doe" for "John Doe <john@example.com>")',
+      },
+    },
     {
       name: 'replyTo',
       type: 'text',

src/jobs/sendEmailTask.ts

@@ -15,7 +15,10 @@ export interface SendEmailTaskInput {
   to: string | string[]
   cc?: string | string[]
   bcc?: string | string[]
-  scheduledAt?: string // ISO date string
+  from?: string
+  fromName?: string
+  replyTo?: string
+  scheduledAt?: string | Date // ISO date string or Date object
   priority?: number
 
   // Allow any additional fields that users might have in their email collection
@@ -39,7 +42,7 @@ function transformTaskInputToSendEmailOptions(taskInput: SendEmailTaskInput) {
   }
 
   // Standard email fields that should be copied to data
-  const standardFields = ['to', 'cc', 'bcc', 'subject', 'html', 'text', 'scheduledAt', 'priority']
+  const standardFields = ['to', 'cc', 'bcc', 'from', 'fromName', 'replyTo', 'subject', 'html', 'text', 'scheduledAt', 'priority']
 
   // Template-specific fields that should not be copied to data
   const templateFields = ['templateSlug', 'variables']
@@ -135,6 +138,30 @@ export const sendEmailJob = {
         description: 'Optional comma-separated list of BCC email addresses'
       }
     },
+    {
+      name: 'from',
+      type: 'text' as const,
+      label: 'From Email',
+      admin: {
+        description: 'Optional sender email address (uses default if not provided)'
+      }
+    },
+    {
+      name: 'fromName',
+      type: 'text' as const,
+      label: 'From Name',
+      admin: {
+        description: 'Optional sender display name (e.g., "John Doe")'
+      }
+    },
+    {
+      name: 'replyTo',
+      type: 'text' as const,
+      label: 'Reply To',
+      admin: {
+        description: 'Optional reply-to email address'
+      }
+    },
     {
       name: 'scheduledAt',
       type: 'date' as const,

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

@@ -74,10 +74,15 @@ export const mailingPlugin = (pluginConfig: MailingPluginConfig) => (config: Con
     }),
   } satisfies CollectionConfig
 
+  // Filter out any existing collections with the same slugs to prevent duplicates
+  const existingCollections = (config.collections || []).filter(
+    (collection) => collection.slug !== templatesSlug && collection.slug !== emailsSlug
+  )
+
   return {
     ...config,
     collections: [
-      ...(config.collections || []),
+      ...existingCollections,
       templatesCollection,
       emailsCollection,
     ],

src/sendEmail.ts

@@ -83,23 +83,51 @@ 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 = emailData.fromName
+      .trim()
+      // Remove/replace newlines and carriage returns to prevent header injection
+      .replace(/[\r\n]/g, ' ')
+      // Remove control characters (except space and printable characters)
+      .replace(/[\x00-\x1F\x7F-\x9F]/g, '')
+      // Note: We don't escape quotes here as that's handled in MailingService
+  }
+
+  // Normalize Date objects to ISO strings for consistent database storage
+  if (emailData.scheduledAt instanceof Date) {
+    emailData.scheduledAt = emailData.scheduledAt.toISOString()
+  }
+  if (emailData.sentAt instanceof Date) {
+    emailData.sentAt = emailData.sentAt.toISOString()
+  }
+  if (emailData.lastAttemptAt instanceof Date) {
+    emailData.lastAttemptAt = emailData.lastAttemptAt.toISOString()
+  }
+  if (emailData.createdAt instanceof Date) {
+    emailData.createdAt = emailData.createdAt.toISOString()
+  }
+  if (emailData.updatedAt instanceof Date) {
+    emailData.updatedAt = emailData.updatedAt.toISOString()
+  }
+
   // Create the email in the collection with proper typing
   const email = await payload.create({
     collection: collectionSlug,

src/services/MailingService.ts

@@ -29,10 +29,7 @@ export class MailingService implements IMailingService {
     const emailsConfig = config.collections?.emails
     this.emailsCollection = typeof emailsConfig === 'string' ? emailsConfig : 'emails'
 
-    // Only initialize transporter if payload is properly set
+    this.initializeTransporter()
-    if (payload && payload.db) {
-      this.initializeTransporter()
-    }
   }
 
   private initializeTransporter(): void {
@@ -48,6 +45,7 @@ export class MailingService implements IMailingService {
       // Use Payload's configured mailer (cast to any to handle different adapter types)
       this.transporter = this.payload.email as any
     } else {
+      console.log('[DEBUG] email: ', this.payload.email);
       throw new Error('Email transport configuration is required either in plugin config or Payload config')
     }
 
@@ -63,15 +61,39 @@ export class MailingService implements IMailingService {
     }
   }
 
+  /**
+   * Sanitizes a display name for use in email headers to prevent header injection
+   * and ensure proper formatting
+   */
+  private sanitizeDisplayName(name: string): string {
+    return name
+      .trim()
+      // Remove/replace newlines and carriage returns to prevent header injection
+      .replace(/[\r\n]/g, ' ')
+      // Remove control characters (except space and printable characters)
+      .replace(/[\x00-\x1F\x7F-\x9F]/g, '')
+      // Escape quotes to prevent malformed headers
+      .replace(/"/g, '\\"')
+  }
+
+  /**
+   * Formats an email address with optional display name
+   */
+  private formatEmailAddress(email: string, displayName?: string | null): string {
+    if (displayName && displayName.trim()) {
+      const sanitizedName = this.sanitizeDisplayName(displayName)
+      return `"${sanitizedName}" <${email}>`
+    }
+    return email
+  }
+
   private getDefaultFrom(): string {
     const fromEmail = this.config.defaultFrom
     const fromName = this.config.defaultFromName
 
     // Check if fromName exists, is not empty after trimming, and fromEmail exists
     if (fromName && fromName.trim() && fromEmail) {
-      // Escape quotes in the display name to prevent malformed headers
+      return this.formatEmailAddress(fromEmail, fromName)
-      const escapedName = fromName.replace(/"/g, '\\"')
-      return `"${escapedName}" <${fromEmail}>`
     }
 
     return fromEmail || ''
@@ -238,8 +260,16 @@ export class MailingService implements IMailingService {
         id: emailId,
       }) 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,
@@ -249,6 +279,30 @@ export class MailingService implements IMailingService {
         text: email.text || undefined,
       }
 
+      // 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'}`)
+        }
+      }
+
       await this.transporter.sendMail(mailOptions)
 
       await this.payload.update({

src/types/index.ts

@@ -13,20 +13,21 @@ export interface BaseEmailDocument {
   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 | null
+  scheduledAt?: string | Date | null
-  sentAt?: string | null
+  sentAt?: string | Date | null
   status?: 'pending' | 'processing' | 'sent' | 'failed' | null
   attempts?: number | null
-  lastAttemptAt?: string | null
+  lastAttemptAt?: string | Date | null
   error?: string | null
   priority?: number | null
-  createdAt?: string | null
+  createdAt?: string | Date | null
-  updatedAt?: string | null
+  updatedAt?: string | Date | null
 }
 
 export interface BaseEmailTemplateDocument {
@@ -35,8 +36,8 @@ export interface BaseEmailTemplateDocument {
   slug: string
   subject?: string | null
   content?: any
-  createdAt?: string | null
+  createdAt?: string | Date | null
-  updatedAt?: string | 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}
@@ -47,6 +48,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>
@@ -61,6 +77,7 @@ export interface MailingPluginConfig {
   templateRenderer?: TemplateRendererHook
   templateEngine?: TemplateEngine
   richTextEditor?: RichTextField['editor']
+  beforeSend?: BeforeSendHook
   onReady?: (payload: any) => Promise<void>
   initOrder?: 'before' | 'after'
 }
@@ -83,16 +100,17 @@ export interface QueuedEmail {
   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 | null
+  scheduledAt?: string | Date | null
-  sentAt?: string | null
+  sentAt?: string | Date | null
   status: 'pending' | 'processing' | 'sent' | 'failed'
   attempts: number
-  lastAttemptAt?: string | null
+  lastAttemptAt?: string | Date | null
   error?: string | null
   priority?: number | null
   createdAt: string