@iann29/rastro 0.1.0-alpha.2 → 0.1.0-alpha.4

package/src/component/retention.ts

@@ -1,12 +1,22 @@
 import { v } from "convex/values";
+import { internal } from "./_generated/api.js";
 import type { Id } from "./_generated/dataModel.js";
 import type { MutationCtx } from "./_generated/server.js";
-import { mutation } from "./_generated/server.js";
-import { MAX_RETENTION_BATCH } from "./constants.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(
+export const cleanupKindValidator = v.union(
   v.literal("events"),
   v.literal("sessions"),
   v.literal("conversions"),
@@ -16,12 +26,21 @@ const cleanupKindValidator = v.union(
   v.literal("funnelProgress"),
   v.literal("funnelSteps"),
   v.literal("affiliateStats"),
+  v.literal("goalRollups"),
+  v.literal("funnelRollups"),
+  v.literal("affiliateRollups"),
   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"),
@@ -29,38 +48,371 @@ 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) => {
-    if (!Number.isFinite(args.before) || args.before < 0) {
-      fail("INVALID_ARGUMENT", "before must be a positive timestamp");
+    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 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 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) => {
+    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);
+    } 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" as const,
+        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,
       });
     }
-    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 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,
+      });
+    }
+    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" as const : "complete" as const,
+      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 as CleanupKind,
+      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 as CleanupKind, 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 as CleanupKind;
+    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 as CleanupKind,
+      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,
     };
   },
 });
@@ -75,11 +427,215 @@ type CleanupKind =
   | "funnelProgress"
   | "funnelSteps"
   | "affiliateStats"
+  | "goalRollups"
+  | "funnelRollups"
+  | "affiliateRollups"
   | "attributions"
   | "liveSessions"
   | "ingestWindows"
   | "siteIngestWindows";
 
+const POLICY_CLEANUP_KINDS: CleanupKind[] = [
+  "events",
+  "sessions",
+  "conversions",
+  "aggregateHour",
+  "aggregateDay",
+  "goalCompletions",
+  "funnelProgress",
+  "funnelSteps",
+  "affiliateStats",
+  "goalRollups",
+  "funnelRollups",
+  "affiliateRollups",
+  "attributions",
+  "ingestWindows",
+  "siteIngestWindows",
+];
+
+function validatePolicy(policy: {
+  eventsDays: number;
+  sessionsDays: number;
+  conversionsDays: number;
+  aggregatesDays: number;
+  reportsDays: number;
+}) {
+  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: {
+    eventsDays: number;
+    sessionsDays: number;
+    conversionsDays: number;
+    aggregatesDays: number;
+    reportsDays: number;
+  },
+  kind: CleanupKind,
+) {
+  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: CleanupKind, requested: number, now: number) {
+  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"
+  ) {
+    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: number, now: number, intervalMs: number) {
+  return Math.min(
+    Math.floor(requested / intervalMs) * intervalMs,
+    Math.floor(now / intervalMs) * intervalMs,
+  );
+}
+
+async function loadState(ctx: MutationCtx, siteId: Id<"sites">, kind: CleanupKind) {
+  return ctx.db
+    .query("retentionStates")
+    .withIndex("by_siteId_and_kind", (range) =>
+      range.eq("siteId", siteId).eq("kind", kind),
+    )
+    .unique();
+}
+
+async function persistDirectState(
+  ctx: MutationCtx,
+  args: { siteId: Id<"sites">; kind: CleanupKind; before: number },
+  result: { deleted: number; hasMore: boolean },
+) {
+  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" as const : "complete" as const,
+    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: MutationCtx,
+  siteId: Id<"sites">,
+  kind: CleanupKind,
+  before: number,
+) {
+  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: CleanupKind): string[] {
+  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"];
+  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"];
+  return [];
+}
+
+async function executeCleanupBatch(
+  ctx: MutationCtx,
+  args: {
+    siteId: Id<"sites">;
+    kind: CleanupKind;
+    before: number;
+    batchSize?: number;
+  },
+) {
+  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,
+  };
+}
+
 type CleanupDelete = () => Promise<void>;
 
 async function deletionsForCleanup(
@@ -90,94 +646,74 @@ async function deletionsForCleanup(
   limit: number,
 ): Promise<CleanupDelete[]> {
   if (kind === "sessions") {
-    return (await ctx.db
-      .query("sessions")
-      .withIndex("by_siteId_and_lastSeenAt", (range) =>
-        range.eq("siteId", siteId).lt("lastSeenAt", before),
-      )
+    return (await ctx.db.query("sessions")
+      .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),
-      )
+    return (await ctx.db.query("conversions")
+      .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),
-      )
+    return (await ctx.db.query("goalCompletions")
+      .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),
-      )
+    return (await ctx.db.query("aggregateBuckets")
+      .withIndex("by_siteId_and_granularity_and_bucketStart", (q) => q
+        .eq("siteId", siteId)
+        .eq("granularity", kind === "aggregateHour" ? "hour" : "day")
+        .lt("bucketStart", before))
       .take(limit)).map((row) => () => ctx.db.delete("aggregateBuckets", row._id));
   }
   if (kind === "funnelProgress") {
-    return (await ctx.db
-      .query("funnelProgress")
-      .withIndex("by_siteId_and_lastStepAt", (range) =>
-        range.eq("siteId", siteId).lt("lastStepAt", before),
-      )
+    return (await ctx.db.query("funnelProgress")
+      .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),
-      )
+    return (await ctx.db.query("funnelStepBuckets")
+      .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),
-      )
+    return (await ctx.db.query("affiliateDailyStats")
+      .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 === "attributions") {
-    return (await ctx.db
-      .query("visitorAttributions")
-      .withIndex("by_siteId_and_expiresAt", (range) =>
-        range.eq("siteId", siteId).lt("expiresAt", before),
-      )
-      .take(limit)).map((row) => () =>
-        ctx.db.delete("visitorAttributions", row._id),
-      );
+    return (await ctx.db.query("visitorAttributions")
+      .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),
-      )
+    return (await ctx.db.query("liveSessions")
+      .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),
-      )
+    return (await ctx.db.query("siteIngestWindows")
+      .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),
-    )
+  return (await ctx.db.query("ingestWindows")
+    .withIndex("by_siteId_and_updatedAt", (q) => q.eq("siteId", siteId).lt("updatedAt", before))
     .take(limit)).map((row) => () => ctx.db.delete("ingestWindows", row._id));
 }