@primocaredentgroup/convex-campaigns-component 0.1.3 → 0.3.1

package/convex/components/campaigns/functions/playground.ts

@@ -0,0 +1,780 @@
+import { v } from "convex/values";
+import { mutation, query } from "../../../_generated/server";
+import { assertCanManageCampaigns } from "../permissions";
+import { canTransitionCampaignStatus } from "../domain/stateMachine";
+import { normalizeClinicIds } from "../lib/helpers";
+import { dataSource } from "../v2/dataSource";
+import { getDefaultCallPolicy, validateCallPolicyInput } from "../v2/callPolicy";
+import { fieldRegistry, getFieldRegistryPublic } from "../v2/fieldRegistry";
+import { evaluateRuleGroup, validateRuleDsl } from "../v2/rules";
+import type { RuleGroup } from "../v2/types";
+import { DEFAULT_CALL_POLICY } from "../domain/types";
+
+const MAX_PREVIEW = 5000;
+
+function hashRules(rules: unknown): string {
+  const text = JSON.stringify(rules);
+  let h = 2166136261;
+  for (let i = 0; i < text.length; i += 1) {
+    h ^= text.charCodeAt(i);
+    h += (h << 1) + (h << 4) + (h << 7) + (h << 8) + (h << 24);
+  }
+  return `rules_${(h >>> 0).toString(16)}`;
+}
+
+function hashPolicy(policy: unknown): string {
+  const text = JSON.stringify(policy);
+  let h = 2166136261;
+  for (let i = 0; i < text.length; i += 1) {
+    h ^= text.charCodeAt(i);
+    h += (h << 1) + (h << 4) + (h << 7) + (h << 8) + (h << 24);
+  }
+  return `policy_${(h >>> 0).toString(16)}`;
+}
+
+async function safeCampaignsByOrg(ctx: any, orgId: string) {
+  try {
+    return await ctx.db
+      .query("campaigns")
+      .withIndex("by_org", (q: any) => q.eq("orgId", orgId))
+      .collect();
+  } catch {
+    return await ctx.db
+      .query("campaigns")
+      .filter((q: any) => q.eq(q.field("orgId"), orgId))
+      .collect();
+  }
+}
+
+async function safeCampaignsByOrgStatus(ctx: any, orgId: string, status: string) {
+  try {
+    return await ctx.db
+      .query("campaigns")
+      .withIndex("by_org_status", (q: any) => q.eq("orgId", orgId).eq("status", status))
+      .collect();
+  } catch {
+    return await ctx.db
+      .query("campaigns")
+      .filter((q: any) => q.and(q.eq(q.field("orgId"), orgId), q.eq(q.field("status"), status)))
+      .collect();
+  }
+}
+
+async function latestContactByPatient(ctx: any, patientId: string, orgId: string): Promise<number | null> {
+  try {
+    const logs = await ctx.db
+      .query("contactLog")
+      .withIndex("by_patient_time", (q: any) => q.eq("patientId", patientId))
+      .collect();
+    const byOrg = logs.filter((l: any) => l.orgId === orgId);
+    if (byOrg.length === 0) return null;
+    return byOrg.reduce((acc: number, curr: any) => Math.max(acc, curr.createdAt), 0);
+  } catch {
+    return null;
+  }
+}
+
+export const getFieldRegistry = query({
+  args: {},
+  handler: async () => getFieldRegistryPublic(),
+});
+
+export const seedDemoData = mutation({
+  args: {
+    orgId: v.string(),
+    clinicIds: v.array(v.string()),
+    nPatients: v.number(),
+  },
+  handler: async (ctx, args) => {
+    await assertCanManageCampaigns(ctx);
+    const clinicIds = normalizeClinicIds(args.clinicIds);
+    if (clinicIds.length === 0) throw new Error("Almeno una clinicId è obbligatoria.");
+
+    const firstNames = ["Mario", "Luca", "Anna", "Giulia", "Sara", "Marco", "Paolo", "Elena"];
+    const lastNames = ["Rossi", "Bianchi", "Verdi", "Conti", "Neri", "Marino", "Gallo", "Costa"];
+    const cities = ["Milano", "Roma", "Torino", "Bologna", "Napoli", "Brescia"];
+    const now = Date.now();
+    let inserted = 0;
+
+    for (let i = 0; i < args.nPatients; i += 1) {
+      const clinicId = clinicIds[i % clinicIds.length];
+      const patientId = `demo-${args.orgId}-${clinicId}-${i + 1}`;
+      const birthYear = 1950 + Math.floor(Math.random() * 55);
+      const birthDate = `${birthYear}-${String(1 + (i % 12)).padStart(2, "0")}-${String(
+        1 + (i % 28),
+      ).padStart(2, "0")}`;
+      const firstName = firstNames[i % firstNames.length];
+      const lastName = lastNames[(i * 3) % lastNames.length];
+      const city = cities[(i * 5) % cities.length];
+      const hasCallConsent = i % 7 !== 0;
+      const phoneMasked = i % 9 === 0 ? undefined : `+39*******${String(100 + i).slice(-3)}`;
+
+      const existing = await ctx.db
+        .query("demoPatients")
+        .withIndex("by_org_patient", (q: any) => q.eq("orgId", args.orgId).eq("patientId", patientId))
+        .first();
+      if (!existing) {
+        await ctx.db.insert("demoPatients", {
+          orgId: args.orgId,
+          clinicId,
+          patientId,
+          firstName,
+          lastName,
+          city,
+          birthDate,
+          hasCallConsent,
+          phoneMasked,
+        });
+        inserted += 1;
+      }
+
+      const daysAgo = 10 + (i % 220);
+      await ctx.db.insert("demoAppointments", {
+        orgId: args.orgId,
+        clinicId,
+        patientId,
+        date: now - daysAgo * 24 * 60 * 60 * 1000,
+        status: i % 8 === 0 ? "missed" : "done",
+      });
+      if (i % 5 === 0) {
+        await ctx.db.insert("demoAppointments", {
+          orgId: args.orgId,
+          clinicId,
+          patientId,
+          date: now + (3 + (i % 20)) * 24 * 60 * 60 * 1000,
+          status: "booked",
+        });
+      }
+
+      const estStatus = i % 6 === 0 ? "expired" : i % 4 === 0 ? "accepted" : "open";
+      await ctx.db.insert("demoEstimates", {
+        orgId: args.orgId,
+        clinicId,
+        patientId,
+        status: estStatus,
+        amount: 400 + (i % 15) * 120,
+        createdAt: now - (i % 120) * 24 * 60 * 60 * 1000,
+        expiredAt: estStatus === "expired" ? now - (5 + (i % 30)) * 24 * 60 * 60 * 1000 : undefined,
+      });
+
+      await ctx.db.insert("demoTreatmentPlans", {
+        orgId: args.orgId,
+        clinicId,
+        patientId,
+        status: i % 3 === 0 ? "open" : "closed",
+        lastActivityAt: now - (i % 90) * 24 * 60 * 60 * 1000,
+      });
+    }
+
+    const clinicIdsUsed = [...new Set(clinicIds)];
+    const samplePatientIds = Array.from(
+      { length: Math.min(5, args.nPatients) },
+      (_, i) => {
+        const c = clinicIdsUsed[i % clinicIdsUsed.length];
+        return `demo-${args.orgId}-${c}-${i + 1}`;
+      },
+    );
+    return {
+      insertedPatients: inserted,
+      requested: args.nPatients,
+      clinicIds: clinicIdsUsed,
+      samplePatientIds,
+    };
+  },
+});
+
+export const updateCampaignCallPolicy = mutation({
+  args: {
+    campaignId: v.id("campaigns"),
+    callPolicy: v.any(),
+  },
+  handler: async (ctx, args) => {
+    await assertCanManageCampaigns(ctx);
+    const validation = validateCallPolicyInput(args.callPolicy);
+    if (!validation.ok) {
+      throw new Error(`CALL_POLICY_VALIDATION_ERROR: ${validation.errors.join(" | ")}`);
+    }
+
+    const campaign = await ctx.db.get(args.campaignId);
+    if (!campaign) throw new Error("Campaign non trovata.");
+
+    const identity = await ctx.auth.getUserIdentity();
+    const actor = identity?.email ?? identity?.subject ?? "unknown";
+    const now = Date.now();
+
+    await ctx.db.patch(args.campaignId, {
+      callPolicy: validation.data,
+      policyUpdatedAt: now,
+      policyUpdatedBy: actor,
+      updatedAt: now,
+      updatedBy: actor,
+    });
+
+    return await ctx.db.get(args.campaignId);
+  },
+});
+
+export const getCampaignCallPolicy = query({
+  args: { campaignId: v.id("campaigns") },
+  handler: async (ctx, args) => {
+    try {
+      await assertCanManageCampaigns(ctx);
+      const campaign = await ctx.db.get(args.campaignId);
+      if (!campaign) return null;
+      const policy = campaign.callPolicy ?? getDefaultCallPolicy();
+      return { callPolicy: policy, defaults: DEFAULT_CALL_POLICY };
+    } catch (error) {
+      console.error("[getCampaignCallPolicy]", error);
+      return null;
+    }
+  },
+});
+
+export const upsertCampaign = mutation({
+  args: {
+    id: v.optional(v.id("campaigns")),
+    orgId: v.string(),
+    name: v.string(),
+    description: v.optional(v.string()),
+    priority: v.optional(v.number()),
+    status: v.optional(v.union(v.literal("draft"), v.literal("ready"), v.literal("archived"))),
+    clinicIds: v.optional(v.array(v.string())),
+    rules: v.any(),
+    frequencyCapDays: v.optional(v.number()),
+  },
+  handler: async (ctx, args) => {
+    await assertCanManageCampaigns(ctx);
+
+    const rulesValidation = validateRuleDsl(args.rules);
+    if (!rulesValidation.ok) {
+      throw new Error(`RULES_VALIDATION_ERROR: ${rulesValidation.errors.join(" | ")}`);
+    }
+
+    const now = Date.now();
+    const identity = await ctx.auth.getUserIdentity();
+    const actor = identity?.email ?? identity?.subject ?? "unknown";
+    const clinicIds = normalizeClinicIds(args.clinicIds as (string | unknown)[] | undefined);
+    const status = args.status ?? "draft";
+    const rawPriority = args.priority ?? 100;
+    const priority = Math.max(1, rawPriority);
+    if (rawPriority < 1) {
+      throw new Error("PRIORITY_VALIDATION: priority deve essere >= 1");
+    }
+
+    const payload = {
+      orgId: args.orgId,
+      name: args.name,
+      description: args.description,
+      priority,
+      status,
+      scope: { orgId: args.orgId, clinicIds },
+      rules: rulesValidation.data,
+      frequencyCapDays: args.frequencyCapDays,
+      scopeType: clinicIds.length > 0 ? "CLINIC" : "HQ",
+      scopeClinicIds: clinicIds,
+      createdBy: actor,
+      updatedBy: actor,
+      updatedAt: now,
+      createdAt: now,
+      defaultRunConfig: { capWindowDays: 7, capMaxContacts: 1, lockDays: 7 },
+    } as any;
+
+    if (!args.id) {
+      const id = await ctx.db.insert("campaigns", payload);
+      return { id, created: true };
+    }
+
+    const existing = await ctx.db.get(args.id);
+    if (!existing) throw new Error("Campaign non trovata.");
+    await ctx.db.patch(args.id, {
+      ...payload,
+      createdAt: existing.createdAt ?? now,
+      createdBy: existing.createdBy ?? actor,
+    });
+    return { id: args.id, created: false };
+  },
+});
+
+export const setCampaignLifecycleStatus = mutation({
+  args: {
+    campaignId: v.id("campaigns"),
+    status: v.union(v.literal("draft"), v.literal("ready"), v.literal("archived")),
+  },
+  handler: async (ctx, args) => {
+    await assertCanManageCampaigns(ctx);
+    const campaign = await ctx.db.get(args.campaignId);
+    if (!campaign) throw new Error("Campaign non trovata.");
+    const statusToV2: Record<string, "draft" | "ready" | "archived"> = {
+      DRAFT: "draft",
+      draft: "draft",
+      RUNNING: "ready",
+      ready: "ready",
+      PAUSED: "ready",
+      COMPLETED: "archived",
+      ARCHIVED: "archived",
+      archived: "archived",
+    };
+    const current = statusToV2[campaign.status ?? "draft"] ?? "draft";
+    const next = args.status as "draft" | "ready" | "archived";
+    if (!canTransitionCampaignStatus(current, next)) {
+      throw new Error(
+        `LIFECYCLE_INVALID: transizione da "${current}" a "${next}" non consentita.`,
+      );
+    }
+    const identity = await ctx.auth.getUserIdentity();
+    await ctx.db.patch(args.campaignId, {
+      status: args.status,
+      updatedAt: Date.now(),
+      updatedBy: identity?.email ?? identity?.subject ?? "unknown",
+    });
+    return { success: true };
+  },
+});
+
+export const listCampaignsV2 = query({
+  args: {
+    orgId: v.string(),
+    status: v.optional(v.union(v.literal("draft"), v.literal("ready"), v.literal("archived"))),
+  },
+  handler: async (ctx, args) => {
+    try {
+      await assertCanManageCampaigns(ctx);
+      const rows = args.status
+        ? await safeCampaignsByOrgStatus(ctx, args.orgId, args.status)
+        : await safeCampaignsByOrg(ctx, args.orgId);
+      return rows.sort((a: any, b: any) => (a.priority ?? 100) - (b.priority ?? 100));
+    } catch (error) {
+      console.error("[listCampaignsV2]", error);
+      return [];
+    }
+  },
+});
+
+export const getCampaignV2 = query({
+  args: { id: v.id("campaigns") },
+  handler: async (ctx, args) => {
+    try {
+      await assertCanManageCampaigns(ctx);
+      return await ctx.db.get(args.id);
+    } catch (error) {
+      console.error("[getCampaignV2]", error);
+      return null;
+    }
+  },
+});
+
+export const listCampaignVersions = query({
+  args: { campaignId: v.id("campaigns") },
+  handler: async (ctx, args) => {
+    try {
+      await assertCanManageCampaigns(ctx);
+      const versions = await ctx.db
+        .query("campaignVersions")
+        .withIndex("by_campaign", (q: any) => q.eq("campaignId", args.campaignId))
+        .collect();
+      return versions.sort((a: any, b: any) => b.version - a.version);
+    } catch (error) {
+      console.error("[listCampaignVersions]", error);
+      return [];
+    }
+  },
+});
+
+export const previewCampaignAudience = query({
+  args: {
+    campaignId: v.optional(v.id("campaigns")),
+    orgId: v.optional(v.string()),
+    clinicIds: v.optional(v.array(v.string())),
+    rules: v.optional(v.any()),
+    frequencyCapDays: v.optional(v.number()),
+  },
+  handler: async (ctx, args) => {
+    await assertCanManageCampaigns(ctx);
+
+    let orgId = args.orgId ?? "";
+    let clinicIds = normalizeClinicIds(args.clinicIds);
+    let rules: RuleGroup | null = null;
+    let frequencyCapDays = args.frequencyCapDays;
+
+    if (args.campaignId) {
+      const campaign = await ctx.db.get(args.campaignId);
+      if (!campaign) throw new Error("Campaign non trovata");
+      orgId = campaign.orgId ?? campaign.scope?.orgId;
+      clinicIds = normalizeClinicIds((campaign.scope?.clinicIds as string[]) ?? campaign.scopeClinicIds ?? []);
+      rules = (campaign.rules ?? null) as RuleGroup | null;
+      frequencyCapDays = campaign.frequencyCapDays;
+    } else {
+      orgId = args.orgId ?? "";
+      const parsed = validateRuleDsl(args.rules);
+      if (!parsed.ok) throw new Error(`RULES_VALIDATION_ERROR: ${parsed.errors.join(" | ")}`);
+      rules = parsed.data;
+    }
+
+    if (!orgId) throw new Error("orgId obbligatorio.");
+    if (!rules) throw new Error("Regole mancanti.");
+
+    let cursor: string | null = null;
+    let total = 0;
+    let isTruncated = false;
+    const byClinicMap = new Map<string, number>();
+    const sample: any[] = [];
+
+    while (true) {
+      const page = await dataSource.listPatients(ctx, orgId, clinicIds, cursor, 200);
+      if (page.page.length === 0) break;
+      for (const row of page.page) {
+        const patientCtx = await dataSource.getPatientContext(ctx, row.orgId, row.clinicId, row.patientId);
+        if (!patientCtx) continue;
+
+        const evalResult = evaluateRuleGroup(rules, patientCtx);
+        if (!evalResult.match) continue;
+
+        if (frequencyCapDays && patientCtx.contact.lastContactAt) {
+          const inWindow = patientCtx.contact.lastContactAt >= Date.now() - frequencyCapDays * 24 * 60 * 60 * 1000;
+          if (inWindow) continue;
+        }
+
+        total += 1;
+        byClinicMap.set(row.clinicId, (byClinicMap.get(row.clinicId) ?? 0) + 1);
+        if (sample.length < 20) {
+          sample.push({
+            patientId: row.patientId,
+            clinicId: row.clinicId,
+            reasons: evalResult.reasons,
+            masked: {
+              displayName: `${patientCtx.firstName} ${patientCtx.lastName.charAt(0)}.`,
+              city: patientCtx.city,
+              lastAppointmentDate: patientCtx.appointment.lastDate ?? undefined,
+            },
+          });
+        }
+        if (total >= MAX_PREVIEW) {
+          isTruncated = true;
+          break;
+        }
+      }
+
+      if (isTruncated) break;
+      cursor = page.nextCursor;
+      if (!cursor) break;
+    }
+
+    return {
+      total,
+      byClinic: [...byClinicMap.entries()].map(([clinicId, count]) => ({ clinicId, count })),
+      sample,
+      isTruncated,
+    };
+  },
+});
+
+export const publishCampaignVersion = mutation({
+  args: {
+    campaignId: v.id("campaigns"),
+    label: v.optional(v.string()),
+  },
+  handler: async (ctx, args) => {
+    await assertCanManageCampaigns(ctx);
+    const campaign = await ctx.db.get(args.campaignId);
+    if (!campaign) throw new Error("Campaign non trovata.");
+    if (campaign.status !== "ready") {
+      throw new Error("Campaign deve essere in stato 'ready' per pubblicare una versione.");
+    }
+
+    const orgId = campaign.orgId ?? campaign.scope?.orgId;
+    if (!orgId) throw new Error("Campaign senza orgId.");
+    const clinicIds = normalizeClinicIds((campaign.scope?.clinicIds as string[]) ?? campaign.scopeClinicIds ?? []);
+    const rulesCheck = validateRuleDsl(campaign.rules);
+    if (!rulesCheck.ok) throw new Error(`RULES_VALIDATION_ERROR: ${rulesCheck.errors.join(" | ")}`);
+
+    const identity = await ctx.auth.getUserIdentity();
+    const actor = identity?.email ?? identity?.subject ?? "unknown";
+    const existing = await ctx.db
+      .query("campaignVersions")
+      .withIndex("by_campaign", (q: any) => q.eq("campaignId", args.campaignId))
+      .collect();
+    const version = existing.length === 0 ? 1 : Math.max(...existing.map((v: any) => v.version)) + 1;
+
+    const callPolicySnapshot =
+      campaign.callPolicy ?? getDefaultCallPolicy();
+    const policyHash = hashPolicy(callPolicySnapshot);
+
+    const now = Date.now();
+    const versionId = await ctx.db.insert("campaignVersions", {
+      campaignId: args.campaignId,
+      version,
+      label: args.label,
+      scopeSnapshot: { orgId, clinicIds },
+      rulesSnapshot: rulesCheck.data,
+      rulesHash: hashRules(rulesCheck.data),
+      callPolicySnapshot,
+      policyHash,
+      createdAt: now,
+      createdBy: actor,
+      publishedAt: now,
+      publishedBy: actor,
+    });
+
+    let cursor: string | null = null;
+    let inserted = 0;
+    const dedupe = new Set<string>();
+    while (true) {
+      const page = await dataSource.listPatients(ctx, orgId, clinicIds, cursor, 100);
+      for (const row of page.page) {
+        const dedupeKey = `${versionId}:${row.patientId}`;
+        if (dedupe.has(dedupeKey)) continue;
+        dedupe.add(dedupeKey);
+
+        const already = await ctx.db
+          .query("audienceMembers")
+          .withIndex("by_patient_version", (q: any) =>
+            q.eq("patientId", row.patientId).eq("versionId", versionId),
+          )
+          .first();
+        if (already) continue;
+
+        const patientCtx = await dataSource.getPatientContext(ctx, row.orgId, row.clinicId, row.patientId);
+        if (!patientCtx) continue;
+        const evalResult = evaluateRuleGroup(rulesCheck.data, patientCtx);
+        if (!evalResult.match) continue;
+
+        if (campaign.frequencyCapDays) {
+          const lastContactAt = await latestContactByPatient(ctx, row.patientId, orgId);
+          if (
+            lastContactAt &&
+            lastContactAt >= now - campaign.frequencyCapDays * 24 * 60 * 60 * 1000
+          ) {
+            continue;
+          }
+        }
+
+        await ctx.db.insert("audienceMembers", {
+          orgId,
+          clinicId: row.clinicId,
+          campaignId: args.campaignId,
+          versionId,
+          patientId: row.patientId,
+          reasons: evalResult.reasons,
+          createdAt: now,
+        });
+        inserted += 1;
+      }
+      cursor = page.nextCursor;
+      if (!cursor) break;
+    }
+
+    return { versionId, version, inserted };
+  },
+});
+
+async function safeAudienceMembersByOrgPatient(ctx: any, orgId: string, patientId: string) {
+  try {
+    return await ctx.db
+      .query("audienceMembers")
+      .withIndex("by_org_patient", (q: any) =>
+        q.eq("orgId", orgId).eq("patientId", patientId),
+      )
+      .collect();
+  } catch {
+    return await ctx.db
+      .query("audienceMembers")
+      .filter(
+        (q: any) =>
+          q.eq(q.field("orgId"), orgId) && q.eq(q.field("patientId"), patientId),
+      )
+      .collect();
+  }
+}
+
+export const getPatientCampaignMemberships = query({
+  args: {
+    orgId: v.string(),
+    patientId: v.string(),
+  },
+  handler: async (ctx, args) => {
+    try {
+      await assertCanManageCampaigns(ctx);
+      const memberships = await safeAudienceMembersByOrgPatient(
+        ctx,
+        args.orgId,
+        args.patientId,
+      );
+      if (memberships.length === 0) return [];
+
+      const versionIds = [...new Set(memberships.map((m: any) => m.versionId))];
+      const versionsMap = new Map<string, any>();
+      for (const vid of versionIds) {
+        const ver = await ctx.db.get(vid);
+        if (ver) versionsMap.set(vid, ver);
+      }
+
+      const campaignIds = [
+        ...new Set(
+          [...versionsMap.values()].map((v: any) => v.campaignId as string),
+        ),
+      ];
+      const campaignsMap = new Map<string, any>();
+      for (const cid of campaignIds) {
+        const camp = await ctx.db.get(cid);
+        if (camp && camp.status === "ready") {
+          campaignsMap.set(cid, camp);
+        }
+      }
+
+      const byCampaign = new Map<
+        string,
+        { versionId: string; version: number; versionNumber: number }
+      >();
+      for (const m of memberships) {
+        const ver = versionsMap.get(m.versionId);
+        const camp = campaignsMap.get(ver?.campaignId);
+        if (!ver || !camp) continue;
+
+        const prev = byCampaign.get(ver.campaignId);
+        if (!prev || ver.version > prev.versionNumber) {
+          byCampaign.set(ver.campaignId, {
+            versionId: m.versionId,
+            version: m.versionId,
+            versionNumber: ver.version,
+          });
+        }
+      }
+
+      const result = [...byCampaign.entries()]
+        .map(([campaignId, v]) => {
+          const campaign = campaignsMap.get(campaignId);
+          if (!campaign) return null;
+          return {
+            campaignId,
+            campaignName: campaign.name,
+            priority: campaign.priority ?? 100,
+            status: campaign.status,
+            latestPublishedVersionId: v.versionId,
+            latestPublishedVersionNumber: v.versionNumber,
+          };
+        })
+        .filter(Boolean) as any[];
+
+      return result.sort((a, b) => a.priority - b.priority);
+    } catch (error) {
+      console.error("[getPatientCampaignMemberships]", error);
+      return [];
+    }
+  },
+});
+
+export const getAudiencePage = query({
+  args: {
+    versionId: v.id("campaignVersions"),
+    clinicId: v.optional(v.string()),
+    cursor: v.optional(v.string()),
+    limit: v.optional(v.number()),
+  },
+  handler: async (ctx, args) => {
+    await assertCanManageCampaigns(ctx);
+    const limit = Math.min(200, Math.max(1, args.limit ?? 50));
+    if (args.clinicId) {
+      const page = await ctx.db
+        .query("audienceMembers")
+        .withIndex("by_version_clinic", (q: any) =>
+          q.eq("versionId", args.versionId).eq("clinicId", args.clinicId!),
+        )
+        .paginate({ cursor: args.cursor ?? null, numItems: limit });
+      return {
+        page: page.page,
+        isDone: page.isDone,
+        continueCursor: page.continueCursor,
+      };
+    }
+
+    const page = await ctx.db
+      .query("audienceMembers")
+      .withIndex("by_version", (q: any) => q.eq("versionId", args.versionId))
+      .paginate({ cursor: args.cursor ?? null, numItems: limit });
+    return {
+      page: page.page,
+      isDone: page.isDone,
+      continueCursor: page.continueCursor,
+    };
+  },
+});
+
+export const recordContactAttempt = mutation({
+  args: {
+    orgId: v.string(),
+    clinicId: v.string(),
+    patientId: v.string(),
+    campaignId: v.id("campaigns"),
+    versionId: v.id("campaignVersions"),
+    channel: v.union(v.literal("call"), v.literal("sms"), v.literal("email")),
+    outcome: v.union(
+      v.literal("answered"),
+      v.literal("no_answer"),
+      v.literal("busy"),
+      v.literal("wrong_number"),
+      v.literal("opt_out"),
+      v.literal("success"),
+      v.literal("failed"),
+    ),
+  },
+  handler: async (ctx, args) => {
+    await assertCanManageCampaigns(ctx);
+    const id = await ctx.db.insert("contactLog", {
+      ...args,
+      createdAt: Date.now(),
+    });
+    return { id };
+  },
+});
+
+export const getPlaygroundBootstrap = query({
+  args: {
+    orgId: v.string(),
+  },
+  handler: async (ctx, args) => {
+    try {
+      const sample = await dataSource.getSamplePatients(ctx, args.orgId, [], 20);
+      const clinicIds = [...new Set(sample.map((s) => s.clinicId))];
+      const fieldRegistryPublic = fieldRegistry.map((f) => ({
+        key: f.key,
+        label: f.label,
+        operators: f.operators,
+        type: f.type,
+        category: f.category,
+        enumValues: f.enumValues ?? [],
+      }));
+      return {
+        clinicIds,
+        clinics: clinicIds,
+        fields: fieldRegistryPublic,
+        fieldRegistry: fieldRegistryPublic,
+        defaults: {
+          callPolicy: DEFAULT_CALL_POLICY,
+        },
+      };
+    } catch (error) {
+      console.error("[getPlaygroundBootstrap]", error);
+      return {
+        clinicIds: [],
+        clinics: [],
+        fields: fieldRegistry.map((f) => ({
+          key: f.key,
+          label: f.label,
+          operators: f.operators,
+          type: f.type,
+          category: f.category,
+          enumValues: f.enumValues ?? [],
+        })),
+        fieldRegistry: fieldRegistry.map((f) => ({
+          key: f.key,
+          label: f.label,
+          operators: f.operators,
+          type: f.type,
+          category: f.category,
+          enumValues: f.enumValues ?? [],
+        })),
+        defaults: { callPolicy: DEFAULT_CALL_POLICY },
+      };
+    }
+  },
+});