@astralibx/email-rule-engine 12.7.3 → 12.10.0

package/dist/index.cjs

@@ -18,6 +18,26 @@ var crypto__default = /*#__PURE__*/_interopDefault(crypto);
 
 // src/schemas/template.schema.ts
 
+// src/constants/field-types.ts
+var FIELD_TYPE = {
+  String: "string",
+  Number: "number",
+  Boolean: "boolean",
+  Date: "date",
+  ObjectId: "objectId",
+  Array: "array",
+  Object: "object"
+};
+var TYPE_OPERATORS = {
+  string: ["eq", "neq", "contains", "in", "not_in", "exists", "not_exists"],
+  number: ["eq", "neq", "gt", "gte", "lt", "lte", "in", "not_in", "exists", "not_exists"],
+  boolean: ["eq", "neq", "exists", "not_exists"],
+  date: ["eq", "neq", "gt", "gte", "lt", "lte", "exists", "not_exists"],
+  objectId: ["eq", "neq", "in", "not_in", "exists", "not_exists"],
+  array: ["contains", "in", "not_in", "exists", "not_exists"],
+  object: ["exists", "not_exists"]
+};
+
 // src/constants/index.ts
 var TEMPLATE_CATEGORY = {
   Onboarding: "onboarding",
@@ -159,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 },
@@ -173,15 +204,10 @@ function createEmailRuleSchema(platformValues, audienceValues, collectionPrefix)
       ...platformValues ? { enum: platformValues } : {}
     },
     conditions: [RuleConditionSchema],
-    identifiers: [{ 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 }
+    identifiers: [{ type: String }],
+    collection: { type: String }
   }, { _id: false });
+  const RuleRunStatsSchema = createRunStatsSchema();
   const schema = new mongoose.Schema(
     {
       name: { type: String, required: true },
@@ -264,9 +290,9 @@ function createEmailRuleSendSchema(collectionPrefix) {
   const schema = new mongoose.Schema(
     {
       ruleId: { type: mongoose.Schema.Types.ObjectId, ref: "EmailRule", required: true },
-      userId: { type: mongoose.Schema.Types.ObjectId, required: true },
-      emailIdentifierId: { type: mongoose.Schema.Types.ObjectId },
-      messageId: { type: mongoose.Schema.Types.ObjectId },
+      userId: { type: String, required: true },
+      emailIdentifierId: { type: String },
+      messageId: { type: String },
       sentAt: { type: Date, required: true, default: () => /* @__PURE__ */ new Date() },
       status: { type: String },
       accountId: { type: String },
@@ -306,25 +332,17 @@ function createEmailRuleSendSchema(collectionPrefix) {
   schema.index({ ruleId: 1, userId: 1, sentAt: -1 });
   schema.index({ userId: 1, sentAt: -1 });
   schema.index({ ruleId: 1, sentAt: -1 });
+  schema.index({ status: 1, sentAt: -1 });
   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 },
@@ -348,8 +366,7 @@ function createEmailRuleRunLogSchema(collectionPrefix) {
       }
     }
   );
-  schema.index({ runAt: -1 });
-  schema.index({ runAt: 1 }, { expireAfterSeconds: 90 * 86400 });
+  schema.index({ runAt: -1 }, { expireAfterSeconds: 90 * 86400 });
   return schema;
 }
 function createEmailThrottleConfigSchema(collectionPrefix) {
@@ -476,15 +493,15 @@ var TemplateRenderService = class {
     ensureHelpers();
   }
   renderSingle(subject, body, data, textBody) {
-    const subjectFn = Handlebars__default.default.compile(subject, { strict: true });
+    const subjectFn = Handlebars__default.default.compile(subject, { strict: false });
     const resolvedSubject = subjectFn(data);
-    const bodyFn = Handlebars__default.default.compile(body, { strict: true });
+    const bodyFn = Handlebars__default.default.compile(body, { strict: false });
     const resolvedBody = bodyFn(data);
     const mjmlSource = wrapInMjml(resolvedBody);
     const html = compileMjml(mjmlSource);
     let text;
     if (textBody) {
-      const textFn = Handlebars__default.default.compile(textBody, { strict: true });
+      const textFn = Handlebars__default.default.compile(textBody, { strict: false });
       text = textFn(data);
     } else {
       text = htmlToPlainText(html);
@@ -494,20 +511,20 @@ var TemplateRenderService = class {
   compileBatch(subject, body, textBody) {
     const mjmlSource = wrapInMjml(body);
     const htmlWithHandlebars = compileMjml(mjmlSource);
-    const subjectFn = Handlebars__default.default.compile(subject, { strict: true });
-    const bodyFn = Handlebars__default.default.compile(htmlWithHandlebars, { strict: true });
-    const textBodyFn = textBody ? Handlebars__default.default.compile(textBody, { strict: true }) : void 0;
+    const subjectFn = Handlebars__default.default.compile(subject, { strict: false });
+    const bodyFn = Handlebars__default.default.compile(htmlWithHandlebars, { strict: false });
+    const textBodyFn = textBody ? Handlebars__default.default.compile(textBody, { strict: false }) : void 0;
     return { subjectFn, bodyFn, textBodyFn };
   }
   compileBatchVariants(subjects, bodies, textBody, preheaders) {
-    const subjectFns = subjects.map((s) => Handlebars__default.default.compile(s, { strict: true }));
+    const subjectFns = subjects.map((s) => Handlebars__default.default.compile(s, { strict: false }));
     const bodyFns = bodies.map((b) => {
       const mjmlSource = wrapInMjml(b);
       const htmlWithHandlebars = compileMjml(mjmlSource);
-      return Handlebars__default.default.compile(htmlWithHandlebars, { strict: true });
+      return Handlebars__default.default.compile(htmlWithHandlebars, { strict: false });
     });
-    const textBodyFn = textBody ? Handlebars__default.default.compile(textBody, { strict: true }) : void 0;
-    const preheaderFns = preheaders && preheaders.length > 0 ? preheaders.map((p) => Handlebars__default.default.compile(p, { strict: true })) : void 0;
+    const textBodyFn = textBody ? Handlebars__default.default.compile(textBody, { strict: false }) : void 0;
+    const preheaderFns = preheaders && preheaders.length > 0 ? preheaders.map((p) => Handlebars__default.default.compile(p, { strict: false })) : void 0;
     return { subjectFns, bodyFns, textBodyFn, preheaderFns };
   }
   renderFromCompiled(compiled, data) {
@@ -623,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, "");
@@ -646,9 +695,10 @@ function slugify(name) {
   return name.toLowerCase().trim().replace(/[^a-z0-9]+/g, "-").replace(/^-|-$/g, "");
 }
 var TemplateService = class {
-  constructor(EmailTemplate, config) {
+  constructor(EmailTemplate, config, EmailRule) {
     this.EmailTemplate = EmailTemplate;
     this.config = config;
+    this.EmailRule = EmailRule;
   }
   renderService = new TemplateRenderService();
   async list(filters) {
@@ -657,7 +707,14 @@ var TemplateService = class {
     if (filters?.audience) query["audience"] = filters.audience;
     if (filters?.platform) query["platform"] = filters.platform;
     if (filters?.isActive !== void 0) query["isActive"] = filters.isActive;
-    return this.EmailTemplate.find(query).sort({ category: 1, name: 1 });
+    const page = filters?.page ?? 1;
+    const limit = filters?.limit ?? 200;
+    const skip = (page - 1) * limit;
+    const [templates, total] = await Promise.all([
+      this.EmailTemplate.find(query).sort({ category: 1, name: 1 }).skip(skip).limit(limit),
+      this.EmailTemplate.countDocuments(query)
+    ]);
+    return { templates, total };
   }
   async getById(id) {
     return this.EmailTemplate.findById(id);
@@ -723,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 };
@@ -740,6 +792,13 @@ var TemplateService = class {
     );
   }
   async delete(id) {
+    if (this.EmailRule) {
+      const activeRules = await this.EmailRule.find({ templateId: id, isActive: true });
+      if (activeRules.length > 0) {
+        const names = activeRules.map((r) => r.name).join(", ");
+        throw new Error(`Cannot delete template: ${activeRules.length} active rule(s) reference it (${names}). Deactivate them first.`);
+      }
+    }
     const result = await this.EmailTemplate.findByIdAndDelete(id);
     return result !== null;
   }
@@ -819,7 +878,8 @@ var TemplateService = class {
   async previewWithRecipient(templateId, recipientData) {
     const template = await this.EmailTemplate.findById(templateId);
     if (!template) return null;
-    const data = { ...template.fields ?? {}, ...recipientData };
+    const variables = template.variables ?? [];
+    const data = this._buildSampleData(variables, { ...template.fields ?? {}, ...recipientData });
     return this.renderService.renderPreview(
       template.subjects[0],
       template.bodies[0],
@@ -829,6 +889,125 @@ var TemplateService = class {
   }
 };
 
+// src/controllers/collection.controller.ts
+function flattenFields(fields, prefix = "", parentIsArray = false) {
+  const result = [];
+  for (const field of fields) {
+    const path = prefix ? `${prefix}.${field.name}` : field.name;
+    const isArray = field.type === "array";
+    if (field.type === "object" && field.fields?.length) {
+      result.push({
+        path,
+        type: "object",
+        label: field.label,
+        description: field.description
+      });
+      result.push(...flattenFields(field.fields, path, false));
+    } else if (isArray && field.fields?.length) {
+      result.push({
+        path: `${path}[]`,
+        type: "array",
+        label: field.label,
+        description: field.description,
+        isArray: true
+      });
+      result.push(...flattenFields(field.fields, `${path}[]`, true));
+    } else {
+      result.push({
+        path,
+        type: field.type,
+        label: field.label,
+        description: field.description,
+        enumValues: field.enumValues,
+        isArray: parentIsArray || isArray
+      });
+    }
+  }
+  return result;
+}
+function createCollectionController(collections) {
+  return {
+    list(_req, res) {
+      const summary = collections.map((c) => ({
+        name: c.name,
+        label: c.label,
+        description: c.description,
+        identifierField: c.identifierField,
+        fieldCount: c.fields.length,
+        joinCount: c.joins?.length ?? 0
+      }));
+      res.json({ collections: summary });
+    },
+    getFields(req, res) {
+      const { name } = req.params;
+      const collection = collections.find((c) => c.name === name);
+      if (!collection) {
+        res.status(404).json({ error: `Collection "${name}" not found` });
+        return;
+      }
+      const fields = flattenFields(collection.fields);
+      if (collection.joins?.length) {
+        for (const join of collection.joins) {
+          const joinedCollection = collections.find((c) => c.name === join.from);
+          if (joinedCollection) {
+            const joinedFields = flattenFields(joinedCollection.fields, join.as);
+            fields.push(...joinedFields);
+          }
+        }
+      }
+      res.json({
+        name: collection.name,
+        label: collection.label,
+        identifierField: collection.identifierField,
+        fields,
+        typeOperators: TYPE_OPERATORS
+      });
+    }
+  };
+}
+
+// src/validation/condition.validator.ts
+function validateConditions(conditions, collectionName, collections) {
+  if (!collectionName || collections.length === 0) return [];
+  const collection = collections.find((c) => c.name === collectionName);
+  if (!collection) return [];
+  const flatFields = flattenFields(collection.fields);
+  if (collection.joins?.length) {
+    for (const join of collection.joins) {
+      const joinedCollection = collections.find((c) => c.name === join.from);
+      if (joinedCollection) {
+        flatFields.push(...flattenFields(joinedCollection.fields, join.as));
+      }
+    }
+  }
+  const fieldMap = /* @__PURE__ */ new Map();
+  for (const f of flatFields) {
+    fieldMap.set(f.path, f);
+  }
+  const errors = [];
+  for (let i = 0; i < conditions.length; i++) {
+    const cond = conditions[i];
+    const fieldDef = fieldMap.get(cond.field);
+    if (!fieldDef) {
+      errors.push({
+        index: i,
+        field: cond.field,
+        message: `Field "${cond.field}" does not exist in collection "${collectionName}"`
+      });
+      continue;
+    }
+    const allowedOps = TYPE_OPERATORS[fieldDef.type];
+    if (allowedOps && !allowedOps.includes(cond.operator)) {
+      errors.push({
+        index: i,
+        field: cond.field,
+        message: `Operator "${cond.operator}" is not valid for field type "${fieldDef.type}"`
+      });
+    }
+  }
+  return errors;
+}
+
 // src/services/rule.service.ts
 function isQueryTarget(target) {
   return !target.mode || target.mode === "query";
@@ -879,8 +1058,15 @@ var RuleService = class {
     this.EmailRuleRunLog = EmailRuleRunLog;
     this.config = config;
   }
-  async list() {
-    return this.EmailRule.find().populate("templateId", "name slug").sort({ sortOrder: 1, createdAt: -1 });
+  async list(opts) {
+    const page = opts?.page ?? 1;
+    const limit = opts?.limit ?? 200;
+    const skip = (page - 1) * limit;
+    const [rules, total] = await Promise.all([
+      this.EmailRule.find().populate("templateId", "name slug").sort({ sortOrder: 1, createdAt: -1 }).skip(skip).limit(limit),
+      this.EmailRule.countDocuments()
+    ]);
+    return { rules, total };
   }
   async getById(id) {
     return this.EmailRule.findById(id);
@@ -907,6 +1093,14 @@ var RuleService = class {
         throw new RuleTemplateIncompatibleError("target.identifiers must be a non-empty array for list mode, validation failed");
       }
     }
+    if (isQueryTarget(input.target) && input.target.collection && this.config.collections?.length) {
+      const condErrors = validateConditions(input.target.conditions, input.target.collection, this.config.collections);
+      if (condErrors.length > 0) {
+        throw new RuleTemplateIncompatibleError(
+          `Invalid conditions: ${condErrors.map((e) => e.message).join("; ")}`
+        );
+      }
+    }
     return this.EmailRule.createRule(input);
   }
   async update(id, input) {
@@ -936,12 +1130,18 @@ var RuleService = class {
         throw new RuleTemplateIncompatibleError(compatError);
       }
     }
-    const setFields = {};
-    for (const [key, value] of Object.entries(input)) {
-      if (value !== void 0 && UPDATEABLE_FIELDS2.has(key)) {
-        setFields[key] = value;
+    if (isQueryTarget(effectiveTarget)) {
+      const qt = effectiveTarget;
+      if (qt.collection && this.config.collections?.length) {
+        const condErrors = validateConditions(qt.conditions || [], qt.collection, this.config.collections);
+        if (condErrors.length > 0) {
+          throw new RuleTemplateIncompatibleError(
+            `Invalid conditions: ${condErrors.map((e) => e.message).join("; ")}`
+          );
+        }
       }
     }
+    const setFields = filterUpdateableFields(input, UPDATEABLE_FIELDS2);
     return this.EmailRule.findByIdAndUpdate(
       id,
       { $set: setFields },
@@ -990,7 +1190,10 @@ var RuleService = class {
       const sample2 = identifiers.slice(0, 10).map((id2) => ({ email: id2 }));
       return { matchedCount: matchedCount2, effectiveLimit, willProcess: willProcess2, ruleId: id, sample: sample2 };
     }
-    const users = await this.config.adapters.queryUsers(rule.target, 5e4);
+    const queryTarget = rule.target;
+    const collectionName = queryTarget.collection;
+    const collectionSchema = collectionName ? this.config.collections?.find((c) => c.name === collectionName) : void 0;
+    const users = await this.config.adapters.queryUsers(rule.target, 5e4, collectionSchema ? { collectionSchema } : void 0);
     const matchedCount = users.length;
     const willProcess = Math.min(matchedCount, effectiveLimit);
     const sample = users.slice(0, 10).map((u) => ({
@@ -1012,8 +1215,14 @@ var RuleService = class {
     rest.lastRunStats = void 0;
     return this.EmailRule.create(rest);
   }
-  async getRunHistory(limit = 20) {
-    return this.EmailRuleRunLog.getRecent(limit);
+  async getRunHistory(limit = 20, opts) {
+    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 = buildDateRangeFilter("runAt", opts?.from, opts?.to);
+    return this.EmailRuleRunLog.countDocuments(filter);
   }
 };
 var MS_PER_DAY = 864e5;
@@ -1083,6 +1292,7 @@ var RuleRunnerService = class {
     const lockAcquired = await this.lock.acquire();
     if (!lockAcquired) {
       this.logger.warn("Rule runner already executing, skipping");
+      await this.updateRunProgress(runId, { status: "failed", currentRule: "Another run is already in progress" });
       return { runId };
     }
     const runStartTime = Date.now();
@@ -1233,193 +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" });
-          continue;
-        }
-        const dedupKey = identifier.id;
-        const lastSend = sendMap.get(dedupKey);
-        if (lastSend) {
-          if (rule.sendOnce && !rule.resendAfterDays) {
-            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) {
-            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 (!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" });
+          this.emitSendEvent(rule, email, "invalid", templateId, runId || "", { failureReason: "invalid email" });
           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,
+        const result = await this.processSingleUser({
+          rule,
+          email,
+          userKey: identifier.id,
+          identifier,
+          user: { _id: identifier.id, email },
+          sendMap,
+          throttleMap,
+          throttleConfig,
+          template,
+          compiledVariants,
+          templateId,
           ruleId,
-          autoApprove: rule.autoApprove ?? true,
-          attachments: template.attachments || []
-        });
-        await this.EmailRuleSend.logSend(
-          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 });
-        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;
@@ -1435,14 +1704,15 @@ 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) {
     const limit = rule.maxPerRun || this.config.options?.defaultMaxPerRun || 500;
     let users;
     try {
-      users = await this.config.adapters.queryUsers(rule.target, limit);
+      const collectionName = rule.target?.collection;
+      const collectionSchema = collectionName ? this.config.collections?.find((c) => c.name === collectionName) : void 0;
+      users = await this.config.adapters.queryUsers(rule.target, limit, collectionSchema ? { collectionSchema } : void 0);
     } catch (err) {
       this.logger.error(`Rule "${rule.name}": query failed`, { error: err });
       stats.errorCount = 1;
@@ -1457,186 +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) {
-            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) {
-            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;
-          }
-        }
         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" });
+          this.emitSendEvent(rule, email, "invalid", templateId, runId || "", { 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" });
-          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 });
-        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) {
@@ -1648,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;
       }
     }
@@ -1767,7 +1909,7 @@ var RuleRunnerService = class {
       this.updateRunProgress(runId, { status: "failed" }).catch(() => {
       });
     });
-    return { runId };
+    return { runId, started: true };
   }
   buildThrottleMap(recentSends) {
     const map = /* @__PURE__ */ new Map();
@@ -1788,467 +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 } = req.query;
-      const templates = await templateService.list({
-        category,
-        audience,
-        platform,
-        isActive: isActive !== void 0 ? isActive === "true" : void 0
-      });
-      res.json({ success: true, data: { templates } });
-    } 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 rules = await ruleService.list();
-      res.json({ success: true, data: { rules } });
-    } 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 logs = await ruleService.getRunHistory(limit);
-      res.json({ success: true, data: { logs } });
-    } 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.email = { $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 };
 }
 
@@ -2267,6 +2284,7 @@ function createRoutes(deps) {
   const runnerCtrl = createRunnerController(deps.runnerService, deps.EmailRuleRunLog);
   const settingsCtrl = createSettingsController(deps.EmailThrottleConfig);
   const sendLogCtrl = createSendLogController(deps.EmailRuleSend);
+  const collectionCtrl = createCollectionController(deps.collections || []);
   const templateRouter = express.Router();
   templateRouter.get("/", templateCtrl.list);
   templateRouter.post("/", templateCtrl.create);
@@ -2297,10 +2315,14 @@ function createRoutes(deps) {
   runnerRouter.get("/logs", ruleCtrl.runHistory);
   const sendLogRouter = express.Router();
   sendLogRouter.get("/", sendLogCtrl.list);
+  const collectionRouter = express.Router();
+  collectionRouter.get("/", collectionCtrl.list);
+  collectionRouter.get("/:name/fields", collectionCtrl.getFields);
   router.use("/templates", templateRouter);
   router.use("/rules", ruleRouter);
   router.use("/runner", runnerRouter);
   router.use("/sends", sendLogRouter);
+  router.use("/collections", collectionRouter);
   router.get("/throttle", settingsCtrl.getThrottleConfig);
   router.put("/throttle", settingsCtrl.updateThrottleConfig);
   return router;
@@ -2316,6 +2338,19 @@ var configSchema = zod.z.object({
     findIdentifier: zod.z.function(),
     sendTestEmail: zod.z.function().optional()
   }),
+  collections: zod.z.array(zod.z.object({
+    name: zod.z.string(),
+    label: zod.z.string().optional(),
+    description: zod.z.string().optional(),
+    identifierField: zod.z.string().optional(),
+    fields: zod.z.array(zod.z.any()),
+    joins: zod.z.array(zod.z.object({
+      from: zod.z.string(),
+      localField: zod.z.string(),
+      foreignField: zod.z.string(),
+      as: zod.z.string()
+    })).optional()
+  })).optional(),
   platforms: zod.z.array(zod.z.string()).optional(),
   audiences: zod.z.array(zod.z.string()).optional(),
   categories: zod.z.array(zod.z.string()).optional(),
@@ -2392,7 +2427,10 @@ var SchedulerService = class {
     }, { connection: connectionOpts, prefix: this.keyPrefix });
   }
   async stopWorker() {
-    await this.worker?.close();
+    if (this.worker) {
+      await this.worker.close();
+      this.worker = void 0;
+    }
   }
   async getScheduledJobs() {
     const jobs = await this.queue.getRepeatableJobs();
@@ -2429,7 +2467,7 @@ function createEmailRuleEngine(config) {
     `${prefix}EmailThrottleConfig`,
     createEmailThrottleConfigSchema(prefix)
   );
-  const templateService = new TemplateService(EmailTemplate, config);
+  const templateService = new TemplateService(EmailTemplate, config, EmailRule);
   const ruleService = new RuleService(EmailRule, EmailTemplate, EmailRuleRunLog, config);
   const runnerService = new RuleRunnerService(
     EmailRule,
@@ -2449,7 +2487,8 @@ function createEmailRuleEngine(config) {
     platformValues: config.platforms,
     categoryValues: config.categories,
     audienceValues: config.audiences,
-    logger: config.logger
+    logger: config.logger,
+    collections: config.collections || []
   });
   return {
     routes,
@@ -2469,6 +2508,7 @@ exports.ConfigValidationError = ConfigValidationError;
 exports.DuplicateSlugError = DuplicateSlugError;
 exports.EMAIL_SEND_STATUS = EMAIL_SEND_STATUS;
 exports.EMAIL_TYPE = EMAIL_TYPE;
+exports.FIELD_TYPE = FIELD_TYPE;
 exports.LockAcquisitionError = LockAcquisitionError;
 exports.RULE_OPERATOR = RULE_OPERATOR;
 exports.RUN_LOG_STATUS = RUN_LOG_STATUS;
@@ -2482,6 +2522,7 @@ exports.TARGET_MODE = TARGET_MODE;
 exports.TEMPLATE_AUDIENCE = TEMPLATE_AUDIENCE;
 exports.TEMPLATE_CATEGORY = TEMPLATE_CATEGORY;
 exports.THROTTLE_WINDOW = THROTTLE_WINDOW;
+exports.TYPE_OPERATORS = TYPE_OPERATORS;
 exports.TemplateNotFoundError = TemplateNotFoundError;
 exports.TemplateRenderService = TemplateRenderService;
 exports.TemplateService = TemplateService;
@@ -2492,6 +2533,8 @@ exports.createEmailRuleSchema = createEmailRuleSchema;
 exports.createEmailRuleSendSchema = createEmailRuleSendSchema;
 exports.createEmailTemplateSchema = createEmailTemplateSchema;
 exports.createEmailThrottleConfigSchema = createEmailThrottleConfigSchema;
+exports.flattenFields = flattenFields;
+exports.validateConditions = validateConditions;
 exports.validateConfig = validateConfig;
 //# sourceMappingURL=index.cjs.map
 //# sourceMappingURL=index.cjs.map