@primocaredentgroup/convex-campaigns-component 0.3.17 → 0.3.22

package/convex/campaigns.ts

@@ -13,6 +13,8 @@ export {
   addOrUpdateSteps,
   previewAudience,
   buildAudienceSnapshot,
+  ingestAudienceMembers,
+  sealSnapshot,
 } from "./components/campaigns/functions/mutations";
 
 export {

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

@@ -19,7 +19,7 @@ export const ingestCallOutcome: any = action({
       idempotencyKey: v.string(),
       campaignId: v.id("campaigns"),
       snapshotId: v.id("audience_snapshots"),
-      patientId: v.id("patients"),
+      patientId: v.string(),
       stepId: v.id("campaign_steps"),
       outcome: v.union(v.literal("COMPLETED"), v.literal("FAILED")),
       notes: v.optional(v.string()),
@@ -44,7 +44,7 @@ export const ingestAppointmentBooked: any = action({
       appointmentId: v.optional(v.string()),
       campaignId: v.optional(v.id("campaigns")),
       snapshotId: v.optional(v.id("audience_snapshots")),
-      patientId: v.id("patients"),
+      patientId: v.string(),
       releaseLock: v.optional(v.boolean()),
     }),
   },
@@ -66,7 +66,7 @@ export const ingestDeliveryStatus: any = action({
       idempotencyKey: v.string(),
       campaignId: v.id("campaigns"),
       snapshotId: v.id("audience_snapshots"),
-      patientId: v.id("patients"),
+      patientId: v.string(),
       stepId: v.id("campaign_steps"),
       status: v.union(v.literal("DELIVERED"), v.literal("FAILED")),
       providerMessageId: v.optional(v.string()),

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

@@ -17,7 +17,7 @@ export const ingestCallOutcomeInternal = internalMutation({
       idempotencyKey: v.string(),
       campaignId: v.id("campaigns"),
       snapshotId: v.id("audience_snapshots"),
-      patientId: v.id("patients"),
+      patientId: v.string(),
       stepId: v.id("campaign_steps"),
       outcome: v.union(v.literal("COMPLETED"), v.literal("FAILED")),
       notes: v.optional(v.string()),
@@ -64,7 +64,7 @@ export const ingestAppointmentBookedInternal = internalMutation({
       appointmentId: v.optional(v.string()),
       campaignId: v.optional(v.id("campaigns")),
       snapshotId: v.optional(v.id("audience_snapshots")),
-      patientId: v.id("patients"),
+      patientId: v.string(),
       releaseLock: v.optional(v.boolean()),
     }),
   },
@@ -117,7 +117,7 @@ export const ingestDeliveryStatusInternal = internalMutation({
       idempotencyKey: v.string(),
       campaignId: v.id("campaigns"),
       snapshotId: v.id("audience_snapshots"),
-      patientId: v.id("patients"),
+      patientId: v.string(),
       stepId: v.id("campaign_steps"),
       status: v.union(v.literal("DELIVERED"), v.literal("FAILED")),
       providerMessageId: v.optional(v.string()),

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

@@ -1,5 +1,6 @@
 import { v } from "convex/values";
 import { mutation } from "../../../_generated/server";
+import type { Doc } from "../../../_generated/dataModel";
 import { assertAuthorized } from "../permissions";
 import {
   campaignStatusValidator,
@@ -9,10 +10,8 @@ import {
   stepTypeValidator,
   DEFAULT_RUN_CONFIG,
 } from "../domain/types";
-import * as consentPort from "../ports/consent";
-import * as patientDataPort from "../ports/patientData";
 
-const clinicScopeIdValidator = v.union(v.id("clinics"), v.string());
+const clinicScopeIdValidator = v.string();
 
 function withDefaultRunConfig(input?: {
   capWindowDays?: number;
@@ -42,7 +41,7 @@ export const createCampaign = mutation({
     input: v.object({
       name: v.string(),
       description: v.optional(v.string()),
-      ownerUserId: v.optional(v.id("users")),
+      ownerUserId: v.optional(v.string()),
       scopeType: v.string(),
       scopeClinicIds: v.array(clinicScopeIdValidator),
       priority: v.number(),
@@ -70,7 +69,7 @@ export const updateCampaign = mutation({
     patch: v.object({
       name: v.optional(v.string()),
       description: v.optional(v.string()),
-      ownerUserId: v.optional(v.id("users")),
+      ownerUserId: v.optional(v.string()),
       scopeType: v.optional(v.string()),
       scopeClinicIds: v.optional(v.array(clinicScopeIdValidator)),
       priority: v.optional(v.number()),
@@ -168,68 +167,10 @@ export const previewAudience = mutation({
   },
   handler: async (ctx, args) => {
     await assertAuthorized(ctx, ["Admin", "Marketing"], { trustedUserId: args._trustedUserId });
-    const campaign = await ctx.db.get(args.campaignId);
-    if (!campaign) throw new Error("Campaign not found");
-
-    const sampleSize = Math.min(Math.max(1, args.sampleSize ?? 10), 50);
-    const sample: Array<{
-      patientId: string;
-      firstName?: string;
-      lastName?: string;
-      birthDate?: string;
-      gender?: string;
-      residenceCityName?: string;
-      email?: string;
-      phone?: string;
-    }> = [];
-
-    let cursor: string | null = null;
-    let total = 0;
-    let withEmail = 0;
-    let withPhone = 0;
-    let blacklisted = 0;
-    const maxPages = 3;
-    let pages = 0;
-
-    while (pages < maxPages && sample.length < sampleSize) {
-      const page = await patientDataPort.queryCandidates(
-        ctx,
-        { scopeType: campaign.scopeType, scopeClinicIds: campaign.scopeClinicIds },
-        args.segmentationRules as any,
-        cursor,
-        { includeAnagrafica: true },
-      );
-      for (const p of page.patients) {
-        total += 1;
-        const consent = await consentPort.getConsent(ctx, p.patientId);
-        if (p.email && consent.email) withEmail += 1;
-        if (p.phone && consent.phone) withPhone += 1;
-        if (consent.blacklisted) blacklisted += 1;
-
-        if (sample.length < sampleSize) {
-          sample.push({
-            patientId: p.patientId,
-            firstName: p.firstName,
-            lastName: p.lastName,
-            birthDate: p.birthDate,
-            gender: p.gender,
-            residenceCityName: p.residenceCityName,
-            email: p.email,
-            phone: p.phone,
-          });
-        }
-      }
-      cursor = page.nextCursor;
-      pages += 1;
-      if (!cursor) break;
-    }
-
     return {
-      counts: { total, withEmail, withPhone, blacklisted },
-      warnings: cursor
-        ? ["Preview limited to first pages for performance. Build snapshot for full results."]
-        : [],
-      sample,
+      counts: { total: 0, withEmail: 0, withPhone: 0, blacklisted: 0 },
+      warnings: ["Preview is now handled by the host application. This endpoint is deprecated."],
+      sample: [],
     };
   },
 });
@@ -271,3 +212,283 @@ export const buildAudienceSnapshot = mutation({
     return { snapshotId };
   },
 });
+
+export const ingestAudienceMembers = mutation({
+  args: {
+    ...trustedUserIdArg,
+    snapshotId: v.id("audience_snapshots"),
+    members: v.array(
+      v.object({
+        patientId: v.string(),
+        clinicId: v.optional(v.string()),
+        email: v.optional(v.string()),
+        phone: v.optional(v.string()),
+        consent: v.object({
+          email: v.boolean(),
+          sms: v.boolean(),
+          phone: v.boolean(),
+          blacklisted: v.boolean(),
+        }),
+      }),
+    ),
+  },
+  handler: async (ctx, args) => {
+    await assertAuthorized(ctx, ["Admin", "Marketing", "System"], {
+      trustedUserId: args._trustedUserId,
+    });
+
+    const snapshot = await ctx.db.get(args.snapshotId);
+    if (!snapshot || snapshot.status !== "BUILDING") {
+      throw new Error("Snapshot not found or not in BUILDING status");
+    }
+
+    const campaign = await ctx.db.get(snapshot.campaignId);
+    if (!campaign) throw new Error("Campaign not found");
+
+    let steps: Doc<"campaign_steps">[];
+    try {
+      steps = await ctx.db
+        .query("campaign_steps")
+        .withIndex("by_campaign", (q: any) => q.eq("campaignId", campaign._id))
+        .collect();
+    } catch {
+      steps = (await ctx.db.query("campaign_steps").collect()).filter(
+        (s: any) => s.campaignId === campaign._id,
+      );
+    }
+    const orderedSteps = [...steps].sort((a, b) => a.order - b.order);
+
+    const runConfig = withDefaultRunConfig(snapshot.runConfig);
+    const now = Date.now();
+
+    let deltaTotal = 0;
+    let deltaEligible = 0;
+    let deltaQueued = 0;
+    const suppressedByReason: Record<string, number> = {};
+
+    for (const member of args.members) {
+      deltaTotal += 1;
+
+      let existingMember;
+      try {
+        existingMember = await ctx.db
+          .query("audience_members")
+          .withIndex("by_snapshot_patient", (q: any) =>
+            q.eq("snapshotId", snapshot._id).eq("patientId", member.patientId),
+          )
+          .first();
+      } catch {
+        existingMember = (await ctx.db.query("audience_members").collect()).find(
+          (m: any) => m.snapshotId === snapshot._id && m.patientId === member.patientId,
+        ) ?? null;
+      }
+
+      if (!existingMember) {
+        await ctx.db.insert("audience_members", {
+          snapshotId: snapshot._id,
+          campaignId: campaign._id,
+          patientId: member.patientId,
+          clinicId: member.clinicId,
+          contactRefs: { email: member.email, phone: member.phone },
+          eligibility: member.consent,
+          createdAt: now,
+        });
+      }
+
+      let activeLock;
+      try {
+        activeLock = await ctx.db
+          .query("contact_locks")
+          .withIndex("by_patient", (q: any) => q.eq("patientId", member.patientId))
+          .first();
+      } catch {
+        activeLock = (await ctx.db.query("contact_locks").collect()).find(
+          (l: any) => l.patientId === member.patientId,
+        ) ?? null;
+      }
+      const lockedByOther =
+        Boolean(activeLock) &&
+        (activeLock?.until ?? 0) > now &&
+        activeLock?.lockedByCampaignId !== campaign._id;
+
+      let events;
+      try {
+        events = await ctx.db
+          .query("event_log")
+          .withIndex("by_patient_createdAt", (q: any) =>
+            q.eq("patientId", member.patientId).gte("createdAt", now - runConfig.capWindowDays * 86_400_000),
+          )
+          .collect();
+      } catch {
+        events = (await ctx.db.query("event_log").collect()).filter(
+          (e: any) => e.patientId === member.patientId && e.createdAt >= now - runConfig.capWindowDays * 86_400_000,
+        );
+      }
+      const contactCount = events.filter(
+        (e: any) =>
+          e.type === "message_sent" ||
+          e.type === "message_queued" ||
+          e.type === "call_task_created",
+      ).length;
+      const capExceeded = contactCount >= runConfig.capMaxContacts;
+
+      let hasEligibleStep = false;
+      for (const step of orderedSteps) {
+        let suppression: string | null = null;
+        if (lockedByOther) suppression = "LOCKED";
+        else if (capExceeded) suppression = "CAP";
+        else if (member.consent.blacklisted) suppression = "BLACKLIST";
+        else if (step.type === "EMAIL" && !member.consent.email) suppression = "NO_CONSENT";
+        else if (step.type === "EMAIL" && !member.email) suppression = "INVALID_CONTACT";
+        else if (step.type === "SMS" && !member.consent.sms) suppression = "NO_CONSENT";
+        else if (step.type === "SMS" && !member.phone) suppression = "INVALID_CONTACT";
+        else if ((step.type === "CALL_CENTER" || step.type === "CALL_CLINIC") && !member.consent.phone)
+          suppression = "NO_CONSENT";
+        else if ((step.type === "CALL_CENTER" || step.type === "CALL_CLINIC") && !member.phone)
+          suppression = "INVALID_CONTACT";
+
+        if (suppression) {
+          suppressedByReason[suppression] = (suppressedByReason[suppression] ?? 0) + 1;
+
+          let existingRSSup;
+          try {
+            existingRSSup = await ctx.db
+              .query("recipient_states")
+              .withIndex("by_snapshot_patient_step", (q: any) =>
+                q
+                  .eq("snapshotId", snapshot._id)
+                  .eq("patientId", member.patientId)
+                  .eq("stepId", step._id),
+              )
+              .first();
+          } catch {
+            existingRSSup = (await ctx.db.query("recipient_states").collect()).find(
+              (r: any) => r.snapshotId === snapshot._id && r.patientId === member.patientId && r.stepId === step._id,
+            ) ?? null;
+          }
+          if (!existingRSSup) {
+            await ctx.db.insert("recipient_states", {
+              snapshotId: snapshot._id,
+              campaignId: campaign._id,
+              patientId: member.patientId,
+              stepId: step._id,
+              state: "SUPPRESSED",
+              reason: suppression,
+              createdAt: now,
+              updatedAt: now,
+              lastEventAt: now,
+            });
+          }
+          continue;
+        }
+
+        const dueAt =
+          step.scheduleSpec.mode === "AT" && step.scheduleSpec.at
+            ? step.scheduleSpec.at
+            : step.scheduleSpec.mode === "DELAY"
+              ? snapshot.createdAt + (step.scheduleSpec.delayMinutes ?? 0) * 60_000
+              : now;
+        const nextState = dueAt <= now ? "QUEUED" : "ELIGIBLE";
+        if (nextState === "QUEUED") deltaQueued += 1;
+        hasEligibleStep = true;
+
+        let existingRSElig;
+        try {
+          existingRSElig = await ctx.db
+            .query("recipient_states")
+            .withIndex("by_snapshot_patient_step", (q: any) =>
+              q
+                .eq("snapshotId", snapshot._id)
+                .eq("patientId", member.patientId)
+                .eq("stepId", step._id),
+            )
+            .first();
+        } catch {
+          existingRSElig = (await ctx.db.query("recipient_states").collect()).find(
+            (r: any) => r.snapshotId === snapshot._id && r.patientId === member.patientId && r.stepId === step._id,
+          ) ?? null;
+        }
+        if (!existingRSElig) {
+          await ctx.db.insert("recipient_states", {
+            snapshotId: snapshot._id,
+            campaignId: campaign._id,
+            patientId: member.patientId,
+            stepId: step._id,
+            state: nextState,
+            dueAt,
+            createdAt: now,
+            updatedAt: now,
+            lastEventAt: now,
+          });
+        }
+      }
+
+      if (hasEligibleStep && !lockedByOther) {
+        deltaEligible += 1;
+        const until = now + runConfig.lockDays * 86_400_000;
+        if (!activeLock) {
+          await ctx.db.insert("contact_locks", {
+            patientId: member.patientId,
+            lockedByCampaignId: campaign._id,
+            until,
+            reason: "campaign_snapshot",
+            createdAt: now,
+            updatedAt: now,
+          });
+        } else if (activeLock.lockedByCampaignId === campaign._id) {
+          await ctx.db.patch(activeLock._id, { until, updatedAt: now });
+        }
+      }
+    }
+
+    const mergedSuppressed: Record<string, number> = { ...(snapshot.stats?.suppressedByReason ?? {}) };
+    for (const [reason, count] of Object.entries(suppressedByReason)) {
+      mergedSuppressed[reason] = (mergedSuppressed[reason] ?? 0) + count;
+    }
+
+    await ctx.db.patch(snapshot._id, {
+      updatedAt: now,
+      stats: {
+        ...snapshot.stats,
+        totalCandidates: (snapshot.stats?.totalCandidates ?? 0) + deltaTotal,
+        eligible: (snapshot.stats?.eligible ?? 0) + deltaEligible,
+        queued: (snapshot.stats?.queued ?? 0) + deltaQueued,
+        suppressedByReason: mergedSuppressed,
+      },
+    });
+
+    return { ingested: deltaTotal, eligible: deltaEligible, queued: deltaQueued };
+  },
+});
+
+export const sealSnapshot = mutation({
+  args: {
+    ...trustedUserIdArg,
+    snapshotId: v.id("audience_snapshots"),
+  },
+  handler: async (ctx, args) => {
+    await assertAuthorized(ctx, ["Admin", "Marketing", "System"], {
+      trustedUserId: args._trustedUserId,
+    });
+
+    const snapshot = await ctx.db.get(args.snapshotId);
+    if (!snapshot) throw new Error("Snapshot not found");
+    if (snapshot.status !== "BUILDING") throw new Error("Snapshot not in BUILDING status");
+
+    const now = Date.now();
+    await ctx.db.patch(args.snapshotId, {
+      status: "READY",
+      updatedAt: now,
+    });
+
+    await ctx.db.insert("event_log", {
+      campaignId: snapshot.campaignId,
+      snapshotId: args.snapshotId,
+      type: "audience_snapshot_built",
+      payload: { totalCandidates: snapshot.stats?.totalCandidates ?? 0 },
+      createdAt: now,
+    });
+
+    return { ok: true };
+  },
+});

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

@@ -3,7 +3,7 @@ import { query } from "../../../_generated/server";
 import { assertAuthorized } from "../permissions";
 import { campaignStatusValidator, scopeTypeValidator } from "../domain/types";
 
-const clinicIdFilterValidator = v.union(v.id("clinics"), v.string());
+const clinicIdFilterValidator = v.string();
 const trustedUserIdArg = { _trustedUserId: v.optional(v.string()) };
 
 function isRecoverableQueryError(error: unknown): boolean {
@@ -188,28 +188,39 @@ export const getSnapshotMemberSample = query({
       }> = [];
 
       for (const m of members) {
-        const patient = await ctx.db.get(m.patientId);
-        if (!patient) continue;
-        const p = patient as any;
-        let residenceCityName: string | undefined;
-        if (p.residenceCityId) {
-          try {
-            const city = await ctx.db.get(p.residenceCityId);
-            residenceCityName = (city as any)?.name;
-          } catch {
-            // Host may not have cities table
+        let patient: any = null;
+        try {
+          patient = await ctx.db.get(m.patientId);
+        } catch {
+          // patientId belongs to host DB, not component DB
+        }
+
+        if (patient) {
+          const p = patient as any;
+          let residenceCityName: string | undefined;
+          if (p.residenceCityId) {
+            try {
+              const city = await ctx.db.get(p.residenceCityId);
+              residenceCityName = (city as any)?.name;
+            } catch {}
           }
+          sample.push({
+            patientId: m.patientId,
+            firstName: p.firstName,
+            lastName: p.lastName,
+            birthDate: p.birthDate,
+            gender: p.gender,
+            residenceCityName,
+            email: m.contactRefs?.email ?? p.email,
+            phone: m.contactRefs?.phone ?? p.phone ?? p.mobilePhone,
+          });
+        } else {
+          sample.push({
+            patientId: m.patientId,
+            email: m.contactRefs?.email,
+            phone: m.contactRefs?.phone,
+          });
         }
-        sample.push({
-          patientId: m.patientId,
-          firstName: p.firstName,
-          lastName: p.lastName,
-          birthDate: p.birthDate,
-          gender: p.gender,
-          residenceCityName,
-          email: m.contactRefs?.email ?? p.email,
-          phone: m.contactRefs?.phone ?? p.phone ?? p.mobilePhone,
-        });
       }
 
       return { sample };

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

@@ -2,22 +2,9 @@ import { v } from "convex/values";
 import { internalMutation, mutation } from "../../../_generated/server";
 import type { Id, Doc } from "../../../_generated/dataModel";
 import { assertAuthorized } from "../permissions";
-import { canTransitionRecipientState } from "../domain/stateMachine";
-import { DEFAULT_RUN_CONFIG, type SuppressionReason } from "../domain/types";
-import * as consentPort from "../ports/consent";
-import * as patientDataPort from "../ports/patientData";
 import * as messagingPort from "../ports/messaging";
 import * as callCenterPort from "../ports/callCenter";
 
-function resolveRunConfig(input?: Doc<"audience_snapshots">["runConfig"]) {
-  return {
-    capWindowDays: input?.capWindowDays ?? DEFAULT_RUN_CONFIG.capWindowDays,
-    capMaxContacts: input?.capMaxContacts ?? DEFAULT_RUN_CONFIG.capMaxContacts,
-    lockDays: input?.lockDays ?? DEFAULT_RUN_CONFIG.lockDays,
-    quietHours: input?.quietHours,
-  };
-}
-
 async function safeCollectCampaignSteps(ctx: any, campaignId: Id<"campaigns">) {
   try {
     return await ctx.db
@@ -46,21 +33,6 @@ async function safeCollectSnapshotsByCampaign(ctx: any, campaignId: Id<"campaign
   }
 }
 
-async function safeFirstSnapshotByStatus(ctx: any, status: "BUILDING" | "READY" | "FAILED") {
-  try {
-    return await ctx.db
-      .query("audience_snapshots")
-      .withIndex("by_status", (q: any) => q.eq("status", status))
-      .first();
-  } catch {
-    const docs = await ctx.db
-      .query("audience_snapshots")
-      .filter((q: any) => q.eq(q.field("status"), status))
-      .collect();
-    return docs[0] ?? null;
-  }
-}
-
 async function safeCollectCampaignsByStatus(
   ctx: any,
   status: "DRAFT" | "RUNNING" | "PAUSED" | "COMPLETED" | "ARCHIVED",
@@ -78,302 +50,6 @@ async function safeCollectCampaignsByStatus(
   }
 }
 
-function computeDueAt(
-  schedule: Doc<"campaign_steps">["scheduleSpec"],
-  baseline: number,
-  now: number,
-): number {
-  if (schedule.mode === "AT" && schedule.at) return schedule.at;
-  if (schedule.mode === "DELAY") {
-    return baseline + (schedule.delayMinutes ?? 0) * 60_000;
-  }
-  return now;
-}
-
-async function upsertRecipientState(
-  ctx: any,
-  input: {
-    snapshotId: Id<"audience_snapshots">;
-    campaignId: Id<"campaigns">;
-    patientId: Id<"patients">;
-    stepId: Id<"campaign_steps">;
-    state: Doc<"recipient_states">["state"];
-    reason?: string;
-    dueAt?: number;
-  },
-) {
-  const now = Date.now();
-  const existing = await ctx.db
-    .query("recipient_states")
-    .withIndex("by_snapshot_patient_step", (q: any) =>
-      q
-        .eq("snapshotId", input.snapshotId)
-        .eq("patientId", input.patientId)
-        .eq("stepId", input.stepId),
-    )
-    .first();
-
-  if (!existing) {
-    await ctx.db.insert("recipient_states", {
-      ...input,
-      createdAt: now,
-      updatedAt: now,
-      lastEventAt: now,
-    });
-    return;
-  }
-
-  if (!canTransitionRecipientState(existing.state as any, input.state as any)) {
-    return;
-  }
-
-  if (
-    existing.state !== input.state ||
-    existing.reason !== input.reason ||
-    existing.dueAt !== input.dueAt
-  ) {
-    await ctx.db.patch(existing._id, {
-      state: input.state,
-      reason: input.reason,
-      dueAt: input.dueAt,
-      updatedAt: now,
-      lastEventAt: now,
-    });
-  }
-}
-
-async function countRecentContacts(
-  ctx: any,
-  patientId: Id<"patients">,
-  windowStart: number,
-) {
-  const events = await ctx.db
-    .query("event_log")
-    .withIndex("by_patient_createdAt", (q: any) =>
-      q.eq("patientId", patientId).gte("createdAt", windowStart),
-    )
-    .collect();
-
-  return events.filter(
-    (e: any) =>
-      e.type === "message_sent" ||
-      e.type === "message_queued" ||
-      e.type === "call_task_created",
-  ).length;
-}
-
-async function resolveSuppressionReason(input: {
-  lockedByOther: boolean;
-  capExceeded: boolean;
-  consent: Awaited<ReturnType<typeof consentPort.getConsent>>;
-  stepType: Doc<"campaign_steps">["type"];
-  hasEmail: boolean;
-  hasPhone: boolean;
-}): Promise<SuppressionReason | null> {
-  if (input.lockedByOther) return "LOCKED";
-  if (input.capExceeded) return "CAP";
-  if (input.consent.blacklisted) return "BLACKLIST";
-
-  if (input.stepType === "EMAIL") {
-    if (!input.consent.email) return "NO_CONSENT";
-    if (!input.hasEmail) return "INVALID_CONTACT";
-  }
-  if (input.stepType === "SMS") {
-    if (!input.consent.sms) return "NO_CONSENT";
-    if (!input.hasPhone) return "INVALID_CONTACT";
-  }
-  if (input.stepType === "CALL_CENTER" || input.stepType === "CALL_CLINIC") {
-    if (!input.consent.phone) return "NO_CONSENT";
-    if (!input.hasPhone) return "INVALID_CONTACT";
-  }
-
-  return null;
-}
-
-async function buildSnapshotChunkCore(
-  ctx: any,
-  snapshotId: Id<"audience_snapshots">,
-  forcedCursor?: string,
-) {
-  const snapshot = await ctx.db.get(snapshotId);
-  if (!snapshot || snapshot.status !== "BUILDING") return { done: true, nextCursor: null as string | null };
-
-  const campaign = await ctx.db.get(snapshot.campaignId);
-  if (!campaign) {
-    await ctx.db.patch(snapshotId, { status: "FAILED", updatedAt: Date.now() });
-    return { done: true, nextCursor: null as string | null };
-  }
-
-  const steps = await safeCollectCampaignSteps(ctx, campaign._id);
-  const orderedSteps = [...steps].sort((a, b) => a.order - b.order);
-  if (orderedSteps.length === 0) {
-    await ctx.db.patch(snapshotId, { status: "FAILED", updatedAt: Date.now() });
-    return { done: true, nextCursor: null as string | null };
-  }
-
-  const runConfig = resolveRunConfig(snapshot.runConfig);
-  const cursor = forcedCursor ?? snapshot.nextCursor ?? null;
-  const { patients, nextCursor } = await patientDataPort.queryCandidates(
-    ctx,
-    { scopeType: campaign.scopeType, scopeClinicIds: campaign.scopeClinicIds },
-    snapshot.segmentationRules as any,
-    cursor,
-  );
-
-  const now = Date.now();
-  let deltaTotal = 0;
-  let deltaEligible = 0;
-  let deltaQueued = 0;
-  const suppressedByReason: Record<string, number> = {};
-
-  for (const p of patients) {
-    deltaTotal += 1;
-    const consent = await consentPort.getConsent(ctx, p.patientId);
-    const existingMember = await ctx.db
-      .query("audience_members")
-      .withIndex("by_snapshot_patient", (q: any) =>
-        q.eq("snapshotId", snapshot._id).eq("patientId", p.patientId),
-      )
-      .first();
-
-    if (!existingMember) {
-      await ctx.db.insert("audience_members", {
-        snapshotId: snapshot._id,
-        campaignId: campaign._id,
-        patientId: p.patientId,
-        clinicId: p.clinicId,
-        contactRefs: { email: p.email, phone: p.phone },
-        eligibility: {
-          email: consent.email,
-          sms: consent.sms,
-          phone: consent.phone,
-          blacklisted: consent.blacklisted,
-        },
-        createdAt: now,
-      });
-    }
-
-    const activeLock = await ctx.db
-      .query("contact_locks")
-      .withIndex("by_patient", (q: any) => q.eq("patientId", p.patientId))
-      .first();
-    const lockedByOther =
-      Boolean(activeLock) &&
-      (activeLock?.until ?? 0) > now &&
-      activeLock?.lockedByCampaignId !== campaign._id;
-
-    const contactCount = await countRecentContacts(
-      ctx,
-      p.patientId,
-      now - runConfig.capWindowDays * 24 * 60 * 60 * 1000,
-    );
-    const capExceeded = contactCount >= runConfig.capMaxContacts;
-
-    let patientHasAtLeastOneEligibleStep = false;
-    for (const step of orderedSteps) {
-      const suppression = await resolveSuppressionReason({
-        lockedByOther,
-        capExceeded,
-        consent,
-        stepType: step.type,
-        hasEmail: Boolean(p.email),
-        hasPhone: Boolean(p.phone),
-      });
-
-      if (suppression) {
-        suppressedByReason[suppression] = (suppressedByReason[suppression] ?? 0) + 1;
-        await upsertRecipientState(ctx, {
-          snapshotId: snapshot._id,
-          campaignId: campaign._id,
-          patientId: p.patientId,
-          stepId: step._id,
-          state: "SUPPRESSED",
-          reason: suppression,
-        });
-        continue;
-      }
-
-      const dueAt = computeDueAt(step.scheduleSpec, snapshot.createdAt, now);
-      const nextState = dueAt <= now ? "QUEUED" : "ELIGIBLE";
-      if (nextState === "QUEUED") deltaQueued += 1;
-      patientHasAtLeastOneEligibleStep = true;
-
-      await upsertRecipientState(ctx, {
-        snapshotId: snapshot._id,
-        campaignId: campaign._id,
-        patientId: p.patientId,
-        stepId: step._id,
-        state: nextState,
-        dueAt,
-      });
-    }
-
-    if (patientHasAtLeastOneEligibleStep && !lockedByOther) {
-      deltaEligible += 1;
-      if (!activeLock || activeLock.lockedByCampaignId !== campaign._id) {
-        const until = now + runConfig.lockDays * 24 * 60 * 60 * 1000;
-        if (!activeLock) {
-          await ctx.db.insert("contact_locks", {
-            patientId: p.patientId,
-            lockedByCampaignId: campaign._id,
-            until,
-            reason: "campaign_snapshot",
-            createdAt: now,
-            updatedAt: now,
-          });
-        } else {
-          await ctx.db.patch(activeLock._id, {
-            lockedByCampaignId: campaign._id,
-            until,
-            reason: "campaign_snapshot",
-            updatedAt: now,
-          });
-        }
-      }
-    } else if (lockedByOther) {
-      await ctx.db.insert("event_log", {
-        campaignId: campaign._id,
-        snapshotId: snapshot._id,
-        patientId: p.patientId,
-        type: "recipient_suppressed",
-        payload: { reason: "LOCKED" },
-        createdAt: now,
-      });
-    }
-  }
-
-  const mergedSuppressed = { ...snapshot.stats.suppressedByReason };
-  for (const [reason, count] of Object.entries(suppressedByReason)) {
-    mergedSuppressed[reason] = (mergedSuppressed[reason] ?? 0) + count;
-  }
-
-  const finished = nextCursor === null;
-  await ctx.db.patch(snapshot._id, {
-    nextCursor: nextCursor ?? undefined,
-    status: finished ? "READY" : "BUILDING",
-    updatedAt: now,
-    stats: {
-      ...snapshot.stats,
-      totalCandidates: snapshot.stats.totalCandidates + deltaTotal,
-      eligible: snapshot.stats.eligible + deltaEligible,
-      queued: snapshot.stats.queued + deltaQueued,
-      suppressedByReason: mergedSuppressed,
-    },
-  });
-
-  if (finished) {
-    await ctx.db.insert("event_log", {
-      campaignId: campaign._id,
-      snapshotId: snapshot._id,
-      type: "audience_snapshot_built",
-      payload: { totalCandidates: deltaTotal },
-      createdAt: now,
-    });
-  }
-
-  return { done: finished, nextCursor };
-}
-
 async function enqueueStepJobsCore(
   ctx: any,
   snapshotId: Id<"audience_snapshots">,
@@ -498,17 +174,6 @@ async function enqueueStepJobsCore(
   return { nextCursor: next < due.length ? String(next) : null, processed: batch.length };
 }
 
-export const _buildSnapshotChunk = internalMutation({
-  args: {
-    snapshotId: v.id("audience_snapshots"),
-    cursor: v.optional(v.string()),
-  },
-  handler: async (ctx, args) => {
-    await assertAuthorized(ctx, ["Admin", "Marketing", "System"]);
-    return buildSnapshotChunkCore(ctx as any, args.snapshotId, args.cursor);
-  },
-});
-
 export const _enqueueStepJobs = internalMutation({
   args: {
     snapshotId: v.id("audience_snapshots"),
@@ -521,13 +186,7 @@ export const _enqueueStepJobs = internalMutation({
   },
 });
 
-/** Logica condivisa del tick, usata da _runTickInternal e runTickMutation. */
 async function runTickCore(ctx: any) {
-  const buildingSnapshot = await safeFirstSnapshotByStatus(ctx, "BUILDING");
-  if (buildingSnapshot) {
-    await buildSnapshotChunkCore(ctx, buildingSnapshot._id);
-  }
-
   const runningCampaigns = await safeCollectCampaignsByStatus(ctx, "RUNNING");
 
   for (const campaign of runningCampaigns.slice(0, 10)) {
@@ -556,10 +215,6 @@ export const _runTickInternal = internalMutation({
   },
 });
 
-/**
- * Mutation pubblica per eseguire il tick. Rinominato da internal.ts a tickProcessor.ts
- * per evitare conflitto con il namespace "internal" riservato di Convex.
- */
 export const runTickMutation = mutation({
   args: {},
   handler: async (ctx) => {

package/convex/components/campaigns/permissions.ts

@@ -1,4 +1,3 @@
-import type { Id } from "../../_generated/dataModel";
 import { internal } from "../../_generated/api";
 
 type Role = "Admin" | "Marketing" | "System";
@@ -82,7 +81,7 @@ async function resolveCurrentUserWithDb(ctx: AnyCtx) {
   return null;
 }
 
-async function getUserRoleCodes(ctx: AnyCtx, userId: Id<"users">): Promise<Set<string>> {
+async function getUserRoleCodes(ctx: AnyCtx, userId: string): Promise<Set<string>> {
   if (!ctx.db) return new Set<string>();
   const roles = new Set<string>();
 

package/convex/components/campaigns/ports/callCenter.ts

@@ -4,8 +4,8 @@ import type { Id } from "../../../_generated/dataModel";
 export async function createOutboxTasks(
   ctx: MutationCtx,
   tasks: Array<{
-    patientId: Id<"patients">;
-    clinicId?: Id<"clinics">;
+    patientId: string;
+    clinicId?: string;
     campaignId: Id<"campaigns">;
     snapshotId: Id<"audience_snapshots">;
     stepId: Id<"campaign_steps">;

package/convex/components/campaigns/ports/consent.ts

@@ -1,5 +1,4 @@
 import type { QueryCtx, MutationCtx } from "../../../_generated/server";
-import type { Id } from "../../../_generated/dataModel";
 
 export type ConsentResult = {
   email: boolean;
@@ -10,28 +9,21 @@ export type ConsentResult = {
 
 export async function getConsent(
   ctx: QueryCtx | MutationCtx,
-  patientId: Id<"patients">,
+  patientId: string,
 ): Promise<ConsentResult> {
-  // TODO: Replace with real Consent component port call:
-  // consents.getConsent(patientId) -> { email, sms, phone, blacklisted }
-  const patient = await ctx.db.get(patientId);
-  const p = patient as
-    | (typeof patient & {
-        consentEmail?: boolean;
-        consentSms?: boolean;
-        consentPhone?: boolean;
-        blacklisted?: boolean;
-      })
-    | null;
-
-  if (!patient) {
-    return { email: false, sms: false, phone: false, blacklisted: false };
+  try {
+    const patient = await ctx.db.get(patientId as any);
+    if (!patient) {
+      return { email: true, sms: true, phone: true, blacklisted: false };
+    }
+    const p = patient as any;
+    return {
+      email: p?.consentEmail ?? Boolean(patient.email),
+      sms: p?.consentSms ?? Boolean(patient.phone),
+      phone: p?.consentPhone ?? Boolean(patient.phone),
+      blacklisted: p?.blacklisted ?? false,
+    };
+  } catch {
+    return { email: true, sms: true, phone: true, blacklisted: false };
   }
-
-  return {
-    email: p?.consentEmail ?? Boolean(patient.email),
-    sms: p?.consentSms ?? Boolean(patient.phone),
-    phone: p?.consentPhone ?? Boolean(patient.phone),
-    blacklisted: p?.blacklisted ?? false,
-  };
 }

package/convex/components/campaigns/ports/messaging.ts

@@ -6,7 +6,7 @@ export async function enqueueEmail(
   input: {
     campaignId: Id<"campaigns">;
     snapshotId: Id<"audience_snapshots">;
-    patientId: Id<"patients">;
+    patientId: string;
     stepId: Id<"campaign_steps">;
     dedupeKey: string;
     payload: Record<string, any>;
@@ -37,7 +37,7 @@ export async function enqueueSms(
   input: {
     campaignId: Id<"campaigns">;
     snapshotId: Id<"audience_snapshots">;
-    patientId: Id<"patients">;
+    patientId: string;
     stepId: Id<"campaign_steps">;
     dedupeKey: string;
     payload: Record<string, any>;

package/convex/components/campaigns/ports/patientData.ts

@@ -1,9 +1,8 @@
 import type { QueryCtx, MutationCtx } from "../../../_generated/server";
-import type { Doc, Id } from "../../../_generated/dataModel";
 
 export type CampaignScope = {
   scopeType: string;
-  scopeClinicIds: (Id<"clinics"> | string)[];
+  scopeClinicIds: string[];
 };
 
 export type SegmentationRules = {
@@ -12,8 +11,8 @@ export type SegmentationRules = {
 };
 
 export type CandidatePatient = {
-  patientId: Id<"patients">;
-  clinicId?: Id<"clinics">;
+  patientId: string;
+  clinicId?: string;
   email?: string;
   phone?: string;
   firstName?: string;
@@ -26,7 +25,7 @@ export type CandidatePatient = {
 const DEFAULT_PAGE_SIZE = 200;
 const DAY_MS = 24 * 60 * 60 * 1000;
 
-type AppointmentDoc = Doc<"appointments">;
+type AppointmentDoc = any;
 
 /** Calcola età in anni da birthDate (formato "YYYY-MM-DD" o simile) */
 function ageFromBirthDate(birthDate: string | undefined): number | null {
@@ -93,7 +92,7 @@ async function resolveResidenceCityName(
 
 function buildCandidatePatient(
   patient: any,
-  clinicId: Id<"clinics"> | undefined,
+  clinicId: string | undefined,
   residenceCityName?: string,
 ): CandidatePatient {
   return {
@@ -112,7 +111,7 @@ function buildCandidatePatient(
 async function buildCandidateWithAnagrafica(
   ctx: QueryCtx | MutationCtx,
   patient: any,
-  clinicId: Id<"clinics"> | undefined,
+  clinicId: string | undefined,
 ): Promise<CandidatePatient> {
   const residenceCityName = patient.residenceCityId
     ? await resolveResidenceCityName(ctx, patient.residenceCityId)
@@ -122,9 +121,9 @@ async function buildCandidateWithAnagrafica(
 
 async function deriveClinicIdFromAppointments(
   ctx: QueryCtx | MutationCtx,
-  patient: Doc<"patients">,
+  patient: any,
   scope: CampaignScope,
-): Promise<Id<"clinics"> | undefined> {
+): Promise<string | undefined> {
   const appointments = await ctx.db
     .query("appointments")
     .withIndex("by_patient", (q) => q.eq("patientId", patient._id))
@@ -143,7 +142,7 @@ function isAppointmentActive(appointment: AppointmentDoc): boolean {
 
 function isInScope(
   scope: CampaignScope,
-  clinicId: Id<"clinics"> | undefined,
+  clinicId: string | undefined,
 ): boolean {
   if (scope.scopeType === "HQ") return true;
   if (!clinicId) return false;
@@ -153,8 +152,8 @@ function isInScope(
 async function resolveAppointmentTypeIdsByCodes(
   ctx: QueryCtx | MutationCtx,
   codes: string[],
-): Promise<Set<Id<"appointment_types">>> {
-  const ids = new Set<Id<"appointment_types">>();
+): Promise<Set<string>> {
+  const ids = new Set<string>();
   for (const code of codes) {
     const typeDoc = await ctx.db
       .query("appointment_types")
@@ -174,16 +173,23 @@ async function queryNoShowCandidates(
 ): Promise<{ patients: CandidatePatient[]; nextCursor: string | null }> {
   const daysBack = typeof params?.daysBack === "number" ? params.daysBack : 90;
   const cutoff = Date.now() - daysBack * DAY_MS;
-  const patientPage = await ctx.db
+
+  let q = ctx.db
     .query("patients")
-    .withIndex("by_status", (q) => q.eq("status", "active"))
-    .paginate({ numItems: DEFAULT_PAGE_SIZE, cursor: paginationCursor ?? null });
+    .withIndex("by_status", (q: any) => q.eq("status", "active"));
+  if (paginationCursor) {
+    const cursorTime = Number(paginationCursor);
+    q = q.filter((q: any) => q.gt(q.field("_creationTime"), cursorTime));
+  }
+  const allItems = await q.take(DEFAULT_PAGE_SIZE + 1);
+  const hasMore = allItems.length > DEFAULT_PAGE_SIZE;
+  const pageItems = hasMore ? allItems.slice(0, DEFAULT_PAGE_SIZE) : allItems;
 
   const patients: CandidatePatient[] = [];
-  for (const patient of patientPage.page) {
+  for (const patient of pageItems) {
     const appointments = await ctx.db
       .query("appointments")
-      .withIndex("by_patient", (q) => q.eq("patientId", patient._id))
+      .withIndex("by_patient", (q: any) => q.eq("patientId", patient._id))
       .collect();
 
     const hasNoShow = appointments.some(
@@ -205,10 +211,10 @@ async function queryNoShowCandidates(
     );
   }
 
-  return {
-    patients,
-    nextCursor: patientPage.isDone ? null : patientPage.continueCursor,
-  };
+  const nextCursor = hasMore && pageItems.length > 0
+    ? String(pageItems[pageItems.length - 1]._creationTime)
+    : null;
+  return { patients, nextCursor };
 }
 
 function hasFutureAppointment(appointments: AppointmentDoc[], now: number): boolean {
@@ -228,10 +234,17 @@ async function queryRecallOrQuoteFollowupCandidates(
   options?: { includeAnagrafica?: boolean },
 ): Promise<{ patients: CandidatePatient[]; nextCursor: string | null }> {
   const now = Date.now();
-  const page = await ctx.db
+
+  let q = ctx.db
     .query("patients")
-    .withIndex("by_status", (q) => q.eq("status", "active"))
-    .paginate({ numItems: DEFAULT_PAGE_SIZE, cursor: paginationCursor ?? null });
+    .withIndex("by_status", (q: any) => q.eq("status", "active"));
+  if (paginationCursor) {
+    const cursorTime = Number(paginationCursor);
+    q = q.filter((q: any) => q.gt(q.field("_creationTime"), cursorTime));
+  }
+  const allItems = await q.take(DEFAULT_PAGE_SIZE + 1);
+  const hasMore = allItems.length > DEFAULT_PAGE_SIZE;
+  const pageItems = hasMore ? allItems.slice(0, DEFAULT_PAGE_SIZE) : allItems;
 
   const isRecall = segmentationRules.segmentType === "RECALL";
   const monthsSince = typeof segmentationRules.params?.monthsSince === "number"
@@ -253,20 +266,19 @@ async function queryRecallOrQuoteFollowupCandidates(
   const typeCodes = isRecall ? recallCodes : quoteCodes;
   let typeIds = typeCodes.length
     ? await resolveAppointmentTypeIdsByCodes(ctx, typeCodes)
-    : new Set<Id<"appointment_types">>();
-  // If requested quote codes are not configured yet, fallback to all completed appointments.
+    : new Set<string>();
   if (!isRecall && typeCodes.length > 0 && typeIds.size === 0) {
-    typeIds = new Set<Id<"appointment_types">>();
+    typeIds = new Set<string>();
   }
 
   const patients: CandidatePatient[] = [];
-  for (const patient of page.page) {
+  for (const patient of pageItems) {
     const clinicId = await deriveClinicIdFromAppointments(ctx, patient, campaignScope);
     if (campaignScope.scopeType !== "HQ" && !clinicId) continue;
 
     const appointments = await ctx.db
       .query("appointments")
-      .withIndex("by_patient", (q) => q.eq("patientId", patient._id))
+      .withIndex("by_patient", (q: any) => q.eq("patientId", patient._id))
       .collect();
     const activeAppointments = appointments.filter(isAppointmentActive);
     if (activeAppointments.length === 0) continue;
@@ -296,7 +308,10 @@ async function queryRecallOrQuoteFollowupCandidates(
     );
   }
 
-  return { patients, nextCursor: page.isDone ? null : page.continueCursor };
+  const nextCursor = hasMore && pageItems.length > 0
+    ? String(pageItems[pageItems.length - 1]._creationTime)
+    : null;
+  return { patients, nextCursor };
 }
 
 export async function queryCandidates(
@@ -308,7 +323,7 @@ export async function queryCandidates(
 ): Promise<{ patients: CandidatePatient[]; nextCursor: string | null }> {
   if (segmentationRules.segmentType === "CUSTOM_IDS") {
     const patientIds = Array.isArray(segmentationRules.params?.patientIds)
-      ? (segmentationRules.params.patientIds as Id<"patients">[])
+      ? (segmentationRules.params.patientIds as string[])
       : [];
     const offset = paginationCursor ? Number(paginationCursor) : 0;
     const chunk = patientIds.slice(offset, offset + DEFAULT_PAGE_SIZE);
@@ -354,13 +369,19 @@ export async function queryCandidates(
     );
   }
 
-  const page = await ctx.db
+  let q = ctx.db
     .query("patients")
-    .withIndex("by_status", (q) => q.eq("status", "active"))
-    .paginate({ numItems: DEFAULT_PAGE_SIZE, cursor: paginationCursor ?? null });
+    .withIndex("by_status", (q: any) => q.eq("status", "active"));
+  if (paginationCursor) {
+    const cursorTime = Number(paginationCursor);
+    q = q.filter((q: any) => q.gt(q.field("_creationTime"), cursorTime));
+  }
+  const allItems = await q.take(DEFAULT_PAGE_SIZE + 1);
+  const hasMore = allItems.length > DEFAULT_PAGE_SIZE;
+  const pageItems = hasMore ? allItems.slice(0, DEFAULT_PAGE_SIZE) : allItems;
 
   const patients: CandidatePatient[] = [];
-  for (const patient of page.page) {
+  for (const patient of pageItems) {
     if (!matchesDemographicFilters(patient as any, segmentationRules.params)) continue;
     const clinicId = await deriveClinicIdFromAppointments(ctx, patient, campaignScope);
     if (campaignScope.scopeType !== "HQ" && !clinicId) continue;
@@ -371,5 +392,8 @@ export async function queryCandidates(
     );
   }
 
-  return { patients, nextCursor: page.isDone ? null : page.continueCursor };
+  const nextCursor = hasMore && pageItems.length > 0
+    ? String(pageItems[pageItems.length - 1]._creationTime)
+    : null;
+  return { patients, nextCursor };
 }

package/convex/components/campaigns/schema.ts

@@ -17,10 +17,10 @@ export const campaignsTables = {
     orgId: v.optional(v.string()),
     name: v.string(),
     description: v.optional(v.string()),
-    ownerUserId: v.optional(v.id("users")),
+    ownerUserId: v.optional(v.string()),
     scopeType: scopeTypeValidator,
     // Accept both Convex IDs and plain string clinic identifiers for cross-host compatibility.
-    scopeClinicIds: v.array(v.union(v.id("clinics"), v.string())),
+    scopeClinicIds: v.array(v.string()),
     priority: v.number(),
     status: campaignStatusValidator,
     scope: v.optional(
@@ -60,7 +60,7 @@ export const campaignsTables = {
   audience_snapshots: defineTable({
     campaignId: v.id("campaigns"),
     createdAt: v.number(),
-    createdBy: v.optional(v.id("users")),
+    createdBy: v.optional(v.string()),
     status: snapshotStatusValidator,
     segmentationRules: segmentationRulesValidator,
     runConfig: runConfigValidator,
@@ -84,8 +84,8 @@ export const campaignsTables = {
   audience_members: defineTable({
     snapshotId: v.id("audience_snapshots"),
     campaignId: v.id("campaigns"),
-    patientId: v.id("patients"),
-    clinicId: v.optional(v.id("clinics")),
+    patientId: v.string(),
+    clinicId: v.optional(v.string()),
     contactRefs: v.object({
       email: v.optional(v.string()),
       phone: v.optional(v.string()),
@@ -104,7 +104,7 @@ export const campaignsTables = {
   recipient_states: defineTable({
     campaignId: v.id("campaigns"),
     snapshotId: v.id("audience_snapshots"),
-    patientId: v.id("patients"),
+    patientId: v.string(),
     stepId: v.id("campaign_steps"),
     state: recipientStateValidator,
     reason: v.optional(v.string()),
@@ -118,7 +118,7 @@ export const campaignsTables = {
     .index("by_snapshot_patient_step", ["snapshotId", "patientId", "stepId"]),
 
   contact_locks: defineTable({
-    patientId: v.id("patients"),
+    patientId: v.string(),
     lockedByCampaignId: v.id("campaigns"),
     until: v.number(),
     reason: v.optional(v.string()),
@@ -129,7 +129,7 @@ export const campaignsTables = {
   event_log: defineTable({
     campaignId: v.optional(v.id("campaigns")),
     snapshotId: v.optional(v.id("audience_snapshots")),
-    patientId: v.optional(v.id("patients")),
+    patientId: v.optional(v.string()),
     type: v.string(),
     payload: v.optional(v.any()),
     idempotencyKey: v.optional(v.string()),
@@ -143,7 +143,7 @@ export const campaignsTables = {
     channel: v.union(v.literal("EMAIL"), v.literal("SMS")),
     campaignId: v.id("campaigns"),
     snapshotId: v.id("audience_snapshots"),
-    patientId: v.id("patients"),
+    patientId: v.string(),
     stepId: v.id("campaign_steps"),
     payload: v.any(),
     status: v.string(),
@@ -155,8 +155,8 @@ export const campaignsTables = {
     .index("by_dedupe_key", ["dedupeKey"]),
 
   call_tasks_outbox: defineTable({
-    patientId: v.id("patients"),
-    clinicId: v.optional(v.id("clinics")),
+    patientId: v.string(),
+    clinicId: v.optional(v.string()),
     campaignId: v.id("campaigns"),
     snapshotId: v.id("audience_snapshots"),
     stepId: v.id("campaign_steps"),

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@primocaredentgroup/convex-campaigns-component",
-  "version": "0.3.17",
+  "version": "0.3.22",
   "description": "Convex Campaigns backend component for PrimoCore",
   "license": "UNLICENSED",
   "type": "module",