@astralibx/email-rule-engine 12.7.3 → 12.9.0

package/README.md

@@ -96,6 +96,7 @@ The `createEmailRuleEngine(config)` factory accepts an `EmailRuleEngineConfig` o
 | `db` | Yes | Mongoose connection and optional collection prefix |
 | `redis` | Yes | ioredis connection for distributed locking |
 | `adapters` | Yes | 5 required + 1 optional function bridging your app to the engine |
+| `collections` | No | MongoDB collection schemas for field dropdowns, type-aware operators, and validation |
 | `platforms` | No | Valid platform values for schema validation |
 | `audiences` | No | Valid audience/role values for schema validation |
 | `categories` | No | Valid template categories for schema validation |
@@ -114,6 +115,8 @@ See [docs/configuration.md](https://github.com/Hariprakash1997/astralib/blob/mai
 5. [Execution Flow](https://github.com/Hariprakash1997/astralib/blob/main/packages/email/rule-engine/docs/execution-flow.md) — Understand how the runner processes rules
 6. [Throttling](https://github.com/Hariprakash1997/astralib/blob/main/packages/email/rule-engine/docs/throttling.md) — Configure per-user send limits
 
+7. [Collections](https://github.com/Hariprakash1997/astralib/blob/main/packages/email/rule-engine/docs/collections.md) — Register collection schemas for field dropdowns and type-aware validation
+
 Reference: [API Routes](https://github.com/Hariprakash1997/astralib/blob/main/packages/email/rule-engine/docs/api-routes.md) | [Programmatic API](https://github.com/Hariprakash1997/astralib/blob/main/packages/email/rule-engine/docs/programmatic-api.md) | [Types](https://github.com/Hariprakash1997/astralib/blob/main/packages/email/rule-engine/docs/types.md) | [Constants](https://github.com/Hariprakash1997/astralib/blob/main/packages/email/rule-engine/docs/constants.md) | [Error Handling](https://github.com/Hariprakash1997/astralib/blob/main/packages/email/rule-engine/docs/error-handling.md)
 
 ### Redis Key Prefix (Required for Multi-Project Deployments)

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",
@@ -173,7 +193,8 @@ function createEmailRuleSchema(platformValues, audienceValues, collectionPrefix)
       ...platformValues ? { enum: platformValues } : {}
     },
     conditions: [RuleConditionSchema],
-    identifiers: [{ type: String }]
+    identifiers: [{ type: String }],
+    collection: { type: String }
   }, { _id: false });
   const RuleRunStatsSchema = new mongoose.Schema({
     matched: { type: Number, default: 0 },
@@ -264,9 +285,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,6 +327,7 @@ 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) {
@@ -348,8 +370,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 +497,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 +515,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) {
@@ -646,9 +667,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 +679,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);
@@ -740,6 +769,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 +855,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 +866,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 +1035,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 +1070,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,6 +1107,17 @@ var RuleService = class {
         throw new RuleTemplateIncompatibleError(compatError);
       }
     }
+    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 = {};
     for (const [key, value] of Object.entries(input)) {
       if (value !== void 0 && UPDATEABLE_FIELDS2.has(key)) {
@@ -990,7 +1172,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 +1197,25 @@ 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 = {};
+    if (opts?.from || opts?.to) {
+      filter.runAt = {};
+      if (opts.from) filter.runAt["$gte"] = new Date(opts.from);
+      if (opts.to) filter.runAt["$lte"] = /* @__PURE__ */ new Date(opts.to + "T23:59:59.999Z");
+    }
+    const page = opts?.page ?? 1;
+    const skip = (page - 1) * limit;
+    return this.EmailRuleRunLog.find(filter).sort({ runAt: -1 }).skip(skip).limit(limit);
+  }
+  async getRunHistoryCount(opts) {
+    const filter = {};
+    if (opts?.from || opts?.to) {
+      filter.runAt = {};
+      if (opts.from) filter.runAt["$gte"] = new Date(opts.from);
+      if (opts.to) filter.runAt["$lte"] = /* @__PURE__ */ new Date(opts.to + "T23:59:59.999Z");
+    }
+    return this.EmailRuleRunLog.countDocuments(filter);
   }
 };
 var MS_PER_DAY = 864e5;
@@ -1083,6 +1285,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();
@@ -1295,12 +1498,12 @@ var RuleRunnerService = class {
         const dedupKey = identifier.id;
         const lastSend = sendMap.get(dedupKey);
         if (lastSend) {
-          if (rule.sendOnce && !rule.resendAfterDays) {
+          if (rule.sendOnce && rule.resendAfterDays == null) {
             stats.skipped++;
             this.config.hooks?.onSend?.({ ruleId, ruleName: rule.name, email, status: "skipped", accountId: "", templateId, runId: runId || "", subjectIndex: -1, bodyIndex: -1, failureReason: "send once" });
             continue;
           }
-          if (rule.resendAfterDays) {
+          if (rule.resendAfterDays != null) {
             const daysSince = (Date.now() - new Date(lastSend.sentAt).getTime()) / MS_PER_DAY;
             if (daysSince < rule.resendAfterDays) {
               stats.skipped++;
@@ -1312,6 +1515,14 @@ var RuleRunnerService = class {
             this.config.hooks?.onSend?.({ ruleId, ruleName: rule.name, email, status: "skipped", accountId: "", templateId, runId: runId || "", subjectIndex: -1, bodyIndex: -1, failureReason: "send once" });
             continue;
           }
+          if (rule.cooldownDays) {
+            const daysSince = (Date.now() - new Date(lastSend.sentAt).getTime()) / MS_PER_DAY;
+            if (daysSince < rule.cooldownDays) {
+              stats.skipped++;
+              this.config.hooks?.onSend?.({ ruleId, ruleName: rule.name, email, status: "skipped", accountId: "", templateId, runId: runId || "", subjectIndex: -1, bodyIndex: -1, failureReason: "cooldown period" });
+              continue;
+            }
+          }
         }
         if (!this.checkThrottle(rule, dedupKey, email, throttleMap, throttleConfig, stats, templateId, runId)) continue;
         const agentSelection = await this.config.adapters.selectAgent(identifier.id, { ruleId, templateId });
@@ -1397,7 +1608,7 @@ var RuleRunnerService = class {
           lastSentDate: /* @__PURE__ */ new Date()
         });
         stats.sent++;
-        this.config.hooks?.onSend?.({ ruleId, ruleName: rule.name, email, status: "sent", accountId: agentSelection.accountId, templateId, runId: runId || "", subjectIndex: si, bodyIndex: bi });
+        this.config.hooks?.onSend?.({ ruleId, ruleName: rule.name, email, status: "sent", accountId: agentSelection.accountId, templateId, runId: runId || "", subjectIndex: si, bodyIndex: bi, preheaderIndex: pi });
         totalProcessed++;
         if (runId && totalProcessed % 10 === 0) {
           await this.updateRunSendProgress(runId, stats);
@@ -1442,7 +1653,9 @@ var RuleRunnerService = class {
     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;
@@ -1506,12 +1719,12 @@ var RuleRunnerService = class {
         }
         const lastSend = sendMap.get(userId);
         if (lastSend) {
-          if (rule.sendOnce && !rule.resendAfterDays) {
+          if (rule.sendOnce && rule.resendAfterDays == null) {
             stats.skipped++;
             this.config.hooks?.onSend?.({ ruleId, ruleName: rule.name, email, status: "skipped", accountId: "", templateId, runId: runId || "", subjectIndex: -1, bodyIndex: -1, failureReason: "send once" });
             continue;
           }
-          if (rule.resendAfterDays) {
+          if (rule.resendAfterDays != null) {
             const daysSince = (Date.now() - new Date(lastSend.sentAt).getTime()) / MS_PER_DAY;
             if (daysSince < rule.resendAfterDays) {
               stats.skipped++;
@@ -1523,6 +1736,14 @@ var RuleRunnerService = class {
             this.config.hooks?.onSend?.({ ruleId, ruleName: rule.name, email, status: "skipped", accountId: "", templateId, runId: runId || "", subjectIndex: -1, bodyIndex: -1, failureReason: "send once" });
             continue;
           }
+          if (rule.cooldownDays) {
+            const daysSince = (Date.now() - new Date(lastSend.sentAt).getTime()) / MS_PER_DAY;
+            if (daysSince < rule.cooldownDays) {
+              stats.skipped++;
+              this.config.hooks?.onSend?.({ ruleId, ruleName: rule.name, email, status: "skipped", accountId: "", templateId, runId: runId || "", subjectIndex: -1, bodyIndex: -1, failureReason: "cooldown period" });
+              continue;
+            }
+          }
         }
         const identifier = identifierMap.get(email.toLowerCase().trim());
         if (!identifier) {
@@ -1613,7 +1834,7 @@ var RuleRunnerService = class {
           lastSentDate: /* @__PURE__ */ new Date()
         });
         stats.sent++;
-        this.config.hooks?.onSend?.({ ruleId, ruleName: rule.name, email, status: "sent", accountId: agentSelection.accountId, templateId, runId: runId || "", subjectIndex: si, bodyIndex: bi });
+        this.config.hooks?.onSend?.({ ruleId, ruleName: rule.name, email, status: "sent", accountId: agentSelection.accountId, templateId, runId: runId || "", subjectIndex: si, bodyIndex: bi, preheaderIndex: pi });
         totalProcessed++;
         if (runId && totalProcessed % 10 === 0) {
           await this.updateRunSendProgress(runId, stats);
@@ -1767,7 +1988,7 @@ var RuleRunnerService = class {
       this.updateRunProgress(runId, { status: "failed" }).catch(() => {
       });
     });
-    return { runId };
+    return { runId, started: true };
   }
   buildThrottleMap(recentSends) {
     const map = /* @__PURE__ */ new Map();
@@ -1802,14 +2023,16 @@ function createTemplateController(templateService, options) {
   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({
+      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
+        isActive: isActive !== void 0 ? isActive === "true" : void 0,
+        page: Math.max(1, parseInt(String(page), 10) || 1),
+        limit: Math.min(parseInt(String(limit), 10) || 200, 500)
       });
-      res.json({ success: true, data: { templates } });
+      res.json({ success: true, data: { templates, total } });
     } catch (error) {
       const message = error instanceof Error ? error.message : "Unknown error";
       res.status(500).json({ success: false, error: message });
@@ -1980,10 +2203,12 @@ 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) {
+  async function list(req, res) {
     try {
-      const rules = await ruleService.list();
-      res.json({ success: true, data: { rules } });
+      const page = Math.max(1, parseInt(String(req.query.page), 10) || 1);
+      const limit = Math.min(parseInt(String(req.query.limit), 10) || 200, 500);
+      const { rules, total } = await ruleService.list({ page, limit });
+      res.json({ success: true, data: { rules, total } });
     } catch (error) {
       const message = error instanceof Error ? error.message : "Unknown error";
       res.status(500).json({ success: false, error: message });
@@ -2114,8 +2339,13 @@ function createRuleController(ruleService, options) {
     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 } });
+      const pageParam = req.query.page;
+      const page = Math.max(1, parseInt(String(Array.isArray(pageParam) ? pageParam[0] : pageParam), 10) || 1);
+      const from = req.query.from ? String(req.query.from) : void 0;
+      const to = req.query.to ? String(req.query.to) : void 0;
+      const logs = await ruleService.getRunHistory(limit, { page, from, to });
+      const total = await ruleService.getRunHistoryCount({ from, to });
+      res.json({ success: true, data: { logs, total } });
     } catch (error) {
       const message = error instanceof Error ? error.message : "Unknown error";
       res.status(500).json({ success: false, error: message });
@@ -2230,7 +2460,7 @@ function createSendLogController(EmailRuleSend) {
       const filter = {};
       if (ruleId) filter.ruleId = ruleId;
       if (status) filter.status = status;
-      if (email) filter.email = { $regex: email, $options: "i" };
+      if (email) filter.userId = { $regex: email, $options: "i" };
       if (from || to) {
         filter.sentAt = {};
         if (from) filter.sentAt.$gte = new Date(from);
@@ -2267,6 +2497,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 +2528,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 +2551,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 +2640,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 +2680,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 +2700,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 +2721,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 +2735,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 +2746,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