thatcher 1.0.4

package/src/lib/database-migrations.js

@@ -0,0 +1,96 @@
+/**
+ * Database Migrations - Custom SQL migrations and schema evolution
+ * Runs after auto-migration completes
+ */
+
+/**
+ * Run custom migrations
+ * @param {object} db - better-sqlite3 database instance
+ */
+export function runMigrations(db) {
+  // All migrations defined here are idempotent
+  const migrations = [
+    createTimestampTriggers,
+    createActivityLogTable,
+    createNotificationTable,
+  ];
+
+  for (const migration of migrations) {
+    try {
+      migration(db);
+    } catch (err) {
+      console.error('[Migration] Failed:', err.message);
+    }
+  }
+}
+
+/**
+ * Create triggers to auto-update updated_at on row changes
+ * @param {object} db
+ */
+function createTimestampTriggers(db) {
+  const tables = ['users', 'engagements', 'rfis', 'reviews']; // Could be dynamic
+
+  for (const table of tables) {
+    try {
+      db.exec(`
+        CREATE TRIGGER IF NOT EXISTS set_timestamp_${table}
+        AFTER UPDATE ON ${table}
+        FOR EACH ROW
+        BEGIN
+          UPDATE ${table} SET updated_at = CURRENT_TIMESTAMP WHERE id = NEW.id;
+        END;
+      `);
+    } catch (e) {
+      // Table might not exist yet
+    }
+  }
+}
+
+/**
+ * Create activity_log table for audit trail
+ * @param {object} db
+ */
+function createActivityLogTable(db) {
+  db.exec(`
+    CREATE TABLE IF NOT EXISTS activity_log (
+      id TEXT PRIMARY KEY,
+      entity_type TEXT NOT NULL,
+      entity_id TEXT NOT NULL,
+      action TEXT NOT NULL,
+      message TEXT,
+      details TEXT,
+      user_id TEXT,
+      created_at INTEGER NOT NULL,
+      FOREIGN KEY (user_id) REFERENCES users(id)
+    );
+  `);
+
+  db.exec(`CREATE INDEX IF NOT EXISTS idx_activity_log_entity ON activity_log(entity_type, entity_id)`);
+  db.exec(`CREATE INDEX IF NOT EXISTS idx_activity_log_user ON activity_log(user_id)`);
+  db.exec(`CREATE INDEX IF NOT EXISTS idx_activity_log_created ON activity_log(created_at)`);
+}
+
+/**
+ * Create notification table
+ * @param {object} db
+ */
+function createNotificationTable(db) {
+  db.exec(`
+    CREATE TABLE IF NOT EXISTS notification (
+      id TEXT PRIMARY KEY,
+      type TEXT NOT NULL,
+      user_id TEXT NOT NULL,
+      title TEXT NOT NULL,
+      message TEXT,
+      data TEXT,
+      entity_type TEXT,
+      entity_id TEXT,
+      created_at INTEGER NOT NULL,
+      read_at INTEGER,
+      FOREIGN KEY (user_id) REFERENCES users(id)
+    );
+
+    CREATE INDEX IF NOT EXISTS idx_notification_user ON notification(user_id, read_at);
+  `);
+}

package/src/lib/date-utils.js

@@ -0,0 +1,159 @@
+/**
+ * Date/Time Utilities - Common date operations
+ */
+
+import { now } from './database-core.js';
+
+const SECONDS_PER_MINUTE = 60;
+const SECONDS_PER_HOUR = 60 * SECONDS_PER_MINUTE;
+const SECONDS_PER_DAY = 24 * SECONDS_PER_HOUR;
+const SECONDS_PER_YEAR = 365.25 * SECONDS_PER_DAY;
+
+/**
+ * Format Unix timestamp to human-readable date
+ * @param {number} timestamp - Unix seconds
+ * @param {string} [format='short']
+ * @returns {string}
+ */
+export function formatDate(timestamp, format = 'short') {
+  if (!timestamp) return '—';
+  const date = new Date(timestamp * 1000);
+
+  if (format === 'short') {
+    return date.toLocaleDateString();
+  }
+  if (format === 'long') {
+    return date.toLocaleString();
+  }
+  if (format === 'relative') {
+    return formatRelative(timestamp);
+  }
+  if (format === 'iso') {
+    return date.toISOString();
+  }
+  return date.toLocaleDateString();
+}
+
+/**
+ * Format relative time (e.g., "2 hours ago")
+ * @param {number} timestamp - Unix seconds
+ * @returns {string}
+ */
+export function formatRelative(timestamp) {
+  const nowSec = now();
+  const diff = nowSec - timestamp;
+
+  if (diff < 60) return 'just now';
+  if (diff < SECONDS_PER_HOUR) {
+    const mins = Math.floor(diff / SECONDS_PER_MINUTE);
+    return `${mins}m ago`;
+  }
+  if (diff < SECONDS_PER_DAY) {
+    const hrs = Math.floor(diff / SECONDS_PER_HOUR);
+    return `${hrs}h ago`;
+  }
+  if (diff < 7 * SECONDS_PER_DAY) {
+    const days = Math.floor(diff / SECONDS_PER_DAY);
+    return `${days}d ago`;
+  }
+  return formatDate(timestamp, 'short');
+}
+
+/**
+ * Check if timestamp is within allowed year range
+ * @param {number} timestamp
+ * @param {number} minYearsAgo
+ * @param {number} maxYearsAhead
+ * @returns {boolean}
+ */
+export function isWithinYears(timestamp, minYearsAgo = 10, maxYearsAhead = 5) {
+  const nowSec = now();
+  return (
+    timestamp > nowSec - (minYearsAgo * SECONDS_PER_YEAR) &&
+    timestamp < nowSec + (maxYearsAhead * SECONDS_PER_YEAR)
+  );
+}
+
+/**
+ * Check if date1 is before date2
+ * @param {number} date1 - Unix timestamp
+ * @param {number} date2 - Unix timestamp
+ * @returns {boolean}
+ */
+export function isBeforeDate(date1, date2) {
+  return date1 < date2;
+}
+
+/**
+ * Add days to current timestamp
+ * @param {number} days
+ * @returns {number}
+ */
+export function addDays(days) {
+  return now() + (days * SECONDS_PER_DAY);
+}
+
+/**
+ * Add hours to current timestamp
+ * @param {number} hours
+ * @returns {number}
+ */
+export function addHours(hours) {
+  return now() + (hours * SECONDS_PER_HOUR);
+}
+
+/**
+ * Start of day (midnight) for timestamp
+ * @param {number} [timestamp]
+ * @returns {number}
+ */
+export function startOfDay(timestamp = now()) {
+  const date = new Date(timestamp * 1000);
+  date.setHours(0, 0, 0, 0);
+  return Math.floor(date.getTime() / 1000);
+}
+
+/**
+ * End of day (23:59:59) for timestamp
+ * @param {number} [timestamp]
+ * @returns {number}
+ */
+export function endOfDay(timestamp = now()) {
+  return startOfDay(timestamp) + SECONDS_PER_DAY - 1;
+}
+
+/**
+ * Get days remaining until deadline
+ * @param {number} deadlineTs - Unix timestamp
+ * @returns {number} - negative if past due
+ */
+export function daysRemaining(deadlineTs) {
+  const nowSec = now();
+  const startOfNextDay = startOfDay(nowSec) + SECONDS_PER_DAY;
+  const remaining = deadlineTs - startOfNextDay;
+  return Math.ceil(remaining / SECONDS_PER_DAY);
+}
+
+/**
+ * Check if timestamp is in the past
+ * @param {number} timestamp
+ * @returns {boolean}
+ */
+export function isPast(timestamp) {
+  return now() > timestamp;
+}
+
+/**
+ * Format duration in seconds to human-readable
+ * @param {number} seconds
+ * @returns {string}
+ */
+export function formatDuration(seconds) {
+  if (seconds < 60) return `${seconds}s`;
+  const mins = Math.floor(seconds / 60);
+  if (mins < 60) return `${mins}m`;
+  const hrs = Math.floor(mins / 60);
+  if (hrs < 24) return `${hrs}h`;
+  const days = Math.floor(hrs / 24);
+  return `${days}d`;
+}

package/src/lib/db-backup.js

@@ -0,0 +1,97 @@
+import fs from 'fs';
+import path from 'path';
+import Database from 'better-sqlite3';
+
+const DEFAULT_DB_PATH = path.join(process.cwd(), 'data', 'app.db');
+const DEFAULT_BACKUP_DIR = path.join(process.cwd(), 'data', 'backups');
+
+export function createBackup(options = {}) {
+  const dbPath = options.dbPath || DEFAULT_DB_PATH;
+  const backupDir = options.backupDir || DEFAULT_BACKUP_DIR;
+  const label = options.label || 'backup';
+
+  if (!fs.existsSync(dbPath)) {
+    throw new Error(`Database not found: ${dbPath}`);
+  }
+
+  if (!fs.existsSync(backupDir)) {
+    fs.mkdirSync(backupDir, { recursive: true });
+  }
+
+  const timestamp = new Date().toISOString().replace(/[:.]/g, '-');
+  const backupPath = path.join(backupDir, `app-${label}-${timestamp}.db`);
+
+  const db = new Database(dbPath);
+  try {
+    db.pragma('wal_checkpoint(TRUNCATE)');
+    fs.copyFileSync(dbPath, backupPath);
+  } finally {
+    db.close();
+  }
+
+  const sourceSize = fs.statSync(dbPath).size;
+  const backupSize = fs.statSync(backupPath).size;
+
+  if (sourceSize !== backupSize) {
+    throw new Error(`Backup size mismatch: source=${sourceSize}, backup=${backupSize}`);
+  }
+
+  return { path: backupPath, size: backupSize, timestamp };
+}
+
+export function restoreBackup(backupPath, options = {}) {
+  const dbPath = options.dbPath || DEFAULT_DB_PATH;
+
+  if (!fs.existsSync(backupPath)) {
+    throw new Error(`Backup not found: ${backupPath}`);
+  }
+
+  const verifyDb = new Database(backupPath, { readonly: true });
+  try {
+    const result = verifyDb.pragma('integrity_check');
+    if (result[0]?.integrity_check !== 'ok') {
+      throw new Error(`Backup integrity check failed: ${JSON.stringify(result)}`);
+    }
+  } finally {
+    verifyDb.close();
+  }
+
+  const walPath = dbPath + '-wal';
+  const shmPath = dbPath + '-shm';
+
+  fs.copyFileSync(backupPath, dbPath);
+  if (fs.existsSync(walPath)) fs.unlinkSync(walPath);
+  if (fs.existsSync(shmPath)) fs.unlinkSync(shmPath);
+
+  return { restored: true, from: backupPath, to: dbPath };
+}
+
+export function listBackups(options = {}) {
+  const backupDir = options.backupDir || DEFAULT_BACKUP_DIR;
+
+  if (!fs.existsSync(backupDir)) return [];
+
+  return fs.readdirSync(backupDir)
+    .filter(f => f.endsWith('.db') && f.startsWith('app-'))
+    .map(f => ({
+      name: f,
+      path: path.join(backupDir, f),
+      size: fs.statSync(path.join(backupDir, f)).size,
+      created: fs.statSync(path.join(backupDir, f)).mtime,
+    }))
+    .sort((a, b) => b.created - a.created);
+}
+
+export function pruneBackups(options = {}) {
+  const maxBackups = options.maxBackups || 10;
+  const backups = listBackups(options);
+
+  if (backups.length <= maxBackups) return { pruned: 0 };
+
+  const toDelete = backups.slice(maxBackups);
+  for (const backup of toDelete) {
+    fs.unlinkSync(backup.path);
+  }
+
+  return { pruned: toDelete.length };
+}

package/src/lib/db-monitor.js

@@ -0,0 +1,127 @@
+import { recordDatabase } from '@/lib/metrics-collector.js'
+
+const dbStats = {
+  connections: 0,
+  activeQueries: 0,
+  locks: 0,
+  slowQueries: []
+}
+
+function wrapDatabase(db) {
+  const originalPrepare = db.prepare.bind(db)
+
+  db.prepare = function(sql) {
+    const stmt = originalPrepare(sql)
+    const originalRun = stmt.run.bind(stmt)
+    const originalGet = stmt.get.bind(stmt)
+    const originalAll = stmt.all.bind(stmt)
+
+    stmt.run = function(...args) {
+      const start = process.hrtime.bigint()
+      dbStats.activeQueries++
+
+      try {
+        const result = originalRun(...args)
+        const duration = Number(process.hrtime.bigint() - start) / 1000000
+
+        recordDatabase('run', duration, sql)
+        if (duration > 100) {
+          recordSlowQuery(sql, duration)
+        }
+
+        return result
+      } catch (err) {
+        recordDatabase('error', 0, sql)
+        throw err
+      } finally {
+        dbStats.activeQueries--
+      }
+    }
+
+    stmt.get = function(...args) {
+      const start = process.hrtime.bigint()
+      dbStats.activeQueries++
+
+      try {
+        const result = originalGet(...args)
+        const duration = Number(process.hrtime.bigint() - start) / 1000000
+
+        recordDatabase('get', duration, sql)
+        if (duration > 100) {
+          recordSlowQuery(sql, duration)
+        }
+
+        return result
+      } catch (err) {
+        recordDatabase('error', 0, sql)
+        throw err
+      } finally {
+        dbStats.activeQueries--
+      }
+    }
+
+    stmt.all = function(...args) {
+      const start = process.hrtime.bigint()
+      dbStats.activeQueries++
+
+      try {
+        const result = originalAll(...args)
+        const duration = Number(process.hrtime.bigint() - start) / 1000000
+
+        recordDatabase('all', duration, sql)
+        if (duration > 100) {
+          recordSlowQuery(sql, duration)
+        }
+
+        return result
+      } catch (err) {
+        recordDatabase('error', 0, sql)
+        throw err
+      } finally {
+        dbStats.activeQueries--
+      }
+    }
+
+    return stmt
+  }
+
+  return db
+}
+
+function recordSlowQuery(sql, duration) {
+  dbStats.slowQueries.push({
+    sql: sql.substring(0, 200),
+    duration,
+    timestamp: Date.now()
+  })
+
+  if (dbStats.slowQueries.length > 100) {
+    dbStats.slowQueries.shift()
+  }
+}
+
+function getDatabaseStats() {
+  return {
+    connections: dbStats.connections,
+    activeQueries: dbStats.activeQueries,
+    locks: dbStats.locks,
+    slowQueries: dbStats.slowQueries.slice(-10)
+  }
+}
+
+function clearDatabaseStats() {
+  dbStats.slowQueries.length = 0
+}
+
+export {
+  wrapDatabase,
+  getDatabaseStats,
+  clearDatabaseStats
+}
+
+if (typeof globalThis !== 'undefined') {
+  globalThis.__dbMonitor = {
+    getDatabaseStats,
+    clearDatabaseStats
+  }
+}

package/src/lib/domain-loader.js

@@ -0,0 +1,82 @@
+import { getConfigEngineSync } from '@/lib/config-generator-engine';
+
+const requireStr = (val, label) => { if (!val || typeof val !== 'string') throw new Error(`[DomainLoader] ${label} must be a non-empty string`); };
+
+export class DomainLoader {
+  constructor(engine) {
+    if (!engine?.getEntitiesForDomain) throw new Error('[DomainLoader] requires ConfigGeneratorEngine instance');
+    this.engine = engine;
+    this.validDomains = Object.keys(engine.getDomains());
+    if (!this.validDomains.length) this.validDomains = ['friday', 'mwr'];
+    this.defaultDomain = this.validDomains[0];
+  }
+
+  _domain(name) {
+    requireStr(name, 'domainName');
+    const d = name.toLowerCase();
+    if (!this.validDomains.includes(d)) throw new Error(`[DomainLoader] Invalid domain: ${name}. Valid: ${this.validDomains.join(', ')}`);
+    return d;
+  }
+
+  getEntitiesForDomain(domain) { return [...this.engine.getEntitiesForDomain(this._domain(domain))]; }
+
+  getSpecsForDomain(domain) {
+    return this.getEntitiesForDomain(domain).reduce((acc, name) => {
+      try { acc.push(this.engine.generateEntitySpec(name)); } catch (e) { console.error(`[DomainLoader] spec failed for ${name}:`, e.message); }
+      return acc;
+    }, []);
+  }
+
+  getFeaturesForDomain(domain) {
+    const domainCfg = this.engine.getConfig().domains?.[this._domain(domain)];
+    if (!domainCfg) return [];
+    return Object.keys(domainCfg.features || {}).filter(k => domainCfg.features[k] === true);
+  }
+
+  isEntityInDomain(entity, domain) {
+    requireStr(entity, 'entityName');
+    try { return this.getEntitiesForDomain(domain).map(e => e.toLowerCase()).includes(entity.toLowerCase()); }
+    catch { return false; }
+  }
+
+  isFeatureInDomain(feature, domain) {
+    requireStr(feature, 'featureName');
+    try { return this.getFeaturesForDomain(domain).map(f => f.toLowerCase()).includes(feature.toLowerCase()); }
+    catch { return false; }
+  }
+
+  filterDataByDomain(data, domain, entity) {
+    if (!data) return data;
+    requireStr(domain, 'domainName'); requireStr(entity, 'entityName');
+    const d = this._domain(domain);
+    if (!this.isEntityInDomain(entity, d)) throw new Error(`[DomainLoader] Entity ${entity} not in domain ${domain}`);
+    return Array.isArray(data) ? data.map(item => ({ ...item })) : { ...data };
+  }
+
+  getDomainInfo(domain) {
+    const d = this._domain(domain);
+    const config = this.engine.getConfig();
+    const dc = config.domains?.[d];
+    if (!dc) throw new Error(`[DomainLoader] Domain ${domain} not found in config`);
+    return { name: d, label: dc.label || d, description: dc.description || '', enabled: dc.enabled !== false, primary_color: dc.primary_color || '#3B82F6', icon: dc.icon || 'Circle', features: this.getFeaturesForDomain(d), entities: this.getEntitiesForDomain(d) };
+  }
+
+  getCurrentDomain(request) {
+    if (!request) return this.defaultDomain;
+    try {
+      const param = new URL(request.url).searchParams.get('domain')?.toLowerCase();
+      return param && this.validDomains.includes(param) ? param : this.defaultDomain;
+    } catch { return this.defaultDomain; }
+  }
+
+  getApiBasePathForDomain(domain) { return `/api/${this._domain(domain)}`; }
+  getValidDomains() { return [...this.validDomains]; }
+  getDefaultDomain() { return this.defaultDomain; }
+}
+
+let globalDomainLoader = null;
+export function getDomainLoader() {
+  if (!globalDomainLoader) globalDomainLoader = new DomainLoader(getConfigEngineSync());
+  return globalDomainLoader;
+}
+export function resetDomainLoader() { globalDomainLoader = null; }

package/src/lib/email-sender.js

@@ -0,0 +1,100 @@
+import { now } from '@/lib/database-core';
+import { sendEmail } from '@/adapters/google-gmail';
+import { EMAIL_STATUS } from '@/config/constants';
+import { config } from '@/config/env';
+
+const EMAIL_REGEX = /^[^\s@]+@[^\s@]+\.[^\s@]+$/;
+
+const validateEmail = (email) =>
+  !email ? { valid: false, error: 'Email address required' }
+  : !EMAIL_REGEX.test(email) ? { valid: false, error: 'Invalid email format' }
+  : { valid: true };
+
+export function validateEmailData(emailRecord) {
+  const errors = [];
+  const rv = validateEmail(emailRecord.recipient_email);
+  if (!rv.valid) errors.push(`Recipient: ${rv.error}`);
+  const sv = validateEmail(emailRecord.sender_email);
+  if (!sv.valid) errors.push(`Sender: ${sv.error}`);
+  if (emailRecord.sender_email && config.email.from && emailRecord.sender_email !== config.email.from)
+    errors.push(`Sender email (${emailRecord.sender_email}) does not match configured email (${config.email.from})`);
+  if (!emailRecord.subject?.trim()) errors.push('Subject cannot be empty');
+  if (!emailRecord.body && !emailRecord.html_body) errors.push('Email must have either body or html_body');
+  return errors;
+}
+
+export function parseAttachments(attachmentsJson) {
+  if (!attachmentsJson) return [];
+  try {
+    const a = typeof attachmentsJson === 'string' ? JSON.parse(attachmentsJson) : attachmentsJson;
+    return Array.isArray(a) ? a : [];
+  } catch { return []; }
+}
+
+export function logEmailActivity(db, emailId, action, metadata = {}) {
+  try {
+    db.prepare(`INSERT INTO activity_log (id, entity_type, entity_id, action, metadata, created_at) VALUES (?, ?, ?, ?, ?, ?)`)
+      .run(crypto.randomUUID?.() || `${Date.now()}_${Math.random()}`, 'email', emailId, action, JSON.stringify(metadata), now());
+  } catch (e) { console.error('[EMAIL] Failed to log activity:', e.message); }
+}
+
+export function checkFailureRate(db) {
+  try {
+    const stats = db.prepare(`SELECT COUNT(*) as total, SUM(CASE WHEN status = ? THEN 1 ELSE 0 END) as failed FROM email WHERE created_at >= ?`)
+      .get(EMAIL_STATUS.FAILED, now() - 86400);
+    if (stats.total > 0 && stats.failed / stats.total > 0.5 && stats.total > 10)
+      console.warn('[EMAIL] HIGH FAILURE RATE ALERT:', { failureRate: `${((stats.failed / stats.total) * 100).toFixed(1)}%`, failed: stats.failed, total: stats.total });
+  } catch (e) { console.error('[EMAIL] Failed to check failure rate:', e.message); }
+}
+
+async function exponentialBackoff(attempt, maxDelayMs) {
+  await new Promise(r => setTimeout(r, Math.min(1000 * Math.pow(2, attempt), maxDelayMs)));
+}
+
+export async function sendSingleEmail(db, emailRecord, attempt = 1, maxRetries = 3, maxDelayMs = 30000) {
+  const validationErrors = validateEmailData(emailRecord);
+  if (validationErrors.length > 0) {
+    const errorMsg = validationErrors.join('; ');
+    db.prepare(`UPDATE email SET status=?, processing_error=?, retry_count=?, updated_at=? WHERE id=?`)
+      .run(EMAIL_STATUS.FAILED, errorMsg, attempt, now(), emailRecord.id);
+    logEmailActivity(db, emailRecord.id, 'email_send_failed', { error: errorMsg, attempt });
+    return { success: false, error: errorMsg, emailId: emailRecord.id };
+  }
+
+  try {
+    const emailData = {
+      to: emailRecord.recipient_email,
+      from: emailRecord.sender_email || config.email.from,
+      subject: emailRecord.subject,
+      body: emailRecord.body,
+      html: emailRecord.html_body,
+      cc: emailRecord.cc,
+      bcc: emailRecord.bcc,
+      attachments: parseAttachments(emailRecord.attachments),
+      ...(emailRecord.in_reply_to && { inReplyTo: emailRecord.in_reply_to }),
+      ...(emailRecord.references && { references: emailRecord.references }),
+    };
+
+    const result = await sendEmail(emailData);
+    db.prepare(`UPDATE email SET status=?, processed=?, message_id=?, processing_error=NULL, retry_count=?, processed_at=?, updated_at=? WHERE id=?`)
+      .run(EMAIL_STATUS.PROCESSED, true, result.id || result.messageId, attempt, now(), now(), emailRecord.id);
+    logEmailActivity(db, emailRecord.id, 'email_sent', { messageId: result.id || result.messageId, to: emailData.to, attempt });
+    return { success: true, messageId: result.id || result.messageId, emailId: emailRecord.id };
+  } catch (error) {
+    const isRateLimit = error.message?.includes('429') || /quota|rate limit/i.test(error.message);
+    const isBounce = error.message?.includes('550') || error.message?.includes('551') || /no such user|user unknown|mailbox not found/i.test(error.message);
+    const isPermanent = error.message?.includes('400') || /invalid|not found/i.test(error.message) || isBounce;
+
+    if (isPermanent || attempt >= maxRetries) {
+      const bounceStatus = isBounce ? 'bounced' : EMAIL_STATUS.FAILED;
+      db.prepare(`UPDATE email SET status=?, processing_error=?, retry_count=?, bounce_reason=?, bounced_at=?, bounce_permanent=?, updated_at=? WHERE id=?`)
+        .run(bounceStatus, error.message, attempt, isBounce ? error.message : null, isBounce ? now() : null, isBounce ? 1 : 0, now(), emailRecord.id);
+      logEmailActivity(db, emailRecord.id, 'email_send_failed', { error: error.message, attempt, permanent: isPermanent });
+      return { success: false, error: error.message, emailId: emailRecord.id, permanent: isPermanent };
+    }
+
+    if (isRateLimit) await exponentialBackoff(attempt, maxDelayMs);
+    db.prepare(`UPDATE email SET retry_count=?, processing_error=?, updated_at=? WHERE id=?`).run(attempt, error.message, now(), emailRecord.id);
+    return sendSingleEmail(db, emailRecord, attempt + 1, maxRetries, maxDelayMs);
+  }
+}