@iann29/rastro 0.1.0-alpha.1 → 0.1.0-alpha.11

package/dist/component/retention.js

@@ -1,9 +1,16 @@
 import { v } from "convex/values";
-import { mutation } from "./_generated/server.js";
-import { MAX_RETENTION_BATCH } from "./constants.js";
+import { internal } from "./_generated/api.js";
+import { internalMutation, mutation, query } from "./_generated/server.js";
+import { DAY_MS, HOUR_MS, MAX_RETENTION_BATCH, MINUTE_MS, RATE_LIMIT_WINDOW_MS, RETENTION_LEASE_MS, RETENTION_POLICY_INTERVAL_MS, } from "./constants.js";
+import { ensureAnalyticsControl } from "./coverage.js";
 import { fail } from "./errors.js";
 import { deleteTelemetryBefore } from "./eventStore.js";
-const cleanupKindValidator = v.union(v.literal("events"), v.literal("sessions"), v.literal("conversions"), v.literal("goalCompletions"), v.literal("aggregateHour"), v.literal("aggregateDay"), v.literal("funnelProgress"), v.literal("funnelSteps"), v.literal("affiliateStats"), v.literal("attributions"), v.literal("liveSessions"), v.literal("ingestWindows"), v.literal("siteIngestWindows"));
+export const cleanupKindValidator = v.union(v.literal("events"), v.literal("sessions"), v.literal("conversions"), v.literal("goalCompletions"), v.literal("aggregateHour"), v.literal("aggregateDay"), v.literal("funnelProgress"), v.literal("funnelSteps"), v.literal("affiliateStats"), v.literal("goalRollups"), v.literal("funnelRollups"), v.literal("affiliateRollups"), v.literal("vitalRollups"), v.literal("siteMapRollups"), v.literal("attributions"), v.literal("liveSessions"), v.literal("ingestWindows"), v.literal("siteIngestWindows"));
+const cleanupResultValidator = v.object({
+    deleted: v.number(),
+    hasMore: v.boolean(),
+    before: v.number(),
+});
 export const cleanup = mutation({
     args: {
         siteId: v.id("sites"),
@@ -11,102 +18,618 @@ export const cleanup = mutation({
         before: v.number(),
         batchSize: v.optional(v.number()),
     },
-    returns: v.object({ deleted: v.number(), hasMore: v.boolean() }),
+    returns: cleanupResultValidator,
+    handler: async (ctx, args) => {
+        const policy = await ctx.db
+            .query("retentionPolicies")
+            .withIndex("by_siteId", (range) => range.eq("siteId", args.siteId))
+            .unique();
+        if (policy) {
+            fail("CONFLICT", "disable the retention policy before running manual cleanup");
+        }
+        const before = safeCleanupBoundary(args.kind, args.before, Date.now());
+        const result = await executeCleanupBatch(ctx, { ...args, before });
+        await persistDirectState(ctx, { ...args, before }, result);
+        await recordRetentionBoundary(ctx, args.siteId, args.kind, before);
+        return { ...result, before };
+    },
+});
+const policyValidator = v.object({
+    eventsDays: v.number(),
+    sessionsDays: v.number(),
+    conversionsDays: v.number(),
+    aggregatesDays: v.number(),
+    reportsDays: v.number(),
+});
+export const setPolicy = mutation({
+    args: { siteId: v.id("sites"), ...policyValidator.fields },
+    returns: v.null(),
     handler: async (ctx, args) => {
-        if (!Number.isFinite(args.before) || args.before < 0) {
-            fail("INVALID_ARGUMENT", "before must be a positive timestamp");
+        validatePolicy(args);
+        const now = Date.now();
+        const existingPolicy = await ctx.db
+            .query("retentionPolicies")
+            .withIndex("by_siteId", (range) => range.eq("siteId", args.siteId))
+            .unique();
+        const policy = { ...args, updatedAt: now };
+        if (existingPolicy) {
+            await ctx.db.replace("retentionPolicies", existingPolicy._id, policy);
         }
-        const batchSize = args.batchSize ?? 100;
-        if (!Number.isSafeInteger(batchSize) || batchSize < 1 || batchSize > MAX_RETENTION_BATCH) {
-            fail("INVALID_ARGUMENT", `batchSize must be an integer between 1 and ${MAX_RETENTION_BATCH}`);
+        else {
+            await ctx.db.insert("retentionPolicies", policy);
         }
-        const effectiveBatchSize = args.kind === "events"
-            ? Math.min(batchSize, 32)
-            : batchSize;
-        if (args.kind === "events") {
-            return await deleteTelemetryBefore(ctx, {
+        for (const kind of POLICY_CLEANUP_KINDS) {
+            const requestedBefore = now - retentionDaysForKind(policy, kind) * DAY_MS;
+            const before = safeCleanupBoundary(kind, requestedBefore, now);
+            const existing = await loadState(ctx, args.siteId, kind);
+            const generation = (existing?.generation ?? 0) + 1;
+            const fields = {
                 siteId: args.siteId,
-                before: args.before,
-                batchSize: effectiveBatchSize,
+                kind,
+                before,
+                status: "pending",
+                generation,
+                attempt: 0,
+                scheduledAt: now,
+                deleted: 0,
+                updatedAt: now,
+            };
+            const stateId = existing
+                ? (await ctx.db.replace("retentionStates", existing._id, fields),
+                    existing._id)
+                : await ctx.db.insert("retentionStates", fields);
+            await ctx.scheduler.runAfter(0, internal.retention.runScheduled, {
+                stateId,
+                generation,
+            });
+        }
+        return null;
+    },
+});
+export const disablePolicy = mutation({
+    args: { siteId: v.id("sites") },
+    returns: v.null(),
+    handler: async (ctx, args) => {
+        const policy = await ctx.db
+            .query("retentionPolicies")
+            .withIndex("by_siteId", (range) => range.eq("siteId", args.siteId))
+            .unique();
+        if (policy)
+            await ctx.db.delete("retentionPolicies", policy._id);
+        const now = Date.now();
+        const states = await ctx.db
+            .query("retentionStates")
+            .withIndex("by_siteId_and_kind", (range) => range.eq("siteId", args.siteId))
+            .take(POLICY_CLEANUP_KINDS.length + 1);
+        for (const state of states) {
+            await ctx.db.patch("retentionStates", state._id, {
+                status: "complete",
+                generation: state.generation + 1,
+                leaseExpiresAt: undefined,
+                scheduledAt: undefined,
+                updatedAt: now,
             });
         }
-        const deletions = await deletionsForCleanup(ctx, args.siteId, args.kind, args.before, effectiveBatchSize + 1);
-        for (const remove of deletions.slice(0, effectiveBatchSize)) {
-            await remove();
+        return null;
+    },
+});
+export const runPolicy = mutation({
+    args: {
+        siteId: v.id("sites"),
+        kind: cleanupKindValidator,
+        batchSize: v.optional(v.number()),
+    },
+    returns: cleanupResultValidator,
+    handler: async (ctx, args) => {
+        const policy = await ctx.db
+            .query("retentionPolicies")
+            .withIndex("by_siteId", (range) => range.eq("siteId", args.siteId))
+            .unique();
+        if (!policy)
+            fail("NOT_FOUND", "retention policy not found");
+        const now = Date.now();
+        const existing = await loadState(ctx, args.siteId, args.kind);
+        if (existing?.status === "running" &&
+            existing.leaseExpiresAt !== undefined &&
+            existing.leaseExpiresAt > now) {
+            return { deleted: 0, hasMore: true, before: existing.before };
         }
+        const before = existing && existing.status !== "complete"
+            ? existing.before
+            : safeCleanupBoundary(args.kind, now - retentionDaysForKind(policy, args.kind) * DAY_MS, now);
+        const result = await executeCleanupBatch(ctx, { ...args, before });
+        const generation = existing?.generation ?? 1;
+        const fields = {
+            siteId: args.siteId,
+            kind: args.kind,
+            before,
+            status: result.hasMore ? "pending" : "complete",
+            generation,
+            attempt: existing?.attempt ?? 0,
+            scheduledAt: result.hasMore ? now : now + RETENTION_POLICY_INTERVAL_MS,
+            deleted: existing?.before === before
+                ? existing.deleted + result.deleted
+                : result.deleted,
+            updatedAt: now,
+        };
+        const stateId = existing
+            ? (await ctx.db.replace("retentionStates", existing._id, fields),
+                existing._id)
+            : await ctx.db.insert("retentionStates", fields);
+        await recordRetentionBoundary(ctx, args.siteId, args.kind, before);
+        if (result.hasMore) {
+            await ctx.scheduler.runAfter(0, internal.retention.runScheduled, {
+                stateId,
+                generation,
+            });
+        }
+        else {
+            await ctx.scheduler.runAt(now + RETENTION_POLICY_INTERVAL_MS, internal.retention.startScheduledCycle, { stateId, generation });
+        }
+        return { ...result, before };
+    },
+});
+export const runScheduled = internalMutation({
+    args: { stateId: v.id("retentionStates"), generation: v.number() },
+    returns: v.object({
+        claimed: v.boolean(),
+        stale: v.boolean(),
+        attempt: v.number(),
+    }),
+    handler: async (ctx, args) => {
+        const state = await ctx.db.get("retentionStates", args.stateId);
+        const now = Date.now();
+        if (!state ||
+            state.generation !== args.generation ||
+            state.status === "complete" ||
+            (state.status === "running" &&
+                state.leaseExpiresAt !== undefined &&
+                state.leaseExpiresAt > now)) {
+            return { claimed: false, stale: true, attempt: state?.attempt ?? 0 };
+        }
+        const attempt = state.attempt + 1;
+        const leaseExpiresAt = now + RETENTION_LEASE_MS;
+        await ctx.db.patch("retentionStates", state._id, {
+            status: "running",
+            attempt,
+            leaseExpiresAt,
+            scheduledAt: now,
+            updatedAt: now,
+        });
+        await ctx.scheduler.runAfter(0, internal.retention.executeScheduled, {
+            stateId: state._id,
+            generation: state.generation,
+            attempt,
+        });
+        await ctx.scheduler.runAt(leaseExpiresAt, internal.retention.runScheduled, {
+            stateId: state._id,
+            generation: state.generation,
+        });
+        return { claimed: true, stale: false, attempt };
+    },
+});
+export const executeScheduled = internalMutation({
+    args: {
+        stateId: v.id("retentionStates"),
+        generation: v.number(),
+        attempt: v.number(),
+    },
+    returns: v.object({
+        deleted: v.number(),
+        hasMore: v.boolean(),
+        stale: v.boolean(),
+    }),
+    handler: async (ctx, args) => {
+        const state = await ctx.db.get("retentionStates", args.stateId);
+        if (!state ||
+            state.generation !== args.generation ||
+            state.attempt !== args.attempt ||
+            state.status !== "running") {
+            return { deleted: 0, hasMore: false, stale: true };
+        }
+        const result = await executeCleanupBatch(ctx, {
+            siteId: state.siteId,
+            kind: state.kind,
+            before: state.before,
+            batchSize: 100,
+        });
+        const now = Date.now();
+        const policy = result.hasMore
+            ? null
+            : await ctx.db
+                .query("retentionPolicies")
+                .withIndex("by_siteId", (range) => range.eq("siteId", state.siteId))
+                .unique();
+        const nextCycleAt = policy ? now + RETENTION_POLICY_INTERVAL_MS : undefined;
+        await ctx.db.patch("retentionStates", state._id, {
+            status: result.hasMore ? "pending" : "complete",
+            leaseExpiresAt: undefined,
+            scheduledAt: result.hasMore ? now : nextCycleAt,
+            deleted: state.deleted + result.deleted,
+            updatedAt: now,
+        });
+        await recordRetentionBoundary(ctx, state.siteId, state.kind, state.before);
+        if (result.hasMore) {
+            await ctx.scheduler.runAfter(0, internal.retention.runScheduled, {
+                stateId: state._id,
+                generation: state.generation,
+            });
+        }
+        else if (nextCycleAt !== undefined) {
+            await ctx.scheduler.runAt(nextCycleAt, internal.retention.startScheduledCycle, { stateId: state._id, generation: state.generation });
+        }
+        return { ...result, stale: false };
+    },
+});
+export const startScheduledCycle = internalMutation({
+    args: { stateId: v.id("retentionStates"), generation: v.number() },
+    returns: v.object({
+        started: v.boolean(),
+        stale: v.boolean(),
+        before: v.union(v.number(), v.null()),
+    }),
+    handler: async (ctx, args) => {
+        const state = await ctx.db.get("retentionStates", args.stateId);
+        const now = Date.now();
+        if (!state ||
+            state.generation !== args.generation ||
+            state.status !== "complete" ||
+            (state.scheduledAt !== undefined && state.scheduledAt > now)) {
+            return { started: false, stale: true, before: null };
+        }
+        const policy = await ctx.db
+            .query("retentionPolicies")
+            .withIndex("by_siteId", (range) => range.eq("siteId", state.siteId))
+            .unique();
+        if (!policy)
+            return { started: false, stale: true, before: null };
+        const kind = state.kind;
+        const before = safeCleanupBoundary(kind, now - retentionDaysForKind(policy, kind) * DAY_MS, now);
+        await ctx.db.patch("retentionStates", state._id, {
+            before,
+            status: "pending",
+            attempt: 0,
+            leaseExpiresAt: undefined,
+            scheduledAt: now,
+            deleted: 0,
+            updatedAt: now,
+        });
+        await ctx.scheduler.runAfter(0, internal.retention.runScheduled, {
+            stateId: state._id,
+            generation: state.generation,
+        });
+        return { started: true, stale: false, before };
+    },
+});
+export const status = query({
+    args: { siteId: v.id("sites") },
+    returns: v.object({
+        policy: v.union(policyValidator.extend({ updatedAt: v.number() }), v.null()),
+        jobs: v.array(v.object({
+            kind: cleanupKindValidator,
+            before: v.number(),
+            status: v.union(v.literal("pending"), v.literal("running"), v.literal("complete")),
+            deleted: v.number(),
+            scheduledAt: v.union(v.number(), v.null()),
+            updatedAt: v.number(),
+        })),
+        backlog: v.number(),
+    }),
+    handler: async (ctx, args) => {
+        const policy = await ctx.db
+            .query("retentionPolicies")
+            .withIndex("by_siteId", (range) => range.eq("siteId", args.siteId))
+            .unique();
+        const jobs = await ctx.db
+            .query("retentionStates")
+            .withIndex("by_siteId_and_kind", (range) => range.eq("siteId", args.siteId))
+            .take(POLICY_CLEANUP_KINDS.length + 1);
+        const publicJobs = jobs.map(({ kind, before, status, deleted, scheduledAt, updatedAt }) => ({
+            kind: kind,
+            before,
+            status,
+            deleted,
+            scheduledAt: scheduledAt ?? null,
+            updatedAt,
+        }));
         return {
-            deleted: Math.min(deletions.length, effectiveBatchSize),
-            hasMore: deletions.length > effectiveBatchSize,
+            policy: policy
+                ? {
+                    eventsDays: policy.eventsDays,
+                    sessionsDays: policy.sessionsDays,
+                    conversionsDays: policy.conversionsDays,
+                    aggregatesDays: policy.aggregatesDays,
+                    reportsDays: policy.reportsDays,
+                    updatedAt: policy.updatedAt,
+                }
+                : null,
+            jobs: publicJobs,
+            backlog: publicJobs.filter((job) => job.status !== "complete").length,
         };
     },
 });
+const POLICY_CLEANUP_KINDS = [
+    "events",
+    "sessions",
+    "conversions",
+    "aggregateHour",
+    "aggregateDay",
+    "goalCompletions",
+    "funnelProgress",
+    "funnelSteps",
+    "affiliateStats",
+    "goalRollups",
+    "funnelRollups",
+    "affiliateRollups",
+    "vitalRollups",
+    "siteMapRollups",
+    "attributions",
+    "ingestWindows",
+    "siteIngestWindows",
+];
+function validatePolicy(policy) {
+    for (const [name, days] of Object.entries(policy)) {
+        if (!name.endsWith("Days"))
+            continue;
+        if (!Number.isSafeInteger(days) || days < 1 || days > 3_650) {
+            fail("INVALID_ARGUMENT", `${name} must be an integer between 1 and 3650`);
+        }
+    }
+}
+function retentionDaysForKind(policy, kind) {
+    if (kind === "events")
+        return policy.eventsDays;
+    if (kind === "sessions")
+        return policy.sessionsDays;
+    if (kind === "conversions")
+        return policy.conversionsDays;
+    if (kind === "aggregateHour" || kind === "aggregateDay") {
+        return policy.aggregatesDays;
+    }
+    return policy.reportsDays;
+}
+function safeCleanupBoundary(kind, requested, now) {
+    if (!Number.isFinite(requested) || requested < 0) {
+        fail("INVALID_ARGUMENT", "before must be a positive timestamp");
+    }
+    if (kind === "events")
+        return safeBucketBoundary(requested, now, MINUTE_MS);
+    if (kind === "aggregateHour")
+        return safeBucketBoundary(requested, now, HOUR_MS);
+    if (kind === "aggregateDay" ||
+        kind === "funnelSteps" ||
+        kind === "affiliateStats" ||
+        kind === "goalRollups" ||
+        kind === "funnelRollups" ||
+        kind === "affiliateRollups" ||
+        kind === "vitalRollups" ||
+        kind === "siteMapRollups") {
+        return safeBucketBoundary(requested, now, DAY_MS);
+    }
+    if (kind === "ingestWindows" || kind === "siteIngestWindows") {
+        return Math.min(Math.floor(requested / RATE_LIMIT_WINDOW_MS) * RATE_LIMIT_WINDOW_MS, Math.floor(now / RATE_LIMIT_WINDOW_MS) * RATE_LIMIT_WINDOW_MS);
+    }
+    return Math.trunc(requested);
+}
+function safeBucketBoundary(requested, now, intervalMs) {
+    return Math.min(Math.floor(requested / intervalMs) * intervalMs, Math.floor(now / intervalMs) * intervalMs);
+}
+async function loadState(ctx, siteId, kind) {
+    return ctx.db
+        .query("retentionStates")
+        .withIndex("by_siteId_and_kind", (range) => range.eq("siteId", siteId).eq("kind", kind))
+        .unique();
+}
+async function persistDirectState(ctx, args, result) {
+    const now = Date.now();
+    const existing = await loadState(ctx, args.siteId, args.kind);
+    const fields = {
+        siteId: args.siteId,
+        kind: args.kind,
+        before: args.before,
+        status: result.hasMore ? "pending" : "complete",
+        generation: (existing?.generation ?? 0) + 1,
+        attempt: 0,
+        deleted: existing?.before === args.before
+            ? existing.deleted + result.deleted
+            : result.deleted,
+        updatedAt: now,
+    };
+    if (existing) {
+        await ctx.db.replace("retentionStates", existing._id, fields);
+    }
+    else {
+        await ctx.db.insert("retentionStates", fields);
+    }
+}
+async function recordRetentionBoundary(ctx, siteId, kind, before) {
+    const datasets = coverageDatasetsForKind(kind);
+    if (datasets.length === 0)
+        return;
+    const now = Date.now();
+    const coverage = await ensureAnalyticsControl(ctx, siteId, now, datasets.map((dataset) => ({ dataset, before })));
+    const retained = coverage.retained.filter((item) => !datasets.includes(item.dataset));
+    let changed = retained.length !== coverage.retained.length;
+    for (const dataset of datasets) {
+        const prior = coverage.retained.find((item) => item.dataset === dataset)?.before ?? 0;
+        const next = Math.max(prior, before);
+        retained.push({ dataset, before: next });
+        changed ||= next !== prior;
+    }
+    if (changed) {
+        await ctx.db.patch("analyticsCoverage", coverage._id, {
+            retained,
+            updatedAt: now,
+        });
+    }
+}
+function coverageDatasetsForKind(kind) {
+    if (kind === "events")
+        return ["events"];
+    if (kind === "sessions")
+        return ["sessions"];
+    if (kind === "conversions")
+        return ["conversions"];
+    if (kind === "aggregateHour")
+        return ["overviewHour"];
+    if (kind === "aggregateDay")
+        return ["overviewDay", "overviewLocalDay"];
+    if (kind === "goalCompletions")
+        return ["goalCompletions"];
+    if (kind === "funnelSteps")
+        return ["funnelSteps"];
+    if (kind === "affiliateStats")
+        return ["affiliateStats"];
+    if (kind === "goalRollups")
+        return ["goalRollups"];
+    if (kind === "funnelRollups")
+        return ["funnelRollups"];
+    if (kind === "affiliateRollups")
+        return ["affiliateRollups"];
+    if (kind === "vitalRollups")
+        return ["vitalRollups"];
+    if (kind === "siteMapRollups")
+        return ["siteMapRollups"];
+    return [];
+}
+async function executeCleanupBatch(ctx, args) {
+    const batchSize = args.batchSize ?? 100;
+    if (!Number.isSafeInteger(batchSize) ||
+        batchSize < 1 ||
+        batchSize > MAX_RETENTION_BATCH) {
+        fail("INVALID_ARGUMENT", `batchSize must be an integer between 1 and ${MAX_RETENTION_BATCH}`);
+    }
+    const effectiveBatchSize = args.kind === "events" ? Math.min(batchSize, 32) : batchSize;
+    if (args.kind === "events") {
+        return deleteTelemetryBefore(ctx, {
+            siteId: args.siteId,
+            before: args.before,
+            batchSize: effectiveBatchSize,
+        });
+    }
+    const deletions = await deletionsForCleanup(ctx, args.siteId, args.kind, args.before, effectiveBatchSize + 1);
+    for (const remove of deletions.slice(0, effectiveBatchSize))
+        await remove();
+    return {
+        deleted: Math.min(deletions.length, effectiveBatchSize),
+        hasMore: deletions.length > effectiveBatchSize,
+    };
+}
 async function deletionsForCleanup(ctx, siteId, kind, before, limit) {
     if (kind === "sessions") {
         return (await ctx.db
             .query("sessions")
-            .withIndex("by_siteId_and_lastSeenAt", (range) => range.eq("siteId", siteId).lt("lastSeenAt", before))
+            .withIndex("by_siteId_and_lastSeenAt", (q) => q.eq("siteId", siteId).lt("lastSeenAt", before))
             .take(limit)).map((row) => () => ctx.db.delete("sessions", row._id));
     }
     if (kind === "conversions") {
         return (await ctx.db
             .query("conversions")
-            .withIndex("by_siteId_and_timestamp", (range) => range.eq("siteId", siteId).lt("timestamp", before))
+            .withIndex("by_siteId_and_timestamp", (q) => q.eq("siteId", siteId).lt("timestamp", before))
             .take(limit)).map((row) => () => ctx.db.delete("conversions", row._id));
     }
     if (kind === "goalCompletions") {
         return (await ctx.db
             .query("goalCompletions")
-            .withIndex("by_siteId_and_timestamp", (range) => range.eq("siteId", siteId).lt("timestamp", before))
+            .withIndex("by_siteId_and_timestamp", (q) => q.eq("siteId", siteId).lt("timestamp", before))
             .take(limit)).map((row) => () => ctx.db.delete("goalCompletions", row._id));
     }
     if (kind === "aggregateHour" || kind === "aggregateDay") {
-        return (await ctx.db
-            .query("aggregateBuckets")
-            .withIndex("by_siteId_and_granularity_and_bucketStart", (range) => range
-            .eq("siteId", siteId)
-            .eq("granularity", kind === "aggregateHour" ? "hour" : "day")
-            .lt("bucketStart", before))
-            .take(limit)).map((row) => () => ctx.db.delete("aggregateBuckets", row._id));
+        // The daily kind also retires the site's local-day buckets. Their cutoff
+        // sits a day and an hour earlier than the UTC-aligned one: a local day
+        // may begin almost a day before its UTC counterpart and, across a
+        // fall-back transition, last 25 hours, so this keeps every bucket that
+        // could still contain the cutoff instant.
+        const granularities = kind === "aggregateHour"
+            ? [["hour", before]]
+            : [
+                ["day", before],
+                ["localDay", before - DAY_MS - HOUR_MS],
+            ];
+        const deletions = [];
+        for (const [granularity, cutoff] of granularities) {
+            if (deletions.length >= limit)
+                break;
+            const rows = await ctx.db
+                .query("aggregateBuckets")
+                .withIndex("by_siteId_and_granularity_and_bucketStart", (q) => q
+                .eq("siteId", siteId)
+                .eq("granularity", granularity)
+                .lt("bucketStart", cutoff))
+                .take(limit - deletions.length);
+            deletions.push(...rows.map((row) => () => ctx.db.delete("aggregateBuckets", row._id)));
+        }
+        return deletions;
     }
     if (kind === "funnelProgress") {
         return (await ctx.db
             .query("funnelProgress")
-            .withIndex("by_siteId_and_lastStepAt", (range) => range.eq("siteId", siteId).lt("lastStepAt", before))
+            .withIndex("by_siteId_and_lastStepAt", (q) => q.eq("siteId", siteId).lt("lastStepAt", before))
             .take(limit)).map((row) => () => ctx.db.delete("funnelProgress", row._id));
     }
     if (kind === "funnelSteps") {
         return (await ctx.db
             .query("funnelStepBuckets")
-            .withIndex("by_siteId_and_bucketStart", (range) => range.eq("siteId", siteId).lt("bucketStart", before))
+            .withIndex("by_siteId_and_bucketStart", (q) => q.eq("siteId", siteId).lt("bucketStart", before))
             .take(limit)).map((row) => () => ctx.db.delete("funnelStepBuckets", row._id));
     }
     if (kind === "affiliateStats") {
         return (await ctx.db
             .query("affiliateDailyStats")
-            .withIndex("by_siteId_and_bucketStart", (range) => range.eq("siteId", siteId).lt("bucketStart", before))
+            .withIndex("by_siteId_and_bucketStart", (q) => q.eq("siteId", siteId).lt("bucketStart", before))
             .take(limit)).map((row) => () => ctx.db.delete("affiliateDailyStats", row._id));
     }
+    if (kind === "goalRollups") {
+        return (await ctx.db
+            .query("goalDailyRollups")
+            .withIndex("by_siteId_and_bucketStart", (q) => q.eq("siteId", siteId).lt("bucketStart", before))
+            .take(limit)).map((row) => () => ctx.db.delete("goalDailyRollups", row._id));
+    }
+    if (kind === "funnelRollups") {
+        return (await ctx.db
+            .query("funnelDailyRollups")
+            .withIndex("by_siteId_and_bucketStart", (q) => q.eq("siteId", siteId).lt("bucketStart", before))
+            .take(limit)).map((row) => () => ctx.db.delete("funnelDailyRollups", row._id));
+    }
+    if (kind === "affiliateRollups") {
+        return (await ctx.db
+            .query("affiliateDailyRollups")
+            .withIndex("by_siteId_and_bucketStart", (q) => q.eq("siteId", siteId).lt("bucketStart", before))
+            .take(limit)).map((row) => () => ctx.db.delete("affiliateDailyRollups", row._id));
+    }
+    if (kind === "vitalRollups") {
+        return (await ctx.db
+            .query("vitalRollups")
+            .withIndex("by_siteId_and_bucketStart", (q) => q.eq("siteId", siteId).lt("bucketStart", before))
+            .take(limit)).map((row) => () => ctx.db.delete("vitalRollups", row._id));
+    }
+    if (kind === "siteMapRollups") {
+        return (await ctx.db
+            .query("routeDailyRollups")
+            .withIndex("by_siteId_and_bucketStart", (q) => q.eq("siteId", siteId).lt("bucketStart", before))
+            .take(limit)).map((row) => () => ctx.db.delete("routeDailyRollups", row._id));
+    }
     if (kind === "attributions") {
         return (await ctx.db
             .query("visitorAttributions")
-            .withIndex("by_siteId_and_expiresAt", (range) => range.eq("siteId", siteId).lt("expiresAt", before))
+            .withIndex("by_siteId_and_expiresAt", (q) => q.eq("siteId", siteId).lt("expiresAt", before))
             .take(limit)).map((row) => () => ctx.db.delete("visitorAttributions", row._id));
     }
     if (kind === "liveSessions") {
         return (await ctx.db
             .query("liveSessions")
-            .withIndex("by_siteId_and_expiresAt", (range) => range.eq("siteId", siteId).lt("expiresAt", before))
+            .withIndex("by_siteId_and_expiresAt", (q) => q.eq("siteId", siteId).lt("expiresAt", before))
             .take(limit)).map((row) => () => ctx.db.delete("liveSessions", row._id));
     }
     if (kind === "siteIngestWindows") {
         return (await ctx.db
             .query("siteIngestWindows")
-            .withIndex("by_siteId_and_updatedAt", (range) => range.eq("siteId", siteId).lt("updatedAt", before))
+            .withIndex("by_siteId_and_updatedAt", (q) => q.eq("siteId", siteId).lt("updatedAt", before))
             .take(limit)).map((row) => () => ctx.db.delete("siteIngestWindows", row._id));
     }
     return (await ctx.db
         .query("ingestWindows")
-        .withIndex("by_siteId_and_updatedAt", (range) => range.eq("siteId", siteId).lt("updatedAt", before))
+        .withIndex("by_siteId_and_updatedAt", (q) => q.eq("siteId", siteId).lt("updatedAt", before))
         .take(limit)).map((row) => () => ctx.db.delete("ingestWindows", row._id));
 }
 //# sourceMappingURL=retention.js.map