@iann29/rastro 0.1.0-alpha.0

package/src/component/retention.ts

@@ -0,0 +1,180 @@
+import { v } from "convex/values";
+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 { fail } from "./errors.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 cleanup = mutation({
+  args: {
+    siteId: v.id("sites"),
+    kind: cleanupKindValidator,
+    before: v.number(),
+    batchSize: v.optional(v.number()),
+  },
+  returns: v.object({ deleted: v.number(), hasMore: v.boolean() }),
+  handler: async (ctx, args) => {
+    if (!Number.isFinite(args.before) || args.before < 0) {
+      fail("INVALID_ARGUMENT", "before must be a positive timestamp");
+    }
+    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 deletions = await deletionsForCleanup(
+      ctx,
+      args.siteId,
+      args.kind,
+      args.before,
+      batchSize + 1,
+    );
+    for (const remove of deletions.slice(0, batchSize)) {
+      await remove();
+    }
+    return {
+      deleted: Math.min(deletions.length, batchSize),
+      hasMore: deletions.length > batchSize,
+    };
+  },
+});
+
+type CleanupKind =
+  | "events"
+  | "sessions"
+  | "conversions"
+  | "goalCompletions"
+  | "aggregateHour"
+  | "aggregateDay"
+  | "funnelProgress"
+  | "funnelSteps"
+  | "affiliateStats"
+  | "attributions"
+  | "liveSessions"
+  | "ingestWindows"
+  | "siteIngestWindows";
+
+type CleanupDelete = () => Promise<void>;
+
+async function deletionsForCleanup(
+  ctx: MutationCtx,
+  siteId: Id<"sites">,
+  kind: CleanupKind,
+  before: number,
+  limit: number,
+): Promise<CleanupDelete[]> {
+  if (kind === "events") {
+    return (await ctx.db
+      .query("events")
+      .withIndex("by_siteId_and_timestamp", (range) =>
+        range.eq("siteId", siteId).lt("timestamp", before),
+      )
+      .take(limit)).map((row) => () => ctx.db.delete("events", row._id));
+  }
+  if (kind === "sessions") {
+    return (await ctx.db
+      .query("sessions")
+      .withIndex("by_siteId_and_lastSeenAt", (range) =>
+        range.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),
+      )
+      .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),
+      )
+      .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));
+  }
+  if (kind === "funnelProgress") {
+    return (await ctx.db
+      .query("funnelProgress")
+      .withIndex("by_siteId_and_lastStepAt", (range) =>
+        range.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),
+      )
+      .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),
+      )
+      .take(limit)).map((row) => () => ctx.db.delete("affiliateDailyStats", 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),
+      );
+  }
+  if (kind === "liveSessions") {
+    return (await ctx.db
+      .query("liveSessions")
+      .withIndex("by_siteId_and_expiresAt", (range) =>
+        range.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),
+      )
+      .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),
+    )
+    .take(limit)).map((row) => () => ctx.db.delete("ingestWindows", row._id));
+}

package/src/component/sanitize.ts

@@ -0,0 +1,278 @@
+import {
+  MAX_BATCH_BYTES,
+  MAX_PROPERTIES,
+  MAX_SITE_DOMAINS,
+} from "./constants.js";
+import type {
+  EventProperties,
+  IngestContext,
+  TrackerEvent,
+} from "./validators.js";
+
+const HOST_LABEL = /^[a-z0-9](?:[a-z0-9-]{0,61}[a-z0-9])?$/;
+const SAFE_KEY = /^[A-Za-z][A-Za-z0-9_.-]{0,39}$/;
+const SAFE_OPAQUE_ID = /^[A-Za-z0-9][A-Za-z0-9_.:-]*$/;
+const SAFE_SLUG = /^[a-z0-9](?:[a-z0-9_-]{0,62}[a-z0-9])?$/;
+const MAX_EVENT_AGE_MS = 400 * 86_400_000;
+const MAX_FUTURE_SKEW_MS = 5 * 60_000;
+
+export function cleanString(value: string, maxLength: number): string {
+  let safe = "";
+  for (const character of value) {
+    const codePoint = character.codePointAt(0) ?? 0;
+    if (codePoint <= 0x1f || codePoint === 0x7f) continue;
+    safe += character;
+  }
+  const normalized = safe.trim();
+  let end = 0;
+  let length = 0;
+  for (const character of normalized) {
+    if (length === maxLength) break;
+    end += character.length;
+    length += 1;
+  }
+  return normalized.slice(0, end);
+}
+
+export function requireString(
+  value: string,
+  field: string,
+  maxLength: number,
+): string {
+  const cleaned = cleanString(value, maxLength);
+  if (!cleaned) throw new Error(`${field} is required`);
+  return cleaned;
+}
+
+export function sanitizeOpaqueId(value: string, field: string): string {
+  const cleaned = requireString(value, field, 128);
+  if (!SAFE_OPAQUE_ID.test(cleaned)) {
+    throw new Error(`${field} contains unsupported characters`);
+  }
+  return cleaned;
+}
+
+export function sanitizeSlug(value: string, field = "slug"): string {
+  const cleaned = cleanString(value.toLowerCase(), 64);
+  if (!SAFE_SLUG.test(cleaned)) throw new Error(`${field} is invalid`);
+  return cleaned;
+}
+
+export function sanitizePath(value: string): string {
+  const input = requireString(value, "path", 2048);
+  let path: string;
+  try {
+    path = input.startsWith("http://") || input.startsWith("https://")
+      ? new URL(input).pathname
+      : input.split(/[?#]/, 1)[0];
+  } catch {
+    throw new Error("path is invalid");
+  }
+  if (!path.startsWith("/")) path = `/${path}`;
+  const cleaned = cleanString(path, 512);
+  return cleaned || "/";
+}
+
+export function sanitizePublicUrl(value: string): string | undefined {
+  const input = cleanString(value, 2048);
+  if (!input) return undefined;
+  try {
+    if (input.startsWith("/")) return sanitizePath(input);
+    const url = new URL(input);
+    if (url.protocol !== "http:" && url.protocol !== "https:") return undefined;
+    const port = url.port ? `:${url.port}` : "";
+    return `${url.protocol}//${url.hostname.toLowerCase()}${port}${sanitizePath(url.pathname)}`;
+  } catch {
+    return undefined;
+  }
+}
+
+export function sanitizeProperties(
+  properties: EventProperties | undefined,
+): EventProperties | undefined {
+  if (!properties) return undefined;
+  const entries = Object.entries(properties);
+  if (entries.length > MAX_PROPERTIES) throw new Error("too many properties");
+  const result: EventProperties = {};
+  for (const [rawKey, rawValue] of entries) {
+    const key = cleanString(rawKey, 40);
+    if (!SAFE_KEY.test(key)) throw new Error("property key is invalid");
+    if (typeof rawValue === "string") {
+      result[key] = cleanString(rawValue, 160);
+    } else if (typeof rawValue === "number") {
+      if (!Number.isFinite(rawValue) || Math.abs(rawValue) > 1_000_000_000) {
+        throw new Error("property number is out of range");
+      }
+      result[key] = rawValue;
+    } else if (typeof rawValue === "boolean" || rawValue === null) {
+      result[key] = rawValue;
+    }
+  }
+  return Object.keys(result).length > 0 ? result : undefined;
+}
+
+export function sanitizeEvent(event: TrackerEvent, now: number): TrackerEvent {
+  if (!Number.isFinite(event.timestamp)) throw new Error("timestamp is invalid");
+  if (
+    event.timestamp < now - MAX_EVENT_AGE_MS ||
+    event.timestamp > now + MAX_FUTURE_SKEW_MS
+  ) {
+    throw new Error("timestamp is outside the accepted window");
+  }
+  if (!Number.isSafeInteger(event.sequence) || event.sequence < 0 || event.sequence > 1_000_000_000) {
+    throw new Error("sequence is out of range");
+  }
+  if (event.revenueCents !== undefined && !isValidMoney(event.revenueCents)) {
+    throw new Error("revenueCents is out of range");
+  }
+  let name = event.name === undefined ? undefined : cleanString(event.name, 80);
+  if (event.type === "custom" && !name) {
+    throw new Error("name is required for custom events");
+  }
+  if (event.type === "conversion" && !name) name = "conversion";
+  const currency = event.currency === undefined
+    ? event.type === "conversion" ? "USD" : undefined
+    : sanitizeCurrency(event.currency);
+  return {
+    eventId: sanitizeOpaqueId(event.eventId, "eventId"),
+    sessionId: sanitizeOpaqueId(event.sessionId, "sessionId"),
+    visitorId: sanitizeOpaqueId(event.visitorId, "visitorId"),
+    type: event.type,
+    name,
+    path: sanitizePath(event.path),
+    referrer: event.referrer === undefined
+      ? undefined
+      : sanitizePublicUrl(event.referrer),
+    timestamp: Math.trunc(event.timestamp),
+    sequence: event.sequence,
+    target: event.target === undefined
+      ? undefined
+      : cleanString(event.target, 160) || undefined,
+    href: event.href === undefined ? undefined : sanitizePublicUrl(event.href),
+    properties: sanitizeProperties(event.properties),
+    revenueCents: event.revenueCents,
+    currency,
+    affiliateSlug: event.affiliateSlug === undefined
+      ? undefined
+      : sanitizeSlug(event.affiliateSlug, "affiliateSlug"),
+  };
+}
+
+export function normalizeDomains(domains: string[]): string[] {
+  if (domains.length === 0 || domains.length > MAX_SITE_DOMAINS) {
+    throw new Error(`domains must contain between 1 and ${MAX_SITE_DOMAINS} entries`);
+  }
+  const normalized = domains.map(normalizeDomainPattern);
+  return [...new Set(normalized)].sort();
+}
+
+export function normalizeDomainPattern(value: string): string {
+  const raw = cleanString(value.toLowerCase(), 255);
+  const wildcard = raw.startsWith("*.");
+  const hostInput = wildcard ? raw.slice(2) : raw;
+  let hostname = hostInput;
+  if (hostInput.includes("://")) {
+    if (wildcard) throw new Error("wildcard domains cannot include a scheme");
+    const url = new URL(hostInput);
+    if (url.pathname !== "/" || url.search || url.hash) {
+      throw new Error("domains cannot include paths or query strings");
+    }
+    hostname = url.hostname;
+  } else if (hostInput.includes("/") || hostInput.includes("?") || hostInput.includes("#")) {
+    throw new Error("domain is invalid");
+  }
+  hostname = hostname.replace(/\.$/, "");
+  if (hostname !== "localhost") {
+    const labels = hostname.split(".");
+    if (labels.length < 2 || labels.some((label) => !HOST_LABEL.test(label))) {
+      throw new Error("domain is invalid");
+    }
+  }
+  return wildcard ? `*.${hostname}` : hostname;
+}
+
+export function originAllowed(origin: string, domains: string[]): boolean {
+  let hostname: string;
+  try {
+    const url = new URL(origin);
+    if (url.protocol !== "http:" && url.protocol !== "https:") return false;
+    hostname = url.hostname.toLowerCase().replace(/\.$/, "");
+  } catch {
+    return false;
+  }
+  return domains.some((pattern) => {
+    if (!pattern.startsWith("*.")) return hostname === pattern;
+    const suffix = pattern.slice(2);
+    return hostname !== suffix && hostname.endsWith(`.${suffix}`);
+  });
+}
+
+export function validateTimezone(value: string | undefined): string | undefined {
+  if (value === undefined || value.trim() === "") return undefined;
+  const timezone = cleanString(value, 80);
+  try {
+    new Intl.DateTimeFormat("en-US", { timeZone: timezone }).format(0);
+    return timezone;
+  } catch {
+    throw new Error("timezone is invalid");
+  }
+}
+
+export function sanitizeContext(context: IngestContext | undefined): IngestContext {
+  const latitude = finiteCoordinate(context?.latitude, -90, 90);
+  const longitude = finiteCoordinate(context?.longitude, -180, 180);
+  return {
+    country: context?.country ? cleanString(context.country.toUpperCase(), 2) || undefined : undefined,
+    city: context?.city ? cleanString(context.city, 80) || undefined : undefined,
+    latitude: latitude === undefined ? undefined : Math.round(latitude * 10) / 10,
+    longitude: longitude === undefined ? undefined : Math.round(longitude * 10) / 10,
+    browser: context?.browser ? cleanString(context.browser, 32) || undefined : undefined,
+    os: context?.os ? cleanString(context.os, 32) || undefined : undefined,
+    device: context?.device ? cleanString(context.device, 24) || undefined : undefined,
+  };
+}
+
+export function sanitizeCurrency(value: string): string {
+  const currency = cleanString(value.toUpperCase(), 3);
+  if (!/^[A-Z]{3}$/.test(currency)) throw new Error("currency is invalid");
+  return currency;
+}
+
+export function isValidMoney(value: number): boolean {
+  return Number.isSafeInteger(value) && value >= 0 && value <= 1_000_000_000;
+}
+
+export function ensureBatchBytes(value: unknown): number {
+  const bytes = new TextEncoder().encode(JSON.stringify(value)).byteLength;
+  if (bytes > MAX_BATCH_BYTES) throw new Error("batch exceeds 64 KiB");
+  return bytes;
+}
+
+export function sourceFromReferrer(referrer: string | undefined): string {
+  if (!referrer) return "direct";
+  if (referrer.startsWith("/")) return "internal";
+  try {
+    return new URL(referrer).hostname.toLowerCase().slice(0, 120) || "direct";
+  } catch {
+    return "direct";
+  }
+}
+
+export function stableHash(value: string): number {
+  let hash = 2_166_136_261;
+  for (let index = 0; index < value.length; index += 1) {
+    hash ^= value.charCodeAt(index);
+    hash = Math.imul(hash, 16_777_619);
+  }
+  return hash >>> 0;
+}
+
+function finiteCoordinate(
+  value: number | undefined,
+  minimum: number,
+  maximum: number,
+): number | undefined {
+  if (value === undefined) return undefined;
+  if (!Number.isFinite(value) || value < minimum || value > maximum) return undefined;
+  return value;
+}

package/src/component/schema.ts

@@ -0,0 +1,232 @@
+import { defineSchema, defineTable } from "convex/server";
+import { v } from "convex/values";
+import {
+  affiliateFieldsValidator,
+  aggregateFieldsValidator,
+  eventFieldsValidator,
+  funnelFieldsValidator,
+  goalFieldsValidator,
+  sessionFieldsValidator,
+  siteFieldsValidator,
+} from "./validators.js";
+
+export default defineSchema({
+  sites: defineTable(siteFieldsValidator)
+    .index("by_ownerId", ["ownerId"])
+    .index("by_ownerId_and_name", ["ownerId", "name"])
+    .index("by_networkId", ["networkId"]),
+
+  sessions: defineTable(sessionFieldsValidator)
+    .index("by_siteId_and_sessionId", ["siteId", "sessionId"])
+    .index("by_siteId_and_lastSeenAt", ["siteId", "lastSeenAt"])
+    .index("by_siteId_and_startedAt", ["siteId", "startedAt"])
+    .index("by_siteId_and_visitorId_and_lastSeenAt", [
+      "siteId",
+      "visitorId",
+      "lastSeenAt",
+    ]),
+
+  liveSessions: defineTable({
+    siteId: v.id("sites"),
+    sessionId: v.string(),
+    visitorId: v.string(),
+    path: v.string(),
+    startedAt: v.number(),
+    lastSeenAt: v.number(),
+    expiresAt: v.number(),
+    expiryChainDeadline: v.optional(v.number()),
+    country: v.optional(v.string()),
+    city: v.optional(v.string()),
+    latitude: v.optional(v.number()),
+    longitude: v.optional(v.number()),
+    browser: v.string(),
+    os: v.string(),
+    source: v.string(),
+    device: v.string(),
+    pageviewCount: v.number(),
+    lastHeartbeatEventId: v.optional(v.string()),
+    eventCount: v.number(),
+  })
+    .index("by_siteId_and_sessionId", ["siteId", "sessionId"])
+    .index("by_siteId_and_expiresAt", ["siteId", "expiresAt"])
+    .index("by_siteId_and_lastSeenAt", ["siteId", "lastSeenAt"]),
+
+  events: defineTable(eventFieldsValidator)
+    .index("by_siteId_and_eventId", ["siteId", "eventId"])
+    .index("by_siteId_and_timestamp", ["siteId", "timestamp"])
+    .index("by_siteId_and_visitorId_and_timestamp", [
+      "siteId",
+      "visitorId",
+      "timestamp",
+    ])
+    .index("by_siteId_and_sessionId_and_timestamp", [
+      "siteId",
+      "sessionId",
+      "timestamp",
+    ])
+    .index("by_siteId_and_type_and_timestamp", ["siteId", "type", "timestamp"]),
+
+  aggregateBuckets: defineTable(aggregateFieldsValidator)
+    .index("by_siteId_and_granularity_and_bucketStart_and_shard", [
+      "siteId",
+      "granularity",
+      "bucketStart",
+      "shard",
+    ])
+    .index("by_siteId_and_granularity_and_bucketStart", [
+      "siteId",
+      "granularity",
+      "bucketStart",
+    ]),
+
+  goals: defineTable(goalFieldsValidator)
+    .index("by_siteId", ["siteId"])
+    .index("by_siteId_and_key", ["siteId", "key"]),
+
+  goalCompletions: defineTable({
+    siteId: v.id("sites"),
+    goalId: v.id("goals"),
+    goalKey: v.string(),
+    eventId: v.string(),
+    sessionId: v.string(),
+    visitorId: v.string(),
+    timestamp: v.number(),
+    valueCents: v.number(),
+  })
+    .index("by_siteId_and_goalId_and_eventId", ["siteId", "goalId", "eventId"])
+    .index("by_siteId_and_goalId_and_timestamp", ["siteId", "goalId", "timestamp"])
+    .index("by_siteId_and_timestamp", ["siteId", "timestamp"]),
+
+  funnels: defineTable(funnelFieldsValidator)
+    .index("by_siteId", ["siteId"])
+    .index("by_siteId_and_key", ["siteId", "key"]),
+
+  funnelProgress: defineTable({
+    siteId: v.id("sites"),
+    funnelId: v.id("funnels"),
+    visitorId: v.string(),
+    sessionId: v.string(),
+    currentStep: v.number(),
+    startedAt: v.number(),
+    lastStepAt: v.number(),
+    completedAt: v.optional(v.number()),
+  })
+    .index("by_siteId_and_funnelId_and_visitorId", [
+      "siteId",
+      "funnelId",
+      "visitorId",
+    ])
+    .index("by_siteId_and_visitorId", ["siteId", "visitorId"])
+    .index("by_siteId_and_lastStepAt", ["siteId", "lastStepAt"]),
+
+  funnelStepBuckets: defineTable({
+    siteId: v.id("sites"),
+    funnelId: v.id("funnels"),
+    bucketStart: v.number(),
+    step: v.number(),
+    shard: v.number(),
+    entrants: v.number(),
+    completions: v.number(),
+  })
+    .index("by_siteId_and_funnelId_and_bucketStart_and_step_and_shard", [
+      "siteId",
+      "funnelId",
+      "bucketStart",
+      "step",
+      "shard",
+    ])
+    .index("by_siteId_and_funnelId_and_bucketStart", [
+      "siteId",
+      "funnelId",
+      "bucketStart",
+    ])
+    .index("by_siteId_and_bucketStart", ["siteId", "bucketStart"]),
+
+  affiliates: defineTable(affiliateFieldsValidator)
+    .index("by_siteId", ["siteId"])
+    .index("by_siteId_and_slug", ["siteId", "slug"]),
+
+  visitorAttributions: defineTable({
+    siteId: v.id("sites"),
+    visitorId: v.string(),
+    affiliateId: v.id("affiliates"),
+    affiliateSlug: v.string(),
+    attributedAt: v.number(),
+    expiresAt: v.number(),
+  })
+    .index("by_siteId_and_visitorId", ["siteId", "visitorId"])
+    .index("by_siteId_and_expiresAt", ["siteId", "expiresAt"]),
+
+  affiliateDailyStats: defineTable({
+    siteId: v.id("sites"),
+    affiliateId: v.id("affiliates"),
+    affiliateSlug: v.string(),
+    bucketStart: v.number(),
+    shard: v.number(),
+    conversions: v.number(),
+    revenueCents: v.number(),
+    commissionCents: v.number(),
+  })
+    .index("by_siteId_and_affiliateId_and_bucketStart_and_shard", [
+      "siteId",
+      "affiliateId",
+      "bucketStart",
+      "shard",
+    ])
+    .index("by_siteId_and_bucketStart", ["siteId", "bucketStart"]),
+
+  conversions: defineTable({
+    siteId: v.id("sites"),
+    eventId: v.string(),
+    sessionId: v.string(),
+    visitorId: v.string(),
+    timestamp: v.number(),
+    path: v.string(),
+    revenueCents: v.number(),
+    currency: v.string(),
+    source: v.union(v.literal("tracker"), v.literal("trusted")),
+    goalKey: v.optional(v.string()),
+    affiliateId: v.optional(v.id("affiliates")),
+    affiliateAttributedAt: v.optional(v.number()),
+    affiliateExpiresAt: v.optional(v.number()),
+    affiliateSlug: v.optional(v.string()),
+    commissionCents: v.number(),
+  })
+    .index("by_siteId_and_eventId", ["siteId", "eventId"])
+    .index("by_siteId_and_timestamp", ["siteId", "timestamp"])
+    .index("by_siteId_and_visitorId_and_timestamp", [
+      "siteId",
+      "visitorId",
+      "timestamp",
+    ]),
+
+  ingestWindows: defineTable({
+    siteId: v.id("sites"),
+    sessionId: v.string(),
+    windowStart: v.number(),
+    eventCount: v.number(),
+    byteCount: v.number(),
+    updatedAt: v.number(),
+  })
+    .index("by_siteId_and_sessionId_and_windowStart", [
+      "siteId",
+      "sessionId",
+      "windowStart",
+    ])
+    .index("by_siteId_and_updatedAt", ["siteId", "updatedAt"]),
+
+  siteIngestWindows: defineTable({
+    siteId: v.id("sites"),
+    shard: v.number(),
+    windowStart: v.number(),
+    eventCount: v.number(),
+    byteCount: v.number(),
+    updatedAt: v.number(),
+  })
+    .index("by_siteId_and_shard_and_windowStart", [
+      "siteId",
+      "shard",
+      "windowStart",
+    ])
+    .index("by_siteId_and_updatedAt", ["siteId", "updatedAt"]),
+});