@litemetrics/node 0.1.0

package/dist/index.js

@@ -0,0 +1,2081 @@
+// src/adapters/clickhouse.ts
+import { createClient } from "@clickhouse/client";
+
+// src/adapters/utils.ts
+import { randomBytes } from "crypto";
+function resolvePeriod(q) {
+  const now = /* @__PURE__ */ new Date();
+  const period = q.period ?? "7d";
+  if (period === "custom" && q.dateFrom && q.dateTo) {
+    return { dateRange: { from: q.dateFrom, to: q.dateTo }, period };
+  }
+  const to = now.toISOString();
+  let from;
+  switch (period) {
+    case "1h":
+      from = new Date(now.getTime() - 60 * 60 * 1e3);
+      break;
+    case "24h":
+      from = new Date(now.getTime() - 24 * 60 * 60 * 1e3);
+      break;
+    case "7d":
+      from = new Date(now.getTime() - 7 * 24 * 60 * 60 * 1e3);
+      break;
+    case "30d":
+      from = new Date(now.getTime() - 30 * 24 * 60 * 60 * 1e3);
+      break;
+    case "90d":
+      from = new Date(now.getTime() - 90 * 24 * 60 * 60 * 1e3);
+      break;
+    default:
+      from = new Date(now.getTime() - 7 * 24 * 60 * 60 * 1e3);
+      break;
+  }
+  return { dateRange: { from: from.toISOString(), to }, period };
+}
+function previousPeriodRange(currentRange) {
+  const from = new Date(currentRange.from);
+  const to = new Date(currentRange.to);
+  const duration = to.getTime() - from.getTime();
+  const prevTo = new Date(from.getTime() - 1);
+  const prevFrom = new Date(prevTo.getTime() - duration);
+  return { from: prevFrom.toISOString(), to: prevTo.toISOString() };
+}
+function autoGranularity(period) {
+  switch (period) {
+    case "1h":
+      return "hour";
+    case "24h":
+      return "hour";
+    case "7d":
+      return "day";
+    case "30d":
+      return "day";
+    case "90d":
+      return "week";
+    default:
+      return "day";
+  }
+}
+function granularityToDateFormat(g) {
+  switch (g) {
+    case "hour":
+      return "%Y-%m-%dT%H:00";
+    case "day":
+      return "%Y-%m-%d";
+    case "week":
+      return "%G-W%V";
+    case "month":
+      return "%Y-%m";
+  }
+}
+function fillBuckets(from, to, granularity, dateFormat, rows) {
+  const map = new Map(rows.map((r) => [r._id, r.value]));
+  const points = [];
+  const current = new Date(from);
+  if (granularity === "hour") {
+    current.setMinutes(0, 0, 0);
+  } else if (granularity === "day") {
+    current.setHours(0, 0, 0, 0);
+  } else if (granularity === "week") {
+    const day = current.getDay();
+    const diff = day === 0 ? -6 : 1 - day;
+    current.setDate(current.getDate() + diff);
+    current.setHours(0, 0, 0, 0);
+  } else if (granularity === "month") {
+    current.setDate(1);
+    current.setHours(0, 0, 0, 0);
+  }
+  while (current <= to) {
+    const key = formatDateBucket(current, dateFormat);
+    points.push({ date: current.toISOString(), value: map.get(key) ?? 0 });
+    if (granularity === "hour") {
+      current.setHours(current.getHours() + 1);
+    } else if (granularity === "day") {
+      current.setDate(current.getDate() + 1);
+    } else if (granularity === "week") {
+      current.setDate(current.getDate() + 7);
+    } else if (granularity === "month") {
+      current.setMonth(current.getMonth() + 1);
+    }
+  }
+  return points;
+}
+function formatDateBucket(date, format) {
+  const y = date.getFullYear();
+  const m = String(date.getMonth() + 1).padStart(2, "0");
+  const d = String(date.getDate()).padStart(2, "0");
+  const h = String(date.getHours()).padStart(2, "0");
+  if (format === "%Y-%m-%dT%H:00") return `${y}-${m}-${d}T${h}:00`;
+  if (format === "%Y-%m-%d") return `${y}-${m}-${d}`;
+  if (format === "%Y-%m") return `${y}-${m}`;
+  if (format === "%G-W%V") {
+    const jan4 = new Date(y, 0, 4);
+    const dayOfYear = Math.ceil((date.getTime() - new Date(y, 0, 1).getTime()) / 864e5) + 1;
+    const jan4Day = jan4.getDay() || 7;
+    const weekNum = Math.ceil((dayOfYear + jan4Day - 1) / 7);
+    return `${y}-W${String(weekNum).padStart(2, "0")}`;
+  }
+  return date.toISOString();
+}
+function getISOWeek(date) {
+  const y = date.getFullYear();
+  const jan4 = new Date(y, 0, 4);
+  const dayOfYear = Math.ceil((date.getTime() - new Date(y, 0, 1).getTime()) / 864e5) + 1;
+  const jan4Day = jan4.getDay() || 7;
+  const weekNum = Math.ceil((dayOfYear + jan4Day - 1) / 7);
+  return `${y}-W${String(weekNum).padStart(2, "0")}`;
+}
+function generateSiteId() {
+  const chars = "abcdefghijklmnopqrstuvwxyz0123456789";
+  const bytes = randomBytes(12);
+  let id = "";
+  for (let i = 0; i < 12; i++) id += chars[bytes[i] % chars.length];
+  return `site_${id}`;
+}
+function generateSecretKey() {
+  return `sk_${randomBytes(32).toString("hex")}`;
+}
+
+// src/adapters/clickhouse.ts
+var EVENTS_TABLE = "litemetrics_events";
+var SITES_TABLE = "litemetrics_sites";
+var CREATE_EVENTS_TABLE = `
+CREATE TABLE IF NOT EXISTS ${EVENTS_TABLE} (
+    event_id       UUID DEFAULT generateUUIDv4(),
+    site_id        LowCardinality(String),
+    type           LowCardinality(String),
+    timestamp      DateTime64(3),
+    session_id     String,
+    visitor_id     String,
+    url            Nullable(String),
+    referrer       Nullable(String),
+    title          Nullable(String),
+    event_name     Nullable(String),
+    properties     Nullable(String),
+    user_id        Nullable(String),
+    traits         Nullable(String),
+    country        LowCardinality(Nullable(String)),
+    city           Nullable(String),
+    region         Nullable(String),
+    device_type    LowCardinality(Nullable(String)),
+    browser        LowCardinality(Nullable(String)),
+    os             LowCardinality(Nullable(String)),
+    language       LowCardinality(Nullable(String)),
+    timezone       Nullable(String),
+    screen_width   Nullable(UInt16),
+    screen_height  Nullable(UInt16),
+    utm_source     Nullable(String),
+    utm_medium     Nullable(String),
+    utm_campaign   Nullable(String),
+    utm_term       Nullable(String),
+    utm_content    Nullable(String),
+    ip             Nullable(String),
+    created_at     DateTime64(3) DEFAULT now64(3)
+) ENGINE = MergeTree()
+  PARTITION BY toYYYYMM(timestamp)
+  ORDER BY (site_id, timestamp, visitor_id)
+  SETTINGS index_granularity = 8192
+`;
+var CREATE_SITES_TABLE = `
+CREATE TABLE IF NOT EXISTS ${SITES_TABLE} (
+    site_id          String,
+    secret_key       String,
+    name             String,
+    domain           Nullable(String),
+    allowed_origins  Nullable(String),
+    created_at       DateTime64(3),
+    updated_at       DateTime64(3),
+    version          UInt64,
+    is_deleted       UInt8 DEFAULT 0
+) ENGINE = ReplacingMergeTree(version)
+  ORDER BY (site_id)
+  SETTINGS index_granularity = 8192
+`;
+var ClickHouseAdapter = class {
+  client;
+  constructor(url) {
+    this.client = createClient({
+      url,
+      clickhouse_settings: {
+        wait_end_of_query: 1
+      }
+    });
+  }
+  async init() {
+    await this.client.command({ query: CREATE_EVENTS_TABLE });
+    await this.client.command({ query: CREATE_SITES_TABLE });
+  }
+  async close() {
+    await this.client.close();
+  }
+  // ─── Event Insertion ──────────────────────────────────────
+  async insertEvents(events) {
+    if (events.length === 0) return;
+    const rows = events.map((e) => ({
+      site_id: e.siteId,
+      type: e.type,
+      timestamp: new Date(e.timestamp).toISOString(),
+      session_id: e.sessionId,
+      visitor_id: e.visitorId,
+      url: e.url ?? null,
+      referrer: e.referrer ?? null,
+      title: e.title ?? null,
+      event_name: e.name ?? null,
+      properties: e.properties ? JSON.stringify(e.properties) : null,
+      user_id: e.userId ?? null,
+      traits: e.traits ? JSON.stringify(e.traits) : null,
+      country: e.geo?.country ?? null,
+      city: e.geo?.city ?? null,
+      region: e.geo?.region ?? null,
+      device_type: e.device?.type ?? null,
+      browser: e.device?.browser ?? null,
+      os: e.device?.os ?? null,
+      language: e.language ?? null,
+      timezone: e.timezone ?? null,
+      screen_width: e.screen?.width ?? null,
+      screen_height: e.screen?.height ?? null,
+      utm_source: e.utm?.source ?? null,
+      utm_medium: e.utm?.medium ?? null,
+      utm_campaign: e.utm?.campaign ?? null,
+      utm_term: e.utm?.term ?? null,
+      utm_content: e.utm?.content ?? null,
+      ip: e.ip ?? null
+    }));
+    await this.client.insert({
+      table: EVENTS_TABLE,
+      values: rows,
+      format: "JSONEachRow"
+    });
+  }
+  // ─── Analytics Queries ──────────────────────────────────────
+  async query(q) {
+    const { dateRange, period } = resolvePeriod(q);
+    const siteId = q.siteId;
+    const limit = q.limit ?? 10;
+    const params = {
+      siteId,
+      from: dateRange.from,
+      to: dateRange.to,
+      limit
+    };
+    let data = [];
+    let total = 0;
+    switch (q.metric) {
+      case "pageviews": {
+        const rows = await this.queryRows(
+          `SELECT count() AS value FROM ${EVENTS_TABLE}
+           WHERE site_id = {siteId:String}
+             AND timestamp >= {from:String}
+             AND timestamp <= {to:String}
+             AND type = 'pageview'`,
+          params
+        );
+        total = Number(rows[0]?.value ?? 0);
+        data = [{ key: "pageviews", value: total }];
+        break;
+      }
+      case "visitors": {
+        const rows = await this.queryRows(
+          `SELECT uniq(visitor_id) AS value FROM ${EVENTS_TABLE}
+           WHERE site_id = {siteId:String}
+             AND timestamp >= {from:String}
+             AND timestamp <= {to:String}`,
+          params
+        );
+        total = Number(rows[0]?.value ?? 0);
+        data = [{ key: "visitors", value: total }];
+        break;
+      }
+      case "sessions": {
+        const rows = await this.queryRows(
+          `SELECT uniq(session_id) AS value FROM ${EVENTS_TABLE}
+           WHERE site_id = {siteId:String}
+             AND timestamp >= {from:String}
+             AND timestamp <= {to:String}`,
+          params
+        );
+        total = Number(rows[0]?.value ?? 0);
+        data = [{ key: "sessions", value: total }];
+        break;
+      }
+      case "events": {
+        const rows = await this.queryRows(
+          `SELECT count() AS value FROM ${EVENTS_TABLE}
+           WHERE site_id = {siteId:String}
+             AND timestamp >= {from:String}
+             AND timestamp <= {to:String}
+             AND type = 'event'`,
+          params
+        );
+        total = Number(rows[0]?.value ?? 0);
+        data = [{ key: "events", value: total }];
+        break;
+      }
+      case "top_pages": {
+        const rows = await this.queryRows(
+          `SELECT url AS key, count() AS value FROM ${EVENTS_TABLE}
+           WHERE site_id = {siteId:String}
+             AND timestamp >= {from:String}
+             AND timestamp <= {to:String}
+             AND type = 'pageview'
+             AND url IS NOT NULL
+           GROUP BY url
+           ORDER BY value DESC
+           LIMIT {limit:UInt32}`,
+          params
+        );
+        data = rows.map((r) => ({ key: r.key, value: Number(r.value) }));
+        total = data.reduce((sum, d) => sum + d.value, 0);
+        break;
+      }
+      case "top_referrers": {
+        const rows = await this.queryRows(
+          `SELECT referrer AS key, count() AS value FROM ${EVENTS_TABLE}
+           WHERE site_id = {siteId:String}
+             AND timestamp >= {from:String}
+             AND timestamp <= {to:String}
+             AND type = 'pageview'
+             AND referrer IS NOT NULL
+             AND referrer != ''
+           GROUP BY referrer
+           ORDER BY value DESC
+           LIMIT {limit:UInt32}`,
+          params
+        );
+        data = rows.map((r) => ({ key: r.key, value: Number(r.value) }));
+        total = data.reduce((sum, d) => sum + d.value, 0);
+        break;
+      }
+      case "top_countries": {
+        const rows = await this.queryRows(
+          `SELECT country AS key, uniq(visitor_id) AS value FROM ${EVENTS_TABLE}
+           WHERE site_id = {siteId:String}
+             AND timestamp >= {from:String}
+             AND timestamp <= {to:String}
+             AND country IS NOT NULL
+           GROUP BY country
+           ORDER BY value DESC
+           LIMIT {limit:UInt32}`,
+          params
+        );
+        data = rows.map((r) => ({ key: r.key, value: Number(r.value) }));
+        total = data.reduce((sum, d) => sum + d.value, 0);
+        break;
+      }
+      case "top_cities": {
+        const rows = await this.queryRows(
+          `SELECT city AS key, uniq(visitor_id) AS value FROM ${EVENTS_TABLE}
+           WHERE site_id = {siteId:String}
+             AND timestamp >= {from:String}
+             AND timestamp <= {to:String}
+             AND city IS NOT NULL
+           GROUP BY city
+           ORDER BY value DESC
+           LIMIT {limit:UInt32}`,
+          params
+        );
+        data = rows.map((r) => ({ key: r.key, value: Number(r.value) }));
+        total = data.reduce((sum, d) => sum + d.value, 0);
+        break;
+      }
+      case "top_events": {
+        const rows = await this.queryRows(
+          `SELECT event_name AS key, count() AS value FROM ${EVENTS_TABLE}
+           WHERE site_id = {siteId:String}
+             AND timestamp >= {from:String}
+             AND timestamp <= {to:String}
+             AND type = 'event'
+             AND event_name IS NOT NULL
+           GROUP BY event_name
+           ORDER BY value DESC
+           LIMIT {limit:UInt32}`,
+          params
+        );
+        data = rows.map((r) => ({ key: r.key, value: Number(r.value) }));
+        total = data.reduce((sum, d) => sum + d.value, 0);
+        break;
+      }
+      case "top_devices": {
+        const rows = await this.queryRows(
+          `SELECT device_type AS key, uniq(visitor_id) AS value FROM ${EVENTS_TABLE}
+           WHERE site_id = {siteId:String}
+             AND timestamp >= {from:String}
+             AND timestamp <= {to:String}
+             AND device_type IS NOT NULL
+           GROUP BY device_type
+           ORDER BY value DESC
+           LIMIT {limit:UInt32}`,
+          params
+        );
+        data = rows.map((r) => ({ key: r.key, value: Number(r.value) }));
+        total = data.reduce((sum, d) => sum + d.value, 0);
+        break;
+      }
+      case "top_browsers": {
+        const rows = await this.queryRows(
+          `SELECT browser AS key, uniq(visitor_id) AS value FROM ${EVENTS_TABLE}
+           WHERE site_id = {siteId:String}
+             AND timestamp >= {from:String}
+             AND timestamp <= {to:String}
+             AND browser IS NOT NULL
+           GROUP BY browser
+           ORDER BY value DESC
+           LIMIT {limit:UInt32}`,
+          params
+        );
+        data = rows.map((r) => ({ key: r.key, value: Number(r.value) }));
+        total = data.reduce((sum, d) => sum + d.value, 0);
+        break;
+      }
+      case "top_os": {
+        const rows = await this.queryRows(
+          `SELECT os AS key, uniq(visitor_id) AS value FROM ${EVENTS_TABLE}
+           WHERE site_id = {siteId:String}
+             AND timestamp >= {from:String}
+             AND timestamp <= {to:String}
+             AND os IS NOT NULL
+           GROUP BY os
+           ORDER BY value DESC
+           LIMIT {limit:UInt32}`,
+          params
+        );
+        data = rows.map((r) => ({ key: r.key, value: Number(r.value) }));
+        total = data.reduce((sum, d) => sum + d.value, 0);
+        break;
+      }
+    }
+    const result = { metric: q.metric, period, data, total };
+    if (q.compare && ["pageviews", "visitors", "sessions", "events"].includes(q.metric)) {
+      const prevRange = previousPeriodRange(dateRange);
+      const prevResult = await this.query({
+        ...q,
+        compare: false,
+        period: "custom",
+        dateFrom: prevRange.from,
+        dateTo: prevRange.to
+      });
+      result.previousTotal = prevResult.total;
+      if (prevResult.total > 0) {
+        result.changePercent = Math.round((total - prevResult.total) / prevResult.total * 1e3) / 10;
+      } else if (total > 0) {
+        result.changePercent = 100;
+      } else {
+        result.changePercent = 0;
+      }
+    }
+    return result;
+  }
+  // ─── Time Series ──────────────────────────────────────
+  async queryTimeSeries(params) {
+    const { dateRange, period } = resolvePeriod({
+      period: params.period,
+      dateFrom: params.dateFrom,
+      dateTo: params.dateTo
+    });
+    const granularity = params.granularity ?? autoGranularity(period);
+    const bucketFn = this.granularityToClickHouseFunc(granularity);
+    const dateFormat = granularityToDateFormat(granularity);
+    const typeFilter = params.metric === "pageviews" ? `AND type = 'pageview'` : "";
+    let sql;
+    if (params.metric === "visitors" || params.metric === "sessions") {
+      const field = params.metric === "visitors" ? "visitor_id" : "session_id";
+      sql = `
+        SELECT ${bucketFn} AS bucket, uniq(${field}) AS value
+        FROM ${EVENTS_TABLE}
+        WHERE site_id = {siteId:String}
+          AND timestamp >= {from:String}
+          AND timestamp <= {to:String}
+          ${typeFilter}
+        GROUP BY bucket
+        ORDER BY bucket ASC
+      `;
+    } else {
+      sql = `
+        SELECT ${bucketFn} AS bucket, count() AS value
+        FROM ${EVENTS_TABLE}
+        WHERE site_id = {siteId:String}
+          AND timestamp >= {from:String}
+          AND timestamp <= {to:String}
+          ${typeFilter}
+        GROUP BY bucket
+        ORDER BY bucket ASC
+      `;
+    }
+    const rows = await this.queryRows(sql, {
+      siteId: params.siteId,
+      from: dateRange.from,
+      to: dateRange.to
+    });
+    const mappedRows = rows.map((r) => ({
+      _id: this.convertClickHouseBucket(r.bucket, granularity),
+      value: Number(r.value)
+    }));
+    const data = fillBuckets(
+      new Date(dateRange.from),
+      new Date(dateRange.to),
+      granularity,
+      dateFormat,
+      mappedRows
+    );
+    return { metric: params.metric, granularity, data };
+  }
+  granularityToClickHouseFunc(g) {
+    switch (g) {
+      case "hour":
+        return "toStartOfHour(timestamp)";
+      case "day":
+        return "toStartOfDay(timestamp)";
+      case "week":
+        return "toStartOfWeek(timestamp, 1)";
+      // 1 = Monday
+      case "month":
+        return "toStartOfMonth(timestamp)";
+    }
+  }
+  convertClickHouseBucket(bucket, granularity) {
+    const date = new Date(bucket);
+    const y = date.getFullYear();
+    const m = String(date.getMonth() + 1).padStart(2, "0");
+    const d = String(date.getDate()).padStart(2, "0");
+    const h = String(date.getHours()).padStart(2, "0");
+    switch (granularity) {
+      case "hour":
+        return `${y}-${m}-${d}T${h}:00`;
+      case "day":
+        return `${y}-${m}-${d}`;
+      case "week": {
+        const jan4 = new Date(y, 0, 4);
+        const dayOfYear = Math.ceil((date.getTime() - new Date(y, 0, 1).getTime()) / 864e5) + 1;
+        const jan4Day = jan4.getDay() || 7;
+        const weekNum = Math.ceil((dayOfYear + jan4Day - 1) / 7);
+        return `${y}-W${String(weekNum).padStart(2, "0")}`;
+      }
+      case "month":
+        return `${y}-${m}`;
+    }
+  }
+  // ─── Retention ──────────────────────────────────────
+  async queryRetention(params) {
+    const weeks = params.weeks ?? 8;
+    const now = /* @__PURE__ */ new Date();
+    const startDate = new Date(now.getTime() - weeks * 7 * 24 * 60 * 60 * 1e3);
+    const rows = await this.queryRows(
+      `SELECT
+        visitor_id,
+        min(timestamp) AS first_event,
+        groupUniqArray(toStartOfWeek(timestamp, 1)) AS active_weeks
+      FROM ${EVENTS_TABLE}
+      WHERE site_id = {siteId:String}
+        AND timestamp >= {since:String}
+      GROUP BY visitor_id`,
+      {
+        siteId: params.siteId,
+        since: startDate.toISOString()
+      }
+    );
+    const cohortMap = /* @__PURE__ */ new Map();
+    for (const v of rows) {
+      const firstDate = new Date(v.first_event);
+      const cohortWeek = getISOWeek(firstDate);
+      if (!cohortMap.has(cohortWeek)) {
+        cohortMap.set(cohortWeek, { visitors: /* @__PURE__ */ new Set(), weekSets: /* @__PURE__ */ new Map() });
+      }
+      const cohort = cohortMap.get(cohortWeek);
+      cohort.visitors.add(v.visitor_id);
+      const eventWeeks = (Array.isArray(v.active_weeks) ? v.active_weeks : []).map((w) => {
+        const d = new Date(w);
+        return getISOWeek(d);
+      });
+      for (const w of eventWeeks) {
+        if (!cohort.weekSets.has(w)) {
+          cohort.weekSets.set(w, /* @__PURE__ */ new Set());
+        }
+        cohort.weekSets.get(w).add(v.visitor_id);
+      }
+    }
+    const sortedWeeks = Array.from(cohortMap.keys()).sort();
+    const cohorts = sortedWeeks.map((week) => {
+      const cohort = cohortMap.get(week);
+      const size = cohort.visitors.size;
+      const retention = [];
+      const weekIndex = sortedWeeks.indexOf(week);
+      for (let i = 0; i < weeks && weekIndex + i < sortedWeeks.length; i++) {
+        const targetWeek = sortedWeeks[weekIndex + i];
+        const returnedCount = cohort.weekSets.get(targetWeek)?.size ?? 0;
+        retention.push(size > 0 ? Math.round(returnedCount / size * 1e3) / 10 : 0);
+      }
+      return { week, size, retention };
+    });
+    return { cohorts };
+  }
+  // ─── Event Listing ──────────────────────────────────────
+  async listEvents(params) {
+    const limit = Math.min(params.limit ?? 50, 200);
+    const offset = params.offset ?? 0;
+    const conditions = [`site_id = {siteId:String}`];
+    const queryParams = { siteId: params.siteId, limit, offset };
+    if (params.type) {
+      conditions.push(`type = {type:String}`);
+      queryParams.type = params.type;
+    }
+    if (params.eventName) {
+      conditions.push(`event_name = {eventName:String}`);
+      queryParams.eventName = params.eventName;
+    }
+    if (params.visitorId) {
+      conditions.push(`visitor_id = {visitorId:String}`);
+      queryParams.visitorId = params.visitorId;
+    }
+    if (params.userId) {
+      conditions.push(`user_id = {userId:String}`);
+      queryParams.userId = params.userId;
+    }
+    if (params.period || params.dateFrom) {
+      const { dateRange } = resolvePeriod({
+        period: params.period,
+        dateFrom: params.dateFrom,
+        dateTo: params.dateTo
+      });
+      conditions.push(`timestamp >= {from:String} AND timestamp <= {to:String}`);
+      queryParams.from = dateRange.from;
+      queryParams.to = dateRange.to;
+    }
+    const where = conditions.join(" AND ");
+    const [events, countRows] = await Promise.all([
+      this.queryRows(
+        `SELECT event_id, type, timestamp, session_id, visitor_id, url, referrer, title,
+                event_name, properties, user_id, traits, country, city, region,
+                device_type, browser, os, language,
+                utm_source, utm_medium, utm_campaign, utm_term, utm_content
+         FROM ${EVENTS_TABLE}
+         WHERE ${where}
+         ORDER BY timestamp DESC
+         LIMIT {limit:UInt32}
+         OFFSET {offset:UInt32}`,
+        queryParams
+      ),
+      this.queryRows(
+        `SELECT count() AS total FROM ${EVENTS_TABLE} WHERE ${where}`,
+        queryParams
+      )
+    ]);
+    return {
+      events: events.map((e) => this.toEventListItem(e)),
+      total: Number(countRows[0]?.total ?? 0),
+      limit,
+      offset
+    };
+  }
+  // ─── User Listing ──────────────────────────────────────
+  async listUsers(params) {
+    const limit = Math.min(params.limit ?? 50, 200);
+    const offset = params.offset ?? 0;
+    const conditions = [`site_id = {siteId:String}`];
+    const queryParams = { siteId: params.siteId, limit, offset };
+    if (params.search) {
+      conditions.push(`(visitor_id ILIKE {search:String} OR user_id ILIKE {search:String})`);
+      queryParams.search = `%${params.search}%`;
+    }
+    const where = conditions.join(" AND ");
+    const [userRows, countRows] = await Promise.all([
+      this.queryRows(
+        `SELECT
+          visitor_id,
+          anyLast(user_id) AS userId,
+          anyLast(traits) AS traits,
+          min(timestamp) AS firstSeen,
+          max(timestamp) AS lastSeen,
+          count() AS totalEvents,
+          countIf(type = 'pageview') AS totalPageviews,
+          uniq(session_id) AS totalSessions,
+          anyLast(url) AS lastUrl,
+          anyLast(device_type) AS device_type,
+          anyLast(browser) AS browser,
+          anyLast(os) AS os,
+          anyLast(country) AS country,
+          anyLast(city) AS city,
+          anyLast(region) AS region,
+          anyLast(language) AS language
+        FROM ${EVENTS_TABLE}
+        WHERE ${where}
+        GROUP BY visitor_id
+        ORDER BY lastSeen DESC
+        LIMIT {limit:UInt32}
+        OFFSET {offset:UInt32}`,
+        queryParams
+      ),
+      this.queryRows(
+        `SELECT count() AS total FROM (
+          SELECT visitor_id FROM ${EVENTS_TABLE}
+          WHERE ${where}
+          GROUP BY visitor_id
+        )`,
+        queryParams
+      )
+    ]);
+    const users = userRows.map((u) => ({
+      visitorId: String(u.visitor_id),
+      userId: u.userId ? String(u.userId) : void 0,
+      traits: this.parseJSON(u.traits),
+      firstSeen: new Date(String(u.firstSeen)).toISOString(),
+      lastSeen: new Date(String(u.lastSeen)).toISOString(),
+      totalEvents: Number(u.totalEvents),
+      totalPageviews: Number(u.totalPageviews),
+      totalSessions: Number(u.totalSessions),
+      lastUrl: u.lastUrl ? String(u.lastUrl) : void 0,
+      device: u.device_type ? { type: String(u.device_type), browser: String(u.browser ?? ""), os: String(u.os ?? "") } : void 0,
+      geo: u.country ? { country: String(u.country), city: u.city ? String(u.city) : void 0, region: u.region ? String(u.region) : void 0 } : void 0,
+      language: u.language ? String(u.language) : void 0
+    }));
+    return {
+      users,
+      total: Number(countRows[0]?.total ?? 0),
+      limit,
+      offset
+    };
+  }
+  async getUserDetail(siteId, visitorId) {
+    const result = await this.listUsers({ siteId, search: visitorId, limit: 1 });
+    const user = result.users.find((u) => u.visitorId === visitorId);
+    return user ?? null;
+  }
+  async getUserEvents(siteId, visitorId, params) {
+    return this.listEvents({ ...params, siteId, visitorId });
+  }
+  // ─── Site Management ──────────────────────────────────────
+  async createSite(data) {
+    const now = (/* @__PURE__ */ new Date()).toISOString();
+    const site = {
+      siteId: generateSiteId(),
+      secretKey: generateSecretKey(),
+      name: data.name,
+      domain: data.domain,
+      allowedOrigins: data.allowedOrigins,
+      createdAt: now,
+      updatedAt: now
+    };
+    await this.client.insert({
+      table: SITES_TABLE,
+      values: [{
+        site_id: site.siteId,
+        secret_key: site.secretKey,
+        name: site.name,
+        domain: site.domain ?? null,
+        allowed_origins: site.allowedOrigins ? JSON.stringify(site.allowedOrigins) : null,
+        created_at: now,
+        updated_at: now,
+        version: 1,
+        is_deleted: 0
+      }],
+      format: "JSONEachRow"
+    });
+    return site;
+  }
+  async getSite(siteId) {
+    const rows = await this.queryRows(
+      `SELECT site_id, secret_key, name, domain, allowed_origins, created_at, updated_at
+       FROM ${SITES_TABLE} FINAL
+       WHERE site_id = {siteId:String} AND is_deleted = 0`,
+      { siteId }
+    );
+    return rows.length > 0 ? this.toSite(rows[0]) : null;
+  }
+  async getSiteBySecret(secretKey) {
+    const rows = await this.queryRows(
+      `SELECT site_id, secret_key, name, domain, allowed_origins, created_at, updated_at
+       FROM ${SITES_TABLE} FINAL
+       WHERE secret_key = {secretKey:String} AND is_deleted = 0`,
+      { secretKey }
+    );
+    return rows.length > 0 ? this.toSite(rows[0]) : null;
+  }
+  async listSites() {
+    const rows = await this.queryRows(
+      `SELECT site_id, secret_key, name, domain, allowed_origins, created_at, updated_at
+       FROM ${SITES_TABLE} FINAL
+       WHERE is_deleted = 0
+       ORDER BY created_at DESC`,
+      {}
+    );
+    return rows.map((r) => this.toSite(r));
+  }
+  async updateSite(siteId, data) {
+    const currentRows = await this.queryRows(
+      `SELECT site_id, secret_key, name, domain, allowed_origins, created_at, updated_at, version
+       FROM ${SITES_TABLE} FINAL
+       WHERE site_id = {siteId:String} AND is_deleted = 0`,
+      { siteId }
+    );
+    if (currentRows.length === 0) return null;
+    const current = currentRows[0];
+    const now = (/* @__PURE__ */ new Date()).toISOString();
+    const newVersion = Number(current.version) + 1;
+    const newName = data.name !== void 0 ? data.name : String(current.name);
+    const newDomain = data.domain !== void 0 ? data.domain || null : current.domain ? String(current.domain) : null;
+    const newOrigins = data.allowedOrigins !== void 0 ? data.allowedOrigins.length > 0 ? JSON.stringify(data.allowedOrigins) : null : current.allowed_origins ? String(current.allowed_origins) : null;
+    await this.client.insert({
+      table: SITES_TABLE,
+      values: [{
+        site_id: String(current.site_id),
+        secret_key: String(current.secret_key),
+        name: newName,
+        domain: newDomain,
+        allowed_origins: newOrigins,
+        created_at: String(current.created_at),
+        updated_at: now,
+        version: newVersion,
+        is_deleted: 0
+      }],
+      format: "JSONEachRow"
+    });
+    return {
+      siteId: String(current.site_id),
+      secretKey: String(current.secret_key),
+      name: newName,
+      domain: newDomain ?? void 0,
+      allowedOrigins: newOrigins ? JSON.parse(newOrigins) : void 0,
+      createdAt: String(current.created_at),
+      updatedAt: now
+    };
+  }
+  async deleteSite(siteId) {
+    const currentRows = await this.queryRows(
+      `SELECT site_id, secret_key, name, domain, allowed_origins, created_at, version
+       FROM ${SITES_TABLE} FINAL
+       WHERE site_id = {siteId:String} AND is_deleted = 0`,
+      { siteId }
+    );
+    if (currentRows.length === 0) return false;
+    const current = currentRows[0];
+    const now = (/* @__PURE__ */ new Date()).toISOString();
+    await this.client.insert({
+      table: SITES_TABLE,
+      values: [{
+        site_id: String(current.site_id),
+        secret_key: String(current.secret_key),
+        name: String(current.name),
+        domain: current.domain ? String(current.domain) : null,
+        allowed_origins: current.allowed_origins ? String(current.allowed_origins) : null,
+        created_at: String(current.created_at),
+        updated_at: now,
+        version: Number(current.version) + 1,
+        is_deleted: 1
+      }],
+      format: "JSONEachRow"
+    });
+    return true;
+  }
+  async regenerateSecret(siteId) {
+    const currentRows = await this.queryRows(
+      `SELECT site_id, secret_key, name, domain, allowed_origins, created_at, version
+       FROM ${SITES_TABLE} FINAL
+       WHERE site_id = {siteId:String} AND is_deleted = 0`,
+      { siteId }
+    );
+    if (currentRows.length === 0) return null;
+    const current = currentRows[0];
+    const now = (/* @__PURE__ */ new Date()).toISOString();
+    const newSecret = generateSecretKey();
+    await this.client.insert({
+      table: SITES_TABLE,
+      values: [{
+        site_id: String(current.site_id),
+        secret_key: newSecret,
+        name: String(current.name),
+        domain: current.domain ? String(current.domain) : null,
+        allowed_origins: current.allowed_origins ? String(current.allowed_origins) : null,
+        created_at: String(current.created_at),
+        updated_at: now,
+        version: Number(current.version) + 1,
+        is_deleted: 0
+      }],
+      format: "JSONEachRow"
+    });
+    return {
+      siteId: String(current.site_id),
+      secretKey: newSecret,
+      name: String(current.name),
+      domain: current.domain ? String(current.domain) : void 0,
+      allowedOrigins: current.allowed_origins ? JSON.parse(String(current.allowed_origins)) : void 0,
+      createdAt: String(current.created_at),
+      updatedAt: now
+    };
+  }
+  // ─── Helpers ─────────────────────────────────────────────
+  async queryRows(query, query_params) {
+    const result = await this.client.query({
+      query,
+      query_params,
+      format: "JSONEachRow"
+    });
+    return result.json();
+  }
+  toSite(row) {
+    return {
+      siteId: String(row.site_id),
+      secretKey: String(row.secret_key),
+      name: String(row.name),
+      domain: row.domain ? String(row.domain) : void 0,
+      allowedOrigins: row.allowed_origins ? JSON.parse(String(row.allowed_origins)) : void 0,
+      createdAt: new Date(String(row.created_at)).toISOString(),
+      updatedAt: new Date(String(row.updated_at)).toISOString()
+    };
+  }
+  toEventListItem(row) {
+    return {
+      id: String(row.event_id ?? ""),
+      type: String(row.type),
+      timestamp: new Date(String(row.timestamp)).toISOString(),
+      visitorId: String(row.visitor_id),
+      sessionId: String(row.session_id),
+      url: row.url ? String(row.url) : void 0,
+      referrer: row.referrer ? String(row.referrer) : void 0,
+      title: row.title ? String(row.title) : void 0,
+      name: row.event_name ? String(row.event_name) : void 0,
+      properties: this.parseJSON(row.properties),
+      userId: row.user_id ? String(row.user_id) : void 0,
+      traits: this.parseJSON(row.traits),
+      geo: row.country ? {
+        country: String(row.country),
+        city: row.city ? String(row.city) : void 0,
+        region: row.region ? String(row.region) : void 0
+      } : void 0,
+      device: row.device_type ? {
+        type: String(row.device_type),
+        browser: String(row.browser ?? ""),
+        os: String(row.os ?? "")
+      } : void 0,
+      language: row.language ? String(row.language) : void 0,
+      utm: row.utm_source ? {
+        source: row.utm_source ? String(row.utm_source) : void 0,
+        medium: row.utm_medium ? String(row.utm_medium) : void 0,
+        campaign: row.utm_campaign ? String(row.utm_campaign) : void 0,
+        term: row.utm_term ? String(row.utm_term) : void 0,
+        content: row.utm_content ? String(row.utm_content) : void 0
+      } : void 0
+    };
+  }
+  parseJSON(str) {
+    if (!str) return void 0;
+    try {
+      return JSON.parse(str);
+    } catch {
+      return void 0;
+    }
+  }
+};
+
+// src/adapters/mongodb.ts
+import { MongoClient } from "mongodb";
+var EVENTS_COLLECTION = "litemetrics_events";
+var SITES_COLLECTION = "litemetrics_sites";
+var MongoDBAdapter = class {
+  client;
+  db;
+  collection;
+  sites;
+  constructor(url) {
+    this.client = new MongoClient(url);
+  }
+  async init() {
+    await this.client.connect();
+    this.db = this.client.db();
+    this.collection = this.db.collection(EVENTS_COLLECTION);
+    this.sites = this.db.collection(SITES_COLLECTION);
+    await Promise.all([
+      this.collection.createIndex({ site_id: 1, timestamp: -1 }),
+      this.collection.createIndex({ site_id: 1, type: 1 }),
+      this.collection.createIndex({ site_id: 1, visitor_id: 1 }),
+      this.collection.createIndex({ site_id: 1, session_id: 1 }),
+      this.sites.createIndex({ site_id: 1 }, { unique: true }),
+      this.sites.createIndex({ secret_key: 1 })
+    ]);
+  }
+  async insertEvents(events) {
+    if (events.length === 0) return;
+    const docs = events.map((e) => ({
+      site_id: e.siteId,
+      type: e.type,
+      timestamp: new Date(e.timestamp),
+      session_id: e.sessionId,
+      visitor_id: e.visitorId,
+      url: e.url ?? null,
+      referrer: e.referrer ?? null,
+      title: e.title ?? null,
+      event_name: e.name ?? null,
+      properties: e.properties ?? null,
+      user_id: e.userId ?? null,
+      traits: e.traits ?? null,
+      country: e.geo?.country ?? null,
+      city: e.geo?.city ?? null,
+      region: e.geo?.region ?? null,
+      device_type: e.device?.type ?? null,
+      browser: e.device?.browser ?? null,
+      os: e.device?.os ?? null,
+      language: e.language ?? null,
+      timezone: e.timezone ?? null,
+      screen_width: e.screen?.width ?? null,
+      screen_height: e.screen?.height ?? null,
+      utm_source: e.utm?.source ?? null,
+      utm_medium: e.utm?.medium ?? null,
+      utm_campaign: e.utm?.campaign ?? null,
+      utm_term: e.utm?.term ?? null,
+      utm_content: e.utm?.content ?? null,
+      ip: e.ip ?? null,
+      created_at: /* @__PURE__ */ new Date()
+    }));
+    await this.collection.insertMany(docs);
+  }
+  async query(q) {
+    const { dateRange, period } = resolvePeriod(q);
+    const siteId = q.siteId;
+    const limit = q.limit ?? 10;
+    const baseMatch = {
+      site_id: siteId,
+      timestamp: { $gte: new Date(dateRange.from), $lte: new Date(dateRange.to) }
+    };
+    let data = [];
+    let total = 0;
+    switch (q.metric) {
+      case "pageviews": {
+        const [result2] = await this.collection.aggregate([
+          { $match: { ...baseMatch, type: "pageview" } },
+          { $count: "count" }
+        ]).toArray();
+        total = result2?.count ?? 0;
+        data = [{ key: "pageviews", value: total }];
+        break;
+      }
+      case "visitors": {
+        const [result2] = await this.collection.aggregate([
+          { $match: baseMatch },
+          { $group: { _id: "$visitor_id" } },
+          { $count: "count" }
+        ]).toArray();
+        total = result2?.count ?? 0;
+        data = [{ key: "visitors", value: total }];
+        break;
+      }
+      case "sessions": {
+        const [result2] = await this.collection.aggregate([
+          { $match: baseMatch },
+          { $group: { _id: "$session_id" } },
+          { $count: "count" }
+        ]).toArray();
+        total = result2?.count ?? 0;
+        data = [{ key: "sessions", value: total }];
+        break;
+      }
+      case "events": {
+        const [result2] = await this.collection.aggregate([
+          { $match: { ...baseMatch, type: "event" } },
+          { $count: "count" }
+        ]).toArray();
+        total = result2?.count ?? 0;
+        data = [{ key: "events", value: total }];
+        break;
+      }
+      case "top_pages": {
+        const rows = await this.collection.aggregate([
+          { $match: { ...baseMatch, type: "pageview", url: { $ne: null } } },
+          { $group: { _id: "$url", value: { $sum: 1 } } },
+          { $sort: { value: -1 } },
+          { $limit: limit }
+        ]).toArray();
+        data = rows.map((r) => ({ key: r._id, value: r.value }));
+        total = data.reduce((sum, d) => sum + d.value, 0);
+        break;
+      }
+      case "top_referrers": {
+        const rows = await this.collection.aggregate([
+          { $match: { ...baseMatch, type: "pageview", referrer: { $nin: [null, ""] } } },
+          { $group: { _id: "$referrer", value: { $sum: 1 } } },
+          { $sort: { value: -1 } },
+          { $limit: limit }
+        ]).toArray();
+        data = rows.map((r) => ({ key: r._id, value: r.value }));
+        total = data.reduce((sum, d) => sum + d.value, 0);
+        break;
+      }
+      case "top_countries": {
+        const rows = await this.collection.aggregate([
+          { $match: { ...baseMatch, country: { $ne: null } } },
+          { $group: { _id: "$country", value: { $addToSet: "$visitor_id" } } },
+          { $project: { _id: 1, value: { $size: "$value" } } },
+          { $sort: { value: -1 } },
+          { $limit: limit }
+        ]).toArray();
+        data = rows.map((r) => ({ key: r._id, value: r.value }));
+        total = data.reduce((sum, d) => sum + d.value, 0);
+        break;
+      }
+      case "top_cities": {
+        const rows = await this.collection.aggregate([
+          { $match: { ...baseMatch, city: { $ne: null } } },
+          { $group: { _id: "$city", value: { $addToSet: "$visitor_id" } } },
+          { $project: { _id: 1, value: { $size: "$value" } } },
+          { $sort: { value: -1 } },
+          { $limit: limit }
+        ]).toArray();
+        data = rows.map((r) => ({ key: r._id, value: r.value }));
+        total = data.reduce((sum, d) => sum + d.value, 0);
+        break;
+      }
+      case "top_events": {
+        const rows = await this.collection.aggregate([
+          { $match: { ...baseMatch, type: "event", event_name: { $ne: null } } },
+          { $group: { _id: "$event_name", value: { $sum: 1 } } },
+          { $sort: { value: -1 } },
+          { $limit: limit }
+        ]).toArray();
+        data = rows.map((r) => ({ key: r._id, value: r.value }));
+        total = data.reduce((sum, d) => sum + d.value, 0);
+        break;
+      }
+      case "top_devices": {
+        const rows = await this.collection.aggregate([
+          { $match: { ...baseMatch, device_type: { $ne: null } } },
+          { $group: { _id: "$device_type", value: { $addToSet: "$visitor_id" } } },
+          { $project: { _id: 1, value: { $size: "$value" } } },
+          { $sort: { value: -1 } },
+          { $limit: limit }
+        ]).toArray();
+        data = rows.map((r) => ({ key: r._id, value: r.value }));
+        total = data.reduce((sum, d) => sum + d.value, 0);
+        break;
+      }
+      case "top_browsers": {
+        const rows = await this.collection.aggregate([
+          { $match: { ...baseMatch, browser: { $ne: null } } },
+          { $group: { _id: "$browser", value: { $addToSet: "$visitor_id" } } },
+          { $project: { _id: 1, value: { $size: "$value" } } },
+          { $sort: { value: -1 } },
+          { $limit: limit }
+        ]).toArray();
+        data = rows.map((r) => ({ key: r._id, value: r.value }));
+        total = data.reduce((sum, d) => sum + d.value, 0);
+        break;
+      }
+      case "top_os": {
+        const rows = await this.collection.aggregate([
+          { $match: { ...baseMatch, os: { $ne: null } } },
+          { $group: { _id: "$os", value: { $addToSet: "$visitor_id" } } },
+          { $project: { _id: 1, value: { $size: "$value" } } },
+          { $sort: { value: -1 } },
+          { $limit: limit }
+        ]).toArray();
+        data = rows.map((r) => ({ key: r._id, value: r.value }));
+        total = data.reduce((sum, d) => sum + d.value, 0);
+        break;
+      }
+    }
+    const result = { metric: q.metric, period, data, total };
+    if (q.compare && ["pageviews", "visitors", "sessions", "events"].includes(q.metric)) {
+      const prevRange = previousPeriodRange(dateRange);
+      const prevResult = await this.query({
+        ...q,
+        compare: false,
+        period: "custom",
+        dateFrom: prevRange.from,
+        dateTo: prevRange.to
+      });
+      result.previousTotal = prevResult.total;
+      if (prevResult.total > 0) {
+        result.changePercent = Math.round((total - prevResult.total) / prevResult.total * 1e3) / 10;
+      } else if (total > 0) {
+        result.changePercent = 100;
+      } else {
+        result.changePercent = 0;
+      }
+    }
+    return result;
+  }
+  // ─── Time Series ──────────────────────────────────────
+  async queryTimeSeries(params) {
+    const { dateRange, period } = resolvePeriod({
+      period: params.period,
+      dateFrom: params.dateFrom,
+      dateTo: params.dateTo
+    });
+    const granularity = params.granularity ?? autoGranularity(period);
+    const baseMatch = {
+      site_id: params.siteId,
+      timestamp: { $gte: new Date(dateRange.from), $lte: new Date(dateRange.to) }
+    };
+    if (params.metric === "pageviews") {
+      baseMatch.type = "pageview";
+    }
+    const dateFormat = granularityToDateFormat(granularity);
+    let pipeline;
+    if (params.metric === "visitors" || params.metric === "sessions") {
+      const groupField = params.metric === "visitors" ? "$visitor_id" : "$session_id";
+      pipeline = [
+        { $match: baseMatch },
+        {
+          $group: {
+            _id: {
+              bucket: { $dateToString: { format: dateFormat, date: "$timestamp" } },
+              entity: groupField
+            }
+          }
+        },
+        {
+          $group: {
+            _id: "$_id.bucket",
+            value: { $sum: 1 }
+          }
+        },
+        { $sort: { _id: 1 } }
+      ];
+    } else {
+      pipeline = [
+        { $match: baseMatch },
+        {
+          $group: {
+            _id: { $dateToString: { format: dateFormat, date: "$timestamp" } },
+            value: { $sum: 1 }
+          }
+        },
+        { $sort: { _id: 1 } }
+      ];
+    }
+    const rows = await this.collection.aggregate(pipeline).toArray();
+    const data = fillBuckets(
+      new Date(dateRange.from),
+      new Date(dateRange.to),
+      granularity,
+      dateFormat,
+      rows
+    );
+    return { metric: params.metric, granularity, data };
+  }
+  // ─── Retention ──────────────────────────────────────
+  async queryRetention(params) {
+    const weeks = params.weeks ?? 8;
+    const now = /* @__PURE__ */ new Date();
+    const startDate = new Date(now.getTime() - weeks * 7 * 24 * 60 * 60 * 1e3);
+    const pipeline = [
+      {
+        $match: {
+          site_id: params.siteId,
+          timestamp: { $gte: startDate }
+        }
+      },
+      {
+        $group: {
+          _id: "$visitor_id",
+          firstEvent: { $min: "$timestamp" },
+          eventWeeks: {
+            $addToSet: {
+              $dateToString: { format: "%G-W%V", date: "$timestamp" }
+            }
+          }
+        }
+      }
+    ];
+    const visitors = await this.collection.aggregate(pipeline).toArray();
+    const cohortMap = /* @__PURE__ */ new Map();
+    for (const v of visitors) {
+      const cohortWeek = getISOWeek(v.firstEvent);
+      if (!cohortMap.has(cohortWeek)) {
+        cohortMap.set(cohortWeek, { visitors: /* @__PURE__ */ new Set(), weekSets: /* @__PURE__ */ new Map() });
+      }
+      const cohort = cohortMap.get(cohortWeek);
+      cohort.visitors.add(v._id);
+      for (const w of v.eventWeeks) {
+        if (!cohort.weekSets.has(w)) {
+          cohort.weekSets.set(w, /* @__PURE__ */ new Set());
+        }
+        cohort.weekSets.get(w).add(v._id);
+      }
+    }
+    const sortedWeeks = Array.from(cohortMap.keys()).sort();
+    const cohorts = sortedWeeks.map((week) => {
+      const cohort = cohortMap.get(week);
+      const size = cohort.visitors.size;
+      const retention = [];
+      const weekIndex = sortedWeeks.indexOf(week);
+      for (let i = 0; i < weeks && weekIndex + i < sortedWeeks.length; i++) {
+        const targetWeek = sortedWeeks[weekIndex + i];
+        const returnedCount = cohort.weekSets.get(targetWeek)?.size ?? 0;
+        retention.push(size > 0 ? Math.round(returnedCount / size * 1e3) / 10 : 0);
+      }
+      return { week, size, retention };
+    });
+    return { cohorts };
+  }
+  // ─── Event Listing ──────────────────────────────────────
+  async listEvents(params) {
+    const limit = Math.min(params.limit ?? 50, 200);
+    const offset = params.offset ?? 0;
+    const match = { site_id: params.siteId };
+    if (params.type) match.type = params.type;
+    if (params.eventName) match.event_name = params.eventName;
+    if (params.visitorId) match.visitor_id = params.visitorId;
+    if (params.userId) match.user_id = params.userId;
+    if (params.period || params.dateFrom) {
+      const { dateRange } = resolvePeriod({
+        period: params.period,
+        dateFrom: params.dateFrom,
+        dateTo: params.dateTo
+      });
+      match.timestamp = { $gte: new Date(dateRange.from), $lte: new Date(dateRange.to) };
+    }
+    const [events, countResult] = await Promise.all([
+      this.collection.find(match).sort({ timestamp: -1 }).skip(offset).limit(limit).toArray(),
+      this.collection.countDocuments(match)
+    ]);
+    return {
+      events: events.map((e) => this.toEventListItem(e)),
+      total: countResult,
+      limit,
+      offset
+    };
+  }
+  // ─── User Listing ──────────────────────────────────────
+  async listUsers(params) {
+    const limit = Math.min(params.limit ?? 50, 200);
+    const offset = params.offset ?? 0;
+    const match = { site_id: params.siteId };
+    if (params.search) {
+      match.$or = [
+        { visitor_id: { $regex: params.search, $options: "i" } },
+        { user_id: { $regex: params.search, $options: "i" } }
+      ];
+    }
+    const pipeline = [
+      { $match: match },
+      {
+        $group: {
+          _id: "$visitor_id",
+          userId: { $last: "$user_id" },
+          traits: { $last: "$traits" },
+          firstSeen: { $min: "$timestamp" },
+          lastSeen: { $max: "$timestamp" },
+          totalEvents: { $sum: 1 },
+          totalPageviews: { $sum: { $cond: [{ $eq: ["$type", "pageview"] }, 1, 0] } },
+          sessions: { $addToSet: "$session_id" },
+          lastUrl: { $last: "$url" },
+          device_type: { $last: "$device_type" },
+          browser: { $last: "$browser" },
+          os: { $last: "$os" },
+          country: { $last: "$country" },
+          city: { $last: "$city" },
+          region: { $last: "$region" },
+          language: { $last: "$language" }
+        }
+      },
+      { $sort: { lastSeen: -1 } },
+      {
+        $facet: {
+          data: [{ $skip: offset }, { $limit: limit }],
+          count: [{ $count: "total" }]
+        }
+      }
+    ];
+    const [result] = await this.collection.aggregate(pipeline).toArray();
+    const users = (result?.data ?? []).map((u) => ({
+      visitorId: u._id,
+      userId: u.userId ?? void 0,
+      traits: u.traits ?? void 0,
+      firstSeen: u.firstSeen.toISOString(),
+      lastSeen: u.lastSeen.toISOString(),
+      totalEvents: u.totalEvents,
+      totalPageviews: u.totalPageviews,
+      totalSessions: u.sessions.length,
+      lastUrl: u.lastUrl ?? void 0,
+      device: u.device_type ? { type: u.device_type, browser: u.browser ?? "", os: u.os ?? "" } : void 0,
+      geo: u.country ? { country: u.country, city: u.city ?? void 0, region: u.region ?? void 0 } : void 0,
+      language: u.language ?? void 0
+    }));
+    return {
+      users,
+      total: result?.count?.[0]?.total ?? 0,
+      limit,
+      offset
+    };
+  }
+  async getUserDetail(siteId, visitorId) {
+    const result = await this.listUsers({ siteId, search: visitorId, limit: 1 });
+    const user = result.users.find((u) => u.visitorId === visitorId);
+    return user ?? null;
+  }
+  async getUserEvents(siteId, visitorId, params) {
+    return this.listEvents({ ...params, siteId, visitorId });
+  }
+  toEventListItem(doc) {
+    return {
+      id: doc._id?.toString?.() ?? "",
+      type: doc.type,
+      timestamp: doc.timestamp.toISOString(),
+      visitorId: doc.visitor_id,
+      sessionId: doc.session_id,
+      url: doc.url ?? void 0,
+      referrer: doc.referrer ?? void 0,
+      title: doc.title ?? void 0,
+      name: doc.event_name ?? void 0,
+      properties: doc.properties ?? void 0,
+      userId: doc.user_id ?? void 0,
+      traits: doc.traits ?? void 0,
+      geo: doc.country ? { country: doc.country, city: doc.city ?? void 0, region: doc.region ?? void 0 } : void 0,
+      device: doc.device_type ? { type: doc.device_type, browser: doc.browser ?? "", os: doc.os ?? "" } : void 0,
+      language: doc.language ?? void 0,
+      utm: doc.utm_source ? {
+        source: doc.utm_source ?? void 0,
+        medium: doc.utm_medium ?? void 0,
+        campaign: doc.utm_campaign ?? void 0,
+        term: doc.utm_term ?? void 0,
+        content: doc.utm_content ?? void 0
+      } : void 0
+    };
+  }
+  // ─── Site Management ──────────────────────────────────────
+  async createSite(data) {
+    const now = /* @__PURE__ */ new Date();
+    const doc = {
+      site_id: generateSiteId(),
+      secret_key: generateSecretKey(),
+      name: data.name,
+      domain: data.domain ?? null,
+      allowed_origins: data.allowedOrigins ?? null,
+      created_at: now,
+      updated_at: now
+    };
+    await this.sites.insertOne(doc);
+    return this.toSite(doc);
+  }
+  async getSite(siteId) {
+    const doc = await this.sites.findOne({ site_id: siteId });
+    return doc ? this.toSite(doc) : null;
+  }
+  async getSiteBySecret(secretKey) {
+    const doc = await this.sites.findOne({ secret_key: secretKey });
+    return doc ? this.toSite(doc) : null;
+  }
+  async listSites() {
+    const docs = await this.sites.find({}).sort({ created_at: -1 }).toArray();
+    return docs.map((d) => this.toSite(d));
+  }
+  async updateSite(siteId, data) {
+    const updates = { updated_at: /* @__PURE__ */ new Date() };
+    if (data.name !== void 0) updates.name = data.name;
+    if (data.domain !== void 0) updates.domain = data.domain || null;
+    if (data.allowedOrigins !== void 0) updates.allowed_origins = data.allowedOrigins.length > 0 ? data.allowedOrigins : null;
+    const result = await this.sites.findOneAndUpdate(
+      { site_id: siteId },
+      { $set: updates },
+      { returnDocument: "after" }
+    );
+    return result ? this.toSite(result) : null;
+  }
+  async deleteSite(siteId) {
+    const result = await this.sites.deleteOne({ site_id: siteId });
+    return result.deletedCount > 0;
+  }
+  async regenerateSecret(siteId) {
+    const result = await this.sites.findOneAndUpdate(
+      { site_id: siteId },
+      { $set: { secret_key: generateSecretKey(), updated_at: /* @__PURE__ */ new Date() } },
+      { returnDocument: "after" }
+    );
+    return result ? this.toSite(result) : null;
+  }
+  async close() {
+    await this.client.close();
+  }
+  // ─── Helpers ─────────────────────────────────────────────
+  toSite(doc) {
+    return {
+      siteId: doc.site_id,
+      secretKey: doc.secret_key,
+      name: doc.name,
+      domain: doc.domain ?? void 0,
+      allowedOrigins: doc.allowed_origins ?? void 0,
+      createdAt: doc.created_at.toISOString(),
+      updatedAt: doc.updated_at.toISOString()
+    };
+  }
+};
+
+// src/geoip.ts
+var reader = null;
+var TZ_COUNTRY = {
+  // Americas
+  "America/New_York": "US",
+  "America/Chicago": "US",
+  "America/Denver": "US",
+  "America/Los_Angeles": "US",
+  "America/Anchorage": "US",
+  "Pacific/Honolulu": "US",
+  "America/Phoenix": "US",
+  "America/Detroit": "US",
+  "America/Indiana/Indianapolis": "US",
+  "America/Toronto": "CA",
+  "America/Vancouver": "CA",
+  "America/Edmonton": "CA",
+  "America/Winnipeg": "CA",
+  "America/Halifax": "CA",
+  "America/Montreal": "CA",
+  "America/Mexico_City": "MX",
+  "America/Cancun": "MX",
+  "America/Tijuana": "MX",
+  "America/Sao_Paulo": "BR",
+  "America/Fortaleza": "BR",
+  "America/Manaus": "BR",
+  "America/Argentina/Buenos_Aires": "AR",
+  "America/Bogota": "CO",
+  "America/Santiago": "CL",
+  "America/Lima": "PE",
+  // Europe
+  "Europe/London": "GB",
+  "Europe/Dublin": "IE",
+  "Europe/Paris": "FR",
+  "Europe/Berlin": "DE",
+  "Europe/Amsterdam": "NL",
+  "Europe/Brussels": "BE",
+  "Europe/Zurich": "CH",
+  "Europe/Vienna": "AT",
+  "Europe/Rome": "IT",
+  "Europe/Madrid": "ES",
+  "Europe/Lisbon": "PT",
+  "Europe/Warsaw": "PL",
+  "Europe/Prague": "CZ",
+  "Europe/Budapest": "HU",
+  "Europe/Bucharest": "RO",
+  "Europe/Sofia": "BG",
+  "Europe/Athens": "GR",
+  "Europe/Helsinki": "FI",
+  "Europe/Stockholm": "SE",
+  "Europe/Oslo": "NO",
+  "Europe/Copenhagen": "DK",
+  "Europe/Istanbul": "TR",
+  "Europe/Moscow": "RU",
+  "Europe/Kiev": "UA",
+  "Europe/Belgrade": "RS",
+  "Europe/Zagreb": "HR",
+  // Asia
+  "Asia/Tokyo": "JP",
+  "Asia/Seoul": "KR",
+  "Asia/Shanghai": "CN",
+  "Asia/Hong_Kong": "HK",
+  "Asia/Taipei": "TW",
+  "Asia/Singapore": "SG",
+  "Asia/Kolkata": "IN",
+  "Asia/Mumbai": "IN",
+  "Asia/Karachi": "PK",
+  "Asia/Dubai": "AE",
+  "Asia/Riyadh": "SA",
+  "Asia/Tehran": "IR",
+  "Asia/Baghdad": "IQ",
+  "Asia/Bangkok": "TH",
+  "Asia/Jakarta": "ID",
+  "Asia/Manila": "PH",
+  "Asia/Ho_Chi_Minh": "VN",
+  "Asia/Kuala_Lumpur": "MY",
+  "Asia/Dhaka": "BD",
+  "Asia/Colombo": "LK",
+  "Asia/Jerusalem": "IL",
+  // Oceania
+  "Australia/Sydney": "AU",
+  "Australia/Melbourne": "AU",
+  "Australia/Brisbane": "AU",
+  "Australia/Perth": "AU",
+  "Australia/Adelaide": "AU",
+  "Pacific/Auckland": "NZ",
+  "Pacific/Fiji": "FJ",
+  // Africa
+  "Africa/Cairo": "EG",
+  "Africa/Lagos": "NG",
+  "Africa/Johannesburg": "ZA",
+  "Africa/Nairobi": "KE",
+  "Africa/Casablanca": "MA",
+  "Africa/Algiers": "DZ",
+  "Africa/Accra": "GH",
+  "Africa/Tunis": "TN"
+};
+async function initGeoIP(dbPath) {
+  try {
+    const maxmind = await import("maxmind");
+    const path = dbPath || await findGeoLiteDB();
+    if (path) {
+      reader = await maxmind.open(path);
+    }
+  } catch {
+  }
+}
+function resolveGeo(ip, timezone) {
+  if (!ip && !timezone) return {};
+  if (reader && ip) {
+    try {
+      const cleanIp = ip.replace(/^::ffff:/, "");
+      const result = reader.get(cleanIp);
+      if (result?.country?.iso_code) {
+        return {
+          country: result.country.iso_code,
+          city: result.city?.names?.en || void 0,
+          region: result.subdivisions?.[0]?.names?.en || void 0
+        };
+      }
+    } catch {
+    }
+  }
+  if (timezone) {
+    const country = TZ_COUNTRY[timezone];
+    if (country) {
+      return { country };
+    }
+  }
+  return {};
+}
+async function findGeoLiteDB() {
+  const { existsSync } = await import("fs");
+  const { join } = await import("path");
+  const { homedir } = await import("os");
+  const candidates = [
+    join(process.cwd(), "GeoLite2-City.mmdb"),
+    join(homedir(), ".litemetrics", "GeoLite2-City.mmdb"),
+    "/usr/share/GeoIP/GeoLite2-City.mmdb",
+    "/var/lib/GeoIP/GeoLite2-City.mmdb"
+  ];
+  for (const p of candidates) {
+    if (existsSync(p)) return p;
+  }
+  return null;
+}
+
+// src/useragent.ts
+import { UAParser } from "ua-parser-js";
+var parser = new UAParser();
+function parseUserAgent(ua) {
+  parser.setUA(ua);
+  const result = parser.getResult();
+  return {
+    type: resolveDeviceType(result.device?.type),
+    browser: result.browser?.name || "Unknown",
+    os: result.os?.name || "Unknown"
+  };
+}
+function resolveDeviceType(type) {
+  if (type === "mobile") return "mobile";
+  if (type === "tablet") return "tablet";
+  return "desktop";
+}
+
+// src/collector.ts
+async function createCollector(config) {
+  const db = createAdapter(config.db);
+  await db.init();
+  if (config.geoip) {
+    const geoipConfig = typeof config.geoip === "object" ? config.geoip : {};
+    await initGeoIP(geoipConfig.dbPath);
+  }
+  function isAdmin(req) {
+    if (!config.adminSecret) return false;
+    return req.headers?.["x-litemetrics-admin-secret"] === config.adminSecret;
+  }
+  async function isAuthorizedForSite(req, siteId) {
+    if (isAdmin(req)) return true;
+    const secret = req.headers?.["x-litemetrics-secret"];
+    if (!secret) return false;
+    const site = await db.getSiteBySecret(secret);
+    return site !== null && site.siteId === siteId;
+  }
+  function setCors(req, res, methods, extraHeaders) {
+    if (!config.cors) return false;
+    const origin = req.headers?.origin;
+    const allowed = !config.cors.origins || config.cors.origins.length === 0 || config.cors.origins.includes(origin);
+    if (allowed) {
+      res.setHeader?.("Access-Control-Allow-Origin", origin || "*");
+      res.setHeader?.("Access-Control-Allow-Methods", methods);
+      const headers = ["Content-Type", extraHeaders].filter(Boolean).join(", ");
+      res.setHeader?.("Access-Control-Allow-Headers", headers);
+    }
+    if (req.method === "OPTIONS") {
+      res.writeHead?.(204);
+      res.end?.();
+      return true;
+    }
+    return false;
+  }
+  function enrichEvents(events, ip, userAgent) {
+    const device = parseUserAgent(userAgent);
+    return events.map((event) => {
+      const geo = resolveGeo(ip, event.timezone);
+      return { ...event, ip, geo, device };
+    });
+  }
+  function extractIp(req) {
+    if (config.trustProxy ?? true) {
+      const forwarded = req.headers?.["x-forwarded-for"];
+      if (forwarded) {
+        const first = typeof forwarded === "string" ? forwarded.split(",")[0] : forwarded[0];
+        return first.trim();
+      }
+      if (req.headers?.["x-real-ip"]) return req.headers["x-real-ip"];
+    }
+    return req.ip || req.socket?.remoteAddress || req.connection?.remoteAddress || "";
+  }
+  function handler() {
+    return async (req, res) => {
+      if (setCors(req, res, "POST, OPTIONS")) return;
+      if (req.method !== "POST") {
+        sendJson(res, 405, { ok: false, error: "Method not allowed" });
+        return;
+      }
+      try {
+        const body = await parseBody(req);
+        const payload = body;
+        if (!payload?.events || !Array.isArray(payload.events) || payload.events.length === 0) {
+          sendJson(res, 400, { ok: false, error: "No events provided" });
+          return;
+        }
+        if (payload.events.length > 100) {
+          sendJson(res, 400, { ok: false, error: "Too many events (max 100)" });
+          return;
+        }
+        const ip = extractIp(req);
+        const userAgent = req.headers?.["user-agent"] || "";
+        const enriched = enrichEvents(payload.events, ip, userAgent);
+        await db.insertEvents(enriched);
+        sendJson(res, 200, { ok: true });
+      } catch (err) {
+        sendJson(res, 500, { ok: false, error: err instanceof Error ? err.message : "Internal error" });
+      }
+    };
+  }
+  function queryHandler() {
+    return async (req, res) => {
+      if (setCors(req, res, "GET, OPTIONS", "X-Litemetrics-Secret, X-Litemetrics-Admin-Secret")) return;
+      try {
+        const params = extractQueryParams(req);
+        if (!params.siteId) {
+          sendJson(res, 400, { ok: false, error: "siteId is required" });
+          return;
+        }
+        if (!params.metric) {
+          sendJson(res, 400, { ok: false, error: "metric is required" });
+          return;
+        }
+        const authorized = await isAuthorizedForSite(req, params.siteId);
+        if (!authorized) {
+          sendJson(res, 401, { ok: false, error: "Invalid or missing secret key" });
+          return;
+        }
+        if (params.metric === "timeseries") {
+          const q = req.query ?? Object.fromEntries(new URL(req.url, "http://localhost").searchParams);
+          const tsParams = {
+            siteId: params.siteId,
+            metric: q.tsMetric || "pageviews",
+            period: params.period,
+            dateFrom: params.dateFrom,
+            dateTo: params.dateTo,
+            granularity: q.granularity
+          };
+          const result2 = await db.queryTimeSeries(tsParams);
+          sendJson(res, 200, result2);
+          return;
+        }
+        if (params.metric === "retention") {
+          const q = req.query ?? Object.fromEntries(new URL(req.url, "http://localhost").searchParams);
+          const retentionParams = {
+            siteId: params.siteId,
+            period: params.period,
+            weeks: q.weeks ? parseInt(q.weeks, 10) : void 0
+          };
+          const result2 = await db.queryRetention(retentionParams);
+          sendJson(res, 200, result2);
+          return;
+        }
+        const result = await db.query(params);
+        sendJson(res, 200, result);
+      } catch (err) {
+        sendJson(res, 500, { ok: false, error: err instanceof Error ? err.message : "Internal error" });
+      }
+    };
+  }
+  function sitesHandler() {
+    return async (req, res) => {
+      if (setCors(req, res, "GET, POST, PUT, DELETE, OPTIONS", "X-Litemetrics-Admin-Secret")) return;
+      if (!isAdmin(req)) {
+        sendJson(res, 401, { ok: false, error: "Unauthorized - invalid or missing admin secret" });
+        return;
+      }
+      try {
+        const method = req.method;
+        const url = new URL(req.url || "/", "http://localhost");
+        const pathSegments = url.pathname.split("/").filter(Boolean);
+        const sitesIdx = pathSegments.indexOf("sites");
+        const siteId = sitesIdx >= 0 ? pathSegments[sitesIdx + 1] : void 0;
+        const action = sitesIdx >= 0 ? pathSegments[sitesIdx + 2] : void 0;
+        if (method === "POST" && siteId && action === "regenerate") {
+          const site = await db.regenerateSecret(siteId);
+          if (!site) {
+            sendJson(res, 404, { ok: false, error: "Site not found" });
+            return;
+          }
+          sendJson(res, 200, { site });
+          return;
+        }
+        if (method === "GET" && !siteId) {
+          const sites = await db.listSites();
+          sendJson(res, 200, { sites, total: sites.length });
+          return;
+        }
+        if (method === "GET" && siteId) {
+          const site = await db.getSite(siteId);
+          if (!site) {
+            sendJson(res, 404, { ok: false, error: "Site not found" });
+            return;
+          }
+          sendJson(res, 200, { site });
+          return;
+        }
+        if (method === "POST" && !siteId) {
+          const body = await parseBody(req);
+          if (!body.name || typeof body.name !== "string" || !body.name.trim()) {
+            sendJson(res, 400, { ok: false, error: "Site name is required" });
+            return;
+          }
+          const site = await db.createSite(body);
+          sendJson(res, 201, { site });
+          return;
+        }
+        if (method === "PUT" && siteId) {
+          const body = await parseBody(req);
+          const site = await db.updateSite(siteId, body);
+          if (!site) {
+            sendJson(res, 404, { ok: false, error: "Site not found" });
+            return;
+          }
+          sendJson(res, 200, { site });
+          return;
+        }
+        if (method === "DELETE" && siteId) {
+          const deleted = await db.deleteSite(siteId);
+          if (!deleted) {
+            sendJson(res, 404, { ok: false, error: "Site not found" });
+            return;
+          }
+          sendJson(res, 200, { ok: true });
+          return;
+        }
+        sendJson(res, 404, { ok: false, error: "Not found" });
+      } catch (err) {
+        sendJson(res, 500, { ok: false, error: err instanceof Error ? err.message : "Internal error" });
+      }
+    };
+  }
+  function eventsHandler() {
+    return async (req, res) => {
+      if (setCors(req, res, "GET, OPTIONS", "X-Litemetrics-Secret, X-Litemetrics-Admin-Secret")) return;
+      if (req.method !== "GET") {
+        sendJson(res, 405, { ok: false, error: "Method not allowed" });
+        return;
+      }
+      try {
+        const q = req.query ?? Object.fromEntries(new URL(req.url, "http://localhost").searchParams);
+        if (!q.siteId) {
+          sendJson(res, 400, { ok: false, error: "siteId is required" });
+          return;
+        }
+        const authorized = await isAuthorizedForSite(req, q.siteId);
+        if (!authorized) {
+          sendJson(res, 401, { ok: false, error: "Invalid or missing secret key" });
+          return;
+        }
+        const params = {
+          siteId: q.siteId,
+          type: q.type,
+          eventName: q.eventName,
+          visitorId: q.visitorId,
+          userId: q.userId,
+          period: q.period,
+          dateFrom: q.dateFrom,
+          dateTo: q.dateTo,
+          limit: q.limit ? parseInt(q.limit, 10) : void 0,
+          offset: q.offset ? parseInt(q.offset, 10) : void 0
+        };
+        const result = await db.listEvents(params);
+        sendJson(res, 200, result);
+      } catch (err) {
+        sendJson(res, 500, { ok: false, error: err instanceof Error ? err.message : "Internal error" });
+      }
+    };
+  }
+  function usersHandler() {
+    return async (req, res) => {
+      if (setCors(req, res, "GET, OPTIONS", "X-Litemetrics-Secret, X-Litemetrics-Admin-Secret")) return;
+      if (req.method !== "GET") {
+        sendJson(res, 405, { ok: false, error: "Method not allowed" });
+        return;
+      }
+      try {
+        const q = req.query ?? Object.fromEntries(new URL(req.url, "http://localhost").searchParams);
+        if (!q.siteId) {
+          sendJson(res, 400, { ok: false, error: "siteId is required" });
+          return;
+        }
+        const authorized = await isAuthorizedForSite(req, q.siteId);
+        if (!authorized) {
+          sendJson(res, 401, { ok: false, error: "Invalid or missing secret key" });
+          return;
+        }
+        const url = new URL(req.url || "/", "http://localhost");
+        const pathSegments = url.pathname.split("/").filter(Boolean);
+        const usersIdx = pathSegments.indexOf("users");
+        const visitorId = usersIdx >= 0 ? pathSegments[usersIdx + 1] : void 0;
+        const action = usersIdx >= 0 ? pathSegments[usersIdx + 2] : void 0;
+        if (visitorId && action === "events") {
+          const params2 = {
+            siteId: q.siteId,
+            type: q.type,
+            period: q.period,
+            dateFrom: q.dateFrom,
+            dateTo: q.dateTo,
+            limit: q.limit ? parseInt(q.limit, 10) : void 0,
+            offset: q.offset ? parseInt(q.offset, 10) : void 0
+          };
+          const result2 = await db.getUserEvents(q.siteId, decodeURIComponent(visitorId), params2);
+          sendJson(res, 200, result2);
+          return;
+        }
+        if (visitorId) {
+          const user = await db.getUserDetail(q.siteId, decodeURIComponent(visitorId));
+          if (!user) {
+            sendJson(res, 404, { ok: false, error: "User not found" });
+            return;
+          }
+          sendJson(res, 200, { user });
+          return;
+        }
+        const params = {
+          siteId: q.siteId,
+          search: q.search,
+          limit: q.limit ? parseInt(q.limit, 10) : void 0,
+          offset: q.offset ? parseInt(q.offset, 10) : void 0
+        };
+        const result = await db.listUsers(params);
+        sendJson(res, 200, result);
+      } catch (err) {
+        sendJson(res, 500, { ok: false, error: err instanceof Error ? err.message : "Internal error" });
+      }
+    };
+  }
+  return {
+    handler,
+    queryHandler,
+    eventsHandler,
+    usersHandler,
+    sitesHandler,
+    async query(params) {
+      return db.query(params);
+    },
+    async listEvents(params) {
+      return db.listEvents(params);
+    },
+    async listUsers(params) {
+      return db.listUsers(params);
+    },
+    async getUserDetail(siteId, visitorId) {
+      return db.getUserDetail(siteId, visitorId);
+    },
+    async getUserEvents(siteId, visitorId, params) {
+      return db.getUserEvents(siteId, visitorId, params);
+    },
+    async track(siteId, name, properties, options) {
+      const event = {
+        type: "event",
+        siteId,
+        timestamp: Date.now(),
+        sessionId: "server",
+        visitorId: "server",
+        name,
+        properties,
+        userId: options?.userId,
+        ip: options?.ip,
+        geo: options?.ip ? resolveGeo(options.ip) : void 0
+      };
+      await db.insertEvents([event]);
+    },
+    async identify(siteId, userId, traits, options) {
+      const event = {
+        type: "identify",
+        siteId,
+        timestamp: Date.now(),
+        sessionId: "server",
+        visitorId: "server",
+        userId,
+        traits,
+        ip: options?.ip,
+        geo: options?.ip ? resolveGeo(options.ip) : void 0
+      };
+      await db.insertEvents([event]);
+    },
+    // Programmatic site management
+    createSite: (data) => db.createSite(data),
+    listSites: () => db.listSites(),
+    getSite: (siteId) => db.getSite(siteId),
+    updateSite: (siteId, data) => db.updateSite(siteId, data),
+    deleteSite: (siteId) => db.deleteSite(siteId),
+    regenerateSecret: (siteId) => db.regenerateSecret(siteId),
+    async close() {
+      await db.close();
+    }
+  };
+}
+function createAdapter(config) {
+  const adapter = config.adapter ?? "clickhouse";
+  switch (adapter) {
+    case "clickhouse":
+      return new ClickHouseAdapter(config.url);
+    case "mongodb":
+      return new MongoDBAdapter(config.url);
+    default:
+      throw new Error(`Unknown DB adapter: ${adapter}. Supported: clickhouse, mongodb`);
+  }
+}
+async function parseBody(req) {
+  if (req.body) return req.body;
+  return new Promise((resolve, reject) => {
+    let data = "";
+    req.on("data", (chunk) => {
+      data += chunk.toString();
+    });
+    req.on("end", () => {
+      try {
+        resolve(JSON.parse(data));
+      } catch {
+        reject(new Error("Invalid JSON"));
+      }
+    });
+    req.on("error", reject);
+  });
+}
+function extractQueryParams(req) {
+  const q = req.query ?? Object.fromEntries(new URL(req.url, "http://localhost").searchParams);
+  return {
+    siteId: q.siteId,
+    metric: q.metric,
+    period: q.period,
+    dateFrom: q.dateFrom,
+    dateTo: q.dateTo,
+    limit: q.limit ? parseInt(q.limit, 10) : void 0,
+    filters: q.filters ? JSON.parse(q.filters) : void 0,
+    compare: q.compare === "true" || q.compare === "1"
+  };
+}
+function sendJson(res, status, body) {
+  if (typeof res.status === "function" && typeof res.json === "function") {
+    res.status(status).json(body);
+    return;
+  }
+  res.writeHead(status, { "Content-Type": "application/json" });
+  res.end(JSON.stringify(body));
+}
+export {
+  ClickHouseAdapter,
+  MongoDBAdapter,
+  createCollector
+};
+//# sourceMappingURL=index.js.map