Merge pull request #34 from xtr-dev/dev

Add fromName field support to emails collection

package.json

@@ -1,6 +1,6 @@
 {
   "name": "@xtr-dev/payload-mailing",
-  "version": "0.1.9",
+  "version": "0.1.18",
   "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

@@ -1,5 +1,5 @@
 import { sendEmail } from '../sendEmail.js'
-import { Email } from '../payload-types.js'
+import { BaseEmailDocument } from '../types/index.js'
 
 export interface SendEmailTaskInput {
   // Template mode fields
@@ -15,13 +15,55 @@ export interface SendEmailTaskInput {
   to: string | string[]
   cc?: string | string[]
   bcc?: string | string[]
-  scheduledAt?: string // ISO date string
+  from?: string
+  fromName?: string
+  replyTo?: string
+  scheduledAt?: string | Date // ISO date string or Date object
   priority?: number
 
   // Allow any additional fields that users might have in their email collection
   [key: string]: any
 }
 
+/**
+ * Transforms task input into sendEmail options by separating template and data fields
+ */
+function transformTaskInputToSendEmailOptions(taskInput: SendEmailTaskInput) {
+  const sendEmailOptions: any = {
+    data: {}
+  }
+
+  // If using template mode, set template options
+  if (taskInput.templateSlug) {
+    sendEmailOptions.template = {
+      slug: taskInput.templateSlug,
+      variables: taskInput.variables || {}
+    }
+  }
+
+  // Standard email fields that should be copied to data
+  const standardFields = ['to', 'cc', 'bcc', 'from', 'fromName', 'replyTo', 'subject', 'html', 'text', 'scheduledAt', 'priority']
+
+  // Template-specific fields that should not be copied to data
+  const templateFields = ['templateSlug', 'variables']
+
+  // Copy standard fields to data
+  standardFields.forEach(field => {
+    if (taskInput[field] !== undefined) {
+      sendEmailOptions.data[field] = taskInput[field]
+    }
+  })
+
+  // Copy any additional custom fields that aren't template or standard fields
+  Object.keys(taskInput).forEach(key => {
+    if (!templateFields.includes(key) && !standardFields.includes(key)) {
+      sendEmailOptions.data[key] = taskInput[key]
+    }
+  })
+
+  return sendEmailOptions
+}
+
 export const sendEmailJob = {
   slug: 'send-email',
   label: 'Send Email',
@@ -96,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,
@@ -116,64 +182,42 @@ export const sendEmailJob = {
       }
     }
   ],
+  outputSchema: [
+    {
+      name: 'id',
+      type: 'text' as const
+    }
+  ],
   handler: async ({ input, payload }: any) => {
     // Cast input to our expected type
     const taskInput = input as SendEmailTaskInput
 
     try {
-      // Prepare options for sendEmail based on task input
+      // Transform task input into sendEmail options using helper function
-      const sendEmailOptions: any = {
+      const sendEmailOptions = transformTaskInputToSendEmailOptions(taskInput)
-        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)
+      const email = await sendEmail<BaseEmailDocument>(payload, sendEmailOptions)
 
       return {
         output: {
           success: true,
-          emailId: email.id,
+          id: 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'
+      if (error instanceof Error) {
-      throw new Error(`Failed to queue email: ${errorMessage}`)
+        // Preserve original error and stack trace
+        const wrappedError = new Error(`Failed to queue email: ${error.message}`)
+        wrappedError.stack = error.stack
+        wrappedError.cause = error
+        throw wrappedError
+      } else {
+        throw new Error(`Failed to queue email: ${String(error)}`)
+      }
     }
   }
 }
 
-export default sendEmailJob
+export default sendEmailJob

src/sendEmail.ts

@@ -1,9 +1,9 @@
 import { Payload } from 'payload'
 import { getMailing, renderTemplate, parseAndValidateEmails } from './utils/helpers.js'
-import {Email} from "./payload-types.js"
+import { BaseEmailDocument } from './types/index.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
@@ -35,14 +35,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 collectionSlug = options.collectionSlug || mailing.collections.emails || 'emails'
 
-  let emailData: Partial<T> = { ...options.data } as Partial<T>
+  let emailData: Partial<TEmail> = { ...options.data } as Partial<TEmail>
 
   // If using a template, render it first
   if (options.template) {
@@ -58,7 +58,7 @@ export const sendEmail = async <T extends Email = Email>(
       subject,
       html,
       text,
-    } as Partial<T>
+    } as Partial<TEmail>
   }
 
   // Validate required fields
@@ -83,12 +83,50 @@ export const sendEmail = async <T extends Email = Email>(
   if (emailData.to) {
     emailData.to = parseAndValidateEmails(emailData.to as string | string[])
   }
-  if (emailData.cc) {
+  if (emailData.cc && emailData.cc !== null) {
     emailData.cc = parseAndValidateEmails(emailData.cc as string | string[])
   }
-  if (emailData.bcc) {
+  if (emailData.bcc && emailData.bcc !== null) {
     emailData.bcc = parseAndValidateEmails(emailData.bcc as string | string[])
   }
+  if (emailData.replyTo && emailData.replyTo !== null) {
+    const validated = parseAndValidateEmails(emailData.replyTo as string | string[])
+    // replyTo should be a single email, so take the first one if array
+    emailData.replyTo = validated && validated.length > 0 ? validated[0] : undefined
+  }
+  if (emailData.from && emailData.from !== null) {
+    const validated = parseAndValidateEmails(emailData.from as string | string[])
+    // from should be a single email, so take the first one if array
+    emailData.from = validated && validated.length > 0 ? validated[0] : undefined
+  }
+
+  // Sanitize fromName to prevent header injection
+  if (emailData.fromName && emailData.fromName !== null) {
+    emailData.fromName = emailData.fromName
+      .trim()
+      // Remove/replace newlines and carriage returns to prevent header injection
+      .replace(/[\r\n]/g, ' ')
+      // Remove control characters (except space and printable characters)
+      .replace(/[\x00-\x1F\x7F-\x9F]/g, '')
+      // Note: We don't escape quotes here as that's handled in MailingService
+  }
+
+  // Normalize Date objects to ISO strings for consistent database storage
+  if (emailData.scheduledAt instanceof Date) {
+    emailData.scheduledAt = emailData.scheduledAt.toISOString()
+  }
+  if (emailData.sentAt instanceof Date) {
+    emailData.sentAt = emailData.sentAt.toISOString()
+  }
+  if (emailData.lastAttemptAt instanceof Date) {
+    emailData.lastAttemptAt = emailData.lastAttemptAt.toISOString()
+  }
+  if (emailData.createdAt instanceof Date) {
+    emailData.createdAt = emailData.createdAt.toISOString()
+  }
+  if (emailData.updatedAt instanceof Date) {
+    emailData.updatedAt = emailData.updatedAt.toISOString()
+  }
 
   // Create the email in the collection with proper typing
   const email = await payload.create({
@@ -96,7 +134,12 @@ export const sendEmail = async <T extends Email = Email>(
     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')
+  }
+
+  return email as TEmail
 }
 
 export default sendEmail

src/services/MailingService.ts

@@ -5,10 +5,8 @@ import {
   MailingPluginConfig,
   TemplateVariables,
   MailingService as IMailingService,
-  EmailTemplate,
-  QueuedEmail,
   MailingTransportConfig,
-  BaseEmail
+  BaseEmail, BaseEmailTemplate, BaseEmailDocument, BaseEmailTemplateDocument
 } from '../types/index.js'
 import { serializeRichTextToHTML, serializeRichTextToText } from '../utils/richTextSerializer.js'
 
@@ -65,15 +63,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 || ''
@@ -133,7 +155,7 @@ export class MailingService implements IMailingService {
     }
 
     const emailContent = await this.renderEmailTemplate(template, variables)
-    const subject = await this.renderTemplateString(template.subject, variables)
+    const subject = await this.renderTemplateString(template.subject || '', variables)
 
     return {
       html: emailContent.html,
@@ -238,10 +260,18 @@ export class MailingService implements IMailingService {
       const email = await this.payload.findByID({
         collection: this.emailsCollection as any,
         id: emailId,
-      }) as BaseEmail
+      }) as BaseEmailDocument
+
+      // Combine from and fromName for nodemailer using proper sanitization
+      let fromField: string
+      if (email.from) {
+        fromField = this.formatEmailAddress(email.from, email.fromName)
+      } else {
+        fromField = this.getDefaultFrom()
+      }
 
       const mailOptions = {
-        from: email.from,
+        from: fromField,
         to: email.to,
         cc: email.cc || undefined,
         bcc: email.bcc || undefined,
@@ -287,7 +317,7 @@ export class MailingService implements IMailingService {
     const email = await this.payload.findByID({
       collection: this.emailsCollection as any,
       id: emailId,
-    }) as QueuedEmail
+    }) as BaseEmail
 
     const newAttempts = (email.attempts || 0) + 1
 
@@ -302,7 +332,7 @@ export class MailingService implements IMailingService {
     return newAttempts
   }
 
-  private async getTemplateBySlug(templateSlug: string): Promise<EmailTemplate | null> {
+  private async getTemplateBySlug(templateSlug: string): Promise<BaseEmailTemplateDocument | null> {
     try {
       const { docs } = await this.payload.find({
         collection: this.templatesCollection as any,
@@ -314,7 +344,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 +409,7 @@ export class MailingService implements IMailingService {
     })
   }
 
-  private async renderEmailTemplate(template: EmailTemplate, variables: Record<string, any> = {}): Promise<{ html: string; text: string }> {
+  private async renderEmailTemplate(template: BaseEmailTemplateDocument, variables: Record<string, any> = {}): Promise<{ html: string; text: string }> {
     if (!template.content) {
       return { html: '', text: '' }
     }

src/types/index.ts

@@ -1,9 +1,48 @@
 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>
 
@@ -37,36 +76,27 @@ export interface MailingTransportConfig {
   }
 }
 
-export interface EmailTemplate {
-  id: string
-  name: string
-  slug: string
-  subject: string
-  content: any // Lexical editor state
-  createdAt: string
-  updatedAt: string
-}
-
 
 export interface QueuedEmail {
   id: string
-  template?: string
+  template?: string | null
   to: string[]
-  cc?: string[]
+  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
 }