@astralibx/email-rule-engine 1.2.2 → 3.0.0

package/dist/index.js

@@ -1,67 +1,1733 @@
-"use strict";
-var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    var desc = Object.getOwnPropertyDescriptor(m, k);
-    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
-      desc = { enumerable: true, get: function() { return m[k]; } };
-    }
-    Object.defineProperty(o, k2, desc);
-}) : (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    o[k2] = m[k];
-}));
-var __exportStar = (this && this.__exportStar) || function(m, exports) {
-    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.RedisLock = exports.RuleRunnerService = exports.RuleService = exports.TemplateService = exports.TemplateRenderService = void 0;
-exports.createEmailRuleEngine = createEmailRuleEngine;
-const template_schema_1 = require("./schemas/template.schema");
-const rule_schema_1 = require("./schemas/rule.schema");
-const rule_send_schema_1 = require("./schemas/rule-send.schema");
-const run_log_schema_1 = require("./schemas/run-log.schema");
-const throttle_config_schema_1 = require("./schemas/throttle-config.schema");
-const template_service_1 = require("./services/template.service");
-const rule_service_1 = require("./services/rule.service");
-const rule_runner_service_1 = require("./services/rule-runner.service");
-const routes_1 = require("./routes");
-function createEmailRuleEngine(config) {
-    const conn = config.db.connection;
-    const prefix = config.db.collectionPrefix || '';
-    const EmailTemplate = conn.model(`${prefix}EmailTemplate`, (0, template_schema_1.createEmailTemplateSchema)(config.platforms, config.audiences));
-    const EmailRule = conn.model(`${prefix}EmailRule`, (0, rule_schema_1.createEmailRuleSchema)(config.platforms, config.audiences));
-    const EmailRuleSend = conn.model(`${prefix}EmailRuleSend`, (0, rule_send_schema_1.createEmailRuleSendSchema)());
-    const EmailRuleRunLog = conn.model(`${prefix}EmailRuleRunLog`, (0, run_log_schema_1.createEmailRuleRunLogSchema)());
-    const EmailThrottleConfig = conn.model(`${prefix}EmailThrottleConfig`, (0, throttle_config_schema_1.createEmailThrottleConfigSchema)());
-    const templateService = new template_service_1.TemplateService(EmailTemplate, config);
-    const ruleService = new rule_service_1.RuleService(EmailRule, EmailTemplate, EmailRuleRunLog, config);
-    const runnerService = new rule_runner_service_1.RuleRunnerService(EmailRule, EmailTemplate, EmailRuleSend, EmailRuleRunLog, EmailThrottleConfig, config);
-    const routes = (0, routes_1.createRoutes)({
-        templateService,
-        ruleService,
-        runnerService,
-        EmailRuleRunLog,
-        EmailThrottleConfig,
-        platformValues: config.platforms
+'use strict';
+
+var mongoose = require('mongoose');
+var Handlebars = require('handlebars');
+var mjml2html = require('mjml');
+var htmlToText = require('html-to-text');
+var core = require('@astralibx/core');
+var crypto = require('crypto');
+var express = require('express');
+var zod = require('zod');
+
+function _interopDefault (e) { return e && e.__esModule ? e : { default: e }; }
+
+var Handlebars__default = /*#__PURE__*/_interopDefault(Handlebars);
+var mjml2html__default = /*#__PURE__*/_interopDefault(mjml2html);
+var crypto__default = /*#__PURE__*/_interopDefault(crypto);
+
+// src/schemas/template.schema.ts
+
+// src/constants/index.ts
+var TEMPLATE_CATEGORY = {
+  Onboarding: "onboarding",
+  Engagement: "engagement",
+  Transactional: "transactional",
+  ReEngagement: "re-engagement",
+  Announcement: "announcement"
+};
+var TEMPLATE_AUDIENCE = {
+  Customer: "customer",
+  Provider: "provider",
+  All: "all"
+};
+var RULE_OPERATOR = {
+  Eq: "eq",
+  Neq: "neq",
+  Gt: "gt",
+  Gte: "gte",
+  Lt: "lt",
+  Lte: "lte",
+  Exists: "exists",
+  NotExists: "not_exists",
+  In: "in",
+  NotIn: "not_in",
+  Contains: "contains"
+};
+var EMAIL_TYPE = {
+  Automated: "automated",
+  Transactional: "transactional"
+};
+var RUN_TRIGGER = {
+  Cron: "cron",
+  Manual: "manual"
+};
+var THROTTLE_WINDOW = {
+  Rolling: "rolling"
+};
+var EMAIL_SEND_STATUS = {
+  Sent: "sent",
+  Error: "error",
+  Skipped: "skipped",
+  Invalid: "invalid",
+  Throttled: "throttled"
+};
+
+// src/schemas/template.schema.ts
+function createEmailTemplateSchema(platformValues, audienceValues, categoryValues, collectionPrefix) {
+  const schema = new mongoose.Schema(
+    {
+      name: { type: String, required: true },
+      slug: { type: String, required: true, unique: true },
+      description: String,
+      category: { type: String, enum: categoryValues || Object.values(TEMPLATE_CATEGORY), required: true },
+      audience: { type: String, enum: audienceValues || Object.values(TEMPLATE_AUDIENCE), required: true },
+      platform: {
+        type: String,
+        required: true,
+        ...platformValues ? { enum: platformValues } : {}
+      },
+      subject: { type: String, required: true },
+      body: { type: String, required: true },
+      textBody: String,
+      variables: [{ type: String }],
+      version: { type: Number, default: 1 },
+      isActive: { type: Boolean, default: true, index: true }
+    },
+    {
+      timestamps: true,
+      collection: `${collectionPrefix || ""}email_templates`,
+      statics: {
+        findBySlug(slug) {
+          return this.findOne({ slug });
+        },
+        findActive() {
+          return this.find({ isActive: true }).sort({ category: 1, name: 1 });
+        },
+        findByCategory(category) {
+          return this.find({ category, isActive: true }).sort({ name: 1 });
+        },
+        findByAudience(audience) {
+          return this.find({
+            $or: [{ audience }, { audience: TEMPLATE_AUDIENCE.All }],
+            isActive: true
+          }).sort({ name: 1 });
+        },
+        async createTemplate(input) {
+          return this.create({
+            name: input.name,
+            slug: input.slug,
+            description: input.description,
+            category: input.category,
+            audience: input.audience,
+            platform: input.platform,
+            subject: input.subject,
+            body: input.body,
+            textBody: input.textBody,
+            variables: input.variables || [],
+            version: 1,
+            isActive: true
+          });
+        }
+      }
+    }
+  );
+  schema.index({ category: 1, isActive: 1 });
+  schema.index({ audience: 1, platform: 1, isActive: 1 });
+  return schema;
+}
+function createEmailRuleSchema(platformValues, audienceValues, collectionPrefix) {
+  const RuleConditionSchema = new mongoose.Schema({
+    field: { type: String, required: true },
+    operator: { type: String, enum: Object.values(RULE_OPERATOR), required: true },
+    value: { type: mongoose.Schema.Types.Mixed }
+  }, { _id: false });
+  const RuleTargetSchema = new mongoose.Schema({
+    role: { type: String, enum: audienceValues || Object.values(TEMPLATE_AUDIENCE), required: true },
+    platform: {
+      type: String,
+      required: true,
+      ...platformValues ? { enum: platformValues } : {}
+    },
+    conditions: [RuleConditionSchema]
+  }, { _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 },
+    errors: { type: Number, default: 0 }
+  }, { _id: false });
+  const schema = new mongoose.Schema(
+    {
+      name: { type: String, required: true },
+      description: String,
+      isActive: { type: Boolean, default: false, index: true },
+      sortOrder: { type: Number, default: 10 },
+      target: { type: RuleTargetSchema, required: true },
+      templateId: { type: mongoose.Schema.Types.ObjectId, ref: "EmailTemplate", required: true, index: true },
+      sendOnce: { type: Boolean, default: true },
+      resendAfterDays: Number,
+      cooldownDays: Number,
+      autoApprove: { type: Boolean, default: true },
+      maxPerRun: Number,
+      bypassThrottle: { type: Boolean, default: false },
+      emailType: { type: String, enum: Object.values(EMAIL_TYPE), default: EMAIL_TYPE.Automated },
+      totalSent: { type: Number, default: 0 },
+      totalSkipped: { type: Number, default: 0 },
+      lastRunAt: Date,
+      lastRunStats: RuleRunStatsSchema
+    },
+    {
+      timestamps: true,
+      collection: `${collectionPrefix || ""}email_rules`,
+      statics: {
+        findActive() {
+          return this.find({ isActive: true }).sort({ sortOrder: 1 });
+        },
+        findByTemplateId(templateId) {
+          return this.find({ templateId });
+        },
+        async createRule(input) {
+          return this.create({
+            name: input.name,
+            description: input.description,
+            isActive: false,
+            sortOrder: input.sortOrder ?? 10,
+            target: input.target,
+            templateId: input.templateId,
+            sendOnce: input.sendOnce ?? true,
+            resendAfterDays: input.resendAfterDays,
+            cooldownDays: input.cooldownDays,
+            autoApprove: input.autoApprove ?? true,
+            maxPerRun: input.maxPerRun,
+            bypassThrottle: input.bypassThrottle ?? false,
+            emailType: input.emailType ?? EMAIL_TYPE.Automated,
+            totalSent: 0,
+            totalSkipped: 0
+          });
+        }
+      }
+    }
+  );
+  schema.index({ isActive: 1, sortOrder: 1 });
+  schema.index({ templateId: 1 });
+  return schema;
+}
+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 },
+      sentAt: { type: Date, required: true, default: () => /* @__PURE__ */ new Date() },
+      status: { type: String },
+      accountId: { type: String },
+      senderName: { type: String },
+      subject: { type: String },
+      failureReason: { type: String }
+    },
+    {
+      collection: `${collectionPrefix || ""}email_rule_sends`,
+      statics: {
+        findLatestForUser(ruleId, userId) {
+          return this.findOne({ ruleId, userId }).sort({ sentAt: -1 });
+        },
+        findRecentByUserIds(userIds, sinceDays) {
+          const since = new Date(Date.now() - sinceDays * 864e5);
+          return this.find({
+            userId: { $in: userIds },
+            sentAt: { $gte: since }
+          }).sort({ sentAt: -1 });
+        },
+        async logSend(ruleId, userId, emailIdentifierId, messageId, extra) {
+          return this.create({
+            ruleId,
+            userId,
+            emailIdentifierId,
+            messageId,
+            sentAt: /* @__PURE__ */ new Date(),
+            ...extra
+          });
+        }
+      }
+    }
+  );
+  schema.index({ ruleId: 1, userId: 1, sentAt: -1 });
+  schema.index({ userId: 1, sentAt: -1 });
+  schema.index({ ruleId: 1, sentAt: -1 });
+  return schema;
+}
+function createEmailRuleRunLogSchema(collectionPrefix) {
+  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 },
+    errors: { 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 },
+    errors: { type: Number, default: 0 }
+  }, { _id: false });
+  const schema = new mongoose.Schema(
+    {
+      runAt: { type: Date, required: true, default: () => /* @__PURE__ */ new Date() },
+      triggeredBy: { type: String, enum: Object.values(RUN_TRIGGER), required: true },
+      duration: { type: Number, required: true },
+      rulesProcessed: { type: Number, required: true },
+      totalStats: { type: TotalStatsSchema, required: true },
+      perRuleStats: [PerRuleStatsSchema]
+    },
+    {
+      collection: `${collectionPrefix || ""}email_rule_run_logs`,
+      statics: {
+        getRecent(limit = 20) {
+          return this.find().sort({ runAt: -1 }).limit(limit);
+        },
+        getByRuleId(ruleId, limit = 20) {
+          return this.find({ "perRuleStats.ruleId": ruleId }).sort({ runAt: -1 }).limit(limit);
+        }
+      }
+    }
+  );
+  schema.index({ runAt: -1 });
+  schema.index({ runAt: 1 }, { expireAfterSeconds: 90 * 86400 });
+  return schema;
+}
+function createEmailThrottleConfigSchema(collectionPrefix) {
+  const schema = new mongoose.Schema(
+    {
+      maxPerUserPerDay: { type: Number, default: 1 },
+      maxPerUserPerWeek: { type: Number, default: 2 },
+      minGapDays: { type: Number, default: 3 },
+      throttleWindow: { type: String, enum: Object.values(THROTTLE_WINDOW), default: THROTTLE_WINDOW.Rolling }
+    },
+    {
+      timestamps: true,
+      collection: `${collectionPrefix || ""}email_throttle_config`,
+      statics: {
+        async getConfig() {
+          let config = await this.findOne();
+          if (!config) {
+            config = await this.create({
+              maxPerUserPerDay: 1,
+              maxPerUserPerWeek: 2,
+              minGapDays: 3,
+              throttleWindow: THROTTLE_WINDOW.Rolling
+            });
+          }
+          return config;
+        }
+      }
+    }
+  );
+  return schema;
+}
+var MJML_BASE_OPEN = `<mjml>
+  <mj-head>
+    <mj-attributes>
+      <mj-all font-family="Arial, sans-serif" />
+      <mj-text font-size="15px" color="#333333" line-height="1.6" />
+    </mj-attributes>
+  </mj-head>
+  <mj-body background-color="#ffffff">
+    <mj-section padding="20px">
+      <mj-column>
+        <mj-text>`;
+var MJML_BASE_CLOSE = `        </mj-text>
+      </mj-column>
+    </mj-section>
+  </mj-body>
+</mjml>`;
+var DATE_FORMAT_OPTIONS = {
+  day: "numeric",
+  month: "short",
+  year: "numeric"
+};
+function registerHelpers() {
+  Handlebars__default.default.registerHelper("currency", (val) => {
+    return `\u20B9${Number(val).toLocaleString("en-IN")}`;
+  });
+  Handlebars__default.default.registerHelper("formatDate", (date) => {
+    const d = new Date(date);
+    return d.toLocaleDateString("en-IN", DATE_FORMAT_OPTIONS);
+  });
+  Handlebars__default.default.registerHelper("capitalize", (str) => {
+    if (!str) return "";
+    return str.charAt(0).toUpperCase() + str.slice(1);
+  });
+  Handlebars__default.default.registerHelper("eq", (a, b) => a === b);
+  Handlebars__default.default.registerHelper("neq", (a, b) => a !== b);
+  Handlebars__default.default.registerHelper("not", (val) => !val);
+  Handlebars__default.default.registerHelper("gt", (a, b) => a > b);
+  Handlebars__default.default.registerHelper("lt", (a, b) => a < b);
+  Handlebars__default.default.registerHelper("gte", (a, b) => a >= b);
+  Handlebars__default.default.registerHelper("lte", (a, b) => a <= b);
+  Handlebars__default.default.registerHelper("lowercase", (str) => {
+    return str ? str.toLowerCase() : "";
+  });
+  Handlebars__default.default.registerHelper("uppercase", (str) => {
+    return str ? str.toUpperCase() : "";
+  });
+  Handlebars__default.default.registerHelper("join", (arr, separator) => {
+    if (!Array.isArray(arr)) return "";
+    const sep = typeof separator === "string" ? separator : ", ";
+    return arr.join(sep);
+  });
+  Handlebars__default.default.registerHelper("pluralize", (count, singular, plural) => {
+    return count === 1 ? singular : typeof plural === "string" ? plural : singular + "s";
+  });
+}
+var helpersRegistered = false;
+function ensureHelpers() {
+  if (!helpersRegistered) {
+    registerHelpers();
+    helpersRegistered = true;
+  }
+}
+function wrapInMjml(body) {
+  if (body.trim().startsWith("<mjml")) {
+    return body;
+  }
+  return `${MJML_BASE_OPEN}${body}${MJML_BASE_CLOSE}`;
+}
+function compileMjml(mjmlSource) {
+  const result = mjml2html__default.default(mjmlSource, {
+    validationLevel: "soft",
+    minify: false
+  });
+  if (result.errors && result.errors.length > 0) {
+    const criticalErrors = result.errors.filter((e) => e.tagName !== void 0);
+    if (criticalErrors.length > 0) {
+      throw new Error(`MJML compilation errors: ${criticalErrors.map((e) => e.message).join("; ")}`);
+    }
+  }
+  return result.html;
+}
+function htmlToPlainText(html) {
+  return htmlToText.convert(html, {
+    wordwrap: 80,
+    selectors: [
+      { selector: "a", options: { hideLinkHrefIfSameAsText: true } },
+      { selector: "img", format: "skip" }
+    ]
+  });
+}
+var TemplateRenderService = class {
+  constructor() {
+    ensureHelpers();
+  }
+  renderSingle(subject, body, data, textBody) {
+    const subjectFn = Handlebars__default.default.compile(subject, { strict: true });
+    const resolvedSubject = subjectFn(data);
+    const bodyFn = Handlebars__default.default.compile(body, { strict: true });
+    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 });
+      text = textFn(data);
+    } else {
+      text = htmlToPlainText(html);
+    }
+    return { html, text, subject: resolvedSubject };
+  }
+  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;
+    return { subjectFn, bodyFn, textBodyFn };
+  }
+  renderFromCompiled(compiled, data) {
+    const subject = compiled.subjectFn(data);
+    const html = compiled.bodyFn(data);
+    const text = compiled.textBodyFn ? compiled.textBodyFn(data) : htmlToPlainText(html);
+    return { html, text, subject };
+  }
+  renderPreview(subject, body, data, textBody) {
+    return this.renderSingle(subject, body, data, textBody);
+  }
+  extractVariables(template) {
+    const regex = /\{\{(?!#|\/|!|>)([^}]+)\}\}/g;
+    const variables = /* @__PURE__ */ new Set();
+    let match;
+    while ((match = regex.exec(template)) !== null) {
+      const variable = match[1].trim();
+      if (!variable.startsWith("else")) {
+        variables.add(variable);
+      }
+    }
+    return Array.from(variables).sort();
+  }
+  validateTemplate(body) {
+    const errors = [];
+    try {
+      Handlebars__default.default.precompile(body);
+    } catch (e) {
+      errors.push(`Handlebars syntax error: ${e.message}`);
+    }
+    const mjmlSource = wrapInMjml(body);
+    try {
+      const result = mjml2html__default.default(mjmlSource, { validationLevel: "strict" });
+      if (result.errors && result.errors.length > 0) {
+        for (const err of result.errors) {
+          errors.push(`MJML error: ${err.message}`);
+        }
+      }
+    } catch (e) {
+      errors.push(`MJML compilation error: ${e.message}`);
+    }
+    return { valid: errors.length === 0, errors };
+  }
+};
+var AlxEmailError = class extends core.AlxError {
+  constructor(message, code) {
+    super(message, code);
+    this.name = "AlxEmailError";
+  }
+};
+var ConfigValidationError = class extends AlxEmailError {
+  constructor(message, field) {
+    super(message, "CONFIG_VALIDATION");
+    this.field = field;
+    this.name = "ConfigValidationError";
+  }
+};
+var TemplateNotFoundError = class extends AlxEmailError {
+  constructor(templateId) {
+    super(`Template not found: ${templateId}`, "TEMPLATE_NOT_FOUND");
+    this.templateId = templateId;
+    this.name = "TemplateNotFoundError";
+  }
+};
+var TemplateSyntaxError = class extends AlxEmailError {
+  constructor(message, errors) {
+    super(message, "TEMPLATE_SYNTAX");
+    this.errors = errors;
+    this.name = "TemplateSyntaxError";
+  }
+};
+var RuleNotFoundError = class extends AlxEmailError {
+  constructor(ruleId) {
+    super(`Rule not found: ${ruleId}`, "RULE_NOT_FOUND");
+    this.ruleId = ruleId;
+    this.name = "RuleNotFoundError";
+  }
+};
+var RuleTemplateIncompatibleError = class extends AlxEmailError {
+  constructor(reason) {
+    super(`Rule-template incompatibility: ${reason}`, "RULE_TEMPLATE_INCOMPATIBLE");
+    this.reason = reason;
+    this.name = "RuleTemplateIncompatibleError";
+  }
+};
+var LockAcquisitionError = class extends AlxEmailError {
+  constructor() {
+    super("Could not acquire distributed lock \u2014 another run is in progress", "LOCK_ACQUISITION");
+    this.name = "LockAcquisitionError";
+  }
+};
+var DuplicateSlugError = class extends AlxEmailError {
+  constructor(slug) {
+    super(`Template with slug "${slug}" already exists`, "DUPLICATE_SLUG");
+    this.slug = slug;
+    this.name = "DuplicateSlugError";
+  }
+};
+
+// src/services/template.service.ts
+var UPDATEABLE_FIELDS = /* @__PURE__ */ new Set([
+  "name",
+  "description",
+  "category",
+  "audience",
+  "platform",
+  "subject",
+  "body",
+  "textBody",
+  "variables",
+  "isActive"
+]);
+function slugify(name) {
+  return name.toLowerCase().trim().replace(/[^a-z0-9]+/g, "-").replace(/^-|-$/g, "");
+}
+var TemplateService = class {
+  constructor(EmailTemplate, config) {
+    this.EmailTemplate = EmailTemplate;
+    this.config = config;
+  }
+  renderService = new TemplateRenderService();
+  async list(filters) {
+    const query = {};
+    if (filters?.category) query["category"] = filters.category;
+    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 });
+  }
+  async getById(id) {
+    return this.EmailTemplate.findById(id);
+  }
+  async getBySlug(slug) {
+    return this.EmailTemplate.findBySlug(slug);
+  }
+  async create(input) {
+    const slug = input.slug || slugify(input.name);
+    const existing = await this.EmailTemplate.findBySlug(slug);
+    if (existing) {
+      throw new DuplicateSlugError(slug);
+    }
+    const validation = this.renderService.validateTemplate(input.body);
+    if (!validation.valid) {
+      throw new TemplateSyntaxError(`Template validation failed: ${validation.errors.join("; ")}`, validation.errors);
+    }
+    const variables = input.variables || this.renderService.extractVariables(
+      `${input.subject} ${input.body} ${input.textBody || ""}`
+    );
+    return this.EmailTemplate.createTemplate({
+      ...input,
+      slug,
+      variables
     });
-    return {
-        routes,
-        runner: runnerService,
-        templateService,
-        ruleService,
-        models: { EmailTemplate, EmailRule, EmailRuleSend, EmailRuleRunLog, EmailThrottleConfig }
-    };
-}
-__exportStar(require("./types"), exports);
-__exportStar(require("./schemas"), exports);
-var template_render_service_1 = require("./services/template-render.service");
-Object.defineProperty(exports, "TemplateRenderService", { enumerable: true, get: function () { return template_render_service_1.TemplateRenderService; } });
-var template_service_2 = require("./services/template.service");
-Object.defineProperty(exports, "TemplateService", { enumerable: true, get: function () { return template_service_2.TemplateService; } });
-var rule_service_2 = require("./services/rule.service");
-Object.defineProperty(exports, "RuleService", { enumerable: true, get: function () { return rule_service_2.RuleService; } });
-var rule_runner_service_2 = require("./services/rule-runner.service");
-Object.defineProperty(exports, "RuleRunnerService", { enumerable: true, get: function () { return rule_runner_service_2.RuleRunnerService; } });
-var redis_lock_1 = require("./utils/redis-lock");
-Object.defineProperty(exports, "RedisLock", { enumerable: true, get: function () { return redis_lock_1.RedisLock; } });
+  }
+  async update(id, input) {
+    const template = await this.EmailTemplate.findById(id);
+    if (!template) return null;
+    if (input.body) {
+      const validation = this.renderService.validateTemplate(input.body);
+      if (!validation.valid) {
+        throw new TemplateSyntaxError(`Template validation failed: ${validation.errors.join("; ")}`, validation.errors);
+      }
+    }
+    if (input.body || input.subject || input.textBody) {
+      const subject = input.subject ?? template.subject;
+      const body = input.body ?? template.body;
+      const textBody = input.textBody ?? template.textBody;
+      input.variables = this.renderService.extractVariables(
+        `${subject} ${body} ${textBody || ""}`
+      );
+    }
+    const setFields = {};
+    for (const [key, value] of Object.entries(input)) {
+      if (value !== void 0 && UPDATEABLE_FIELDS.has(key)) {
+        setFields[key] = value;
+      }
+    }
+    const update = { $set: setFields };
+    if (input.body || input.subject || input.textBody) {
+      update["$inc"] = { version: 1 };
+    }
+    return this.EmailTemplate.findByIdAndUpdate(
+      id,
+      update,
+      { new: true }
+    );
+  }
+  async delete(id) {
+    const result = await this.EmailTemplate.findByIdAndDelete(id);
+    return result !== null;
+  }
+  async toggleActive(id) {
+    const template = await this.EmailTemplate.findById(id);
+    if (!template) return null;
+    template.isActive = !template.isActive;
+    await template.save();
+    return template;
+  }
+  async preview(id, sampleData) {
+    const template = await this.EmailTemplate.findById(id);
+    if (!template) return null;
+    return this.renderService.renderPreview(
+      template.subject,
+      template.body,
+      sampleData,
+      template.textBody
+    );
+  }
+  async previewRaw(subject, body, sampleData, textBody) {
+    return this.renderService.renderPreview(subject, body, sampleData, textBody);
+  }
+  async validate(body) {
+    const validation = this.renderService.validateTemplate(body);
+    const variables = this.renderService.extractVariables(body);
+    return { ...validation, variables };
+  }
+  async sendTestEmail(id, testEmail, sampleData) {
+    if (!this.config.adapters.sendTestEmail) {
+      return { success: false, error: "Test email sending not configured" };
+    }
+    const template = await this.EmailTemplate.findById(id);
+    if (!template) {
+      return { success: false, error: "Template not found" };
+    }
+    const rendered = this.renderService.renderSingle(
+      template.subject,
+      template.body,
+      sampleData,
+      template.textBody
+    );
+    try {
+      await this.config.adapters.sendTestEmail(
+        testEmail,
+        `[TEST] ${rendered.subject}`,
+        rendered.html,
+        rendered.text
+      );
+      return { success: true };
+    } catch (error) {
+      return { success: false, error: error.message };
+    }
+  }
+};
+
+// src/services/rule.service.ts
+var UPDATEABLE_FIELDS2 = /* @__PURE__ */ new Set([
+  "name",
+  "description",
+  "sortOrder",
+  "target",
+  "templateId",
+  "sendOnce",
+  "resendAfterDays",
+  "cooldownDays",
+  "autoApprove",
+  "maxPerRun",
+  "bypassThrottle",
+  "emailType"
+]);
+function validateRuleTemplateCompat(targetRole, targetPlatform, template) {
+  const templateAudience = template.audience;
+  const templatePlatform = template.platform;
+  if (templateAudience !== "all") {
+    if (targetRole === "all") {
+      return `Template "${template.name}" targets ${templateAudience} only, but rule targets all users`;
+    }
+    if (targetRole !== templateAudience) {
+      return `Template targets ${templateAudience}, but rule targets ${targetRole}`;
+    }
+  }
+  if (templatePlatform !== "both") {
+    if (targetPlatform === "both") {
+      return `Template is for ${templatePlatform} only, but rule targets all platforms`;
+    }
+    if (templatePlatform !== targetPlatform) {
+      return `Template is for ${templatePlatform}, but rule targets ${targetPlatform}`;
+    }
+  }
+  return null;
+}
+var RuleService = class {
+  constructor(EmailRule, EmailTemplate, EmailRuleRunLog, config) {
+    this.EmailRule = EmailRule;
+    this.EmailTemplate = EmailTemplate;
+    this.EmailRuleRunLog = EmailRuleRunLog;
+    this.config = config;
+  }
+  async list() {
+    return this.EmailRule.find().populate("templateId", "name slug").sort({ sortOrder: 1, createdAt: -1 });
+  }
+  async getById(id) {
+    return this.EmailRule.findById(id);
+  }
+  async create(input) {
+    const template = await this.EmailTemplate.findById(input.templateId);
+    if (!template) {
+      throw new TemplateNotFoundError(input.templateId);
+    }
+    const compatError = validateRuleTemplateCompat(
+      input.target.role,
+      input.target.platform,
+      template
+    );
+    if (compatError) {
+      throw new RuleTemplateIncompatibleError(compatError);
+    }
+    return this.EmailRule.createRule(input);
+  }
+  async update(id, input) {
+    const rule = await this.EmailRule.findById(id);
+    if (!rule) return null;
+    const templateId = input.templateId ?? rule.templateId.toString();
+    const targetRole = input.target?.role ?? rule.target.role;
+    const targetPlatform = input.target?.platform ?? rule.target.platform;
+    if (input.templateId || input.target) {
+      const template = await this.EmailTemplate.findById(templateId);
+      if (!template) {
+        throw new TemplateNotFoundError(templateId);
+      }
+      const compatError = validateRuleTemplateCompat(targetRole, targetPlatform, template);
+      if (compatError) {
+        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;
+      }
+    }
+    return this.EmailRule.findByIdAndUpdate(
+      id,
+      { $set: setFields },
+      { new: true }
+    );
+  }
+  async delete(id) {
+    const rule = await this.EmailRule.findById(id);
+    if (!rule) return { deleted: false };
+    if (rule.totalSent > 0) {
+      rule.isActive = false;
+      await rule.save();
+      return { deleted: false, disabled: true };
+    }
+    await this.EmailRule.findByIdAndDelete(id);
+    return { deleted: true };
+  }
+  async toggleActive(id) {
+    const rule = await this.EmailRule.findById(id);
+    if (!rule) return null;
+    if (!rule.isActive) {
+      const template = await this.EmailTemplate.findById(rule.templateId);
+      if (!template) {
+        throw new TemplateNotFoundError(rule.templateId.toString());
+      }
+      if (!template.isActive) {
+        throw new RuleTemplateIncompatibleError("Cannot activate rule: linked template is inactive");
+      }
+    }
+    rule.isActive = !rule.isActive;
+    await rule.save();
+    return rule;
+  }
+  async dryRun(id) {
+    const rule = await this.EmailRule.findById(id);
+    if (!rule) {
+      throw new RuleNotFoundError(id);
+    }
+    const users = await this.config.adapters.queryUsers(rule.target, 5e4);
+    return { matchedCount: users.length, ruleId: id };
+  }
+  async getRunHistory(limit = 20) {
+    return this.EmailRuleRunLog.getRecent(limit);
+  }
+};
+var RedisLock = class {
+  constructor(redis, lockKey, ttlMs, logger) {
+    this.redis = redis;
+    this.lockKey = lockKey;
+    this.ttlMs = ttlMs;
+    this.logger = logger;
+  }
+  lockValue = "";
+  async acquire() {
+    this.lockValue = crypto__default.default.randomUUID();
+    const result = await this.redis.set(this.lockKey, this.lockValue, "PX", this.ttlMs, "NX");
+    return result === "OK";
+  }
+  async release() {
+    try {
+      const script = "if redis.call('get',KEYS[1]) == ARGV[1] then return redis.call('del',KEYS[1]) else return 0 end";
+      await this.redis.eval(script, 1, this.lockKey, this.lockValue);
+    } catch (err) {
+      this.logger?.error("Failed to release lock", { error: err });
+    }
+  }
+};
+
+// src/services/rule-runner.service.ts
+var MS_PER_DAY = 864e5;
+var DEFAULT_LOCK_TTL_MS = 30 * 60 * 1e3;
+var IDENTIFIER_CHUNK_SIZE = 50;
+async function processInChunks(items, fn, chunkSize) {
+  const results = [];
+  for (let i = 0; i < items.length; i += chunkSize) {
+    const chunk = items.slice(i, i + chunkSize);
+    const chunkResults = await Promise.all(chunk.map(fn));
+    results.push(...chunkResults);
+  }
+  return results;
+}
+var defaultLogger = {
+  info: () => {
+  },
+  warn: () => {
+  },
+  error: () => {
+  }
+};
+var RuleRunnerService = class {
+  constructor(EmailRule, EmailTemplate, EmailRuleSend, EmailRuleRunLog, EmailThrottleConfig, config) {
+    this.EmailRule = EmailRule;
+    this.EmailTemplate = EmailTemplate;
+    this.EmailRuleSend = EmailRuleSend;
+    this.EmailRuleRunLog = EmailRuleRunLog;
+    this.EmailThrottleConfig = EmailThrottleConfig;
+    this.config = config;
+    const keyPrefix = config.redis.keyPrefix || "";
+    const lockTTL = config.options?.lockTTLMs || DEFAULT_LOCK_TTL_MS;
+    this.lock = new RedisLock(
+      config.redis.connection,
+      `${keyPrefix}email-rule-runner:lock`,
+      lockTTL,
+      config.logger
+    );
+    this.logger = config.logger || defaultLogger;
+  }
+  templateRenderer = new TemplateRenderService();
+  lock;
+  logger;
+  async runAllRules(triggeredBy = RUN_TRIGGER.Cron) {
+    if (this.config.options?.sendWindow) {
+      const { startHour, endHour, timezone } = this.config.options.sendWindow;
+      const now = /* @__PURE__ */ new Date();
+      const formatter = new Intl.DateTimeFormat("en-US", { hour: "numeric", hour12: false, timeZone: timezone });
+      const currentHour = parseInt(formatter.format(now), 10);
+      if (currentHour < startHour || currentHour >= endHour) {
+        this.logger.info("Outside send window, skipping run", { currentHour, startHour, endHour, timezone });
+        return;
+      }
+    }
+    const lockAcquired = await this.lock.acquire();
+    if (!lockAcquired) {
+      this.logger.warn("Rule runner already executing, skipping");
+      return;
+    }
+    const runStartTime = Date.now();
+    try {
+      const throttleConfig = await this.EmailThrottleConfig.getConfig();
+      const activeRules = await this.EmailRule.findActive();
+      this.config.hooks?.onRunStart?.({ rulesCount: activeRules.length, triggeredBy });
+      if (activeRules.length === 0) {
+        this.logger.info("No active rules to process");
+        await this.EmailRuleRunLog.create({
+          runAt: /* @__PURE__ */ new Date(),
+          triggeredBy,
+          duration: Date.now() - runStartTime,
+          rulesProcessed: 0,
+          totalStats: { matched: 0, sent: 0, skipped: 0, skippedByThrottle: 0, errors: 0 },
+          perRuleStats: []
+        });
+        return;
+      }
+      const templateIds = [...new Set(activeRules.map((r) => r.templateId.toString()))];
+      const templates = await this.EmailTemplate.find({ _id: { $in: templateIds } }).lean();
+      const templateMap = /* @__PURE__ */ new Map();
+      for (const t of templates) {
+        templateMap.set(t._id.toString(), t);
+      }
+      const recentSends = await this.EmailRuleSend.find({
+        sentAt: { $gte: new Date(Date.now() - 7 * MS_PER_DAY) }
+      }).lean();
+      const throttleMap = this.buildThrottleMap(recentSends);
+      const perRuleStats = [];
+      for (const rule of activeRules) {
+        const stats = await this.executeRule(rule, throttleMap, throttleConfig, templateMap);
+        perRuleStats.push({
+          ruleId: rule._id.toString(),
+          ruleName: rule.name,
+          ...stats
+        });
+      }
+      const totalStats = perRuleStats.reduce(
+        (acc, s) => ({
+          matched: acc.matched + s.matched,
+          sent: acc.sent + s.sent,
+          skipped: acc.skipped + s.skipped,
+          skippedByThrottle: acc.skippedByThrottle + s.skippedByThrottle,
+          errors: acc.errors + s.errors
+        }),
+        { matched: 0, sent: 0, skipped: 0, skippedByThrottle: 0, errors: 0 }
+      );
+      await this.EmailRuleRunLog.create({
+        runAt: /* @__PURE__ */ new Date(),
+        triggeredBy,
+        duration: Date.now() - runStartTime,
+        rulesProcessed: activeRules.length,
+        totalStats,
+        perRuleStats
+      });
+      this.config.hooks?.onRunComplete?.({ duration: Date.now() - runStartTime, totalStats, perRuleStats });
+      this.logger.info("Rule run completed", {
+        triggeredBy,
+        rulesProcessed: activeRules.length,
+        totalSent: totalStats.sent,
+        totalSkipped: totalStats.skipped,
+        duration: Date.now() - runStartTime
+      });
+    } finally {
+      await this.lock.release();
+    }
+  }
+  async executeRule(rule, throttleMap, throttleConfig, templateMap) {
+    const stats = { matched: 0, sent: 0, skipped: 0, skippedByThrottle: 0, errors: 0 };
+    const template = templateMap?.get(rule.templateId.toString()) ?? await this.EmailTemplate.findById(rule.templateId);
+    if (!template) {
+      this.logger.error(`Rule "${rule.name}": template ${rule.templateId} not found`);
+      stats.errors = 1;
+      return stats;
+    }
+    let users;
+    try {
+      users = await this.config.adapters.queryUsers(rule.target, rule.maxPerRun || this.config.options?.defaultMaxPerRun || 500);
+    } catch (err) {
+      this.logger.error(`Rule "${rule.name}": query failed`, { error: err });
+      stats.errors = 1;
+      return stats;
+    }
+    stats.matched = users.length;
+    this.config.hooks?.onRuleStart?.({ ruleId: rule._id.toString(), ruleName: rule.name, matchedCount: users.length });
+    if (users.length === 0) return stats;
+    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 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 compiled = this.templateRenderer.compileBatch(
+      template.subject,
+      template.body,
+      template.textBody
+    );
+    const ruleId = rule._id.toString();
+    const templateId = rule.templateId.toString();
+    for (let i = 0; i < users.length; i++) {
+      const user = users[i];
+      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" });
+          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" });
+            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" });
+              continue;
+            }
+          } else {
+            stats.skipped++;
+            this.config.hooks?.onSend?.({ ruleId, ruleName: rule.name, email, status: "skipped" });
+            continue;
+          }
+        }
+        const identifier = identifierMap.get(email.toLowerCase().trim());
+        if (!identifier) {
+          stats.skipped++;
+          this.config.hooks?.onSend?.({ ruleId, ruleName: rule.name, email, status: "invalid" });
+          continue;
+        }
+        if (!this.checkThrottle(rule, userId, email, throttleMap, throttleConfig, stats)) 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" });
+          continue;
+        }
+        const templateData = this.config.adapters.resolveData(user);
+        const rendered = this.templateRenderer.renderFromCompiled(compiled, templateData);
+        await this.config.adapters.sendEmail({
+          identifierId: identifier.id,
+          contactId: identifier.contactId,
+          accountId: agentSelection.accountId,
+          subject: rendered.subject,
+          htmlBody: rendered.html,
+          textBody: rendered.text,
+          ruleId,
+          autoApprove: rule.autoApprove ?? true
+        });
+        await this.EmailRuleSend.logSend(
+          ruleId,
+          userId,
+          identifier.id,
+          void 0,
+          { status: "sent", accountId: agentSelection.accountId, subject: rendered.subject }
+        );
+        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()
+        });
+        stats.sent++;
+        this.config.hooks?.onSend?.({ ruleId, ruleName: rule.name, email, status: "sent" });
+        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));
+          }
+        }
+      } catch (err) {
+        stats.errors++;
+        this.config.hooks?.onSend?.({ ruleId, ruleName: rule.name, email: user.email || "unknown", status: "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 });
+    return stats;
+  }
+  checkThrottle(rule, userId, email, throttleMap, config, stats) {
+    if (rule.emailType === EMAIL_TYPE.Transactional || rule.bypassThrottle) return true;
+    const userThrottle = throttleMap.get(userId) || { today: 0, thisWeek: 0, lastSentDate: null };
+    if (userThrottle.today >= config.maxPerUserPerDay) {
+      stats.skippedByThrottle++;
+      this.config.hooks?.onSend?.({ ruleId: rule._id.toString(), ruleName: rule.name, email, status: "throttled" });
+      return false;
+    }
+    if (userThrottle.thisWeek >= config.maxPerUserPerWeek) {
+      stats.skippedByThrottle++;
+      this.config.hooks?.onSend?.({ ruleId: rule._id.toString(), ruleName: rule.name, email, status: "throttled" });
+      return false;
+    }
+    if (userThrottle.lastSentDate) {
+      const daysSinceLastSend = (Date.now() - userThrottle.lastSentDate.getTime()) / MS_PER_DAY;
+      if (daysSinceLastSend < config.minGapDays) {
+        stats.skippedByThrottle++;
+        this.config.hooks?.onSend?.({ ruleId: rule._id.toString(), ruleName: rule.name, email, status: "throttled" });
+        return false;
+      }
+    }
+    return true;
+  }
+  getTodayStart() {
+    const timezone = this.config.options?.sendWindow?.timezone;
+    if (timezone) {
+      const now = /* @__PURE__ */ new Date();
+      const parts = new Intl.DateTimeFormat("en-US", {
+        timeZone: timezone,
+        year: "numeric",
+        month: "2-digit",
+        day: "2-digit",
+        hour: "2-digit",
+        minute: "2-digit",
+        second: "2-digit",
+        hour12: false
+      }).formatToParts(now);
+      const get = (type) => parts.find((p) => p.type === type)?.value || "0";
+      const tzNowMs = Date.UTC(
+        parseInt(get("year")),
+        parseInt(get("month")) - 1,
+        parseInt(get("day")),
+        parseInt(get("hour")),
+        parseInt(get("minute")),
+        parseInt(get("second"))
+      );
+      const tzMidnightMs = Date.UTC(
+        parseInt(get("year")),
+        parseInt(get("month")) - 1,
+        parseInt(get("day"))
+      );
+      const offsetMs = now.getTime() - tzNowMs;
+      return new Date(tzMidnightMs + offsetMs);
+    }
+    const todayStart = /* @__PURE__ */ new Date();
+    todayStart.setHours(0, 0, 0, 0);
+    return todayStart;
+  }
+  buildThrottleMap(recentSends) {
+    const map = /* @__PURE__ */ new Map();
+    const todayStart = this.getTodayStart();
+    for (const send of recentSends) {
+      const key = send.userId.toString();
+      const current = map.get(key) || { today: 0, thisWeek: 0, lastSentDate: null };
+      const sentAt = new Date(send.sentAt);
+      current.thisWeek++;
+      if (sentAt >= todayStart) {
+        current.today++;
+      }
+      if (!current.lastSentDate || sentAt > current.lastSentDate) {
+        current.lastSentDate = sentAt;
+      }
+      map.set(key, current);
+    }
+    return map;
+  }
+};
+
+// src/utils/express-helpers.ts
+function getParam(req, name) {
+  const val = req.params[name];
+  return Array.isArray(val) ? val[0] : val;
+}
+
+// src/controllers/template.controller.ts
+function isValidValue(allowed, value) {
+  return typeof value === "string" && allowed.includes(value);
+}
+function getErrorStatus(message) {
+  if (message.includes("already exists") || message.includes("validation failed")) return 400;
+  if (message.includes("not found")) return 404;
+  return 500;
+}
+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 });
+    }
+  }
+  async function getById(req, res) {
+    try {
+      const template = await templateService.getById(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 });
+    }
+  }
+  async function create(req, res) {
+    try {
+      const { name, subject, body, category, audience, platform } = req.body;
+      if (!name || !subject || !body || !category || !audience || !platform) {
+        return res.status(400).json({ success: false, error: "name, subject, body, 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 });
+    }
+  }
+  async function update(req, res) {
+    try {
+      const template = await templateService.update(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 });
+    }
+  }
+  async function remove(req, res) {
+    try {
+      const deleted = await templateService.delete(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 });
+    }
+  }
+  async function toggleActive(req, res) {
+    try {
+      const template = await templateService.toggleActive(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 });
+    }
+  }
+  async function preview(req, res) {
+    try {
+      const { sampleData } = req.body;
+      const result = await templateService.preview(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 });
+    }
+  }
+  async function previewRaw(req, res) {
+    try {
+      const { subject, body, textBody, sampleData } = 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 || {}, 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 });
+    }
+  }
+  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 });
+    }
+  }
+  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(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 });
+    }
+  }
+  return { list, getById, create, update, remove, toggleActive, preview, previewRaw, validate, sendTestEmail };
+}
+
+// src/controllers/rule.controller.ts
+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 });
+    }
+  }
+  async function getById(req, res) {
+    try {
+      const rule = await ruleService.getById(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 });
+    }
+  }
+  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" });
+      }
+      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 (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 && !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?.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(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(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(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 });
+    }
+  }
+  async function dryRun(req, res) {
+    try {
+      const result = await ruleService.dryRun(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 });
+    }
+  }
+  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 });
+    }
+  }
+  return { list, getById, create, update, remove, toggleActive, dryRun, runHistory };
+}
+
+// src/controllers/runner.controller.ts
+var defaultLogger2 = {
+  info: () => {
+  },
+  warn: () => {
+  },
+  error: () => {
+  }
+};
+function createRunnerController(runnerService, EmailRuleRunLog, logger) {
+  const log = logger || defaultLogger2;
+  async function triggerManualRun(_req, res) {
+    runnerService.runAllRules(RUN_TRIGGER.Manual).catch((err) => {
+      log.error("Manual rule run failed", { error: err });
+    });
+    res.json({ success: true, data: { message: "Rule run triggered" } });
+  }
+  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 });
+    }
+  }
+  return { triggerManualRun, getLatestRun };
+}
+
+// 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;
+      }
+      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 } });
+    } catch (error) {
+      const message = error instanceof Error ? error.message : "Unknown error";
+      res.status(500).json({ success: false, error: message });
+    }
+  }
+  return { getThrottleConfig, updateThrottleConfig };
+}
+
+// src/routes/index.ts
+function createRoutes(deps) {
+  const router = express.Router();
+  const templateCtrl = createTemplateController(deps.templateService, {
+    platforms: deps.platformValues,
+    categories: deps.categoryValues,
+    audiences: deps.audienceValues
+  });
+  const ruleCtrl = createRuleController(deps.ruleService, {
+    platforms: deps.platformValues,
+    audiences: deps.audienceValues
+  });
+  const runnerCtrl = createRunnerController(deps.runnerService, deps.EmailRuleRunLog, deps.logger);
+  const settingsCtrl = createSettingsController(deps.EmailThrottleConfig);
+  const templateRouter = express.Router();
+  templateRouter.get("/", templateCtrl.list);
+  templateRouter.post("/", templateCtrl.create);
+  templateRouter.post("/validate", templateCtrl.validate);
+  templateRouter.post("/preview", templateCtrl.previewRaw);
+  templateRouter.get("/:id", templateCtrl.getById);
+  templateRouter.put("/:id", templateCtrl.update);
+  templateRouter.delete("/:id", templateCtrl.remove);
+  templateRouter.patch("/:id/toggle", templateCtrl.toggleActive);
+  templateRouter.post("/:id/preview", templateCtrl.preview);
+  templateRouter.post("/:id/test-email", templateCtrl.sendTestEmail);
+  const ruleRouter = express.Router();
+  ruleRouter.get("/", ruleCtrl.list);
+  ruleRouter.post("/", ruleCtrl.create);
+  ruleRouter.get("/run-history", ruleCtrl.runHistory);
+  ruleRouter.get("/:id", ruleCtrl.getById);
+  ruleRouter.patch("/:id", ruleCtrl.update);
+  ruleRouter.delete("/:id", ruleCtrl.remove);
+  ruleRouter.patch("/:id/toggle", ruleCtrl.toggleActive);
+  ruleRouter.post("/:id/dry-run", ruleCtrl.dryRun);
+  const runnerRouter = express.Router();
+  runnerRouter.post("/", runnerCtrl.triggerManualRun);
+  runnerRouter.get("/status", runnerCtrl.getLatestRun);
+  const settingsRouter = express.Router();
+  settingsRouter.get("/throttle", settingsCtrl.getThrottleConfig);
+  settingsRouter.patch("/throttle", settingsCtrl.updateThrottleConfig);
+  router.use("/templates", templateRouter);
+  router.use("/rules", ruleRouter);
+  router.use("/runner", runnerRouter);
+  router.use("/settings", settingsRouter);
+  return router;
+}
+var configSchema = zod.z.object({
+  db: core.baseDbSchema,
+  redis: core.baseRedisSchema,
+  adapters: zod.z.object({
+    queryUsers: zod.z.function(),
+    resolveData: zod.z.function(),
+    sendEmail: zod.z.function(),
+    selectAgent: zod.z.function(),
+    findIdentifier: zod.z.function(),
+    sendTestEmail: zod.z.function().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(),
+  logger: core.loggerSchema.optional(),
+  options: zod.z.object({
+    lockTTLMs: zod.z.number().positive().optional(),
+    defaultMaxPerRun: zod.z.number().positive().optional(),
+    sendWindow: zod.z.object({
+      startHour: zod.z.number().min(0).max(23),
+      endHour: zod.z.number().min(0).max(23),
+      timezone: zod.z.string()
+    }).optional(),
+    delayBetweenSendsMs: zod.z.number().min(0).optional(),
+    jitterMs: zod.z.number().min(0).optional()
+  }).optional(),
+  hooks: zod.z.object({
+    onRunStart: zod.z.function().optional(),
+    onRuleStart: zod.z.function().optional(),
+    onSend: zod.z.function().optional(),
+    onRuleComplete: zod.z.function().optional(),
+    onRunComplete: zod.z.function().optional()
+  }).optional()
+});
+function validateConfig(raw) {
+  const result = configSchema.safeParse(raw);
+  if (!result.success) {
+    const issues = result.error.issues.map((i) => `  ${i.path.join(".")}: ${i.message}`).join("\n");
+    throw new ConfigValidationError(
+      `Invalid EmailRuleEngineConfig:
+${issues}`,
+      result.error.issues[0]?.path.join(".") ?? ""
+    );
+  }
+}
+
+// src/index.ts
+function createEmailRuleEngine(config) {
+  validateConfig(config);
+  const conn = config.db.connection;
+  const prefix = config.db.collectionPrefix || "";
+  const EmailTemplate = conn.model(
+    `${prefix}EmailTemplate`,
+    createEmailTemplateSchema(config.platforms, config.audiences, config.categories, prefix)
+  );
+  const EmailRule = conn.model(
+    `${prefix}EmailRule`,
+    createEmailRuleSchema(config.platforms, config.audiences, prefix)
+  );
+  const EmailRuleSend = conn.model(
+    `${prefix}EmailRuleSend`,
+    createEmailRuleSendSchema(prefix)
+  );
+  const EmailRuleRunLog = conn.model(
+    `${prefix}EmailRuleRunLog`,
+    createEmailRuleRunLogSchema(prefix)
+  );
+  const EmailThrottleConfig = conn.model(
+    `${prefix}EmailThrottleConfig`,
+    createEmailThrottleConfigSchema(prefix)
+  );
+  const templateService = new TemplateService(EmailTemplate, config);
+  const ruleService = new RuleService(EmailRule, EmailTemplate, EmailRuleRunLog, config);
+  const runnerService = new RuleRunnerService(
+    EmailRule,
+    EmailTemplate,
+    EmailRuleSend,
+    EmailRuleRunLog,
+    EmailThrottleConfig,
+    config
+  );
+  const routes = createRoutes({
+    templateService,
+    ruleService,
+    runnerService,
+    EmailRuleRunLog,
+    EmailThrottleConfig,
+    platformValues: config.platforms,
+    categoryValues: config.categories,
+    audienceValues: config.audiences,
+    logger: config.logger
+  });
+  return {
+    routes,
+    runner: runnerService,
+    templateService,
+    ruleService,
+    models: { EmailTemplate, EmailRule, EmailRuleSend, EmailRuleRunLog, EmailThrottleConfig }
+  };
+}
+
+exports.AlxEmailError = AlxEmailError;
+exports.ConfigValidationError = ConfigValidationError;
+exports.DuplicateSlugError = DuplicateSlugError;
+exports.EMAIL_SEND_STATUS = EMAIL_SEND_STATUS;
+exports.EMAIL_TYPE = EMAIL_TYPE;
+exports.LockAcquisitionError = LockAcquisitionError;
+exports.RULE_OPERATOR = RULE_OPERATOR;
+exports.RUN_TRIGGER = RUN_TRIGGER;
+exports.RedisLock = RedisLock;
+exports.RuleNotFoundError = RuleNotFoundError;
+exports.RuleRunnerService = RuleRunnerService;
+exports.RuleService = RuleService;
+exports.RuleTemplateIncompatibleError = RuleTemplateIncompatibleError;
+exports.TEMPLATE_AUDIENCE = TEMPLATE_AUDIENCE;
+exports.TEMPLATE_CATEGORY = TEMPLATE_CATEGORY;
+exports.THROTTLE_WINDOW = THROTTLE_WINDOW;
+exports.TemplateNotFoundError = TemplateNotFoundError;
+exports.TemplateRenderService = TemplateRenderService;
+exports.TemplateService = TemplateService;
+exports.TemplateSyntaxError = TemplateSyntaxError;
+exports.createEmailRuleEngine = createEmailRuleEngine;
+exports.createEmailRuleRunLogSchema = createEmailRuleRunLogSchema;
+exports.createEmailRuleSchema = createEmailRuleSchema;
+exports.createEmailRuleSendSchema = createEmailRuleSendSchema;
+exports.createEmailTemplateSchema = createEmailTemplateSchema;
+exports.createEmailThrottleConfigSchema = createEmailThrottleConfigSchema;
+exports.validateConfig = validateConfig;
+//# sourceMappingURL=index.js.map
 //# sourceMappingURL=index.js.map