@astralibx/email-rule-engine 12.9.0 → 12.10.0

package/dist/index.cjs

@@ -179,6 +179,17 @@ function createEmailTemplateSchema(platformValues, audienceValues, categoryValue
   schema.index({ audience: 1, platform: 1, isActive: 1 });
   return schema;
 }
+function createRunStatsSchema() {
+  return new mongoose.Schema({
+    matched: { type: Number, default: 0 },
+    sent: { type: Number, default: 0 },
+    skipped: { type: Number, default: 0 },
+    skippedByThrottle: { type: Number, default: 0 },
+    errorCount: { type: Number, default: 0 }
+  }, { _id: false });
+}
+
+// src/schemas/rule.schema.ts
 function createEmailRuleSchema(platformValues, audienceValues, collectionPrefix) {
   const RuleConditionSchema = new mongoose.Schema({
     field: { type: String, required: true },
@@ -196,13 +207,7 @@ function createEmailRuleSchema(platformValues, audienceValues, collectionPrefix)
     identifiers: [{ type: String }],
     collection: { type: String }
   }, { _id: false });
-  const RuleRunStatsSchema = new mongoose.Schema({
-    matched: { type: Number, default: 0 },
-    sent: { type: Number, default: 0 },
-    skipped: { type: Number, default: 0 },
-    skippedByThrottle: { type: Number, default: 0 },
-    errorCount: { type: Number, default: 0 }
-  }, { _id: false });
+  const RuleRunStatsSchema = createRunStatsSchema();
   const schema = new mongoose.Schema(
     {
       name: { type: String, required: true },
@@ -331,22 +336,13 @@ function createEmailRuleSendSchema(collectionPrefix) {
   return schema;
 }
 function createEmailRuleRunLogSchema(collectionPrefix) {
+  const baseStatsSchema = createRunStatsSchema();
   const PerRuleStatsSchema = new mongoose.Schema({
     ruleId: { type: mongoose.Schema.Types.ObjectId, ref: "EmailRule", required: true },
     ruleName: { type: String, required: true },
-    matched: { type: Number, default: 0 },
-    sent: { type: Number, default: 0 },
-    skipped: { type: Number, default: 0 },
-    skippedByThrottle: { type: Number, default: 0 },
-    errorCount: { type: Number, default: 0 }
-  }, { _id: false });
-  const TotalStatsSchema = new mongoose.Schema({
-    matched: { type: Number, default: 0 },
-    sent: { type: Number, default: 0 },
-    skipped: { type: Number, default: 0 },
-    skippedByThrottle: { type: Number, default: 0 },
-    errorCount: { type: Number, default: 0 }
+    ...baseStatsSchema.obj
   }, { _id: false });
+  const TotalStatsSchema = createRunStatsSchema();
   const schema = new mongoose.Schema(
     {
       runId: { type: String, index: true },
@@ -644,6 +640,38 @@ var DuplicateSlugError = class extends AlxEmailError {
   }
 };
 
+// src/utils/query-helpers.ts
+function isValidDateString(s) {
+  return s.trim() !== "" && !isNaN(new Date(s).getTime());
+}
+function buildDateRangeFilter(dateField, from, to) {
+  const validFrom = from && isValidDateString(from) ? from : void 0;
+  const validTo = to && isValidDateString(to) ? to : void 0;
+  if (!validFrom && !validTo) return {};
+  const filter = {};
+  filter[dateField] = {};
+  if (validFrom) filter[dateField].$gte = new Date(validFrom);
+  if (validTo) filter[dateField].$lte = /* @__PURE__ */ new Date(validTo + "T23:59:59.999Z");
+  return filter;
+}
+function calculatePagination(page, limit, maxLimit = 500) {
+  const rawPage = page != null && !isNaN(page) ? page : 1;
+  const rawLimit = limit != null && !isNaN(limit) ? limit : 200;
+  const p = Math.max(1, rawPage);
+  const l = Math.max(1, Math.min(rawLimit, maxLimit));
+  const skip = (p - 1) * l;
+  return { page: p, limit: l, skip };
+}
+function filterUpdateableFields(input, allowedFields) {
+  const result = {};
+  for (const [key, value] of Object.entries(input)) {
+    if (value !== void 0 && allowedFields.has(key)) {
+      result[key] = value;
+    }
+  }
+  return result;
+}
+
 // src/services/template.service.ts
 function stripScriptTags(text) {
   return text.replace(/<script\b[^<]*(?:(?!<\/script>)<[^<]*)*<\/script>/gi, "");
@@ -752,12 +780,7 @@ var TemplateService = class {
       const allContent = [...subjects, ...bodies, ...preheaders, textBody || ""].join(" ");
       input.variables = this.renderService.extractVariables(allContent);
     }
-    const setFields = {};
-    for (const [key, value] of Object.entries(input)) {
-      if (value !== void 0 && UPDATEABLE_FIELDS.has(key)) {
-        setFields[key] = value;
-      }
-    }
+    const setFields = filterUpdateableFields(input, UPDATEABLE_FIELDS);
     const update = { $set: setFields };
     if (input.textBody || input.subjects || input.bodies || input.preheaders) {
       update["$inc"] = { version: 1 };
@@ -1118,12 +1141,7 @@ var RuleService = class {
         }
       }
     }
-    const setFields = {};
-    for (const [key, value] of Object.entries(input)) {
-      if (value !== void 0 && UPDATEABLE_FIELDS2.has(key)) {
-        setFields[key] = value;
-      }
-    }
+    const setFields = filterUpdateableFields(input, UPDATEABLE_FIELDS2);
     return this.EmailRule.findByIdAndUpdate(
       id,
       { $set: setFields },
@@ -1198,23 +1216,12 @@ var RuleService = class {
     return this.EmailRule.create(rest);
   }
   async getRunHistory(limit = 20, opts) {
-    const filter = {};
-    if (opts?.from || opts?.to) {
-      filter.runAt = {};
-      if (opts.from) filter.runAt["$gte"] = new Date(opts.from);
-      if (opts.to) filter.runAt["$lte"] = /* @__PURE__ */ new Date(opts.to + "T23:59:59.999Z");
-    }
-    const page = opts?.page ?? 1;
-    const skip = (page - 1) * limit;
-    return this.EmailRuleRunLog.find(filter).sort({ runAt: -1 }).skip(skip).limit(limit);
+    const filter = buildDateRangeFilter("runAt", opts?.from, opts?.to);
+    const pagination = calculatePagination(opts?.page, limit);
+    return this.EmailRuleRunLog.find(filter).sort({ runAt: -1 }).skip(pagination.skip).limit(pagination.limit);
   }
   async getRunHistoryCount(opts) {
-    const filter = {};
-    if (opts?.from || opts?.to) {
-      filter.runAt = {};
-      if (opts.from) filter.runAt["$gte"] = new Date(opts.from);
-      if (opts.to) filter.runAt["$lte"] = /* @__PURE__ */ new Date(opts.to + "T23:59:59.999Z");
-    }
+    const filter = buildDateRangeFilter("runAt", opts?.from, opts?.to);
     return this.EmailRuleRunLog.countDocuments(filter);
   }
 };
@@ -1436,201 +1443,252 @@ var RuleRunnerService = class {
     }
     return this.executeQueryMode(rule, template, throttleMap, throttleConfig, stats, runId);
   }
-  async executeListMode(rule, template, throttleMap, throttleConfig, stats, runId) {
-    const rawIdentifiers = rule.target.identifiers || [];
-    const uniqueEmails = [...new Set(rawIdentifiers.map((e) => e.toLowerCase().trim()).filter(Boolean))];
-    const limit = rule.maxPerRun || this.config.options?.defaultMaxPerRun || 500;
-    if (uniqueEmails.length > limit) {
-      this.logger.warn(`Rule "${rule.name}" matched ${uniqueEmails.length} users but maxPerRun is ${limit} \u2014 only ${limit} will be processed`, { ruleId: rule._id.toString(), matchedCount: uniqueEmails.length, maxPerRun: limit });
+  emitSendEvent(rule, email, status, templateId, runId, opts) {
+    this.config.hooks?.onSend?.({
+      ruleId: rule._id.toString(),
+      ruleName: rule.name,
+      email,
+      status,
+      accountId: opts?.accountId ?? "",
+      templateId,
+      runId: runId || "",
+      subjectIndex: opts?.subjectIndex ?? -1,
+      bodyIndex: opts?.bodyIndex ?? -1,
+      preheaderIndex: opts?.preheaderIndex,
+      failureReason: opts?.failureReason
+    });
+  }
+  async processSingleUser(params) {
+    const { rule, email, userKey, identifier, user, sendMap, throttleMap, throttleConfig, template, compiledVariants, templateId, ruleId, runId, stats } = params;
+    const lastSend = sendMap.get(userKey);
+    if (lastSend) {
+      if (rule.sendOnce && rule.resendAfterDays == null) {
+        stats.skipped++;
+        this.emitSendEvent(rule, email, "skipped", templateId, runId || "", { failureReason: "send once" });
+        return "skipped";
+      }
+      if (rule.resendAfterDays != null) {
+        const daysSince = (Date.now() - new Date(lastSend.sentAt).getTime()) / MS_PER_DAY;
+        if (daysSince < rule.resendAfterDays) {
+          stats.skipped++;
+          this.emitSendEvent(rule, email, "skipped", templateId, runId || "", { failureReason: "resend too soon" });
+          return "skipped";
+        }
+      } else {
+        stats.skipped++;
+        this.emitSendEvent(rule, email, "skipped", templateId, runId || "", { failureReason: "send once" });
+        return "skipped";
+      }
+      if (rule.cooldownDays) {
+        const daysSince = (Date.now() - new Date(lastSend.sentAt).getTime()) / MS_PER_DAY;
+        if (daysSince < rule.cooldownDays) {
+          stats.skipped++;
+          this.emitSendEvent(rule, email, "skipped", templateId, runId || "", { failureReason: "cooldown period" });
+          return "skipped";
+        }
+      }
     }
-    const emailsToProcess = uniqueEmails.slice(0, limit);
-    stats.matched = emailsToProcess.length;
-    const ruleId = rule._id.toString();
-    const templateId = rule.templateId.toString();
-    this.config.hooks?.onRuleStart?.({ ruleId, ruleName: rule.name, matchedCount: emailsToProcess.length, templateId, runId: runId || "" });
-    if (emailsToProcess.length === 0) return stats;
+    if (!this.checkThrottle(rule, userKey, email, throttleMap, throttleConfig, stats, templateId, runId)) return "skipped";
+    const agentSelection = await this.config.adapters.selectAgent(identifier.id, { ruleId, templateId });
+    if (!agentSelection) {
+      stats.skipped++;
+      this.emitSendEvent(rule, email, "skipped", templateId, runId || "", { failureReason: "no account available" });
+      return "skipped";
+    }
+    const resolvedData = this.config.adapters.resolveData(user);
+    const templateData = { ...template.fields || {}, ...resolvedData };
+    const si = Math.floor(Math.random() * compiledVariants.subjectFns.length);
+    const bi = Math.floor(Math.random() * compiledVariants.bodyFns.length);
+    const renderedSubject = compiledVariants.subjectFns[si](templateData);
+    const renderedHtml = compiledVariants.bodyFns[bi](templateData);
+    const renderedText = compiledVariants.textBodyFn ? compiledVariants.textBodyFn(templateData) : this.templateRenderer.htmlToText(renderedHtml);
+    let finalHtml = renderedHtml;
+    let finalText = renderedText;
+    let finalSubject = renderedSubject;
+    let pi;
+    if (compiledVariants.preheaderFns && compiledVariants.preheaderFns.length > 0) {
+      pi = Math.floor(Math.random() * compiledVariants.preheaderFns.length);
+      const renderedPreheader = compiledVariants.preheaderFns[pi](templateData);
+      if (renderedPreheader) {
+        const preheaderHtml = `<div style="display:none;font-size:1px;color:#ffffff;line-height:1px;max-height:0px;max-width:0px;opacity:0;overflow:hidden;">${renderedPreheader}</div>`;
+        finalHtml = finalHtml.replace(/(<body[^>]*>)/i, `$1${preheaderHtml}`);
+      }
+    }
+    if (this.config.hooks?.beforeSend) {
+      try {
+        const modified = await this.config.hooks.beforeSend({
+          htmlBody: finalHtml,
+          textBody: finalText,
+          subject: finalSubject,
+          account: {
+            id: agentSelection.accountId,
+            email: agentSelection.email,
+            metadata: agentSelection.metadata
+          },
+          user: {
+            id: String(userKey),
+            email,
+            name: String(user.name || user.firstName || "")
+          },
+          context: {
+            ruleId,
+            templateId,
+            runId: runId || ""
+          }
+        });
+        finalHtml = modified.htmlBody;
+        finalText = modified.textBody;
+        finalSubject = modified.subject;
+      } catch (hookErr) {
+        this.logger.error(`beforeSend hook failed for email ${email}: ${hookErr.message}`);
+        stats.errorCount++;
+        this.emitSendEvent(rule, email, "error", templateId, runId || "", { accountId: agentSelection.accountId, subjectIndex: si, bodyIndex: bi, failureReason: hookErr.message });
+        return "error";
+      }
+    }
+    await this.config.adapters.sendEmail({
+      identifierId: identifier.id,
+      contactId: identifier.contactId,
+      accountId: agentSelection.accountId,
+      subject: finalSubject,
+      htmlBody: finalHtml,
+      textBody: finalText,
+      ruleId,
+      autoApprove: rule.autoApprove ?? true,
+      attachments: template.attachments || []
+    });
+    await this.EmailRuleSend.logSend(
+      ruleId,
+      userKey,
+      identifier.id,
+      void 0,
+      { status: "sent", accountId: agentSelection.accountId, subject: finalSubject, subjectIndex: si, bodyIndex: bi, preheaderIndex: pi }
+    );
+    const current = throttleMap.get(userKey) || { today: 0, thisWeek: 0};
+    throttleMap.set(userKey, {
+      today: current.today + 1,
+      thisWeek: current.thisWeek + 1,
+      lastSentDate: /* @__PURE__ */ new Date()
+    });
+    stats.sent++;
+    this.emitSendEvent(rule, email, "sent", templateId, runId || "", { accountId: agentSelection.accountId, subjectIndex: si, bodyIndex: bi, preheaderIndex: pi });
+    return "sent";
+  }
+  async resolveIdentifiers(emails) {
     const identifierResults = await processInChunks(
-      emailsToProcess,
+      emails,
       async (email) => {
         const result = await this.config.adapters.findIdentifier(email);
         return result ? { email, ...result } : null;
       },
       IDENTIFIER_CHUNK_SIZE
     );
-    const identifierMap = /* @__PURE__ */ new Map();
+    const map = /* @__PURE__ */ new Map();
     for (const result of identifierResults) {
       if (result) {
-        identifierMap.set(result.email, { id: result.id, contactId: result.contactId });
+        map.set(result.email, { id: result.id, contactId: result.contactId });
       }
     }
-    const validEmails = emailsToProcess.filter((e) => identifierMap.has(e));
-    const identifierIds = validEmails.map((e) => identifierMap.get(e).id);
-    const allRuleSends = await this.EmailRuleSend.find({ ruleId: rule._id, userId: { $in: identifierIds } }).sort({ sentAt: -1 }).lean();
-    const sendMap = /* @__PURE__ */ new Map();
-    for (const send of allRuleSends) {
+    return map;
+  }
+  buildSendMap(sends) {
+    const map = /* @__PURE__ */ new Map();
+    for (const send of sends) {
       const uid = send.userId.toString();
-      if (!sendMap.has(uid)) {
-        sendMap.set(uid, send);
+      if (!map.has(uid)) {
+        map.set(uid, send);
       }
     }
+    return map;
+  }
+  compileTemplateVariants(template) {
     const preheaders = template.preheaders || [];
-    const compiledVariants = this.templateRenderer.compileBatchVariants(
+    return this.templateRenderer.compileBatchVariants(
       template.subjects,
       template.bodies,
       template.textBody,
       preheaders
     );
+  }
+  async checkCancelled(runId, index) {
+    if (!runId || index % 10 !== 0) return false;
+    const cancelKey = `${this.keyPrefix}run:${runId}:cancel`;
+    return !!await this.redis.exists(cancelKey);
+  }
+  async applySendDelay(isLast) {
+    if (isLast) return;
+    const delayMs = this.config.options?.delayBetweenSendsMs || 0;
+    const jitterMs = this.config.options?.jitterMs || 0;
+    if (delayMs > 0 || jitterMs > 0) {
+      const totalDelay = delayMs + Math.floor(Math.random() * (jitterMs + 1));
+      if (totalDelay > 0) await new Promise((resolve) => setTimeout(resolve, totalDelay));
+    }
+  }
+  async finalizeRuleStats(rule, stats, ruleId, templateId, runId) {
+    await this.EmailRule.findByIdAndUpdate(rule._id, {
+      $set: { lastRunAt: /* @__PURE__ */ new Date(), lastRunStats: stats },
+      $inc: { totalSent: stats.sent, totalSkipped: stats.skipped }
+    });
+    this.config.hooks?.onRuleComplete?.({ ruleId, ruleName: rule.name, stats, templateId, runId: runId || "" });
+  }
+  async executeListMode(rule, template, throttleMap, throttleConfig, stats, runId) {
+    const rawIdentifiers = rule.target.identifiers || [];
+    const uniqueEmails = [...new Set(rawIdentifiers.map((e) => e.toLowerCase().trim()).filter(Boolean))];
+    const limit = rule.maxPerRun || this.config.options?.defaultMaxPerRun || 500;
+    if (uniqueEmails.length > limit) {
+      this.logger.warn(`Rule "${rule.name}" matched ${uniqueEmails.length} users but maxPerRun is ${limit} \u2014 only ${limit} will be processed`, { ruleId: rule._id.toString(), matchedCount: uniqueEmails.length, maxPerRun: limit });
+    }
+    const emailsToProcess = uniqueEmails.slice(0, limit);
+    stats.matched = emailsToProcess.length;
+    const ruleId = rule._id.toString();
+    const templateId = rule.templateId.toString();
+    this.config.hooks?.onRuleStart?.({ ruleId, ruleName: rule.name, matchedCount: emailsToProcess.length, templateId, runId: runId || "" });
+    if (emailsToProcess.length === 0) return stats;
+    const identifierMap = await this.resolveIdentifiers(emailsToProcess);
+    const validEmails = emailsToProcess.filter((e) => identifierMap.has(e));
+    const identifierIds = validEmails.map((e) => identifierMap.get(e).id);
+    const allRuleSends = await this.EmailRuleSend.find({ ruleId: rule._id, userId: { $in: identifierIds } }).sort({ sentAt: -1 }).lean();
+    const sendMap = this.buildSendMap(allRuleSends);
+    const compiledVariants = this.compileTemplateVariants(template);
     let totalProcessed = 0;
     for (let i = 0; i < emailsToProcess.length; i++) {
       const email = emailsToProcess[i];
-      if (runId && i % 10 === 0) {
-        const cancelKey = `${this.keyPrefix}run:${runId}:cancel`;
-        const cancelled = await this.redis.exists(cancelKey);
-        if (cancelled) break;
-      }
+      if (await this.checkCancelled(runId, i)) break;
       try {
         const identifier = identifierMap.get(email);
         if (!identifier) {
           stats.skipped++;
-          this.config.hooks?.onSend?.({ ruleId, ruleName: rule.name, email, status: "invalid", accountId: "", templateId, runId: runId || "", subjectIndex: -1, bodyIndex: -1, failureReason: "invalid email" });
+          this.emitSendEvent(rule, email, "invalid", templateId, runId || "", { failureReason: "invalid email" });
           continue;
         }
-        const dedupKey = identifier.id;
-        const lastSend = sendMap.get(dedupKey);
-        if (lastSend) {
-          if (rule.sendOnce && rule.resendAfterDays == null) {
-            stats.skipped++;
-            this.config.hooks?.onSend?.({ ruleId, ruleName: rule.name, email, status: "skipped", accountId: "", templateId, runId: runId || "", subjectIndex: -1, bodyIndex: -1, failureReason: "send once" });
-            continue;
-          }
-          if (rule.resendAfterDays != null) {
-            const daysSince = (Date.now() - new Date(lastSend.sentAt).getTime()) / MS_PER_DAY;
-            if (daysSince < rule.resendAfterDays) {
-              stats.skipped++;
-              this.config.hooks?.onSend?.({ ruleId, ruleName: rule.name, email, status: "skipped", accountId: "", templateId, runId: runId || "", subjectIndex: -1, bodyIndex: -1, failureReason: "resend too soon" });
-              continue;
-            }
-          } else {
-            stats.skipped++;
-            this.config.hooks?.onSend?.({ ruleId, ruleName: rule.name, email, status: "skipped", accountId: "", templateId, runId: runId || "", subjectIndex: -1, bodyIndex: -1, failureReason: "send once" });
-            continue;
-          }
-          if (rule.cooldownDays) {
-            const daysSince = (Date.now() - new Date(lastSend.sentAt).getTime()) / MS_PER_DAY;
-            if (daysSince < rule.cooldownDays) {
-              stats.skipped++;
-              this.config.hooks?.onSend?.({ ruleId, ruleName: rule.name, email, status: "skipped", accountId: "", templateId, runId: runId || "", subjectIndex: -1, bodyIndex: -1, failureReason: "cooldown period" });
-              continue;
-            }
-          }
-        }
-        if (!this.checkThrottle(rule, dedupKey, email, throttleMap, throttleConfig, stats, templateId, runId)) continue;
-        const agentSelection = await this.config.adapters.selectAgent(identifier.id, { ruleId, templateId });
-        if (!agentSelection) {
-          stats.skipped++;
-          this.config.hooks?.onSend?.({ ruleId, ruleName: rule.name, email, status: "skipped", accountId: "", templateId, runId: runId || "", subjectIndex: -1, bodyIndex: -1, failureReason: "no account available" });
-          continue;
-        }
-        const user = { _id: identifier.id, email };
-        const resolvedData = this.config.adapters.resolveData(user);
-        const templateData = { ...template.fields || {}, ...resolvedData };
-        const si = Math.floor(Math.random() * compiledVariants.subjectFns.length);
-        const bi = Math.floor(Math.random() * compiledVariants.bodyFns.length);
-        const renderedSubject = compiledVariants.subjectFns[si](templateData);
-        const renderedHtml = compiledVariants.bodyFns[bi](templateData);
-        const renderedText = compiledVariants.textBodyFn ? compiledVariants.textBodyFn(templateData) : this.templateRenderer.htmlToText(renderedHtml);
-        let finalHtml = renderedHtml;
-        let finalText = renderedText;
-        let finalSubject = renderedSubject;
-        let pi;
-        if (compiledVariants.preheaderFns && compiledVariants.preheaderFns.length > 0) {
-          pi = Math.floor(Math.random() * compiledVariants.preheaderFns.length);
-          const renderedPreheader = compiledVariants.preheaderFns[pi](templateData);
-          if (renderedPreheader) {
-            const preheaderHtml = `<div style="display:none;font-size:1px;color:#ffffff;line-height:1px;max-height:0px;max-width:0px;opacity:0;overflow:hidden;">${renderedPreheader}</div>`;
-            finalHtml = finalHtml.replace(/(<body[^>]*>)/i, `$1${preheaderHtml}`);
-          }
-        }
-        if (this.config.hooks?.beforeSend) {
-          try {
-            const modified = await this.config.hooks.beforeSend({
-              htmlBody: finalHtml,
-              textBody: finalText,
-              subject: finalSubject,
-              account: {
-                id: agentSelection.accountId,
-                email: agentSelection.email,
-                metadata: agentSelection.metadata
-              },
-              user: {
-                id: dedupKey,
-                email,
-                name: ""
-              },
-              context: {
-                ruleId,
-                templateId,
-                runId: runId || ""
-              }
-            });
-            finalHtml = modified.htmlBody;
-            finalText = modified.textBody;
-            finalSubject = modified.subject;
-          } catch (hookErr) {
-            this.logger.error(`beforeSend hook failed for email ${email}: ${hookErr.message}`);
-            stats.errorCount++;
-            this.config.hooks?.onSend?.({ ruleId, ruleName: rule.name, email, status: "error", accountId: agentSelection.accountId, templateId, runId: runId || "", subjectIndex: si, bodyIndex: bi, failureReason: hookErr.message });
-            continue;
-          }
-        }
-        await this.config.adapters.sendEmail({
-          identifierId: identifier.id,
-          contactId: identifier.contactId,
-          accountId: agentSelection.accountId,
-          subject: finalSubject,
-          htmlBody: finalHtml,
-          textBody: finalText,
-          ruleId,
-          autoApprove: rule.autoApprove ?? true,
-          attachments: template.attachments || []
-        });
-        await this.EmailRuleSend.logSend(
+        const result = await this.processSingleUser({
+          rule,
+          email,
+          userKey: identifier.id,
+          identifier,
+          user: { _id: identifier.id, email },
+          sendMap,
+          throttleMap,
+          throttleConfig,
+          template,
+          compiledVariants,
+          templateId,
           ruleId,
-          dedupKey,
-          identifier.id,
-          void 0,
-          { status: "sent", accountId: agentSelection.accountId, subject: finalSubject, subjectIndex: si, bodyIndex: bi, preheaderIndex: pi }
-        );
-        const current = throttleMap.get(dedupKey) || { today: 0, thisWeek: 0, lastSentDate: null };
-        throttleMap.set(dedupKey, {
-          today: current.today + 1,
-          thisWeek: current.thisWeek + 1,
-          lastSentDate: /* @__PURE__ */ new Date()
+          runId,
+          stats
         });
-        stats.sent++;
-        this.config.hooks?.onSend?.({ ruleId, ruleName: rule.name, email, status: "sent", accountId: agentSelection.accountId, templateId, runId: runId || "", subjectIndex: si, bodyIndex: bi, preheaderIndex: pi });
-        totalProcessed++;
-        if (runId && totalProcessed % 10 === 0) {
-          await this.updateRunSendProgress(runId, stats);
-        }
-        if (i < emailsToProcess.length - 1) {
-          const delayMs = this.config.options?.delayBetweenSendsMs || 0;
-          const jitterMs = this.config.options?.jitterMs || 0;
-          if (delayMs > 0 || jitterMs > 0) {
-            const totalDelay = delayMs + Math.floor(Math.random() * (jitterMs + 1));
-            if (totalDelay > 0) await new Promise((resolve) => setTimeout(resolve, totalDelay));
-          }
+        if (result === "sent") {
+          totalProcessed++;
+          if (runId && totalProcessed % 10 === 0) await this.updateRunSendProgress(runId, stats);
+          await this.applySendDelay(i >= emailsToProcess.length - 1);
         }
       } catch (err) {
         stats.errorCount++;
-        this.config.hooks?.onSend?.({ ruleId, ruleName: rule.name, email, status: "error", accountId: "", templateId, runId: runId || "", subjectIndex: -1, bodyIndex: -1, failureReason: err.message || "unknown error" });
+        this.emitSendEvent(rule, email, "error", templateId, runId || "", { failureReason: err.message || "unknown error" });
         this.logger.error(`Rule "${rule.name}" failed for identifier ${email}`, { error: err });
       }
     }
-    await this.EmailRule.findByIdAndUpdate(rule._id, {
-      $set: { lastRunAt: /* @__PURE__ */ new Date(), lastRunStats: stats },
-      $inc: { totalSent: stats.sent, totalSkipped: stats.skipped }
-    });
+    await this.finalizeRuleStats(rule, stats, ruleId, templateId, runId);
     if (rule.sendOnce) {
       const allIdentifiers = rule.target.identifiers || [];
       const totalIdentifiers = new Set(allIdentifiers.map((e) => e.toLowerCase().trim()).filter(Boolean)).size;
@@ -1646,7 +1704,6 @@ var RuleRunnerService = class {
         this.logger.info(`Rule '${rule.name}' auto-disabled \u2014 all identifiers processed`);
       }
     }
-    this.config.hooks?.onRuleComplete?.({ ruleId, ruleName: rule.name, stats, templateId, runId: runId || "" });
     return stats;
   }
   async executeQueryMode(rule, template, throttleMap, throttleConfig, stats, runId) {
@@ -1670,194 +1727,58 @@ var RuleRunnerService = class {
     const userIds = users.map((u) => u._id?.toString()).filter(Boolean);
     const emails = users.map((u) => u.email).filter(Boolean);
     const allRuleSends = await this.EmailRuleSend.find({ ruleId: rule._id, userId: { $in: userIds } }).sort({ sentAt: -1 }).lean();
-    const sendMap = /* @__PURE__ */ new Map();
-    for (const send of allRuleSends) {
-      const uid = send.userId.toString();
-      if (!sendMap.has(uid)) {
-        sendMap.set(uid, send);
-      }
-    }
+    const sendMap = this.buildSendMap(allRuleSends);
     const uniqueEmails = [...new Set(emails.map((e) => e.toLowerCase().trim()))];
-    const identifierResults = await processInChunks(
-      uniqueEmails,
-      async (email) => {
-        const result = await this.config.adapters.findIdentifier(email);
-        return result ? { email, ...result } : null;
-      },
-      IDENTIFIER_CHUNK_SIZE
-    );
-    const identifierMap = /* @__PURE__ */ new Map();
-    for (const result of identifierResults) {
-      if (result) {
-        identifierMap.set(result.email, { id: result.id, contactId: result.contactId });
-      }
-    }
-    const preheadersQ = template.preheaders || [];
-    const compiledVariants = this.templateRenderer.compileBatchVariants(
-      template.subjects,
-      template.bodies,
-      template.textBody,
-      preheadersQ
-    );
+    const identifierMap = await this.resolveIdentifiers(uniqueEmails);
+    const compiledVariants = this.compileTemplateVariants(template);
     const ruleId = rule._id.toString();
     const templateId = rule.templateId.toString();
     let totalProcessed = 0;
     for (let i = 0; i < users.length; i++) {
       const user = users[i];
-      if (runId && i % 10 === 0) {
-        const cancelKey = `${this.keyPrefix}run:${runId}:cancel`;
-        const cancelled = await this.redis.exists(cancelKey);
-        if (cancelled) break;
-      }
+      if (await this.checkCancelled(runId, i)) break;
       try {
         const userId = user._id?.toString();
         const email = user.email;
         if (!userId || !email) {
           stats.skipped++;
-          this.config.hooks?.onSend?.({ ruleId, ruleName: rule.name, email: email || "unknown", status: "invalid", accountId: "", templateId, runId: runId || "", subjectIndex: -1, bodyIndex: -1, failureReason: "invalid email" });
+          this.emitSendEvent(rule, email || "unknown", "invalid", templateId, runId || "", { failureReason: "invalid email" });
           continue;
         }
-        const lastSend = sendMap.get(userId);
-        if (lastSend) {
-          if (rule.sendOnce && rule.resendAfterDays == null) {
-            stats.skipped++;
-            this.config.hooks?.onSend?.({ ruleId, ruleName: rule.name, email, status: "skipped", accountId: "", templateId, runId: runId || "", subjectIndex: -1, bodyIndex: -1, failureReason: "send once" });
-            continue;
-          }
-          if (rule.resendAfterDays != null) {
-            const daysSince = (Date.now() - new Date(lastSend.sentAt).getTime()) / MS_PER_DAY;
-            if (daysSince < rule.resendAfterDays) {
-              stats.skipped++;
-              this.config.hooks?.onSend?.({ ruleId, ruleName: rule.name, email, status: "skipped", accountId: "", templateId, runId: runId || "", subjectIndex: -1, bodyIndex: -1, failureReason: "resend too soon" });
-              continue;
-            }
-          } else {
-            stats.skipped++;
-            this.config.hooks?.onSend?.({ ruleId, ruleName: rule.name, email, status: "skipped", accountId: "", templateId, runId: runId || "", subjectIndex: -1, bodyIndex: -1, failureReason: "send once" });
-            continue;
-          }
-          if (rule.cooldownDays) {
-            const daysSince = (Date.now() - new Date(lastSend.sentAt).getTime()) / MS_PER_DAY;
-            if (daysSince < rule.cooldownDays) {
-              stats.skipped++;
-              this.config.hooks?.onSend?.({ ruleId, ruleName: rule.name, email, status: "skipped", accountId: "", templateId, runId: runId || "", subjectIndex: -1, bodyIndex: -1, failureReason: "cooldown period" });
-              continue;
-            }
-          }
-        }
         const identifier = identifierMap.get(email.toLowerCase().trim());
         if (!identifier) {
           stats.skipped++;
-          this.config.hooks?.onSend?.({ ruleId, ruleName: rule.name, email, status: "invalid", accountId: "", templateId, runId: runId || "", subjectIndex: -1, bodyIndex: -1, failureReason: "invalid email" });
-          continue;
-        }
-        if (!this.checkThrottle(rule, userId, email, throttleMap, throttleConfig, stats, templateId, runId)) continue;
-        const agentSelection = await this.config.adapters.selectAgent(identifier.id, { ruleId, templateId });
-        if (!agentSelection) {
-          stats.skipped++;
-          this.config.hooks?.onSend?.({ ruleId, ruleName: rule.name, email, status: "skipped", accountId: "", templateId, runId: runId || "", subjectIndex: -1, bodyIndex: -1, failureReason: "no account available" });
+          this.emitSendEvent(rule, email, "invalid", templateId, runId || "", { failureReason: "invalid email" });
           continue;
         }
-        const resolvedData = this.config.adapters.resolveData(user);
-        const templateData = { ...template.fields || {}, ...resolvedData };
-        const si = Math.floor(Math.random() * compiledVariants.subjectFns.length);
-        const bi = Math.floor(Math.random() * compiledVariants.bodyFns.length);
-        const renderedSubject = compiledVariants.subjectFns[si](templateData);
-        const renderedHtml = compiledVariants.bodyFns[bi](templateData);
-        const renderedText = compiledVariants.textBodyFn ? compiledVariants.textBodyFn(templateData) : this.templateRenderer.htmlToText(renderedHtml);
-        let finalHtml = renderedHtml;
-        let finalText = renderedText;
-        let finalSubject = renderedSubject;
-        let pi;
-        if (compiledVariants.preheaderFns && compiledVariants.preheaderFns.length > 0) {
-          pi = Math.floor(Math.random() * compiledVariants.preheaderFns.length);
-          const renderedPreheader = compiledVariants.preheaderFns[pi](templateData);
-          if (renderedPreheader) {
-            const preheaderHtml = `<div style="display:none;font-size:1px;color:#ffffff;line-height:1px;max-height:0px;max-width:0px;opacity:0;overflow:hidden;">${renderedPreheader}</div>`;
-            finalHtml = finalHtml.replace(/(<body[^>]*>)/i, `$1${preheaderHtml}`);
-          }
-        }
-        if (this.config.hooks?.beforeSend) {
-          try {
-            const modified = await this.config.hooks.beforeSend({
-              htmlBody: finalHtml,
-              textBody: finalText,
-              subject: finalSubject,
-              account: {
-                id: agentSelection.accountId,
-                email: agentSelection.email,
-                metadata: agentSelection.metadata
-              },
-              user: {
-                id: String(userId),
-                email,
-                name: String(user.name || user.firstName || "")
-              },
-              context: {
-                ruleId,
-                templateId,
-                runId: runId || ""
-              }
-            });
-            finalHtml = modified.htmlBody;
-            finalText = modified.textBody;
-            finalSubject = modified.subject;
-          } catch (hookErr) {
-            this.logger.error(`beforeSend hook failed for email ${email}: ${hookErr.message}`);
-            stats.errorCount++;
-            this.config.hooks?.onSend?.({ ruleId, ruleName: rule.name, email, status: "error", accountId: agentSelection.accountId, templateId, runId: runId || "", subjectIndex: si, bodyIndex: bi, failureReason: hookErr.message });
-            continue;
-          }
-        }
-        await this.config.adapters.sendEmail({
-          identifierId: identifier.id,
-          contactId: identifier.contactId,
-          accountId: agentSelection.accountId,
-          subject: finalSubject,
-          htmlBody: finalHtml,
-          textBody: finalText,
+        const result = await this.processSingleUser({
+          rule,
+          email,
+          userKey: userId,
+          identifier,
+          user,
+          sendMap,
+          throttleMap,
+          throttleConfig,
+          template,
+          compiledVariants,
+          templateId,
           ruleId,
-          autoApprove: rule.autoApprove ?? true,
-          attachments: template.attachments || []
-        });
-        await this.EmailRuleSend.logSend(
-          ruleId,
-          userId,
-          identifier.id,
-          void 0,
-          { status: "sent", accountId: agentSelection.accountId, subject: finalSubject, subjectIndex: si, bodyIndex: bi, preheaderIndex: pi }
-        );
-        const current = throttleMap.get(userId) || { today: 0, thisWeek: 0, lastSentDate: null };
-        throttleMap.set(userId, {
-          today: current.today + 1,
-          thisWeek: current.thisWeek + 1,
-          lastSentDate: /* @__PURE__ */ new Date()
+          runId,
+          stats
         });
-        stats.sent++;
-        this.config.hooks?.onSend?.({ ruleId, ruleName: rule.name, email, status: "sent", accountId: agentSelection.accountId, templateId, runId: runId || "", subjectIndex: si, bodyIndex: bi, preheaderIndex: pi });
-        totalProcessed++;
-        if (runId && totalProcessed % 10 === 0) {
-          await this.updateRunSendProgress(runId, stats);
-        }
-        if (i < users.length - 1) {
-          const delayMs = this.config.options?.delayBetweenSendsMs || 0;
-          const jitterMs = this.config.options?.jitterMs || 0;
-          if (delayMs > 0 || jitterMs > 0) {
-            const totalDelay = delayMs + Math.floor(Math.random() * (jitterMs + 1));
-            if (totalDelay > 0) await new Promise((resolve) => setTimeout(resolve, totalDelay));
-          }
+        if (result === "sent") {
+          totalProcessed++;
+          if (runId && totalProcessed % 10 === 0) await this.updateRunSendProgress(runId, stats);
+          await this.applySendDelay(i >= users.length - 1);
         }
       } catch (err) {
         stats.errorCount++;
-        this.config.hooks?.onSend?.({ ruleId, ruleName: rule.name, email: user.email || "unknown", status: "error", accountId: "", templateId, runId: runId || "", subjectIndex: -1, bodyIndex: -1, failureReason: err.message || "unknown error" });
+        this.emitSendEvent(rule, user.email || "unknown", "error", templateId, runId || "", { failureReason: err.message || "unknown error" });
         this.logger.error(`Rule "${rule.name}" failed for user ${user._id?.toString()}`, { error: err });
       }
     }
-    await this.EmailRule.findByIdAndUpdate(rule._id, {
-      $set: { lastRunAt: /* @__PURE__ */ new Date(), lastRunStats: stats },
-      $inc: { totalSent: stats.sent, totalSkipped: stats.skipped }
-    });
-    this.config.hooks?.onRuleComplete?.({ ruleId, ruleName: rule.name, stats, templateId, runId: runId || "" });
+    await this.finalizeRuleStats(rule, stats, ruleId, templateId, runId);
     return stats;
   }
   checkThrottle(rule, userId, email, throttleMap, config, stats, templateId, runId) {
@@ -1869,19 +1790,19 @@ var RuleRunnerService = class {
     const userThrottle = throttleMap.get(userId) || { today: 0, thisWeek: 0, lastSentDate: null };
     if (userThrottle.today >= dailyLimit) {
       stats.skippedByThrottle++;
-      this.config.hooks?.onSend?.({ ruleId: rule._id.toString(), ruleName: rule.name, email, status: "throttled", accountId: "", templateId: templateId || "", runId: runId || "", subjectIndex: -1, bodyIndex: -1, failureReason: "daily throttle limit" });
+      this.emitSendEvent(rule, email, "throttled", templateId || "", runId || "", { failureReason: "daily throttle limit" });
       return false;
     }
     if (userThrottle.thisWeek >= weeklyLimit) {
       stats.skippedByThrottle++;
-      this.config.hooks?.onSend?.({ ruleId: rule._id.toString(), ruleName: rule.name, email, status: "throttled", accountId: "", templateId: templateId || "", runId: runId || "", subjectIndex: -1, bodyIndex: -1, failureReason: "weekly throttle limit" });
+      this.emitSendEvent(rule, email, "throttled", templateId || "", runId || "", { failureReason: "weekly throttle limit" });
       return false;
     }
     if (userThrottle.lastSentDate) {
       const daysSinceLastSend = (Date.now() - userThrottle.lastSentDate.getTime()) / MS_PER_DAY;
       if (daysSinceLastSend < minGap) {
         stats.skippedByThrottle++;
-        this.config.hooks?.onSend?.({ ruleId: rule._id.toString(), ruleName: rule.name, email, status: "throttled", accountId: "", templateId: templateId || "", runId: runId || "", subjectIndex: -1, bodyIndex: -1, failureReason: "min gap days" });
+        this.emitSendEvent(rule, email, "throttled", templateId || "", runId || "", { failureReason: "min gap days" });
         return false;
       }
     }
@@ -2009,476 +1930,342 @@ var RuleRunnerService = class {
     return map;
   }
 };
-function isValidValue(allowed, value) {
-  return typeof value === "string" && allowed.includes(value);
-}
+
+// src/utils/controller.ts
 function getErrorStatus(message) {
-  if (message.includes("already exists") || message.includes("validation failed")) return 400;
   if (message.includes("not found")) return 404;
+  if (message.includes("already exists") || message.includes("validation failed") || message.includes("mismatch") || message.includes("Cannot activate") || message.includes("Cannot delete")) return 400;
   return 500;
 }
+function isValidValue(allowed, value) {
+  return typeof value === "string" && allowed.includes(value);
+}
+function asyncHandler(handler) {
+  return (req, res) => {
+    handler(req, res).catch((error) => {
+      if (res.headersSent) return;
+      const message = error instanceof Error ? error.message : "Unknown error";
+      const status = getErrorStatus(message);
+      res.status(status).json({ success: false, error: message });
+    });
+  };
+}
+
+// src/controllers/template.controller.ts
 function createTemplateController(templateService, options) {
   const platformValues = options?.platforms;
   const validCategories = options?.categories || Object.values(TEMPLATE_CATEGORY);
   const validAudiences = options?.audiences || Object.values(TEMPLATE_AUDIENCE);
-  async function list(req, res) {
-    try {
-      const { category, audience, platform, isActive, page, limit } = req.query;
-      const { templates, total } = await templateService.list({
-        category,
-        audience,
-        platform,
-        isActive: isActive !== void 0 ? isActive === "true" : void 0,
-        page: Math.max(1, parseInt(String(page), 10) || 1),
-        limit: Math.min(parseInt(String(limit), 10) || 200, 500)
-      });
-      res.json({ success: true, data: { templates, total } });
-    } catch (error) {
-      const message = error instanceof Error ? error.message : "Unknown error";
-      res.status(500).json({ success: false, error: message });
+  const list = asyncHandler(async (req, res) => {
+    const { category, audience, platform, isActive, page, limit } = req.query;
+    const { templates, total } = await templateService.list({
+      category,
+      audience,
+      platform,
+      isActive: isActive !== void 0 ? isActive === "true" : void 0,
+      ...calculatePagination(parseInt(String(page), 10) || void 0, parseInt(String(limit), 10) || void 0)
+    });
+    res.json({ success: true, data: { templates, total } });
+  });
+  const getById = asyncHandler(async (req, res) => {
+    const template = await templateService.getById(core.getParam(req, "id"));
+    if (!template) {
+      return res.status(404).json({ success: false, error: "Template not found" });
     }
-  }
-  async function getById(req, res) {
-    try {
-      const template = await templateService.getById(core.getParam(req, "id"));
-      if (!template) {
-        return res.status(404).json({ success: false, error: "Template not found" });
-      }
-      res.json({ success: true, data: { template } });
-    } catch (error) {
-      const message = error instanceof Error ? error.message : "Unknown error";
-      res.status(500).json({ success: false, error: message });
+    res.json({ success: true, data: { template } });
+  });
+  const create = asyncHandler(async (req, res) => {
+    const { name, subjects, bodies, category, audience, platform, preheaders } = req.body;
+    if (!name || !subjects || subjects.length === 0 || !bodies || bodies.length === 0 || !category || !audience || !platform) {
+      return res.status(400).json({ success: false, error: "name, subjects, bodies, category, audience, and platform are required" });
     }
-  }
-  async function create(req, res) {
-    try {
-      const { name, subjects, bodies, category, audience, platform, preheaders } = req.body;
-      if (!name || !subjects || subjects.length === 0 || !bodies || bodies.length === 0 || !category || !audience || !platform) {
-        return res.status(400).json({ success: false, error: "name, subjects, bodies, category, audience, and platform are required" });
-      }
-      if (!isValidValue(validCategories, category)) {
-        return res.status(400).json({ success: false, error: `Invalid category. Must be one of: ${validCategories.join(", ")}` });
-      }
-      if (!isValidValue(validAudiences, audience)) {
-        return res.status(400).json({ success: false, error: `Invalid audience. Must be one of: ${validAudiences.join(", ")}` });
-      }
-      if (platformValues && !platformValues.includes(platform)) {
-        return res.status(400).json({ success: false, error: `Invalid platform. Must be one of: ${platformValues.join(", ")}` });
-      }
-      const template = await templateService.create(req.body);
-      res.status(201).json({ success: true, data: { template } });
-    } catch (error) {
-      const message = error instanceof Error ? error.message : "Unknown error";
-      res.status(getErrorStatus(message)).json({ success: false, error: message });
+    if (!isValidValue(validCategories, category)) {
+      return res.status(400).json({ success: false, error: `Invalid category. Must be one of: ${validCategories.join(", ")}` });
     }
-  }
-  async function update(req, res) {
-    try {
-      const template = await templateService.update(core.getParam(req, "id"), req.body);
-      if (!template) {
-        return res.status(404).json({ success: false, error: "Template not found" });
-      }
-      res.json({ success: true, data: { template } });
-    } catch (error) {
-      const message = error instanceof Error ? error.message : "Unknown error";
-      res.status(getErrorStatus(message)).json({ success: false, error: message });
+    if (!isValidValue(validAudiences, audience)) {
+      return res.status(400).json({ success: false, error: `Invalid audience. Must be one of: ${validAudiences.join(", ")}` });
     }
-  }
-  async function remove(req, res) {
-    try {
-      const deleted = await templateService.delete(core.getParam(req, "id"));
-      if (!deleted) {
-        return res.status(404).json({ success: false, error: "Template not found" });
-      }
-      res.json({ success: true });
-    } catch (error) {
-      const message = error instanceof Error ? error.message : "Unknown error";
-      res.status(500).json({ success: false, error: message });
+    if (platformValues && !platformValues.includes(platform)) {
+      return res.status(400).json({ success: false, error: `Invalid platform. Must be one of: ${platformValues.join(", ")}` });
     }
-  }
-  async function toggleActive(req, res) {
-    try {
-      const template = await templateService.toggleActive(core.getParam(req, "id"));
-      if (!template) {
-        return res.status(404).json({ success: false, error: "Template not found" });
-      }
-      res.json({ success: true, data: { template } });
-    } catch (error) {
-      const message = error instanceof Error ? error.message : "Unknown error";
-      res.status(500).json({ success: false, error: message });
+    const template = await templateService.create(req.body);
+    res.status(201).json({ success: true, data: { template } });
+  });
+  const update = asyncHandler(async (req, res) => {
+    const template = await templateService.update(core.getParam(req, "id"), req.body);
+    if (!template) {
+      return res.status(404).json({ success: false, error: "Template not found" });
     }
-  }
-  async function preview(req, res) {
-    try {
-      const { sampleData } = req.body;
-      const result = await templateService.preview(core.getParam(req, "id"), sampleData || {});
-      if (!result) {
-        return res.status(404).json({ success: false, error: "Template not found" });
-      }
-      res.json({ success: true, data: result });
-    } catch (error) {
-      const message = error instanceof Error ? error.message : "Unknown error";
-      res.status(500).json({ success: false, error: message });
+    res.json({ success: true, data: { template } });
+  });
+  const remove = asyncHandler(async (req, res) => {
+    const deleted = await templateService.delete(core.getParam(req, "id"));
+    if (!deleted) {
+      return res.status(404).json({ success: false, error: "Template not found" });
     }
-  }
-  async function previewRaw(req, res) {
-    try {
-      const { subject, body, textBody, sampleData, variables } = req.body;
-      if (!subject || !body) {
-        return res.status(400).json({ success: false, error: "subject and body are required" });
-      }
-      const result = await templateService.previewRaw(subject, body, sampleData || {}, variables, textBody);
-      res.json({ success: true, data: result });
-    } catch (error) {
-      const message = error instanceof Error ? error.message : "Unknown error";
-      res.status(500).json({ success: false, error: message });
+    res.json({ success: true });
+  });
+  const toggleActive = asyncHandler(async (req, res) => {
+    const template = await templateService.toggleActive(core.getParam(req, "id"));
+    if (!template) {
+      return res.status(404).json({ success: false, error: "Template not found" });
     }
-  }
-  async function validate(req, res) {
-    try {
-      const { body: templateBody } = req.body;
-      if (!templateBody) {
-        return res.status(400).json({ success: false, error: "body is required" });
-      }
-      const result = await templateService.validate(templateBody);
-      res.json({ success: true, data: result });
-    } catch (error) {
-      const message = error instanceof Error ? error.message : "Unknown error";
-      res.status(500).json({ success: false, error: message });
+    res.json({ success: true, data: { template } });
+  });
+  const preview = asyncHandler(async (req, res) => {
+    const { sampleData } = req.body;
+    const result = await templateService.preview(core.getParam(req, "id"), sampleData || {});
+    if (!result) {
+      return res.status(404).json({ success: false, error: "Template not found" });
     }
-  }
-  async function clone(req, res) {
-    try {
-      const { name } = req.body;
-      const result = await templateService.clone(core.getParam(req, "id"), name);
-      res.json({ success: true, data: result });
-    } catch (error) {
-      const message = error instanceof Error ? error.message : "Unknown error";
-      res.status(error instanceof Error && error.message === "Template not found" ? 404 : 500).json({ success: false, error: message });
+    res.json({ success: true, data: result });
+  });
+  const previewRaw = asyncHandler(async (req, res) => {
+    const { subject, body, textBody, sampleData, variables } = req.body;
+    if (!subject || !body) {
+      return res.status(400).json({ success: false, error: "subject and body are required" });
     }
-  }
-  async function sendTestEmail(req, res) {
-    try {
-      const { testEmail, sampleData } = req.body;
-      if (!testEmail) {
-        return res.status(400).json({ success: false, error: "testEmail is required" });
-      }
-      const result = await templateService.sendTestEmail(core.getParam(req, "id"), testEmail, sampleData || {});
-      if (!result.success) {
-        return res.status(400).json({ success: false, error: result.error });
-      }
-      res.json({ success: true });
-    } catch (error) {
-      const message = error instanceof Error ? error.message : "Unknown error";
-      res.status(500).json({ success: false, error: message });
+    const result = await templateService.previewRaw(subject, body, sampleData || {}, variables, textBody);
+    res.json({ success: true, data: result });
+  });
+  const validate = asyncHandler(async (req, res) => {
+    const { body: templateBody } = req.body;
+    if (!templateBody) {
+      return res.status(400).json({ success: false, error: "body is required" });
     }
-  }
-  async function previewWithRecipient(req, res) {
-    try {
-      const { recipientData } = req.body;
-      if (!recipientData || typeof recipientData !== "object") {
-        return res.status(400).json({ success: false, error: "recipientData object is required" });
-      }
-      const result = await templateService.previewWithRecipient(core.getParam(req, "id"), recipientData);
-      if (!result) {
-        return res.status(404).json({ success: false, error: "Template not found" });
-      }
-      res.json({ success: true, data: result });
-    } catch (error) {
-      const message = error instanceof Error ? error.message : "Unknown error";
-      res.status(500).json({ success: false, error: message });
+    const result = await templateService.validate(templateBody);
+    res.json({ success: true, data: result });
+  });
+  const clone = asyncHandler(async (req, res) => {
+    const { name } = req.body;
+    const result = await templateService.clone(core.getParam(req, "id"), name);
+    res.json({ success: true, data: result });
+  });
+  const sendTestEmail = asyncHandler(async (req, res) => {
+    const { testEmail, sampleData } = req.body;
+    if (!testEmail) {
+      return res.status(400).json({ success: false, error: "testEmail is required" });
     }
-  }
+    const result = await templateService.sendTestEmail(core.getParam(req, "id"), testEmail, sampleData || {});
+    if (!result.success) {
+      return res.status(400).json({ success: false, error: result.error });
+    }
+    res.json({ success: true });
+  });
+  const previewWithRecipient = asyncHandler(async (req, res) => {
+    const { recipientData } = req.body;
+    if (!recipientData || typeof recipientData !== "object") {
+      return res.status(400).json({ success: false, error: "recipientData object is required" });
+    }
+    const result = await templateService.previewWithRecipient(core.getParam(req, "id"), recipientData);
+    if (!result) {
+      return res.status(404).json({ success: false, error: "Template not found" });
+    }
+    res.json({ success: true, data: result });
+  });
   return { list, getById, create, update, remove, toggleActive, preview, previewRaw, validate, sendTestEmail, clone, previewWithRecipient };
 }
-function isValidValue2(allowed, value) {
-  return typeof value === "string" && allowed.includes(value);
-}
-function getErrorStatus2(message) {
-  if (message.includes("not found")) return 404;
-  if (message.includes("mismatch") || message.includes("validation failed") || message.includes("Cannot activate")) return 400;
-  return 500;
-}
 function createRuleController(ruleService, options) {
   const platformValues = options?.platforms;
   const validAudiences = options?.audiences || Object.values(TEMPLATE_AUDIENCE);
   const validEmailTypes = Object.values(EMAIL_TYPE);
-  async function list(req, res) {
-    try {
-      const page = Math.max(1, parseInt(String(req.query.page), 10) || 1);
-      const limit = Math.min(parseInt(String(req.query.limit), 10) || 200, 500);
-      const { rules, total } = await ruleService.list({ page, limit });
-      res.json({ success: true, data: { rules, total } });
-    } catch (error) {
-      const message = error instanceof Error ? error.message : "Unknown error";
-      res.status(500).json({ success: false, error: message });
+  const list = asyncHandler(async (req, res) => {
+    const { page, limit } = calculatePagination(
+      parseInt(String(req.query.page), 10) || void 0,
+      parseInt(String(req.query.limit), 10) || void 0
+    );
+    const { rules, total } = await ruleService.list({ page, limit });
+    res.json({ success: true, data: { rules, total } });
+  });
+  const getById = asyncHandler(async (req, res) => {
+    const rule = await ruleService.getById(core.getParam(req, "id"));
+    if (!rule) {
+      return res.status(404).json({ success: false, error: "Rule not found" });
     }
-  }
-  async function getById(req, res) {
-    try {
-      const rule = await ruleService.getById(core.getParam(req, "id"));
-      if (!rule) {
-        return res.status(404).json({ success: false, error: "Rule not found" });
-      }
-      res.json({ success: true, data: { rule } });
-    } catch (error) {
-      const message = error instanceof Error ? error.message : "Unknown error";
-      res.status(500).json({ success: false, error: message });
+    res.json({ success: true, data: { rule } });
+  });
+  const create = asyncHandler(async (req, res) => {
+    const { name, target, templateId } = req.body;
+    if (!name || !target || !templateId) {
+      return res.status(400).json({ success: false, error: "name, target, and templateId are required" });
     }
-  }
-  async function create(req, res) {
-    try {
-      const { name, target, templateId } = req.body;
-      if (!name || !target || !templateId) {
-        return res.status(400).json({ success: false, error: "name, target, and templateId are required" });
+    const mode = target.mode || "query";
+    if (mode === "list") {
+      if (!Array.isArray(target.identifiers) || target.identifiers.length === 0) {
+        return res.status(400).json({ success: false, error: "target.identifiers must be a non-empty array for list mode" });
+      }
+    } else {
+      if (!target.role || !isValidValue(validAudiences, target.role)) {
+        return res.status(400).json({ success: false, error: `Invalid target.role. Must be one of: ${validAudiences.join(", ")}` });
       }
+      if (platformValues && !platformValues.includes(target.platform)) {
+        return res.status(400).json({ success: false, error: `Invalid target.platform. Must be one of: ${platformValues.join(", ")}` });
+      }
+      if (!Array.isArray(target.conditions)) {
+        return res.status(400).json({ success: false, error: "target.conditions must be an array" });
+      }
+    }
+    if (req.body.emailType && !isValidValue(validEmailTypes, req.body.emailType)) {
+      return res.status(400).json({ success: false, error: `Invalid emailType. Must be one of: ${validEmailTypes.join(", ")}` });
+    }
+    const rule = await ruleService.create(req.body);
+    res.status(201).json({ success: true, data: { rule } });
+  });
+  const update = asyncHandler(async (req, res) => {
+    const { target, emailType } = req.body;
+    if (target) {
       const mode = target.mode || "query";
       if (mode === "list") {
-        if (!Array.isArray(target.identifiers) || target.identifiers.length === 0) {
+        if (target.identifiers && (!Array.isArray(target.identifiers) || target.identifiers.length === 0)) {
           return res.status(400).json({ success: false, error: "target.identifiers must be a non-empty array for list mode" });
         }
       } else {
-        if (!target.role || !isValidValue2(validAudiences, target.role)) {
+        if (target.role && !isValidValue(validAudiences, target.role)) {
           return res.status(400).json({ success: false, error: `Invalid target.role. Must be one of: ${validAudiences.join(", ")}` });
         }
-        if (platformValues && !platformValues.includes(target.platform)) {
+        if (target.platform && platformValues && !platformValues.includes(target.platform)) {
           return res.status(400).json({ success: false, error: `Invalid target.platform. Must be one of: ${platformValues.join(", ")}` });
         }
-        if (!Array.isArray(target.conditions)) {
+        if (target.conditions && !Array.isArray(target.conditions)) {
           return res.status(400).json({ success: false, error: "target.conditions must be an array" });
         }
       }
-      if (req.body.emailType && !isValidValue2(validEmailTypes, req.body.emailType)) {
-        return res.status(400).json({ success: false, error: `Invalid emailType. Must be one of: ${validEmailTypes.join(", ")}` });
-      }
-      const rule = await ruleService.create(req.body);
-      res.status(201).json({ success: true, data: { rule } });
-    } catch (error) {
-      const message = error instanceof Error ? error.message : "Unknown error";
-      res.status(getErrorStatus2(message)).json({ success: false, error: message });
-    }
-  }
-  async function update(req, res) {
-    try {
-      const { target, emailType } = req.body;
-      if (target) {
-        const mode = target.mode || "query";
-        if (mode === "list") {
-          if (target.identifiers && (!Array.isArray(target.identifiers) || target.identifiers.length === 0)) {
-            return res.status(400).json({ success: false, error: "target.identifiers must be a non-empty array for list mode" });
-          }
-        } else {
-          if (target.role && !isValidValue2(validAudiences, target.role)) {
-            return res.status(400).json({ success: false, error: `Invalid target.role. Must be one of: ${validAudiences.join(", ")}` });
-          }
-          if (target.platform && platformValues && !platformValues.includes(target.platform)) {
-            return res.status(400).json({ success: false, error: `Invalid target.platform. Must be one of: ${platformValues.join(", ")}` });
-          }
-          if (target.conditions && !Array.isArray(target.conditions)) {
-            return res.status(400).json({ success: false, error: "target.conditions must be an array" });
-          }
-        }
-      }
-      if (emailType && !isValidValue2(validEmailTypes, emailType)) {
-        return res.status(400).json({ success: false, error: `Invalid emailType. Must be one of: ${validEmailTypes.join(", ")}` });
-      }
-      const rule = await ruleService.update(core.getParam(req, "id"), req.body);
-      if (!rule) {
-        return res.status(404).json({ success: false, error: "Rule not found" });
-      }
-      res.json({ success: true, data: { rule } });
-    } catch (error) {
-      const message = error instanceof Error ? error.message : "Unknown error";
-      res.status(getErrorStatus2(message)).json({ success: false, error: message });
     }
-  }
-  async function remove(req, res) {
-    try {
-      const result = await ruleService.delete(core.getParam(req, "id"));
-      if (!result.deleted && !result.disabled) {
-        return res.status(404).json({ success: false, error: "Rule not found" });
-      }
-      res.json({ success: true, data: result });
-    } catch (error) {
-      const message = error instanceof Error ? error.message : "Unknown error";
-      res.status(500).json({ success: false, error: message });
-    }
-  }
-  async function toggleActive(req, res) {
-    try {
-      const rule = await ruleService.toggleActive(core.getParam(req, "id"));
-      if (!rule) {
-        return res.status(404).json({ success: false, error: "Rule not found" });
-      }
-      res.json({ success: true, data: { rule } });
-    } catch (error) {
-      const message = error instanceof Error ? error.message : "Unknown error";
-      res.status(getErrorStatus2(message)).json({ success: false, error: message });
+    if (emailType && !isValidValue(validEmailTypes, emailType)) {
+      return res.status(400).json({ success: false, error: `Invalid emailType. Must be one of: ${validEmailTypes.join(", ")}` });
     }
-  }
-  async function dryRun(req, res) {
-    try {
-      const result = await ruleService.dryRun(core.getParam(req, "id"));
-      res.json({ success: true, data: result });
-    } catch (error) {
-      const message = error instanceof Error ? error.message : "Unknown error";
-      res.status(getErrorStatus2(message)).json({ success: false, error: message });
+    const rule = await ruleService.update(core.getParam(req, "id"), req.body);
+    if (!rule) {
+      return res.status(404).json({ success: false, error: "Rule not found" });
     }
-  }
-  async function clone(req, res) {
-    try {
-      const { name } = req.body;
-      const result = await ruleService.clone(core.getParam(req, "id"), name);
-      res.json({ success: true, data: result });
-    } catch (error) {
-      const message = error instanceof Error ? error.message : "Unknown error";
-      res.status(error instanceof Error && error.message === "Rule not found" ? 404 : 500).json({ success: false, error: message });
+    res.json({ success: true, data: { rule } });
+  });
+  const remove = asyncHandler(async (req, res) => {
+    const result = await ruleService.delete(core.getParam(req, "id"));
+    if (!result.deleted && !result.disabled) {
+      return res.status(404).json({ success: false, error: "Rule not found" });
     }
-  }
-  async function runHistory(req, res) {
-    try {
-      const limitParam = req.query.limit;
-      const limit = parseInt(String(Array.isArray(limitParam) ? limitParam[0] : limitParam), 10) || 20;
-      const pageParam = req.query.page;
-      const page = Math.max(1, parseInt(String(Array.isArray(pageParam) ? pageParam[0] : pageParam), 10) || 1);
-      const from = req.query.from ? String(req.query.from) : void 0;
-      const to = req.query.to ? String(req.query.to) : void 0;
-      const logs = await ruleService.getRunHistory(limit, { page, from, to });
-      const total = await ruleService.getRunHistoryCount({ from, to });
-      res.json({ success: true, data: { logs, total } });
-    } catch (error) {
-      const message = error instanceof Error ? error.message : "Unknown error";
-      res.status(500).json({ success: false, error: message });
+    res.json({ success: true, data: result });
+  });
+  const toggleActive = asyncHandler(async (req, res) => {
+    const rule = await ruleService.toggleActive(core.getParam(req, "id"));
+    if (!rule) {
+      return res.status(404).json({ success: false, error: "Rule not found" });
     }
-  }
+    res.json({ success: true, data: { rule } });
+  });
+  const dryRun = asyncHandler(async (req, res) => {
+    const result = await ruleService.dryRun(core.getParam(req, "id"));
+    res.json({ success: true, data: result });
+  });
+  const clone = asyncHandler(async (req, res) => {
+    const { name } = req.body;
+    const result = await ruleService.clone(core.getParam(req, "id"), name);
+    res.json({ success: true, data: result });
+  });
+  const runHistory = asyncHandler(async (req, res) => {
+    const { page, limit } = calculatePagination(
+      parseInt(String(req.query.page), 10) || void 0,
+      parseInt(String(req.query.limit), 10) || 20
+    );
+    const from = req.query.from ? String(req.query.from) : void 0;
+    const to = req.query.to ? String(req.query.to) : void 0;
+    const logs = await ruleService.getRunHistory(limit, { page, from, to });
+    const total = await ruleService.getRunHistoryCount({ from, to });
+    res.json({ success: true, data: { logs, total } });
+  });
   return { list, getById, create, update, remove, toggleActive, dryRun, runHistory, clone };
 }
 function createRunnerController(runnerService, EmailRuleRunLog, logger) {
-  async function triggerManualRun(_req, res) {
+  const triggerManualRun = asyncHandler(async (_req, res) => {
     const { runId } = runnerService.trigger(RUN_TRIGGER.Manual);
     res.json({ success: true, data: { message: "Rule run triggered", runId } });
-  }
-  async function getLatestRun(_req, res) {
-    try {
-      const latestRun = await EmailRuleRunLog.findOne().sort({ runAt: -1 });
-      res.json({ success: true, data: { latestRun } });
-    } catch (error) {
-      const message = error instanceof Error ? error.message : "Unknown error";
-      res.status(500).json({ success: false, error: message });
-    }
-  }
-  async function getStatusByRunId(req, res) {
-    try {
-      const status = await runnerService.getStatus(core.getParam(req, "runId"));
-      if (!status) {
-        res.status(404).json({ success: false, error: "Run not found" });
-        return;
-      }
-      res.json({ success: true, data: status });
-    } catch (error) {
-      const message = error instanceof Error ? error.message : "Unknown error";
-      res.status(500).json({ success: false, error: message });
+  });
+  const getLatestRun = asyncHandler(async (_req, res) => {
+    const latestRun = await EmailRuleRunLog.findOne().sort({ runAt: -1 });
+    res.json({ success: true, data: { latestRun } });
+  });
+  const getStatusByRunId = asyncHandler(async (req, res) => {
+    const status = await runnerService.getStatus(core.getParam(req, "runId"));
+    if (!status) {
+      res.status(404).json({ success: false, error: "Run not found" });
+      return;
     }
-  }
-  async function cancelRun(req, res) {
-    try {
-      const result = await runnerService.cancel(core.getParam(req, "runId"));
-      if (!result.ok) {
-        res.status(404).json({ success: false, error: "Run not found" });
-        return;
-      }
-      res.json({ success: true, data: { message: "Cancel requested" } });
-    } catch (error) {
-      const message = error instanceof Error ? error.message : "Unknown error";
-      res.status(500).json({ success: false, error: message });
+    res.json({ success: true, data: status });
+  });
+  const cancelRun = asyncHandler(async (req, res) => {
+    const result = await runnerService.cancel(core.getParam(req, "runId"));
+    if (!result.ok) {
+      res.status(404).json({ success: false, error: "Run not found" });
+      return;
     }
-  }
+    res.json({ success: true, data: { message: "Cancel requested" } });
+  });
   return { triggerManualRun, getLatestRun, getStatusByRunId, cancelRun };
 }
 
 // src/controllers/settings.controller.ts
 function createSettingsController(EmailThrottleConfig) {
-  async function getThrottleConfig(_req, res) {
-    try {
-      const config = await EmailThrottleConfig.getConfig();
-      res.json({ success: true, data: { config } });
-    } catch (error) {
-      const message = error instanceof Error ? error.message : "Unknown error";
-      res.status(500).json({ success: false, error: message });
-    }
-  }
-  async function updateThrottleConfig(req, res) {
-    try {
-      const { maxPerUserPerDay, maxPerUserPerWeek, minGapDays } = req.body;
-      const updates = {};
-      if (maxPerUserPerDay !== void 0) {
-        if (!Number.isInteger(maxPerUserPerDay) || maxPerUserPerDay < 1) {
-          return res.status(400).json({ success: false, error: "maxPerUserPerDay must be a positive integer" });
-        }
-        updates.maxPerUserPerDay = maxPerUserPerDay;
-      }
-      if (maxPerUserPerWeek !== void 0) {
-        if (!Number.isInteger(maxPerUserPerWeek) || maxPerUserPerWeek < 1) {
-          return res.status(400).json({ success: false, error: "maxPerUserPerWeek must be a positive integer" });
-        }
-        updates.maxPerUserPerWeek = maxPerUserPerWeek;
-      }
-      if (minGapDays !== void 0) {
-        if (!Number.isInteger(minGapDays) || minGapDays < 0) {
-          return res.status(400).json({ success: false, error: "minGapDays must be a non-negative integer" });
-        }
-        updates.minGapDays = minGapDays;
+  const getThrottleConfig = asyncHandler(async (_req, res) => {
+    const config = await EmailThrottleConfig.getConfig();
+    res.json({ success: true, data: { config } });
+  });
+  const updateThrottleConfig = asyncHandler(async (req, res) => {
+    const { maxPerUserPerDay, maxPerUserPerWeek, minGapDays } = req.body;
+    const updates = {};
+    if (maxPerUserPerDay !== void 0) {
+      if (!Number.isInteger(maxPerUserPerDay) || maxPerUserPerDay < 1) {
+        return res.status(400).json({ success: false, error: "maxPerUserPerDay must be a positive integer" });
       }
-      if (Object.keys(updates).length === 0) {
-        return res.status(400).json({ success: false, error: "No valid fields to update" });
+      updates.maxPerUserPerDay = maxPerUserPerDay;
+    }
+    if (maxPerUserPerWeek !== void 0) {
+      if (!Number.isInteger(maxPerUserPerWeek) || maxPerUserPerWeek < 1) {
+        return res.status(400).json({ success: false, error: "maxPerUserPerWeek must be a positive integer" });
       }
-      const config = await EmailThrottleConfig.getConfig();
-      const finalDaily = updates.maxPerUserPerDay ?? config.maxPerUserPerDay;
-      const finalWeekly = updates.maxPerUserPerWeek ?? config.maxPerUserPerWeek;
-      if (finalWeekly < finalDaily) {
-        return res.status(400).json({ success: false, error: "maxPerUserPerWeek must be >= maxPerUserPerDay" });
+      updates.maxPerUserPerWeek = maxPerUserPerWeek;
+    }
+    if (minGapDays !== void 0) {
+      if (!Number.isInteger(minGapDays) || minGapDays < 0) {
+        return res.status(400).json({ success: false, error: "minGapDays must be a non-negative integer" });
       }
-      const updated = await EmailThrottleConfig.findByIdAndUpdate(
-        config._id,
-        { $set: updates },
-        { new: true }
-      );
-      res.json({ success: true, data: { config: updated } });
-    } catch (error) {
-      const message = error instanceof Error ? error.message : "Unknown error";
-      res.status(500).json({ success: false, error: message });
+      updates.minGapDays = minGapDays;
     }
-  }
+    if (Object.keys(updates).length === 0) {
+      return res.status(400).json({ success: false, error: "No valid fields to update" });
+    }
+    const config = await EmailThrottleConfig.getConfig();
+    const finalDaily = updates.maxPerUserPerDay ?? config.maxPerUserPerDay;
+    const finalWeekly = updates.maxPerUserPerWeek ?? config.maxPerUserPerWeek;
+    if (finalWeekly < finalDaily) {
+      return res.status(400).json({ success: false, error: "maxPerUserPerWeek must be >= maxPerUserPerDay" });
+    }
+    const updated = await EmailThrottleConfig.findByIdAndUpdate(
+      config._id,
+      { $set: updates },
+      { new: true }
+    );
+    res.json({ success: true, data: { config: updated } });
+  });
   return { getThrottleConfig, updateThrottleConfig };
 }
 
 // src/controllers/send-log.controller.ts
 function createSendLogController(EmailRuleSend) {
-  async function list(req, res) {
-    try {
-      const { ruleId, status, email, from, to, page, limit } = req.query;
-      const filter = {};
-      if (ruleId) filter.ruleId = ruleId;
-      if (status) filter.status = status;
-      if (email) filter.userId = { $regex: email, $options: "i" };
-      if (from || to) {
-        filter.sentAt = {};
-        if (from) filter.sentAt.$gte = new Date(from);
-        if (to) filter.sentAt.$lte = new Date(to);
-      }
-      const pageNum = Number(page) || 1;
-      const limitNum = Math.min(Number(limit) || 50, 200);
-      const skip = (pageNum - 1) * limitNum;
-      const [sends, total] = await Promise.all([
-        EmailRuleSend.find(filter).sort({ sentAt: -1 }).skip(skip).limit(limitNum).lean(),
-        EmailRuleSend.countDocuments(filter)
-      ]);
-      res.json({ success: true, data: { sends, total } });
-    } catch (error) {
-      const message = error instanceof Error ? error.message : "Failed to query send logs";
-      res.status(500).json({ success: false, error: message });
-    }
-  }
+  const list = asyncHandler(async (req, res) => {
+    const { ruleId, status, email, from, to, page, limit } = req.query;
+    const filter = {};
+    if (ruleId) filter.ruleId = ruleId;
+    if (status) filter.status = status;
+    if (email) filter.userId = { $regex: email, $options: "i" };
+    Object.assign(filter, buildDateRangeFilter("sentAt", from, to));
+    const pagination = calculatePagination(Number(page) || void 0, Number(limit) || 50, 200);
+    const [sends, total] = await Promise.all([
+      EmailRuleSend.find(filter).sort({ sentAt: -1 }).skip(pagination.skip).limit(pagination.limit).lean(),
+      EmailRuleSend.countDocuments(filter)
+    ]);
+    res.json({ success: true, data: { sends, total } });
+  });
   return { list };
 }