Fix critical race conditions and error handling inconsistencies

Race Condition Fixes (jobScheduler.ts):
- Implement optimistic job creation with graceful fallback
- Minimize race condition window by trying create first, then check
- Add enhanced error detection for constraint violations
- Provide detailed error context for debugging data consistency issues

Error Handling Improvements (sendEmail.ts):
- Distinguish between POLLING_TIMEOUT vs JOB_NOT_FOUND errors
- Add specific error types for programmatic handling
- Provide actionable troubleshooting steps in error messages
- Include recovery instructions (processEmailById fallback)

Benefits:
- Eliminates the check-then-create race condition vulnerability
- Provides clear error classification for different failure modes
- Enables better monitoring and debugging of job scheduling issues
- Maintains robustness under high concurrency scenarios

🤖 Generated with [Claude Code](https://claude.ai/code)

Co-Authored-By: Claude <noreply@anthropic.com>

src/sendEmail.ts

@@ -187,9 +187,20 @@ export const sendEmail = async <TEmail extends BaseEmailDocument = BaseEmailDocu
     }
 
     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(
-        `No processing job found for email ${email.id} after ${maxAttempts} attempts (${Date.now() - startTime}ms). ` +
+        `${errorType}: ${baseMessage}. ` +
-        `The auto-scheduling may have failed or is taking longer than expected.`
+        `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}').`
       )
     }
 

src/utils/jobScheduler.ts

@@ -47,21 +47,9 @@ export async function ensureEmailJob(
   const mailingContext = (payload as any).mailing
   const queueName = options?.queueName || mailingContext?.config?.queue || 'default'
 
-  // Implement atomic check-and-create with minimal retry for efficiency
+  // First, optimistically try to create the job
-  const maxAttempts = 3 // Reduced from 5 for better performance
+  // If it fails due to uniqueness constraint, then check for existing jobs
-  const baseDelay = 50 // Reduced from 100ms for faster response
+  // This approach minimizes the race condition window
-
-  for (let attempt = 0; attempt < maxAttempts; attempt++) {
-    // Check for existing jobs with precise matching
-    const existingJobs = await findExistingJobs(payload, normalizedEmailId)
-
-    if (existingJobs.totalDocs > 0) {
-      // Job already exists - return existing job IDs
-      return {
-        jobIds: existingJobs.docs.map(job => job.id),
-        created: false
-      }
-    }
 
   try {
     // Attempt to create job - rely on database constraints for duplicate prevention
@@ -80,41 +68,39 @@ export async function ensureEmailJob(
       jobIds: [job.id],
       created: true
     }
-    } catch (error) {
+  } catch (createError) {
-      // On any creation error, wait briefly and check again for concurrent creation
+    // Job creation failed - likely due to duplicate constraint or system issue
-      if (attempt < maxAttempts - 1) {
-        const delay = Math.min(baseDelay * Math.pow(1.5, attempt), 200) // Gentler exponential backoff, capped at 200ms
-        await new Promise(resolve => setTimeout(resolve, delay))
 
-        // Check if another process succeeded while we were failing
+    // Check if duplicate jobs exist (handles race condition where another process created job)
-        const recheckJobs = await findExistingJobs(payload, normalizedEmailId)
+    const existingJobs = await findExistingJobs(payload, normalizedEmailId)
-        if (recheckJobs.totalDocs > 0) {
+
+    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: recheckJobs.docs.map(job => job.id),
+        jobIds: existingJobs.docs.map(job => job.id),
         created: false
       }
     }
 
-        // Continue to next attempt
+    // No existing jobs found - this is a genuine error
-        continue
+    // 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}`
+      )
     }
 
-      // Final attempt failed - perform one last check before throwing
+    // Non-constraint related error
-      const finalCheckJobs = await findExistingJobs(payload, normalizedEmailId)
+    throw new Error(`Failed to create job for email ${normalizedEmailId}: ${errorMessage}`)
-      if (finalCheckJobs.totalDocs > 0) {
-        return {
-          jobIds: finalCheckJobs.docs.map(job => job.id),
-          created: false
   }
-      }
-
-      // No concurrent job found - this is a real error
-      throw new Error(`Failed to create job for email ${normalizedEmailId} after ${maxAttempts} attempts: ${String(error)}`)
-    }
-  }
-
-  // This should never be reached, but TypeScript requires it
-  throw new Error(`Unexpected error in ensureEmailJob after ${maxAttempts} attempts`)
 }
 
 /**