thatcher 1.0.7 → 1.0.34

package/src/lib/crud-handlers.js

@@ -1,10 +1,7 @@
-/**
- * CRUD Handlers - HTTP handler implementations for entity operations
- * This is where request/response handling, validation, auth, and business logic meet
- */
+import { createLogger } from './logger.js';
+import { get, listWithPagination, searchWithPagination, create, update, remove } from './busybase-store.js';
 
-import { list, get, listWithPagination, searchWithPagination } from './query-engine.js';
-import { create, update, remove } from './query-engine-write.js';
+const log = createLogger('[CRUD]');
 import { validateEntity, validateUpdate, sanitizeData } from './validate.js';
 import { requirePermission, getSessionToken } from './auth-middleware.js';
 import { executeHook } from './hook-engine.js';
@@ -13,24 +10,16 @@ import { ok, created, paginated, noContent, error } from './response-formatter.j
 import { HTTP } from '../config/constants.js';
 import { permissionService } from '../services/permission.service.js';
 import { parse as parseQuery } from './query-string-adapter.js';
-import { now } from './database-core.js';
+import { now } from './id-helpers.js';
 import { getConfigEngineSync } from './config-generator-engine.js';
-import { logAction } from './audit-logger.js';
+import { logAction } from './busybase-audit.js';
 
-/**
- * Build a complete set of CRUD handlers for an entity
- * @param {object} spec - Entity specification
- * @returns {object}
- */
 export function createCrudHandlers(entityName, spec) {
   if (!spec) {
     spec = getConfigEngineSync().generateEntitySpec(entityName);
   }
 
   return {
-    /**
-     * List entities (GET /api/:entity)
-     */
     list: async (req, context) => {
       const { user } = context;
       await requirePermission(user, spec, 'list');
@@ -76,16 +65,13 @@ export function createCrudHandlers(entityName, spec) {
       return paginated(filteredItems, pagination);
     },
 
-    /**
-     * Get single entity (GET /api/:entity/:id)
-     */
     get: async (id, req, context) => {
       const { user } = context;
       await requirePermission(user, spec, 'view');
 
       if (!id) throw new AppError('ID required', 'BAD_REQUEST', HTTP.BAD_REQUEST);
 
-      const item = get(entityName, id);
+      const item = await get(entityName, id);
       if (!item) throw NotFoundError(entityName, id);
 
       if (!permissionService.checkRowAccess(user, spec, item)) {
@@ -95,9 +81,6 @@ export function createCrudHandlers(entityName, spec) {
       return ok(permissionService.filterFields(user, spec, item));
     },
 
-    /**
-     * Create entity (POST /api/:entity)
-     */
     create: async (req, context) => {
       const { user } = context;
       await requirePermission(user, spec, 'create');
@@ -111,32 +94,28 @@ export function createCrudHandlers(entityName, spec) {
       }
 
       const sanitized = sanitizeData(entityName, rawData, spec);
-      const record = create(entityName, sanitized, user);
+      const record = await create(entityName, sanitized, user);
 
       // Audit log (ported from moon)
       logAction(entityName, record.id, 'create', user?.id, null, record);
 
-      // Execute hooks
       executeHook(`create:${entityName}:after`, {
         entity: entityName,
         id: record.id,
         data: record,
         user,
-      }).catch(console.error);
+      }).catch(e => log.error(e.message));
 
       return created(permissionService.filterFields(user, spec, record));
     },
 
-    /**
-     * Update entity (PUT/PATCH /api/:entity/:id)
-     */
     update: async (id, req, context) => {
       const { user } = context;
       await requirePermission(user, spec, 'edit');
 
       if (!id) throw new AppError('ID required', 'BAD_REQUEST', HTTP.BAD_REQUEST);
 
-      const existing = get(entityName, id);
+      const existing = await get(entityName, id);
       if (!existing) throw NotFoundError(entityName, id);
 
       if (!permissionService.checkRowAccess(user, spec, existing)) {
@@ -152,7 +131,7 @@ export function createCrudHandlers(entityName, spec) {
       }
 
       const sanitized = sanitizeData(entityName, rawData, spec, existing);
-      const record = update(entityName, id, sanitized, user);
+      const record = await update(entityName, id, sanitized, user);
 
       // Audit log (ported from moon)
       logAction(entityName, id, 'update', user?.id, existing, record);
@@ -164,21 +143,18 @@ export function createCrudHandlers(entityName, spec) {
         before: existing,
         after: record,
         user,
-      }).catch(console.error);
+      }).catch(e => log.error(e.message));
 
       return ok(permissionService.filterFields(user, spec, record));
     },
 
-    /**
-     * Delete entity (DELETE /api/:entity/:id)
-     */
     remove: async (id, req, context) => {
       const { user } = context;
       await requirePermission(user, spec, 'delete');
 
       if (!id) throw new AppError('ID required', 'BAD_REQUEST', HTTP.BAD_REQUEST);
 
-      const existing = get(entityName, id);
+      const existing = await get(entityName, id);
       if (!existing) throw NotFoundError(entityName, id);
 
       if (!permissionService.checkRowAccess(user, spec, existing)) {
@@ -190,13 +166,13 @@ export function createCrudHandlers(entityName, spec) {
       let result;
       if (spec.immutable === true && spec.immutable_strategy === 'move_to_archive') {
         const archiveData = { archived: true, archived_at: now(), archived_by: user?.id };
-        result = update(entityName, id, archiveData, user);
+        result = await update(entityName, id, archiveData, user);
         logAction(entityName, id, 'archive', user?.id, existing, archiveData);
       } else if (spec.fields?.status) {
-        result = update(entityName, id, { status: 'deleted' }, user);
+        result = await update(entityName, id, { status: 'deleted' }, user);
         logAction(entityName, id, 'delete', user?.id, existing, { status: 'deleted' });
       } else {
-        result = remove(entityName, id);
+        result = await remove(entityName, id);
         logAction(entityName, id, 'delete', user?.id, existing, null);
       }
 
@@ -205,22 +181,18 @@ export function createCrudHandlers(entityName, spec) {
         id,
         data: result,
         user,
-      }).catch(console.error);
+      }).catch(e => log.error(e.message));
 
       return noContent();
     },
 
-    /**
-     * Custom action handler
-     */
     customAction: async (action, id, data, context) => {
       const { user } = context;
       await requirePermission(user, spec, 'edit'); // Simplified permission check
 
-      const record = get(entityName, id);
+      const record = await get(entityName, id);
       if (!record) throw NotFoundError(entityName, id);
 
-      // Custom action logic (upload, manage_flags, etc.)
       if (action === 'upload_files') {
         const files = Array.isArray(data.files) ? data.files : [data.files];
         executeHook(`upload_files:${entityName}:after`, {
@@ -232,18 +204,11 @@ export function createCrudHandlers(entityName, spec) {
         return ok({ id, uploaded_files: files });
       }
 
-      // More actions can be added here
       throw new AppError(`Unknown action: ${action}`, 'BAD_REQUEST', HTTP.BAD_REQUEST);
     },
   };
 }
 
-/**
- * Coerce field value to correct type
- * @param {any} value
- * @param {string} type
- * @returns {any}
- */
 function coerceFieldValue(value, type) {
   if (value === null || value === undefined) return value;
 

package/src/lib/csrf-protection.js

@@ -1,6 +1,9 @@
+import { createLogger } from './logger.js';
 import crypto from 'crypto';
 import { HTTP } from '@/config/constants';
 
+const log = createLogger('[CSRF]');
+
 const tokens = new Map();
 const TOKEN_TTL = 3600000;
 
@@ -44,14 +47,14 @@ export async function withCsrfValidation(handler) {
       const token = request.headers.get('x-csrf-token');
 
       if (!token || !validateToken(token)) {
-        console.warn(`[CSRF] Invalid token for ${method}`);
+        log.warn(`invalid token for ${method}`);
         return new Response(JSON.stringify({ error: 'Invalid CSRF token' }), {
           status: HTTP.FORBIDDEN,
           headers: { 'Content-Type': 'application/json' },
         });
       }
     } catch (e) {
-      console.error('[CSRF] Validation error:', e.message);
+      log.error('validation error:', { message: e.message });
       return new Response(JSON.stringify({ error: 'CSRF validation failed' }), {
         status: HTTP.BAD_REQUEST,
         headers: { 'Content-Type': 'application/json' },

package/src/lib/date-utils.js

@@ -1,20 +1,10 @@
-/**
- * Date/Time Utilities - Common date operations
- */
-
-import { now } from './database-core.js';
+import { now } from './id-helpers.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);
@@ -34,11 +24,6 @@ export function formatDate(timestamp, format = 'short') {
   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;
@@ -59,13 +44,6 @@ export function formatRelative(timestamp) {
   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 (
@@ -74,59 +52,28 @@ export function isWithinYears(timestamp, minYearsAgo = 10, maxYearsAhead = 5) {
   );
 }
 
-/**
- * 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;
@@ -134,20 +81,10 @@ export function daysRemaining(deadlineTs) {
   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);
@@ -162,23 +99,12 @@ export function formatDuration(seconds) {
 // Additive helpers ported from moonlanding (adapted to Unix-seconds model)
 // ---------------------------------------------------------------------------
 
-/**
- * Whether a timestamp falls on a working day (Mon–Fri).
- * @param {number} timestamp - Unix seconds
- * @returns {boolean}
- */
 export function isWorkingDay(timestamp) {
   if (!timestamp) return false;
   const day = new Date(timestamp * 1000).getDay();
   return day !== 0 && day !== 6;
 }
 
-/**
- * Count working days (inclusive) between two Unix-seconds timestamps.
- * @param {number} startTs - Unix seconds
- * @param {number} endTs - Unix seconds
- * @returns {number}
- */
 export function getWorkingDaysDiff(startTs, endTs) {
   if (!startTs || !endTs) return 0;
   const end = new Date(endTs * 1000);
@@ -191,12 +117,6 @@ export function getWorkingDaysDiff(startTs, endTs) {
   return count;
 }
 
-/**
- * Add a number of working days (Mon–Fri) to a Unix-seconds timestamp.
- * @param {number} startTs - Unix seconds
- * @param {number} numDays
- * @returns {number} Unix seconds
- */
 export function addWorkingDays(startTs, numDays) {
   if (!startTs || numDays <= 0) return startTs;
   const date = new Date(startTs * 1000);
@@ -208,11 +128,7 @@ export function addWorkingDays(startTs, numDays) {
   return Math.floor(date.getTime() / 1000);
 }
 
-/**
- * Financial year (Mar 1 – Feb end) for a Unix-seconds timestamp.
- * @param {number} [timestamp] - Unix seconds (defaults to now)
- * @returns {number|null}
- */
+// Financial year runs March 1 to end of February (South African fiscal convention).
 export function getFinancialYear(timestamp) {
   const ms = timestamp ? timestamp * 1000 : Date.now();
   const date = new Date(ms);
@@ -222,11 +138,6 @@ export function getFinancialYear(timestamp) {
   return month >= 2 ? year : year - 1;
 }
 
-/**
- * Start/end Unix-seconds bounds for a financial year (Mar 1 – Feb end).
- * @param {number} year
- * @returns {{ start: number, end: number }}
- */
 export function getFinancialYearRange(year) {
   const start = new Date(year, 2, 1);
   const lastDay = new Date(year + 1, 2, 0).getDate();
@@ -237,13 +148,6 @@ export function getFinancialYearRange(year) {
   };
 }
 
-/**
- * Format an amount as currency.
- * @param {number|string} amount
- * @param {string} [currency='ZAR']
- * @param {string} [locale='en-ZA']
- * @returns {string|null}
- */
 export function formatCurrency(amount, currency = 'ZAR', locale = 'en-ZA') {
   if (amount === null || amount === undefined) return null;
   const num = typeof amount === 'string' ? parseFloat(amount) : amount;
@@ -251,13 +155,6 @@ export function formatCurrency(amount, currency = 'ZAR', locale = 'en-ZA') {
   return new Intl.NumberFormat(locale, { style: 'currency', currency }).format(num);
 }
 
-/**
- * Format a number with fixed decimals.
- * @param {number|string} value
- * @param {number} [decimals=0]
- * @param {string} [locale='en-ZA']
- * @returns {string|null}
- */
 export function formatNumber(value, decimals = 0, locale = 'en-ZA') {
   if (value === null || value === undefined) return null;
   const num = typeof value === 'string' ? parseFloat(value) : value;
@@ -268,11 +165,6 @@ export function formatNumber(value, decimals = 0, locale = 'en-ZA') {
   }).format(num);
 }
 
-/**
- * Human-readable file size.
- * @param {number} bytes
- * @returns {string|null}
- */
 export function formatFileSize(bytes) {
   if (bytes === null || bytes === undefined || bytes < 0) return null;
   if (bytes === 0) return '0 B';
@@ -282,13 +174,6 @@ export function formatFileSize(bytes) {
   return `${size.toFixed(i === 0 ? 0 : 1)} ${units[i]}`;
 }
 
-/**
- * Truncate text to a maximum length, appending a suffix.
- * @param {*} text
- * @param {number} [maxLength=100]
- * @param {string} [suffix='...']
- * @returns {string}
- */
 export function truncateText(text, maxLength = 100, suffix = '...') {
   if (!text) return '';
   const str = String(text);
@@ -296,11 +181,6 @@ export function truncateText(text, maxLength = 100, suffix = '...') {
   return str.substring(0, maxLength) + suffix;
 }
 
-/**
- * Convert a Unix-seconds timestamp to a UTC ISO-8601 string.
- * @param {number} timestamp - Unix seconds
- * @returns {string|null}
- */
 export function toUtcIso(timestamp) {
   if (!timestamp) return null;
   const date = new Date(timestamp * 1000);
@@ -308,11 +188,7 @@ export function toUtcIso(timestamp) {
   return date.toISOString();
 }
 
-/**
- * Normalize a Firestore timestamp (or number/date) to Unix seconds.
- * @param {*} ts
- * @returns {number|null}
- */
+// Firestore Timestamp objects expose ._seconds (newer SDK) or .seconds (older); plain numbers and date strings are also accepted.
 export function fromFirestoreTimestamp(ts) {
   if (!ts) return null;
   if (ts._seconds !== undefined) return ts._seconds;

package/src/lib/debug-registry.js

@@ -1,8 +1,3 @@
-/**
- * Debug Registry - Comprehensive globalThis.__debug__ registry for all Thatcher subsystems
- * Modules register on import/init; supports nested namespaces and live data
- */
-
 import { createLogger } from './logger.js';
 
 const logger = createLogger('[DebugRegistry]');

package/src/lib/domain-loader.js

@@ -1,5 +1,8 @@
+import { createLogger } from './logger.js';
 import { getConfigEngineSync } from '@/lib/config-generator-engine';
 
+const log = createLogger('[DomainLoader]');
+
 const requireStr = (val, label) => { if (!val || typeof val !== 'string') throw new Error(`[DomainLoader] ${label} must be a non-empty string`); };
 
 export class DomainLoader {
@@ -22,7 +25,7 @@ export class DomainLoader {
 
   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); }
+      try { acc.push(this.engine.generateEntitySpec(name)); } catch (e) { log.error(`spec failed for ${name}:`, { message: e.message }); }
       return acc;
     }, []);
   }

package/src/lib/email-sender.js

@@ -1,4 +1,8 @@
-import { now } from '@/lib/database-core';
+import { createLogger } from './logger.js';
+import { now, genId } from '@/lib/id-helpers';
+
+const log = createLogger('[Email]');
+import { list, update, create } from '@/lib/busybase-store';
 import { sendEmail } from '@/adapters/google-gmail';
 import { EMAIL_STATUS } from '@/config/constants';
 import { config } from '@/config/env';
@@ -31,33 +35,33 @@ export function parseAttachments(attachmentsJson) {
   } catch { return []; }
 }
 
-export function logEmailActivity(db, emailId, action, metadata = {}) {
+export async function logEmailActivity(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); }
+    await create('activity_log', { id: genId(), entity_type: 'email', entity_id: emailId, action, metadata: JSON.stringify(metadata), created_at: now() });
+  } catch (e) { log.error('failed to log activity:', { message: e.message }); }
 }
 
-export function checkFailureRate(db) {
+export async function checkFailureRate() {
   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); }
+    const cutoff = now() - 86400;
+    const recent = (await list('email', {})).filter(e => (e.created_at || 0) >= cutoff);
+    const total = recent.length;
+    const failed = recent.filter(e => e.status === EMAIL_STATUS.FAILED).length;
+    if (total > 10 && failed / total > 0.5)
+      log.warn('HIGH FAILURE RATE ALERT:', { failureRate: `${((failed / total) * 100).toFixed(1)}%`, failed, total });
+  } catch (e) { log.error('failed to check failure rate:', { message: 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) {
+export async function sendSingleEmail(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 });
+    await update('email', emailRecord.id, { status: EMAIL_STATUS.FAILED, processing_error: errorMsg, retry_count: attempt, updated_at: now() });
+    await logEmailActivity(emailRecord.id, 'email_send_failed', { error: errorMsg, attempt });
     return { success: false, error: errorMsg, emailId: emailRecord.id };
   }
 
@@ -76,9 +80,8 @@ export async function sendSingleEmail(db, emailRecord, attempt = 1, maxRetries =
     };
 
     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 });
+    await update('email', emailRecord.id, { status: EMAIL_STATUS.PROCESSED, processed: true, message_id: result.id || result.messageId, processing_error: '', retry_count: attempt, processed_at: now(), updated_at: now() });
+    await logEmailActivity(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);
@@ -87,14 +90,13 @@ export async function sendSingleEmail(db, emailRecord, attempt = 1, maxRetries =
 
     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 });
+      await update('email', emailRecord.id, { status: bounceStatus, processing_error: error.message, retry_count: attempt, bounce_reason: isBounce ? error.message : '', bounced_at: isBounce ? now() : 0, bounce_permanent: isBounce ? 1 : 0, updated_at: now() });
+      await logEmailActivity(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);
+    await update('email', emailRecord.id, { retry_count: attempt, processing_error: error.message, updated_at: now() });
+    return sendSingleEmail(emailRecord, attempt + 1, maxRetries, maxDelayMs);
   }
 }

package/src/lib/error-handler.js

@@ -1,6 +1,4 @@
-/**
- * Error Handling - Centralized error types and utilities
- */
+import { createLogger } from './logger.js';
 
 // AppError stays a real class (base error type; `instanceof AppError` works).
 export class AppError extends Error {
@@ -44,40 +42,12 @@ export function BadRequestError(message = 'Invalid request') {
   const e = new AppError(message, 'BAD_REQUEST', 400); e.name = 'BadRequestError'; return e;
 }
 
-/**
- * Create an error logger
- * @param {string} context
- * @returns {object}
- */
 export function createErrorLogger(context = '') {
-  return {
-    error: (msg, meta = {}) => {
-      console.error(`[${context}] ${msg}`, meta);
-    },
-    warn: (msg, meta = {}) => {
-      console.warn(`[${context}] ${msg}`, meta);
-    },
-    info: (_msg, _meta = {}) => {},
-    debug: (msg, meta = {}) => {
-      if (process.env.DEBUG) {
-        console.debug(`[${context}] Debug:`, msg, meta);
-      }
-    },
-  };
+  const log = createLogger(`[${context}]`);
+  return { error: log.error, warn: log.warn, info: (_msg, _meta = {}) => {}, debug: log.debug };
 }
 
-/**
- * Normalize an arbitrary thrown value into one of thatcher's AppError-class
- * instances. AppError instances (and anything already shaped like one — a
- * numeric `status` + a `code`) pass through untouched; common low-level
- * errors are mapped to the appropriate thatcher error class.
- *
- * (Ported from moonlanding, adapted to thatcher's class-based hierarchy and
- * its `status`/`code`/`details` shape. Kept import-free so the module stays
- * loadable under the plain-node test runner.)
- * @param {unknown} error
- * @returns {AppError}
- */
+// Ported from moonlanding; kept import-free so this module loads under the plain-node test runner.
 export function normalizeError(error) {
   if (error instanceof AppError) {
     return error;
@@ -112,13 +82,7 @@ export function normalizeError(error) {
   });
 }
 
-/**
- * Build a JSON-serializable error response body from any thrown value.
- * (Ported from moonlanding, adapted to thatcher's error shape.)
- * @param {unknown} error
- * @param {boolean} [includeStack=false]
- * @returns {object}
- */
+// Ported from moonlanding.
 export function formatErrorResponse(error, includeStack = false) {
   const normalized = normalizeError(error);
   const response = {