@astralibx/email-analytics 2.0.0

package/dist/index.mjs

@@ -0,0 +1,927 @@
+import { z } from 'zod';
+import { baseDbSchema, loggerSchema, AlxError, ConfigValidationError } from '@astralibx/core';
+export { ConfigValidationError } from '@astralibx/core';
+import { Schema, Types } from 'mongoose';
+import { Router } from 'express';
+
+// src/validation/config.schema.ts
+var AlxAnalyticsError = class extends AlxError {
+  constructor(message, code) {
+    super(message, code);
+    this.code = code;
+    this.name = "AlxAnalyticsError";
+  }
+};
+var InvalidDateRangeError = class extends AlxAnalyticsError {
+  constructor(startDate, endDate) {
+    super(
+      `Invalid date range: ${startDate} to ${endDate}`,
+      "INVALID_DATE_RANGE"
+    );
+    this.startDate = startDate;
+    this.endDate = endDate;
+    this.name = "InvalidDateRangeError";
+  }
+};
+var AggregationError = class extends AlxAnalyticsError {
+  constructor(pipeline, originalError) {
+    super(
+      `Aggregation pipeline failed (${pipeline}): ${originalError.message}`,
+      "AGGREGATION_FAILED"
+    );
+    this.pipeline = pipeline;
+    this.originalError = originalError;
+    this.name = "AggregationError";
+  }
+};
+
+// src/validation/config.schema.ts
+var configSchema = z.object({
+  db: baseDbSchema,
+  logger: loggerSchema.optional(),
+  options: z.object({
+    eventTTLDays: z.number().int().positive().optional(),
+    timezone: z.string().optional(),
+    aggregationSchedule: z.array(
+      z.enum(["daily", "weekly", "monthly"])
+    ).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 EmailAnalyticsConfig:
+${issues}`,
+      result.error.issues[0]?.path.join(".") ?? ""
+    );
+  }
+}
+
+// src/constants/index.ts
+var EVENT_TYPE = {
+  Sent: "sent",
+  Delivered: "delivered",
+  Bounced: "bounced",
+  Complained: "complained",
+  Opened: "opened",
+  Clicked: "clicked",
+  Unsubscribed: "unsubscribed",
+  Failed: "failed"
+};
+var AGGREGATION_INTERVAL = {
+  Daily: "daily",
+  Weekly: "weekly",
+  Monthly: "monthly"
+};
+var STATS_GROUP_BY = {
+  Account: "account",
+  Rule: "rule",
+  Template: "template"
+};
+
+// src/schemas/email-event.schema.ts
+function createEmailEventSchema(options) {
+  const eventTypeValues = Object.values(EVENT_TYPE);
+  const schema = new Schema(
+    {
+      type: { type: String, required: true, enum: eventTypeValues, index: true },
+      accountId: { type: Schema.Types.ObjectId, required: true, index: true },
+      ruleId: { type: Schema.Types.ObjectId, index: true },
+      templateId: { type: Schema.Types.ObjectId, index: true },
+      recipientEmail: { type: String, required: true },
+      identifierId: { type: Schema.Types.ObjectId },
+      metadata: { type: Schema.Types.Mixed },
+      timestamp: { type: Date, required: true, default: () => /* @__PURE__ */ new Date() }
+    },
+    {
+      timestamps: true,
+      collection: options?.collectionName || "email_events",
+      statics: {
+        record(event) {
+          return this.create({
+            type: event.type,
+            accountId: new Types.ObjectId(event.accountId),
+            ruleId: event.ruleId ? new Types.ObjectId(event.ruleId) : void 0,
+            templateId: event.templateId ? new Types.ObjectId(event.templateId) : void 0,
+            recipientEmail: event.recipientEmail,
+            identifierId: event.identifierId ? new Types.ObjectId(event.identifierId) : void 0,
+            metadata: event.metadata,
+            timestamp: event.timestamp || /* @__PURE__ */ new Date()
+          });
+        },
+        findByDateRange(start, end, filters) {
+          const query = {
+            timestamp: { $gte: start, $lte: end }
+          };
+          if (filters?.type) query.type = filters.type;
+          if (filters?.accountId) query.accountId = new Types.ObjectId(filters.accountId);
+          if (filters?.ruleId) query.ruleId = new Types.ObjectId(filters.ruleId);
+          if (filters?.templateId) query.templateId = new Types.ObjectId(filters.templateId);
+          return this.find(query).sort({ timestamp: -1 });
+        }
+      }
+    }
+  );
+  const ttlDays = options?.eventTTLDays ?? 90;
+  schema.index({ timestamp: 1 }, { expireAfterSeconds: ttlDays * 24 * 60 * 60 });
+  schema.index({ type: 1, timestamp: -1 });
+  schema.index({ accountId: 1, timestamp: -1 });
+  schema.index({ ruleId: 1, timestamp: -1 });
+  return schema;
+}
+function createAnalyticsStatsSchema(options) {
+  const intervalValues = Object.values(AGGREGATION_INTERVAL);
+  const schema = new Schema(
+    {
+      date: { type: String, required: true, index: true },
+      interval: { type: String, required: true, enum: intervalValues },
+      accountId: { type: Schema.Types.ObjectId, default: null },
+      ruleId: { type: Schema.Types.ObjectId, default: null },
+      templateId: { type: Schema.Types.ObjectId, default: null },
+      sent: { type: Number, default: 0 },
+      delivered: { type: Number, default: 0 },
+      bounced: { type: Number, default: 0 },
+      complained: { type: Number, default: 0 },
+      opened: { type: Number, default: 0 },
+      clicked: { type: Number, default: 0 },
+      unsubscribed: { type: Number, default: 0 },
+      failed: { type: Number, default: 0 }
+    },
+    {
+      timestamps: true,
+      collection: options?.collectionName || "analytics_stats",
+      statics: {
+        upsertStats(date, interval, dimensions, increments) {
+          const filter = { date, interval };
+          filter.accountId = dimensions.accountId ? new Types.ObjectId(dimensions.accountId) : null;
+          filter.ruleId = dimensions.ruleId ? new Types.ObjectId(dimensions.ruleId) : null;
+          filter.templateId = dimensions.templateId ? new Types.ObjectId(dimensions.templateId) : null;
+          const $inc = {};
+          for (const [key, value] of Object.entries(increments)) {
+            if (value) $inc[key] = value;
+          }
+          return this.findOneAndUpdate(
+            filter,
+            { $inc },
+            { upsert: true, new: true }
+          );
+        }
+      }
+    }
+  );
+  schema.index({ date: 1, interval: 1, accountId: 1, ruleId: 1, templateId: 1 }, { unique: true });
+  schema.index({ date: 1, interval: 1 });
+  return schema;
+}
+
+// src/services/event-recorder.ts
+var EventRecorderService = class {
+  constructor(EmailEvent, logger) {
+    this.EmailEvent = EmailEvent;
+    this.logger = logger;
+  }
+  async record(event) {
+    await this.EmailEvent.record(event);
+    this.logger.info("Event recorded", { type: event.type, accountId: event.accountId });
+  }
+  async recordBatch(events) {
+    if (events.length === 0) return;
+    const docs = events.map((e) => ({
+      ...e,
+      timestamp: e.timestamp || /* @__PURE__ */ new Date()
+    }));
+    await this.EmailEvent.insertMany(docs, { ordered: false });
+    this.logger.info("Batch events recorded", { count: events.length });
+  }
+  async getEvents(filters, page = 1, limit = 50) {
+    const query = {
+      timestamp: { $gte: filters.dateFrom, $lte: filters.dateTo }
+    };
+    if (filters.type) query.type = filters.type;
+    if (filters.accountId) query.accountId = filters.accountId;
+    if (filters.ruleId) query.ruleId = filters.ruleId;
+    if (filters.recipientEmail) query.recipientEmail = filters.recipientEmail;
+    const skip = (page - 1) * limit;
+    const [events, total] = await Promise.all([
+      this.EmailEvent.find(query).sort({ timestamp: -1 }).skip(skip).limit(limit).lean(),
+      this.EmailEvent.countDocuments(query)
+    ]);
+    return { events, total };
+  }
+  async purgeOldEvents(olderThanDays) {
+    const cutoff = /* @__PURE__ */ new Date();
+    cutoff.setDate(cutoff.getDate() - olderThanDays);
+    const result = await this.EmailEvent.deleteMany({
+      timestamp: { $lt: cutoff }
+    });
+    const count = result.deletedCount || 0;
+    this.logger.info("Purged old events", { olderThanDays, deleted: count });
+    return count;
+  }
+};
+
+// src/services/aggregator.ts
+var METRIC_CONDS = {
+  sent: { $cond: [{ $eq: ["$type", EVENT_TYPE.Sent] }, 1, 0] },
+  failed: { $cond: [{ $eq: ["$type", EVENT_TYPE.Failed] }, 1, 0] },
+  delivered: { $cond: [{ $eq: ["$type", EVENT_TYPE.Delivered] }, 1, 0] },
+  bounced: { $cond: [{ $eq: ["$type", EVENT_TYPE.Bounced] }, 1, 0] },
+  complained: { $cond: [{ $eq: ["$type", EVENT_TYPE.Complained] }, 1, 0] },
+  opened: { $cond: [{ $eq: ["$type", EVENT_TYPE.Opened] }, 1, 0] },
+  clicked: { $cond: [{ $eq: ["$type", EVENT_TYPE.Clicked] }, 1, 0] },
+  unsubscribed: { $cond: [{ $eq: ["$type", EVENT_TYPE.Unsubscribed] }, 1, 0] }
+};
+function buildSumGroup() {
+  return {
+    sent: { $sum: METRIC_CONDS.sent },
+    failed: { $sum: METRIC_CONDS.failed },
+    delivered: { $sum: METRIC_CONDS.delivered },
+    bounced: { $sum: METRIC_CONDS.bounced },
+    complained: { $sum: METRIC_CONDS.complained },
+    opened: { $sum: METRIC_CONDS.opened },
+    clicked: { $sum: METRIC_CONDS.clicked },
+    unsubscribed: { $sum: METRIC_CONDS.unsubscribed }
+  };
+}
+var AggregatorService = class {
+  constructor(EmailEvent, AnalyticsStats, timezone, logger) {
+    this.EmailEvent = EmailEvent;
+    this.AnalyticsStats = AnalyticsStats;
+    this.timezone = timezone;
+    this.logger = logger;
+  }
+  async aggregateDaily(date) {
+    const targetDate = date || /* @__PURE__ */ new Date();
+    const dayStart = this.getDayStart(targetDate);
+    const dayEnd = this.getDayEnd(targetDate);
+    const dateKey = this.toDateKey(dayStart);
+    this.logger.info("Running daily aggregation", { date: dateKey });
+    await this.aggregateByAccount(dayStart, dayEnd, dateKey);
+    await this.aggregateByRule(dayStart, dayEnd, dateKey);
+    await this.aggregateByTemplate(dayStart, dayEnd, dateKey);
+    await this.aggregateOverall(dayStart, dayEnd, dateKey);
+    this.logger.info("Daily aggregation complete", { date: dateKey });
+  }
+  async aggregateRange(from, to) {
+    if (!(from instanceof Date) || isNaN(from.getTime())) {
+      throw new InvalidDateRangeError(String(from), String(to));
+    }
+    if (!(to instanceof Date) || isNaN(to.getTime())) {
+      throw new InvalidDateRangeError(String(from), String(to));
+    }
+    if (from > to) {
+      throw new InvalidDateRangeError(from.toISOString(), to.toISOString());
+    }
+    const current = this.getDayStart(from);
+    const end = this.getDayStart(to);
+    this.logger.info("Running range aggregation", {
+      from: this.toDateKey(current),
+      to: this.toDateKey(end)
+    });
+    while (current <= end) {
+      await this.aggregateDaily(new Date(current));
+      current.setDate(current.getDate() + 1);
+    }
+    this.logger.info("Range aggregation complete");
+  }
+  async aggregateByAccount(dayStart, dayEnd, dateKey) {
+    let results;
+    try {
+      results = await this.EmailEvent.aggregate([
+        { $match: { timestamp: { $gte: dayStart, $lt: dayEnd } } },
+        { $group: { _id: "$accountId", ...buildSumGroup() } }
+      ]);
+    } catch (error) {
+      throw new AggregationError("byAccount", error instanceof Error ? error : new Error(String(error)));
+    }
+    const bulkOps = results.map((r) => ({
+      updateOne: {
+        filter: { date: dateKey, interval: AGGREGATION_INTERVAL.Daily, accountId: r._id, ruleId: null, templateId: null },
+        update: {
+          $set: {
+            date: dateKey,
+            interval: AGGREGATION_INTERVAL.Daily,
+            accountId: r._id,
+            ruleId: null,
+            templateId: null,
+            sent: r.sent,
+            failed: r.failed,
+            delivered: r.delivered,
+            bounced: r.bounced,
+            complained: r.complained,
+            opened: r.opened,
+            clicked: r.clicked,
+            unsubscribed: r.unsubscribed,
+            updatedAt: /* @__PURE__ */ new Date()
+          }
+        },
+        upsert: true
+      }
+    }));
+    if (bulkOps.length > 0) {
+      await this.AnalyticsStats.bulkWrite(bulkOps);
+    }
+  }
+  async aggregateByRule(dayStart, dayEnd, dateKey) {
+    let results;
+    try {
+      results = await this.EmailEvent.aggregate([
+        { $match: { timestamp: { $gte: dayStart, $lt: dayEnd }, ruleId: { $exists: true, $ne: null } } },
+        { $group: { _id: "$ruleId", ...buildSumGroup() } }
+      ]);
+    } catch (error) {
+      throw new AggregationError("byRule", error instanceof Error ? error : new Error(String(error)));
+    }
+    const bulkOps = results.map((r) => ({
+      updateOne: {
+        filter: { date: dateKey, interval: AGGREGATION_INTERVAL.Daily, ruleId: r._id, accountId: null, templateId: null },
+        update: {
+          $set: {
+            date: dateKey,
+            interval: AGGREGATION_INTERVAL.Daily,
+            ruleId: r._id,
+            accountId: null,
+            templateId: null,
+            sent: r.sent,
+            failed: r.failed,
+            delivered: r.delivered,
+            bounced: r.bounced,
+            complained: r.complained,
+            opened: r.opened,
+            clicked: r.clicked,
+            unsubscribed: r.unsubscribed,
+            updatedAt: /* @__PURE__ */ new Date()
+          }
+        },
+        upsert: true
+      }
+    }));
+    if (bulkOps.length > 0) {
+      await this.AnalyticsStats.bulkWrite(bulkOps);
+    }
+  }
+  async aggregateByTemplate(dayStart, dayEnd, dateKey) {
+    let results;
+    try {
+      results = await this.EmailEvent.aggregate([
+        { $match: { timestamp: { $gte: dayStart, $lt: dayEnd }, templateId: { $exists: true, $ne: null } } },
+        { $group: { _id: "$templateId", ...buildSumGroup() } }
+      ]);
+    } catch (error) {
+      throw new AggregationError("byTemplate", error instanceof Error ? error : new Error(String(error)));
+    }
+    const bulkOps = results.map((r) => ({
+      updateOne: {
+        filter: { date: dateKey, interval: AGGREGATION_INTERVAL.Daily, templateId: r._id, accountId: null, ruleId: null },
+        update: {
+          $set: {
+            date: dateKey,
+            interval: AGGREGATION_INTERVAL.Daily,
+            templateId: r._id,
+            accountId: null,
+            ruleId: null,
+            sent: r.sent,
+            failed: r.failed,
+            delivered: r.delivered,
+            bounced: r.bounced,
+            complained: r.complained,
+            opened: r.opened,
+            clicked: r.clicked,
+            unsubscribed: r.unsubscribed,
+            updatedAt: /* @__PURE__ */ new Date()
+          }
+        },
+        upsert: true
+      }
+    }));
+    if (bulkOps.length > 0) {
+      await this.AnalyticsStats.bulkWrite(bulkOps);
+    }
+  }
+  async aggregateOverall(dayStart, dayEnd, dateKey) {
+    let results;
+    try {
+      results = await this.EmailEvent.aggregate([
+        { $match: { timestamp: { $gte: dayStart, $lt: dayEnd } } },
+        { $group: { _id: null, ...buildSumGroup() } }
+      ]);
+    } catch (error) {
+      throw new AggregationError("overall", error instanceof Error ? error : new Error(String(error)));
+    }
+    if (results.length > 0) {
+      const r = results[0];
+      await this.AnalyticsStats.updateOne(
+        { date: dateKey, interval: AGGREGATION_INTERVAL.Daily, accountId: null, ruleId: null, templateId: null },
+        {
+          $set: {
+            date: dateKey,
+            interval: AGGREGATION_INTERVAL.Daily,
+            accountId: null,
+            ruleId: null,
+            templateId: null,
+            sent: r.sent,
+            failed: r.failed,
+            delivered: r.delivered,
+            bounced: r.bounced,
+            complained: r.complained,
+            opened: r.opened,
+            clicked: r.clicked,
+            unsubscribed: r.unsubscribed,
+            updatedAt: /* @__PURE__ */ new Date()
+          }
+        },
+        { upsert: true }
+      );
+    }
+  }
+  getDayStart(date) {
+    const formatter = new Intl.DateTimeFormat("en-CA", {
+      timeZone: this.timezone,
+      year: "numeric",
+      month: "2-digit",
+      day: "2-digit"
+    });
+    const parts = formatter.formatToParts(date);
+    const year = parseInt(parts.find((p) => p.type === "year").value, 10);
+    const month = parseInt(parts.find((p) => p.type === "month").value, 10) - 1;
+    const day = parseInt(parts.find((p) => p.type === "day").value, 10);
+    const localMidnight = new Date(Date.UTC(year, month, day));
+    const offsetMs = this.getTimezoneOffsetMs(localMidnight);
+    return new Date(localMidnight.getTime() - offsetMs);
+  }
+  getDayEnd(date) {
+    const dayStart = this.getDayStart(date);
+    return new Date(dayStart.getTime() + 24 * 60 * 60 * 1e3);
+  }
+  getTimezoneOffsetMs(utcDate) {
+    const utcStr = utcDate.toLocaleString("en-US", { timeZone: "UTC" });
+    const tzStr = utcDate.toLocaleString("en-US", { timeZone: this.timezone });
+    return new Date(tzStr).getTime() - new Date(utcStr).getTime();
+  }
+  toDateKey(date) {
+    const formatter = new Intl.DateTimeFormat("en-CA", {
+      timeZone: this.timezone,
+      year: "numeric",
+      month: "2-digit",
+      day: "2-digit"
+    });
+    return formatter.format(date);
+  }
+};
+
+// src/services/query.service.ts
+var QueryService = class {
+  constructor(AnalyticsStats, logger) {
+    this.AnalyticsStats = AnalyticsStats;
+    this.logger = logger;
+  }
+  async getOverview(dateFrom, dateTo) {
+    const fromKey = this.toDateKey(dateFrom);
+    const toKey = this.toDateKey(dateTo);
+    const pipeline = [
+      {
+        $match: {
+          interval: "daily",
+          date: { $gte: fromKey, $lte: toKey },
+          accountId: null,
+          ruleId: null,
+          templateId: null
+        }
+      },
+      {
+        $group: {
+          _id: null,
+          sent: { $sum: "$sent" },
+          failed: { $sum: "$failed" },
+          delivered: { $sum: "$delivered" },
+          bounced: { $sum: "$bounced" },
+          complained: { $sum: "$complained" },
+          opened: { $sum: "$opened" },
+          clicked: { $sum: "$clicked" },
+          unsubscribed: { $sum: "$unsubscribed" }
+        }
+      }
+    ];
+    const results = await this.AnalyticsStats.aggregate(pipeline);
+    const empty = {
+      startDate: fromKey,
+      endDate: toKey,
+      sent: 0,
+      failed: 0,
+      delivered: 0,
+      bounced: 0,
+      complained: 0,
+      opened: 0,
+      clicked: 0,
+      unsubscribed: 0
+    };
+    if (results.length === 0) return empty;
+    const r = results[0];
+    return {
+      startDate: fromKey,
+      endDate: toKey,
+      sent: r.sent,
+      failed: r.failed,
+      delivered: r.delivered,
+      bounced: r.bounced,
+      complained: r.complained,
+      opened: r.opened,
+      clicked: r.clicked,
+      unsubscribed: r.unsubscribed
+    };
+  }
+  async getTimeline(dateFrom, dateTo, interval = "daily") {
+    const fromKey = this.toDateKey(dateFrom);
+    const toKey = this.toDateKey(dateTo);
+    const groupId = this.buildTimeGroupId(interval);
+    const pipeline = [
+      {
+        $match: {
+          interval: "daily",
+          date: { $gte: fromKey, $lte: toKey },
+          accountId: null,
+          ruleId: null,
+          templateId: null
+        }
+      },
+      {
+        $group: {
+          _id: groupId,
+          sent: { $sum: "$sent" },
+          failed: { $sum: "$failed" },
+          delivered: { $sum: "$delivered" },
+          bounced: { $sum: "$bounced" },
+          complained: { $sum: "$complained" },
+          opened: { $sum: "$opened" },
+          clicked: { $sum: "$clicked" },
+          unsubscribed: { $sum: "$unsubscribed" }
+        }
+      },
+      { $sort: { _id: 1 } }
+    ];
+    const results = await this.AnalyticsStats.aggregate(pipeline);
+    return results.map((r) => ({
+      date: r._id,
+      interval,
+      sent: r.sent,
+      failed: r.failed,
+      delivered: r.delivered,
+      bounced: r.bounced,
+      complained: r.complained,
+      opened: r.opened,
+      clicked: r.clicked,
+      unsubscribed: r.unsubscribed
+    }));
+  }
+  async getAccountStats(dateFrom, dateTo) {
+    const fromKey = this.toDateKey(dateFrom);
+    const toKey = this.toDateKey(dateTo);
+    const results = await this.AnalyticsStats.aggregate([
+      {
+        $match: {
+          interval: "daily",
+          date: { $gte: fromKey, $lte: toKey },
+          accountId: { $ne: null },
+          ruleId: null,
+          templateId: null
+        }
+      },
+      {
+        $group: {
+          _id: "$accountId",
+          sent: { $sum: "$sent" },
+          failed: { $sum: "$failed" },
+          delivered: { $sum: "$delivered" },
+          bounced: { $sum: "$bounced" },
+          complained: { $sum: "$complained" },
+          opened: { $sum: "$opened" },
+          clicked: { $sum: "$clicked" },
+          unsubscribed: { $sum: "$unsubscribed" }
+        }
+      },
+      { $sort: { sent: -1 } }
+    ]);
+    return results.map((r) => ({
+      accountId: r._id.toString(),
+      sent: r.sent,
+      failed: r.failed,
+      delivered: r.delivered,
+      bounced: r.bounced,
+      complained: r.complained,
+      opened: r.opened,
+      clicked: r.clicked,
+      unsubscribed: r.unsubscribed
+    }));
+  }
+  async getRuleStats(dateFrom, dateTo) {
+    const fromKey = this.toDateKey(dateFrom);
+    const toKey = this.toDateKey(dateTo);
+    const results = await this.AnalyticsStats.aggregate([
+      {
+        $match: {
+          interval: "daily",
+          date: { $gte: fromKey, $lte: toKey },
+          ruleId: { $ne: null },
+          accountId: null,
+          templateId: null
+        }
+      },
+      {
+        $group: {
+          _id: "$ruleId",
+          sent: { $sum: "$sent" },
+          failed: { $sum: "$failed" },
+          delivered: { $sum: "$delivered" },
+          bounced: { $sum: "$bounced" },
+          complained: { $sum: "$complained" },
+          opened: { $sum: "$opened" },
+          clicked: { $sum: "$clicked" },
+          unsubscribed: { $sum: "$unsubscribed" }
+        }
+      },
+      { $sort: { sent: -1 } }
+    ]);
+    return results.map((r) => ({
+      ruleId: r._id.toString(),
+      sent: r.sent,
+      failed: r.failed,
+      delivered: r.delivered,
+      bounced: r.bounced,
+      complained: r.complained,
+      opened: r.opened,
+      clicked: r.clicked,
+      unsubscribed: r.unsubscribed
+    }));
+  }
+  async getTemplateStats(dateFrom, dateTo) {
+    const fromKey = this.toDateKey(dateFrom);
+    const toKey = this.toDateKey(dateTo);
+    const results = await this.AnalyticsStats.aggregate([
+      {
+        $match: {
+          interval: "daily",
+          date: { $gte: fromKey, $lte: toKey },
+          templateId: { $ne: null },
+          accountId: null,
+          ruleId: null
+        }
+      },
+      {
+        $group: {
+          _id: "$templateId",
+          sent: { $sum: "$sent" },
+          failed: { $sum: "$failed" },
+          delivered: { $sum: "$delivered" },
+          bounced: { $sum: "$bounced" },
+          complained: { $sum: "$complained" },
+          opened: { $sum: "$opened" },
+          clicked: { $sum: "$clicked" },
+          unsubscribed: { $sum: "$unsubscribed" }
+        }
+      },
+      { $sort: { sent: -1 } }
+    ]);
+    return results.map((r) => ({
+      templateId: r._id.toString(),
+      sent: r.sent,
+      failed: r.failed,
+      delivered: r.delivered,
+      bounced: r.bounced,
+      complained: r.complained,
+      opened: r.opened,
+      clicked: r.clicked,
+      unsubscribed: r.unsubscribed
+    }));
+  }
+  buildTimeGroupId(interval) {
+    switch (interval) {
+      case "weekly": {
+        const dateExpr = { $dateFromString: { dateString: "$date" } };
+        return {
+          $concat: [
+            { $substr: ["$date", 0, 4] },
+            "-W",
+            {
+              $cond: [
+                { $lt: [{ $isoWeek: dateExpr }, 10] },
+                { $concat: ["0", { $toString: { $isoWeek: dateExpr } }] },
+                { $toString: { $isoWeek: dateExpr } }
+              ]
+            }
+          ]
+        };
+      }
+      case "monthly":
+        return { $substr: ["$date", 0, 7] };
+      case "daily":
+      default:
+        return "$date";
+    }
+  }
+  toDateKey(date) {
+    return date.toISOString().slice(0, 10);
+  }
+};
+
+// src/controllers/analytics.controller.ts
+var MAX_AGGREGATION_RANGE_DAYS = 365;
+function parseDateRange(req) {
+  const now = /* @__PURE__ */ new Date();
+  const thirtyDaysAgo = /* @__PURE__ */ new Date();
+  thirtyDaysAgo.setDate(thirtyDaysAgo.getDate() - 30);
+  const dateFrom = req.query.from ? new Date(req.query.from) : thirtyDaysAgo;
+  const dateTo = req.query.to ? new Date(req.query.to) : now;
+  if (isNaN(dateFrom.getTime())) {
+    return { error: `Invalid 'from' date: ${req.query.from}` };
+  }
+  if (isNaN(dateTo.getTime())) {
+    return { error: `Invalid 'to' date: ${req.query.to}` };
+  }
+  return { dateFrom, dateTo };
+}
+function createAnalyticsController(eventRecorder, aggregator, queryService) {
+  return {
+    async getOverview(req, res) {
+      try {
+        const parsed = parseDateRange(req);
+        if ("error" in parsed) {
+          return res.status(400).json({ success: false, error: parsed.error });
+        }
+        const data = await queryService.getOverview(parsed.dateFrom, parsed.dateTo);
+        res.json({ success: true, data });
+      } catch (error) {
+        const message = error instanceof Error ? error.message : "Unknown error";
+        res.status(500).json({ success: false, error: message });
+      }
+    },
+    async getTimeline(req, res) {
+      try {
+        const parsed = parseDateRange(req);
+        if ("error" in parsed) {
+          return res.status(400).json({ success: false, error: parsed.error });
+        }
+        const interval = req.query.interval || "daily";
+        if (!["daily", "weekly", "monthly"].includes(interval)) {
+          return res.status(400).json({
+            success: false,
+            error: "interval must be daily, weekly, or monthly"
+          });
+        }
+        const data = await queryService.getTimeline(
+          parsed.dateFrom,
+          parsed.dateTo,
+          interval
+        );
+        res.json({ success: true, data });
+      } catch (error) {
+        const message = error instanceof Error ? error.message : "Unknown error";
+        res.status(500).json({ success: false, error: message });
+      }
+    },
+    async getAccountStats(req, res) {
+      try {
+        const parsed = parseDateRange(req);
+        if ("error" in parsed) {
+          return res.status(400).json({ success: false, error: parsed.error });
+        }
+        const data = await queryService.getAccountStats(parsed.dateFrom, parsed.dateTo);
+        res.json({ success: true, data });
+      } catch (error) {
+        const message = error instanceof Error ? error.message : "Unknown error";
+        res.status(500).json({ success: false, error: message });
+      }
+    },
+    async getRuleStats(req, res) {
+      try {
+        const parsed = parseDateRange(req);
+        if ("error" in parsed) {
+          return res.status(400).json({ success: false, error: parsed.error });
+        }
+        const data = await queryService.getRuleStats(parsed.dateFrom, parsed.dateTo);
+        res.json({ success: true, data });
+      } catch (error) {
+        const message = error instanceof Error ? error.message : "Unknown error";
+        res.status(500).json({ success: false, error: message });
+      }
+    },
+    async getTemplateStats(req, res) {
+      try {
+        const parsed = parseDateRange(req);
+        if ("error" in parsed) {
+          return res.status(400).json({ success: false, error: parsed.error });
+        }
+        const data = await queryService.getTemplateStats(parsed.dateFrom, parsed.dateTo);
+        res.json({ success: true, data });
+      } catch (error) {
+        const message = error instanceof Error ? error.message : "Unknown error";
+        res.status(500).json({ success: false, error: message });
+      }
+    },
+    async triggerAggregation(req, res) {
+      try {
+        const { from, to } = req.body;
+        if (from && to) {
+          const fromDate = new Date(from);
+          const toDate = new Date(to);
+          if (isNaN(fromDate.getTime()) || isNaN(toDate.getTime())) {
+            return res.status(400).json({
+              success: false,
+              error: "Invalid date format for from/to"
+            });
+          }
+          if (fromDate > toDate) {
+            return res.status(400).json({
+              success: false,
+              error: `Invalid date range: 'from' must be before 'to'`
+            });
+          }
+          const diffDays = (toDate.getTime() - fromDate.getTime()) / (1e3 * 60 * 60 * 24);
+          if (diffDays > MAX_AGGREGATION_RANGE_DAYS) {
+            return res.status(400).json({
+              success: false,
+              error: `Date range exceeds maximum of ${MAX_AGGREGATION_RANGE_DAYS} days`
+            });
+          }
+          await aggregator.aggregateRange(fromDate, toDate);
+          res.json({ success: true, message: "Range aggregation complete" });
+        } else {
+          let date;
+          if (from) {
+            date = new Date(from);
+            if (isNaN(date.getTime())) {
+              return res.status(400).json({
+                success: false,
+                error: "Invalid date format for from"
+              });
+            }
+          }
+          await aggregator.aggregateDaily(date);
+          res.json({ success: true, message: "Daily aggregation complete" });
+        }
+      } catch (error) {
+        if (error instanceof InvalidDateRangeError) {
+          return res.status(400).json({ success: false, error: error.message });
+        }
+        const message = error instanceof Error ? error.message : "Unknown error";
+        res.status(500).json({ success: false, error: message });
+      }
+    }
+  };
+}
+function createAnalyticsRoutes(controller) {
+  const router = Router();
+  router.get("/overview", controller.getOverview);
+  router.get("/timeline", controller.getTimeline);
+  router.get("/accounts", controller.getAccountStats);
+  router.get("/rules", controller.getRuleStats);
+  router.get("/templates", controller.getTemplateStats);
+  router.post("/aggregate", controller.triggerAggregation);
+  return router;
+}
+
+// src/index.ts
+var noopLogger = {
+  info: () => {
+  },
+  warn: () => {
+  },
+  error: () => {
+  }
+};
+function createEmailAnalytics(config) {
+  validateConfig(config);
+  const conn = config.db.connection;
+  const prefix = config.db.collectionPrefix || "";
+  const logger = config.logger || noopLogger;
+  const timezone = config.options?.timezone || "UTC";
+  const ttlDays = config.options?.eventTTLDays;
+  const EmailEvent = conn.model(
+    `${prefix}EmailEvent`,
+    createEmailEventSchema(ttlDays ? { eventTTLDays: ttlDays } : void 0)
+  );
+  const AnalyticsStats = conn.model(
+    `${prefix}AnalyticsStats`,
+    createAnalyticsStatsSchema()
+  );
+  const eventRecorder = new EventRecorderService(EmailEvent, logger);
+  const aggregator = new AggregatorService(EmailEvent, AnalyticsStats, timezone, logger);
+  const queryService = new QueryService(AnalyticsStats, logger);
+  const controller = createAnalyticsController(eventRecorder, aggregator, queryService);
+  const routes = createAnalyticsRoutes(controller);
+  return {
+    routes,
+    events: eventRecorder,
+    aggregator,
+    query: queryService,
+    models: {
+      EmailEvent,
+      AnalyticsStats
+    }
+  };
+}
+
+export { AGGREGATION_INTERVAL, AggregationError, AggregatorService, AlxAnalyticsError, EVENT_TYPE, EventRecorderService, InvalidDateRangeError, QueryService, STATS_GROUP_BY, createAnalyticsController, createAnalyticsRoutes, createAnalyticsStatsSchema, createEmailAnalytics, createEmailEventSchema, validateConfig };
+//# sourceMappingURL=index.mjs.map
+//# sourceMappingURL=index.mjs.map