@atproto/ozone 0.1.173 → 0.1.174

package/dist/report/stats.js

@@ -0,0 +1,619 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ReportStatsService = exports.REPORT_TYPE_GROUPS = void 0;
+const kysely_1 = require("kysely");
+const common_1 = require("@atproto/common");
+const pagination_1 = require("../db/pagination");
+const types_1 = require("../db/types");
+const logger_1 = require("../logger");
+/**
+ * Grouped report types. Stats are computed per group rather than per individual report type.
+ */
+exports.REPORT_TYPE_GROUPS = {
+    Legacy: [
+        'com.atproto.moderation.defs#reasonSpam',
+        'com.atproto.moderation.defs#reasonViolation',
+        'com.atproto.moderation.defs#reasonMisleading',
+        'com.atproto.moderation.defs#reasonSexual',
+        'com.atproto.moderation.defs#reasonRude',
+        'com.atproto.moderation.defs#reasonOther',
+        'com.atproto.moderation.defs#reasonAppeal',
+    ],
+    Appeal: ['tools.ozone.report.defs#reasonAppeal'],
+    Violence: [
+        'tools.ozone.report.defs#reasonViolenceAnimalWelfare',
+        'tools.ozone.report.defs#reasonViolenceThreats',
+        'tools.ozone.report.defs#reasonViolenceGraphicContent',
+        'tools.ozone.report.defs#reasonViolenceSelfHarm',
+        'tools.ozone.report.defs#reasonViolenceGlorification',
+        'tools.ozone.report.defs#reasonViolenceExtremistContent',
+        'tools.ozone.report.defs#reasonViolenceTrafficking',
+        'tools.ozone.report.defs#reasonViolenceOther',
+    ],
+    Sexual: [
+        'tools.ozone.report.defs#reasonSexualAbuseContent',
+        'tools.ozone.report.defs#reasonSexualNCII',
+        'tools.ozone.report.defs#reasonSexualSextortion',
+        'tools.ozone.report.defs#reasonSexualDeepfake',
+        'tools.ozone.report.defs#reasonSexualAnimal',
+        'tools.ozone.report.defs#reasonSexualUnlabeled',
+        'tools.ozone.report.defs#reasonSexualOther',
+    ],
+    'Child Safety': [
+        'tools.ozone.report.defs#reasonChildSafetyCSAM',
+        'tools.ozone.report.defs#reasonChildSafetyGroom',
+        'tools.ozone.report.defs#reasonChildSafetyMinorPrivacy',
+        'tools.ozone.report.defs#reasonChildSafetyEndangerment',
+        'tools.ozone.report.defs#reasonChildSafetyHarassment',
+        'tools.ozone.report.defs#reasonChildSafetyPromotion',
+        'tools.ozone.report.defs#reasonChildSafetyOther',
+    ],
+    Harassment: [
+        'tools.ozone.report.defs#reasonHarassmentTroll',
+        'tools.ozone.report.defs#reasonHarassmentTargeted',
+        'tools.ozone.report.defs#reasonHarassmentHateSpeech',
+        'tools.ozone.report.defs#reasonHarassmentDoxxing',
+        'tools.ozone.report.defs#reasonHarassmentOther',
+    ],
+    Misleading: [
+        'tools.ozone.report.defs#reasonMisleadingBot',
+        'tools.ozone.report.defs#reasonMisleadingImpersonation',
+        'tools.ozone.report.defs#reasonMisleadingSpam',
+        'tools.ozone.report.defs#reasonMisleadingScam',
+        'tools.ozone.report.defs#reasonMisleadingSyntheticContent',
+        'tools.ozone.report.defs#reasonMisleadingMisinformation',
+        'tools.ozone.report.defs#reasonMisleadingOther',
+    ],
+    'Rule Violations': [
+        'tools.ozone.report.defs#reasonRuleSiteSecurity',
+        'tools.ozone.report.defs#reasonRuleStolenContent',
+        'tools.ozone.report.defs#reasonRuleProhibitedSales',
+        'tools.ozone.report.defs#reasonRuleBanEvasion',
+        'tools.ozone.report.defs#reasonRuleOther',
+    ],
+    Civic: [
+        'tools.ozone.report.defs#reasonCivicElectoralProcess',
+        'tools.ozone.report.defs#reasonCivicDisclosure',
+        'tools.ozone.report.defs#reasonCivicInterference',
+        'tools.ozone.report.defs#reasonCivicMisinformation',
+        'tools.ozone.report.defs#reasonCivicImpersonation',
+    ],
+};
+const REPORT_STAT_LIVE_TTL = 15 * common_1.MINUTE;
+class ReportStatsService {
+    constructor(db) {
+        Object.defineProperty(this, "db", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: db
+        });
+    }
+    static creator() {
+        return (db) => new ReportStatsService(db);
+    }
+    /**
+     * Compute stats for today and finalize yesterday if needed.
+     * Called periodically by the StatsComputer daemon.
+     */
+    async materializeAll(opts) {
+        try {
+            const start = Date.now();
+            const today = toDateString(new Date());
+            const yesterday = toDateString(new Date(Date.now() - 24 * 60 * 60 * 1000));
+            // Always compute today's stats
+            await this.materializeDate(today, opts);
+            // Finalize yesterday if its snapshot is missing or stale
+            if (!opts?.force) {
+                const yesterdayRow = await this.db.db
+                    .selectFrom('report_stat')
+                    .select('computedAt')
+                    .where('date', '=', yesterday)
+                    .orderBy('computedAt', 'desc')
+                    .executeTakeFirst();
+                const endOfYesterday = new Date(`${yesterday}T23:59:59.999Z`).getTime();
+                if (!yesterdayRow ||
+                    new Date(yesterdayRow.computedAt).getTime() < endOfYesterday) {
+                    await this.materializeDate(yesterday, { force: true });
+                }
+            }
+            else {
+                await this.materializeDate(yesterday, { force: true });
+            }
+            const duration = Date.now() - start;
+            logger_1.dbLogger.info({ duration }, 'report stats materialization completed');
+        }
+        catch (err) {
+            logger_1.dbLogger.error({ err }, 'report stats materialization errored');
+        }
+    }
+    /**
+     * Compute stats for a specific date range. Used by the refreshStats endpoint.
+     */
+    async refreshDateRange(opts) {
+        const start = new Date(opts.startDate);
+        const end = new Date(opts.endDate);
+        for (let d = new Date(start); d <= end; d.setUTCDate(d.getUTCDate() + 1)) {
+            const dateStr = toDateString(d);
+            if (opts.queueIds?.length) {
+                // Recompute only specific queue groups for this date
+                const batched = await this.computeBatchedStats(dateStr);
+                const rows = [];
+                for (const queueId of opts.queueIds) {
+                    const group = {
+                        queueId,
+                        moderatorDid: null,
+                        reportTypes: null,
+                    };
+                    const stats = this.resolveGroupStats(group, batched);
+                    rows.push(this.buildUpsertRow(dateStr, group, stats));
+                }
+                await this.bulkUpsert(rows);
+            }
+            else {
+                await this.materializeDate(dateStr, { force: true });
+            }
+        }
+    }
+    /** Compute and write all groups for a single date. */
+    async materializeDate(date, opts) {
+        const groups = await this.enumerateGroups();
+        const batched = await this.computeBatchedStats(date);
+        const today = toDateString(new Date());
+        const isToday = date === today;
+        // Batch the cache check so we don't issue one SELECT per group.
+        const existingByKey = !opts?.force
+            ? await this.fetchExistingStatsByKey(date)
+            : null;
+        const rows = [];
+        for (const group of groups) {
+            try {
+                if (existingByKey) {
+                    const cached = existingByKey.get(groupKey(group));
+                    if (cached) {
+                        // Historical dates: never recompute. Today: recompute if stale.
+                        if (!isToday)
+                            continue;
+                        const age = Date.now() - new Date(cached.computedAt).getTime();
+                        if (age < REPORT_STAT_LIVE_TTL)
+                            continue;
+                    }
+                }
+                const stats = this.resolveGroupStats(group, batched);
+                rows.push(this.buildUpsertRow(date, group, stats));
+            }
+            catch (err) {
+                logger_1.dbLogger.error({ err, group, date }, 'error preparing report stats group');
+            }
+        }
+        await this.bulkUpsert(rows);
+    }
+    /** Fetch all stat rows for a date, keyed by groupKey for O(1) lookup. */
+    async fetchExistingStatsByKey(date) {
+        const existing = await this.db.db
+            .selectFrom('report_stat')
+            .selectAll()
+            .where('date', '=', date)
+            .execute();
+        const map = new Map();
+        for (const row of existing) {
+            map.set(groupKey({
+                queueId: row.queueId,
+                moderatorDid: row.moderatorDid,
+                reportTypes: row.reportTypes,
+            }), row);
+        }
+        return map;
+    }
+    /** List out the groups to compute stats for. */
+    async enumerateGroups() {
+        const groups = [];
+        const queues = await this.db.db
+            .selectFrom('report_queue')
+            .selectAll()
+            .where('enabled', '=', true)
+            .where('deletedAt', 'is', null)
+            .execute();
+        const members = await this.db.db
+            .selectFrom('member')
+            .select('did')
+            .where('disabled', '=', false)
+            .where('role', 'in', [
+            'tools.ozone.team.defs#roleAdmin',
+            'tools.ozone.team.defs#roleModerator',
+            'tools.ozone.team.defs#roleTriage',
+        ])
+            .execute();
+        // aggregate
+        groups.push({ queueId: null, moderatorDid: null, reportTypes: null });
+        // per queue
+        for (const queue of queues) {
+            groups.push({ queueId: queue.id, moderatorDid: null, reportTypes: null });
+        }
+        // unqueued
+        groups.push({ queueId: -1, moderatorDid: null, reportTypes: null });
+        // per moderator
+        for (const member of members) {
+            groups.push({
+                queueId: null,
+                moderatorDid: member.did,
+                reportTypes: null,
+            });
+        }
+        // per report type group
+        for (const groupTypes of Object.values(exports.REPORT_TYPE_GROUPS)) {
+            groups.push({
+                queueId: null,
+                moderatorDid: null,
+                reportTypes: groupTypes,
+            });
+        }
+        return groups;
+    }
+    /**
+     * Run batched GROUP BY queries for a calendar date.
+     * Returns 5 result sets covering all group types.
+     */
+    async computeBatchedStats(date) {
+        const dayStart = `${date}T00:00:00.000Z`;
+        const dayEnd = `${nextDate(date)}T00:00:00.000Z`;
+        const [queuePending, aggregatePending] = await Promise.all([
+            // Pending count is a snapshot of all non-closed reports at time of computation
+            this.db.db
+                .selectFrom('report')
+                .select(['queueId', (0, kysely_1.sql) `count(*)`.as('count')])
+                .where('status', '!=', 'closed')
+                .where('queueId', 'is not', null)
+                .groupBy('queueId')
+                .execute(),
+            // Aggregate pending (includes all reports, even un-routed)
+            this.db.db
+                .selectFrom('report')
+                .select((0, kysely_1.sql) `count(*)`.as('count'))
+                .where('status', '!=', 'closed')
+                .executeTakeFirst(),
+        ]);
+        const queueWindow = await this.db.db
+            .selectFrom('report')
+            .select([
+            'queueId',
+            (0, kysely_1.sql) `count(*)`.as('inboundCount'),
+            (0, kysely_1.sql) `count(*) filter (where "status" = 'closed' and "closedAt" >= ${dayStart} and "closedAt" < ${dayEnd})`.as('actionedCount'),
+            (0, kysely_1.sql) `count(*) filter (where "status" = 'escalated')`.as('escalatedCount'),
+            (0, kysely_1.sql) `sum(extract(epoch from ("closedAt"::timestamp - "createdAt"::timestamp))) filter (where "status" = 'closed' and "closedAt" is not null and "closedAt" >= ${dayStart} and "closedAt" < ${dayEnd})`.as('handlingTimeSum'),
+            (0, kysely_1.sql) `count(*) filter (where "status" = 'closed' and "closedAt" is not null and "closedAt" >= ${dayStart} and "closedAt" < ${dayEnd})`.as('handlingTimeCount'),
+        ])
+            .where('createdAt', '>=', dayStart)
+            .where('createdAt', '<', dayEnd)
+            .where('queueId', 'is not', null)
+            .groupBy('queueId')
+            .execute();
+        // Aggregate windowed (includes all reports)
+        const aggregateWindow = await this.db.db
+            .selectFrom('report')
+            .select([
+            (0, kysely_1.sql) `count(*)`.as('inboundCount'),
+            (0, kysely_1.sql) `count(*) filter (where "status" = 'closed' and "closedAt" >= ${dayStart} and "closedAt" < ${dayEnd})`.as('actionedCount'),
+            (0, kysely_1.sql) `count(*) filter (where "status" = 'escalated')`.as('escalatedCount'),
+            (0, kysely_1.sql) `sum(extract(epoch from ("closedAt"::timestamp - "createdAt"::timestamp))) filter (where "status" = 'closed' and "closedAt" is not null and "closedAt" >= ${dayStart} and "closedAt" < ${dayEnd})`.as('handlingTimeSum'),
+            (0, kysely_1.sql) `count(*) filter (where "status" = 'closed' and "closedAt" is not null and "closedAt" >= ${dayStart} and "closedAt" < ${dayEnd})`.as('handlingTimeCount'),
+        ])
+            .where('createdAt', '>=', dayStart)
+            .where('createdAt', '<', dayEnd)
+            .executeTakeFirst();
+        const typePending = await this.db.db
+            .selectFrom('report')
+            .select(['reportType', (0, kysely_1.sql) `count(*)`.as('count')])
+            .where('status', '!=', 'closed')
+            .groupBy('reportType')
+            .execute();
+        const typeWindow = await this.db.db
+            .selectFrom('report')
+            .select([
+            'reportType',
+            (0, kysely_1.sql) `count(*)`.as('inboundCount'),
+            (0, kysely_1.sql) `count(*) filter (where "status" = 'closed' and "closedAt" >= ${dayStart} and "closedAt" < ${dayEnd})`.as('actionedCount'),
+            (0, kysely_1.sql) `count(*) filter (where "status" = 'escalated')`.as('escalatedCount'),
+            (0, kysely_1.sql) `sum(extract(epoch from ("closedAt"::timestamp - "createdAt"::timestamp))) filter (where "status" = 'closed' and "closedAt" is not null and "closedAt" >= ${dayStart} and "closedAt" < ${dayEnd})`.as('handlingTimeSum'),
+            (0, kysely_1.sql) `count(*) filter (where "status" = 'closed' and "closedAt" is not null and "closedAt" >= ${dayStart} and "closedAt" < ${dayEnd})`.as('handlingTimeCount'),
+        ])
+            .where('createdAt', '>=', dayStart)
+            .where('createdAt', '<', dayEnd)
+            .groupBy('reportType')
+            .execute();
+        const moderator = await this.db.db
+            .selectFrom('report as r')
+            .innerJoin('moderator_assignment as ma', (join) => join.onRef('ma.reportId', '=', 'r.id').on('ma.endAt', 'is', null))
+            .select([
+            'ma.did',
+            (0, kysely_1.sql) `count(*)`.as('inboundCount'),
+            (0, kysely_1.sql) `count(*) filter (where r."status" = 'closed')`.as('actionedCount'),
+            (0, kysely_1.sql) `sum(extract(epoch from (r."closedAt"::timestamp - ma."startAt"::timestamp))) filter (where r."status" = 'closed' and r."closedAt" is not null)`.as('handlingTimeSum'),
+            (0, kysely_1.sql) `count(*) filter (where r."status" = 'closed' and r."closedAt" is not null)`.as('handlingTimeCount'),
+        ])
+            .where('r.createdAt', '>=', dayStart)
+            .where('r.createdAt', '<', dayEnd)
+            .groupBy('ma.did')
+            .execute();
+        // Inject aggregate as a synthetic row with queueId=null so resolveQueueStats can find it
+        const allQueuePending = [
+            ...queuePending,
+            { queueId: null, count: aggregatePending?.count ?? '0' },
+        ];
+        const allQueueWindow = aggregateWindow
+            ? [
+                ...queueWindow,
+                {
+                    queueId: null,
+                    inboundCount: aggregateWindow.inboundCount,
+                    actionedCount: aggregateWindow.actionedCount,
+                    escalatedCount: aggregateWindow.escalatedCount,
+                    handlingTimeSum: aggregateWindow.handlingTimeSum,
+                    handlingTimeCount: aggregateWindow.handlingTimeCount,
+                },
+            ]
+            : queueWindow;
+        return {
+            queuePending: allQueuePending,
+            queueWindow: allQueueWindow,
+            typePending,
+            typeWindow,
+            moderator,
+        };
+    }
+    /** Resolve a single group's stats from batched query results (pure in-memory). */
+    resolveGroupStats(group, batched) {
+        if (group.moderatorDid) {
+            return this.resolveModeratorStats(group.moderatorDid, batched.moderator);
+        }
+        if (group.reportTypes !== null) {
+            return this.resolveReportTypeStats(group.reportTypes, batched);
+        }
+        return this.resolveQueueStats(group.queueId, batched);
+    }
+    resolveQueueStats(queueId, batched) {
+        // queueId=null is the synthetic aggregate row
+        const pending = batched.queuePending.find((r) => r.queueId === queueId);
+        const window = batched.queueWindow.find((r) => r.queueId === queueId);
+        const pendingCount = num(pending?.count);
+        const inboundCount = num(window?.inboundCount);
+        const actionedCount = num(window?.actionedCount);
+        const escalatedCount = num(window?.escalatedCount);
+        const handlingTimeSum = Number(window?.handlingTimeSum ?? 0);
+        const handlingTimeCount = num(window?.handlingTimeCount);
+        const actionRate = inboundCount > 0 ? Math.round((actionedCount / inboundCount) * 100) : 0;
+        const avgHandlingTimeSec = handlingTimeCount > 0
+            ? Math.round(handlingTimeSum / handlingTimeCount)
+            : undefined;
+        return {
+            inboundCount,
+            pendingCount,
+            actionedCount,
+            escalatedCount,
+            actionRate,
+            avgHandlingTimeSec,
+        };
+    }
+    resolveReportTypeStats(reportTypes, batched) {
+        const types = new Set(reportTypes);
+        const matchingPending = batched.typePending.filter((r) => types.has(r.reportType));
+        const matchingWindow = batched.typeWindow.filter((r) => types.has(r.reportType));
+        const pendingCount = sumNum(matchingPending, 'count');
+        const inboundCount = sumNum(matchingWindow, 'inboundCount');
+        const actionedCount = sumNum(matchingWindow, 'actionedCount');
+        const escalatedCount = sumNum(matchingWindow, 'escalatedCount');
+        const handlingTimeSum = matchingWindow.reduce((sum, r) => sum + Number(r.handlingTimeSum ?? 0), 0);
+        const handlingTimeCount = sumNum(matchingWindow, 'handlingTimeCount');
+        const actionRate = inboundCount > 0 ? Math.round((actionedCount / inboundCount) * 100) : 0;
+        const avgHandlingTimeSec = handlingTimeCount > 0
+            ? Math.round(handlingTimeSum / handlingTimeCount)
+            : undefined;
+        return {
+            inboundCount,
+            pendingCount,
+            actionedCount,
+            escalatedCount,
+            actionRate,
+            avgHandlingTimeSec,
+        };
+    }
+    resolveModeratorStats(moderatorDid, rows) {
+        const row = rows.find((r) => r.did === moderatorDid);
+        const inboundCount = num(row?.inboundCount);
+        const actionedCount = num(row?.actionedCount);
+        const handlingTimeCount = num(row?.handlingTimeCount);
+        const avgHandlingTimeSec = handlingTimeCount > 0 && row?.handlingTimeSum
+            ? Math.round(Number(row.handlingTimeSum) / handlingTimeCount)
+            : undefined;
+        return { inboundCount, actionedCount, avgHandlingTimeSec };
+    }
+    /** Build an upsert row from (date, group, stats). */
+    buildUpsertRow(date, group, stats) {
+        const pendingCount = 'pendingCount' in stats ? stats.pendingCount ?? null : null;
+        const escalatedCount = 'escalatedCount' in stats ? stats.escalatedCount ?? null : null;
+        const actionRate = 'actionRate' in stats ? stats.actionRate ?? null : null;
+        return {
+            date,
+            queueId: group.queueId,
+            moderatorDid: group.moderatorDid,
+            reportTypes: group.reportTypes,
+            inboundCount: stats.inboundCount ?? null,
+            pendingCount,
+            actionedCount: stats.actionedCount ?? null,
+            escalatedCount,
+            actionRate,
+            avgHandlingTimeSec: stats.avgHandlingTimeSec ?? null,
+            computedAt: new Date().toISOString(),
+        };
+    }
+    /**
+     * Wraps a DELETE+INSERT for each row in a single transaction so we pay one
+     * commit per cycle instead of one per group. NULL-aware WHERE clauses match
+     * the existing PG <15 NULL semantics without needing a unique index.
+     */
+    async bulkUpsert(rows) {
+        if (!rows.length)
+            return;
+        await this.db.transaction(async (dbTxn) => {
+            for (const r of rows) {
+                let del = dbTxn.db.deleteFrom('report_stat').where('date', '=', r.date);
+                del =
+                    r.queueId !== null
+                        ? del.where('queueId', '=', r.queueId)
+                        : del.where('queueId', 'is', null);
+                del =
+                    r.moderatorDid !== null
+                        ? del.where('moderatorDid', '=', r.moderatorDid)
+                        : del.where('moderatorDid', 'is', null);
+                del =
+                    r.reportTypes !== null
+                        ? del.where((0, kysely_1.sql) `"reportTypes"::jsonb = ${(0, types_1.jsonb)(r.reportTypes)}::jsonb`)
+                        : del.where('reportTypes', 'is', null);
+                await del.execute();
+                await dbTxn.db
+                    .insertInto('report_stat')
+                    .values({
+                    date: r.date,
+                    queueId: r.queueId,
+                    moderatorDid: r.moderatorDid,
+                    reportTypes: r.reportTypes !== null ? (0, types_1.jsonb)(r.reportTypes) : null,
+                    inboundCount: r.inboundCount,
+                    pendingCount: r.pendingCount,
+                    actionedCount: r.actionedCount,
+                    escalatedCount: r.escalatedCount,
+                    actionRate: r.actionRate,
+                    avgHandlingTimeSec: r.avgHandlingTimeSec,
+                    computedAt: r.computedAt,
+                })
+                    .execute();
+            }
+        });
+    }
+    // ─── Read methods ───
+    /** Get a single stat row for a date + group. */
+    async getStatForDate(date, group) {
+        let qb = this.db.db
+            .selectFrom('report_stat')
+            .selectAll()
+            .where('date', '=', date);
+        if (group.queueId !== null) {
+            qb = qb.where('queueId', '=', group.queueId);
+        }
+        else {
+            qb = qb.where('queueId', 'is', null);
+        }
+        if (group.moderatorDid) {
+            qb = qb.where('moderatorDid', '=', group.moderatorDid);
+        }
+        else {
+            qb = qb.where('moderatorDid', 'is', null);
+        }
+        if (group.reportTypes !== null) {
+            qb = qb.where((0, kysely_1.sql) `"reportTypes"::jsonb = ${(0, types_1.jsonb)(group.reportTypes)}::jsonb`);
+        }
+        else {
+            qb = qb.where('reportTypes', 'is', null);
+        }
+        return qb.executeTakeFirst();
+    }
+    /** Get today's live stats for a group. */
+    async getLiveStats(group) {
+        const today = toDateString(new Date());
+        return this.getStatForDate(today, group);
+    }
+    /** Get live stats for multiple queues in a single query. */
+    async getLiveStatsForQueues(queueIds) {
+        if (!queueIds.length)
+            return new Map();
+        const today = toDateString(new Date());
+        const rows = await this.db.db
+            .selectFrom('report_stat')
+            .selectAll()
+            .where('date', '=', today)
+            .where('queueId', 'in', queueIds)
+            .where('moderatorDid', 'is', null)
+            .where('reportTypes', 'is', null)
+            .execute();
+        const result = new Map();
+        for (const row of rows) {
+            if (row.queueId !== null) {
+                result.set(row.queueId, row);
+            }
+        }
+        return result;
+    }
+    /** Get historical stats for a date range, paginated. */
+    async getHistoricalStats(opts) {
+        const { group, startDate, endDate, limit } = opts;
+        const { queueId, moderatorDid, reportTypes } = group;
+        const { ref } = this.db.db.dynamic;
+        let qb = this.db.db.selectFrom('report_stat').selectAll();
+        if (queueId !== null) {
+            qb = qb.where('queueId', '=', queueId);
+        }
+        else {
+            qb = qb.where('queueId', 'is', null);
+        }
+        if (moderatorDid) {
+            qb = qb.where('moderatorDid', '=', moderatorDid);
+        }
+        else {
+            qb = qb.where('moderatorDid', 'is', null);
+        }
+        if (reportTypes !== null) {
+            qb = qb.where((0, kysely_1.sql) `"reportTypes"::jsonb = ${(0, types_1.jsonb)(reportTypes)}::jsonb`);
+        }
+        else {
+            qb = qb.where('reportTypes', 'is', null);
+        }
+        if (startDate) {
+            qb = qb.where('date', '>=', toDateString(new Date(startDate)));
+        }
+        if (endDate) {
+            qb = qb.where('date', '<=', toDateString(new Date(endDate)));
+        }
+        const keyset = new pagination_1.ComputedAtIdKeyset(ref('computedAt'), ref('id'));
+        const paginatedBuilder = (0, pagination_1.paginate)(qb, {
+            limit,
+            cursor: opts.cursor,
+            keyset,
+            direction: 'desc',
+            tryIndex: true,
+        });
+        const stats = await paginatedBuilder.execute();
+        return { stats, cursor: keyset.packFromResult(stats) };
+    }
+}
+exports.ReportStatsService = ReportStatsService;
+// ─── Helpers ───
+/** Parse a pg bigint string to number, defaulting to 0. */
+function num(val) {
+    return val ? Number(val) : 0;
+}
+/** Sum a numeric string field across rows. */
+function sumNum(rows, field) {
+    return rows.reduce((sum, r) => sum + Number(r[field] ?? 0), 0);
+}
+/**
+ * Stable cache-key for a stat group. Used to look up an existing row in the
+ * batched cache map without issuing per-group SELECTs. Report types are
+ * stringified in stored order, which matches REPORT_TYPE_GROUPS.
+ */
+function groupKey(g) {
+    return [
+        g.queueId ?? 'null',
+        g.moderatorDid ?? 'null',
+        g.reportTypes ? JSON.stringify(g.reportTypes) : 'null',
+    ].join('|');
+}
+/** Convert a Date to an ISO date string (YYYY-MM-DD). */
+function toDateString(d) {
+    return d.toISOString().slice(0, 10);
+}
+/** Get the next calendar date string. */
+function nextDate(dateStr) {
+    const d = new Date(`${dateStr}T00:00:00.000Z`);
+    d.setUTCDate(d.getUTCDate() + 1);
+    return toDateString(d);
+}
+//# sourceMappingURL=stats.js.map