@primocaredentgroup/convex-campaigns-component 0.1.3 → 0.3.0

package/convex/components/campaigns/permissions.ts

@@ -12,30 +12,66 @@ function normalizeRole(value: string | undefined): string {
   return (value ?? "").trim().toLowerCase();
 }
 
+function authError(code: string, message: string): Error {
+  return new Error(`${code}: ${message}`);
+}
+
+function isIndexError(error: unknown): boolean {
+  const message = error instanceof Error ? error.message : String(error);
+  return message.includes("Index") && message.includes("not found");
+}
+
+function missingUserModeAllowsAccess(): boolean {
+  return (process.env.CAMPAIGNS_AUTH_MISSING_USER_MODE ?? "").toLowerCase() === "allow";
+}
+
+async function queryUserByAuth0WithFallback(ctx: AnyCtx, subject: string) {
+  if (!ctx.db) return null;
+  try {
+    const byAuth0 = await ctx.db
+      .query("users")
+      .withIndex("by_auth0", (q: any) => q.eq("auth0Id", subject))
+      .first();
+    if (byAuth0?.isActive) return byAuth0;
+  } catch (error) {
+    // Fallback for hosts where users.by_auth0 is unavailable.
+    if (!isIndexError(error)) throw error;
+  }
+
+  const users = await ctx.db.query("users").collect();
+  return users.find((user: any) => user?.isActive && user?.auth0Id === subject) ?? null;
+}
+
+async function queryUserByEmailWithFallback(ctx: AnyCtx, email: string) {
+  if (!ctx.db) return null;
+  try {
+    const byEmail = await ctx.db
+      .query("users")
+      .withIndex("by_email", (q: any) => q.eq("email", email))
+      .first();
+    if (byEmail?.isActive) return byEmail;
+  } catch (error) {
+    // Fallback for hosts where users.by_email is unavailable.
+    if (!isIndexError(error)) throw error;
+  }
+
+  const users = await ctx.db.query("users").collect();
+  return users.find((user: any) => user?.isActive && user?.email === email) ?? null;
+}
+
 async function resolveCurrentUserWithDb(ctx: AnyCtx) {
   if (!ctx.db) return null;
   const identity = await ctx.auth.getUserIdentity();
   if (!identity) return null;
 
   if (identity.subject) {
-    try {
-      // Fallback for hosts where users.by_auth0 is unavailable.
-      const byAuth0 = await ctx.db
-        .query("users")
-        .withIndex("by_auth0", (q: any) => q.eq("auth0Id", identity.subject))
-        .first();
-      if (byAuth0?.isActive) return byAuth0;
-    } catch {
-      // Ignore index-resolution errors and continue with by_email fallback.
-    }
+    const bySubject = await queryUserByAuth0WithFallback(ctx, identity.subject);
+    if (bySubject) return bySubject;
   }
 
   if (identity.email) {
-    const byEmail = await ctx.db
-      .query("users")
-      .withIndex("by_email", (q: any) => q.eq("email", identity.email!))
-      .first();
-    if (byEmail?.isActive) return byEmail;
+    const byEmail = await queryUserByEmailWithFallback(ctx, identity.email);
+    if (byEmail) return byEmail;
   }
 
   return null;
@@ -78,14 +114,20 @@ export async function assertAuthorized(ctx: AnyCtx, requiredRoles: Role[]): Prom
     if (requiredRoles.includes("System")) {
       return;
     }
-    throw new Error("Unauthorized: missing identity");
+    throw authError("CAMPAIGNS_UNAUTHORIZED", "Missing identity in request context.");
   }
 
   let userRoles = new Set<string>();
   if (ctx.db) {
     const user = await resolveCurrentUserWithDb(ctx);
     if (!user) {
-      throw new Error("Unauthorized: authenticated identity not mapped to active user");
+      if (missingUserModeAllowsAccess()) {
+        return;
+      }
+      throw authError(
+        "CAMPAIGNS_AUTH_USER_NOT_MAPPED",
+        "Authenticated identity is not mapped to an active user.",
+      );
     }
     userRoles = await getUserRoleCodes(ctx, user._id);
   } else if (ctx.runQuery) {
@@ -98,20 +140,37 @@ export async function assertAuthorized(ctx: AnyCtx, requiredRoles: Role[]): Prom
     );
     userRoles = new Set<string>((resolved?.roles ?? []) as string[]);
     if (userRoles.size === 0) {
-      throw new Error("Unauthorized: identity has no mapped active roles");
+      if (missingUserModeAllowsAccess()) {
+        return;
+      }
+      throw authError(
+        "CAMPAIGNS_AUTH_NO_ACTIVE_ROLES",
+        "Identity resolved but no active mapped roles were found.",
+      );
     }
   } else {
-    throw new Error("Unauthorized: unsupported execution context");
+    throw authError(
+      "CAMPAIGNS_UNAUTHORIZED_CONTEXT",
+      "Unsupported execution context for authorization.",
+    );
   }
 
   const required = requiredRoles.map((r) => normalizeRole(r));
   const hasRole = required.some((role) => userRoles.has(role));
 
   if (!hasRole) {
-    throw new Error(
-      `Forbidden: required one of roles [${requiredRoles.join(", ")}], user roles: [${[
-        ...userRoles,
-      ].join(", ")}]`,
+    throw authError(
+      "CAMPAIGNS_FORBIDDEN",
+      `Required roles: [${requiredRoles.join(", ")}], user roles: [${[...userRoles].join(", ")}].`,
     );
   }
 }
+
+export async function assertCanManageCampaigns(ctx: AnyCtx): Promise<void> {
+  const identity = await ctx.auth.getUserIdentity();
+  if (!identity) {
+    throw authError("CAMPAIGNS_UNAUTHORIZED", "Missing identity in request context.");
+  }
+  // Placeholder policy: any authenticated user can manage campaigns.
+  // TODO: replace with PrimoCore role checks (admin/marketing).
+}

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

@@ -3,7 +3,7 @@ import type { Doc, Id } from "../../../_generated/dataModel";
 
 export type CampaignScope = {
   scopeType: "HQ" | "CLINIC";
-  scopeClinicIds: Id<"clinics">[];
+  scopeClinicIds: string[];
 };
 
 export type SegmentationRules = {
@@ -36,7 +36,7 @@ async function deriveClinicIdFromAppointments(
   const withClinic = appointments.find((a) => a.clinicId);
   if (!withClinic?.clinicId) return undefined;
   if (scope.scopeType === "HQ") return withClinic.clinicId;
-  if (scope.scopeClinicIds.includes(withClinic.clinicId)) return withClinic.clinicId;
+  if (scope.scopeClinicIds.includes(String(withClinic.clinicId))) return withClinic.clinicId;
   return undefined;
 }
 
@@ -50,7 +50,7 @@ function isInScope(
 ): boolean {
   if (scope.scopeType === "HQ") return true;
   if (!clinicId) return false;
-  return scope.scopeClinicIds.includes(clinicId);
+  return scope.scopeClinicIds.includes(String(clinicId));
 }
 
 async function resolveAppointmentTypeIdsByCodes(

package/convex/components/campaigns/schema.ts

@@ -2,6 +2,7 @@ import { defineTable } from "convex/server";
 import { v } from "convex/values";
 import {
   campaignStatusValidator,
+  callPolicyValidator,
   recipientStateValidator,
   runConfigValidator,
   scopeTypeValidator,
@@ -13,17 +14,36 @@ import {
 
 export const campaignsTables = {
   campaigns: defineTable({
+    orgId: v.optional(v.string()),
     name: v.string(),
     description: v.optional(v.string()),
     ownerUserId: v.optional(v.id("users")),
     scopeType: scopeTypeValidator,
-    scopeClinicIds: v.array(v.id("clinics")),
+    // Accept both Convex IDs and plain string clinic identifiers for cross-host compatibility.
+    scopeClinicIds: v.array(v.union(v.id("clinics"), v.string())),
     priority: v.number(),
     status: campaignStatusValidator,
+    scope: v.optional(
+      v.object({
+        orgId: v.string(),
+        clinicIds: v.array(v.string()),
+      }),
+    ),
+    rules: v.optional(v.any()),
+    frequencyCapDays: v.optional(v.number()),
+    callPolicy: v.optional(callPolicyValidator),
+    policyUpdatedAt: v.optional(v.number()),
+    policyUpdatedBy: v.optional(v.string()),
+    createdBy: v.optional(v.string()),
+    updatedBy: v.optional(v.string()),
     defaultRunConfig: runConfigValidator,
     createdAt: v.number(),
     updatedAt: v.number(),
-  }).index("by_status", ["status"]),
+  })
+    .index("by_status", ["status"])
+    .index("by_org", ["orgId"])
+    .index("by_org_status", ["orgId", "status"])
+    .index("by_org_priority", ["orgId", "priority"]),
 
   campaign_steps: defineTable({
     campaignId: v.id("campaigns"),
@@ -151,4 +171,106 @@ export const campaignsTables = {
   })
     .index("by_status", ["status"])
     .index("by_dedupe_key", ["dedupeKey"]),
+
+  campaignVersions: defineTable({
+    campaignId: v.id("campaigns"),
+    version: v.number(),
+    label: v.optional(v.string()),
+    scopeSnapshot: v.object({
+      orgId: v.string(),
+      clinicIds: v.array(v.string()),
+    }),
+    rulesSnapshot: v.any(),
+    rulesHash: v.string(),
+    callPolicySnapshot: v.optional(callPolicyValidator),
+    policyHash: v.optional(v.string()),
+    createdAt: v.number(),
+    createdBy: v.string(),
+    publishedAt: v.number(),
+    publishedBy: v.string(),
+  })
+    .index("by_campaign", ["campaignId"])
+    .index("by_campaign_version", ["campaignId", "version"]),
+
+  audienceMembers: defineTable({
+    orgId: v.string(),
+    clinicId: v.string(),
+    campaignId: v.id("campaigns"),
+    versionId: v.id("campaignVersions"),
+    patientId: v.string(),
+    reasons: v.array(v.string()),
+    createdAt: v.number(),
+  })
+    .index("by_version", ["versionId"])
+    .index("by_version_clinic", ["versionId", "clinicId"])
+    .index("by_version_createdAt", ["versionId", "createdAt"])
+    .index("by_version_clinic_createdAt", ["versionId", "clinicId", "createdAt"])
+    .index("by_patient_version", ["patientId", "versionId"])
+    .index("by_org_patient", ["orgId", "patientId"]),
+
+  contactLog: defineTable({
+    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"),
+    ),
+    createdAt: v.number(),
+  })
+    .index("by_patient_time", ["patientId", "createdAt"])
+    .index("by_org_patient_time", ["orgId", "patientId", "createdAt"])
+    .index("by_campaign_time", ["campaignId", "createdAt"])
+    .index("by_version_time", ["versionId", "createdAt"]),
+
+  demoPatients: defineTable({
+    orgId: v.string(),
+    clinicId: v.string(),
+    patientId: v.string(),
+    firstName: v.string(),
+    lastName: v.string(),
+    city: v.string(),
+    birthDate: v.string(),
+    hasCallConsent: v.boolean(),
+    phoneMasked: v.optional(v.string()),
+  })
+    .index("by_org", ["orgId"])
+    .index("by_org_clinic", ["orgId", "clinicId"])
+    .index("by_org_patient", ["orgId", "patientId"]),
+
+  demoAppointments: defineTable({
+    orgId: v.string(),
+    clinicId: v.string(),
+    patientId: v.string(),
+    date: v.number(),
+    status: v.union(v.literal("done"), v.literal("missed"), v.literal("booked")),
+  })
+    .index("by_org_patient_date", ["orgId", "patientId", "date"])
+    .index("by_org_clinic_date", ["orgId", "clinicId", "date"]),
+
+  demoEstimates: defineTable({
+    orgId: v.string(),
+    clinicId: v.string(),
+    patientId: v.string(),
+    status: v.union(v.literal("open"), v.literal("accepted"), v.literal("expired")),
+    amount: v.number(),
+    createdAt: v.number(),
+    expiredAt: v.optional(v.number()),
+  }).index("by_org_patient_createdAt", ["orgId", "patientId", "createdAt"]),
+
+  demoTreatmentPlans: defineTable({
+    orgId: v.string(),
+    clinicId: v.string(),
+    patientId: v.string(),
+    status: v.union(v.literal("open"), v.literal("closed")),
+    lastActivityAt: v.number(),
+  }).index("by_org_patient_lastActivity", ["orgId", "patientId", "lastActivityAt"]),
 };

package/convex/components/campaigns/v2/callPolicy.ts

@@ -0,0 +1,67 @@
+import { z } from "zod";
+import { DEFAULT_CALL_POLICY } from "../domain/types";
+import type { CampaignCallPolicy, CampaignOutcome } from "./types";
+
+const outcomeCategorySchema = z.enum(["success", "retry", "fail", "optout"]);
+
+export const campaignOutcomeSchema = z.object({
+  id: z.string().min(1, "outcome id richiesto"),
+  label: z.string().min(1, "label richiesta"),
+  category: outcomeCategorySchema,
+  isActive: z.boolean(),
+});
+
+export const callPolicyInputSchema = z
+  .object({
+    dailyQuotaByClinic: z.record(z.string(), z.number()).optional(),
+    maxAttempts: z.number().min(1, "maxAttempts deve essere >= 1"),
+    retryDelaysDays: z
+      .array(z.number().int().min(0))
+      .max(10, "retryDelaysDays max 10 elementi"),
+    outcomes: z
+      .array(campaignOutcomeSchema)
+      .refine(
+        (arr) => new Set(arr.map((o) => o.id)).size === arr.length,
+        "outcome ids devono essere univoci",
+      )
+      .refine(
+        (arr) => arr.every((o) => o.label.trim().length > 0),
+        "label non vuota per ogni outcome",
+      ),
+  })
+  .strict();
+
+export type CallPolicyInput = z.infer<typeof callPolicyInputSchema>;
+
+function formatZodErrors(err: z.ZodError): string[] {
+  const issues = err.issues ?? [];
+  return issues.map((e: { path?: (string | number)[]; message?: string }) =>
+    (e.path ?? []).length > 0 ? `${(e.path ?? []).join(".")}: ${e.message ?? "invalid"}` : (e.message ?? "invalid"),
+  );
+}
+
+export function validateCallPolicyInput(
+  input: unknown,
+): { ok: true; data: CampaignCallPolicy } | { ok: false; errors: string[] } {
+  const parsed = callPolicyInputSchema.safeParse(input);
+  if (parsed.success) {
+    const data: CampaignCallPolicy = {
+      dailyQuotaByClinic: parsed.data.dailyQuotaByClinic ?? {},
+      maxAttempts: parsed.data.maxAttempts,
+      retryDelaysDays: parsed.data.retryDelaysDays,
+      outcomes: parsed.data.outcomes as CampaignOutcome[],
+    };
+    return { ok: true, data };
+  }
+  const errors = formatZodErrors(parsed.error);
+  return { ok: false, errors };
+}
+
+export function getDefaultCallPolicy(): CampaignCallPolicy {
+  return {
+    dailyQuotaByClinic: DEFAULT_CALL_POLICY.dailyQuotaByClinic,
+    maxAttempts: DEFAULT_CALL_POLICY.maxAttempts,
+    retryDelaysDays: [...DEFAULT_CALL_POLICY.retryDelaysDays],
+    outcomes: DEFAULT_CALL_POLICY.outcomes.map((o) => ({ ...o })),
+  };
+}

package/convex/components/campaigns/v2/dataSource.ts

@@ -0,0 +1,262 @@
+import type { QueryCtx, MutationCtx } from "../../../_generated/server";
+import type { PatientContext } from "./types";
+
+type AnyCtx = QueryCtx | MutationCtx | any;
+
+export type CampaignDataSource = {
+  listPatients: (
+    ctx: AnyCtx,
+    orgId: string,
+    clinicIds: string[],
+    cursor: string | null,
+    limit: number,
+  ) => Promise<{ page: Array<{ orgId: string; clinicId: string; patientId: string }>; nextCursor: string | null }>;
+  getPatientContext: (
+    ctx: AnyCtx,
+    orgId: string,
+    clinicId: string,
+    patientId: string,
+  ) => Promise<PatientContext | null>;
+  getSamplePatients: (
+    ctx: AnyCtx,
+    orgId: string,
+    clinicIds: string[],
+    limit: number,
+  ) => Promise<Array<{ orgId: string; clinicId: string; patientId: string }>>;
+};
+
+const DAY_MS = 24 * 60 * 60 * 1000;
+
+/** Default: true in dev (NODE_ENV !== "production"), false in production. */
+function useDemoDataSource(): boolean {
+  const envVal = process.env.CAMPAIGNS_USE_DEMO_DATASOURCE;
+  if (envVal === "false" || envVal === "0") return false;
+  if (envVal === "true" || envVal === "1") return true;
+  return process.env.NODE_ENV !== "production";
+}
+
+function toAge(birthDate: string): number | null {
+  const ts = Date.parse(birthDate);
+  if (Number.isNaN(ts)) return null;
+  const diffYears = (Date.now() - ts) / (365.25 * DAY_MS);
+  return Math.max(0, Math.floor(diffYears));
+}
+
+async function demoAvailable(ctx: AnyCtx): Promise<boolean> {
+  try {
+    const first = await ctx.db.query("demoPatients").first();
+    return Boolean(first);
+  } catch {
+    return false;
+  }
+}
+
+async function listDemoPatients(
+  ctx: AnyCtx,
+  orgId: string,
+  clinicIds: string[],
+  cursor: string | null,
+  limit: number,
+) {
+  const page =
+    clinicIds.length > 0
+      ? await ctx.db
+          .query("demoPatients")
+          .withIndex("by_org_clinic", (q: any) => q.eq("orgId", orgId).eq("clinicId", clinicIds[0]))
+          .paginate({ cursor, numItems: limit })
+      : await ctx.db
+          .query("demoPatients")
+          .withIndex("by_org", (q: any) => q.eq("orgId", orgId))
+          .paginate({ cursor, numItems: limit });
+
+  const filtered = clinicIds.length
+    ? page.page.filter((p: any) => clinicIds.includes(p.clinicId))
+    : page.page;
+  return {
+    page: filtered.map((p: any) => ({ orgId: p.orgId, clinicId: p.clinicId, patientId: p.patientId })),
+    nextCursor: page.isDone ? null : page.continueCursor,
+  };
+}
+
+async function getLastContactAt(ctx: AnyCtx, orgId: string, patientId: 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;
+  }
+}
+
+async function getDemoContext(
+  ctx: AnyCtx,
+  orgId: string,
+  clinicId: string,
+  patientId: string,
+): Promise<PatientContext | null> {
+  const patient = await ctx.db
+    .query("demoPatients")
+    .withIndex("by_org_patient", (q: any) => q.eq("orgId", orgId).eq("patientId", patientId))
+    .first();
+  if (!patient) return null;
+
+  const appointments = await ctx.db
+    .query("demoAppointments")
+    .withIndex("by_org_patient_date", (q: any) => q.eq("orgId", orgId).eq("patientId", patientId))
+    .collect();
+  const estimates = await ctx.db
+    .query("demoEstimates")
+    .withIndex("by_org_patient_createdAt", (q: any) => q.eq("orgId", orgId).eq("patientId", patientId))
+    .collect();
+  const plans = await ctx.db
+    .query("demoTreatmentPlans")
+    .withIndex("by_org_patient_lastActivity", (q: any) => q.eq("orgId", orgId).eq("patientId", patientId))
+    .collect();
+
+  const doneAppointments = appointments.filter((a: any) => a.status === "done");
+  const lastAppointmentDate =
+    doneAppointments.length === 0
+      ? null
+      : doneAppointments.reduce((acc: number, curr: any) => Math.max(acc, curr.date), 0);
+  const missedLast30d = appointments.some(
+    (a: any) => a.status === "missed" && a.date >= Date.now() - 30 * DAY_MS,
+  );
+  const hasUpcomingNext30d = appointments.some(
+    (a: any) => a.status === "booked" && a.date <= Date.now() + 30 * DAY_MS && a.date >= Date.now(),
+  );
+
+  const latestEstimate = [...estimates].sort((a: any, b: any) => b.createdAt - a.createdAt)[0];
+  const estimateStatus = latestEstimate ? latestEstimate.status : "none";
+  const estimateAmount = latestEstimate ? latestEstimate.amount : null;
+  const expiredDaysAgo =
+    latestEstimate?.status === "expired" && latestEstimate.expiredAt
+      ? Math.floor((Date.now() - latestEstimate.expiredAt) / DAY_MS)
+      : null;
+
+  const openPlan = plans.find((p: any) => p.status === "open");
+  const latestPlan = [...plans].sort((a: any, b: any) => b.lastActivityAt - a.lastActivityAt)[0];
+  const daysSinceLastActivity = latestPlan
+    ? Math.floor((Date.now() - latestPlan.lastActivityAt) / DAY_MS)
+    : null;
+
+  return {
+    orgId,
+    clinicId: patient.clinicId ?? clinicId,
+    patientId,
+    firstName: patient.firstName,
+    lastName: patient.lastName,
+    city: patient.city,
+    birthDate: patient.birthDate,
+    hasCallConsent: Boolean(patient.hasCallConsent),
+    phoneMasked: patient.phoneMasked,
+    age: toAge(patient.birthDate),
+    hasPhone: Boolean(patient.phoneMasked),
+    appointment: {
+      lastDate: lastAppointmentDate,
+      daysSinceLast: lastAppointmentDate ? Math.floor((Date.now() - lastAppointmentDate) / DAY_MS) : null,
+      missedLast30d,
+      hasUpcomingNext30d,
+    },
+    estimate: {
+      status: estimateStatus,
+      amount: estimateAmount,
+      expiredDaysAgo,
+    },
+    treatment: {
+      hasOpenPlan: Boolean(openPlan),
+      daysSinceLastActivity,
+    },
+    contact: {
+      lastContactAt: await getLastContactAt(ctx, orgId, patientId),
+    },
+  };
+}
+
+async function listCorePatients(
+  ctx: AnyCtx,
+  orgId: string,
+  clinicIds: string[],
+  cursor: string | null,
+  limit: number,
+) {
+  const doQuery = async () => {
+    const page = await ctx.db.query("patients").paginate({ cursor, numItems: limit });
+    const mapped = page.page
+      .filter((p: any) => p.status !== "archived")
+      .map((p: any) => ({
+        orgId,
+        clinicId: String(p.clinicId ?? clinicIds[0] ?? "unknown"),
+        patientId: String(p.patientId ?? p._id),
+      }))
+      .filter((p: any) => clinicIds.length === 0 || clinicIds.includes(p.clinicId));
+    return { page: mapped, nextCursor: page.isDone ? null : page.continueCursor };
+  };
+  if (useDemoDataSource()) {
+    try {
+      return await doQuery();
+    } catch {
+      return { page: [], nextCursor: null };
+    }
+  }
+  return doQuery();
+}
+
+async function getCoreContext(
+  ctx: AnyCtx,
+  orgId: string,
+  clinicId: string,
+  patientId: string,
+): Promise<PatientContext | null> {
+  try {
+    const all = await ctx.db.query("patients").collect();
+    const patient = all.find((p: any) => String(p._id) === patientId || String(p.patientId) === patientId);
+    if (!patient) return null;
+    return {
+      orgId,
+      clinicId,
+      patientId,
+      firstName: patient.firstName ?? "N/A",
+      lastName: patient.lastName ?? "N/A",
+      city: patient.city ?? "N/A",
+      birthDate: patient.birthDate ?? "1990-01-01",
+      hasCallConsent: true,
+      phoneMasked: patient.phone,
+      age: patient.birthDate ? toAge(patient.birthDate) : null,
+      hasPhone: Boolean(patient.phone),
+      appointment: {
+        lastDate: null,
+        daysSinceLast: null,
+        missedLast30d: false,
+        hasUpcomingNext30d: false,
+      },
+      estimate: { status: "none", amount: null, expiredDaysAgo: null },
+      treatment: { hasOpenPlan: false, daysSinceLastActivity: null },
+      contact: { lastContactAt: await getLastContactAt(ctx, orgId, patientId) },
+    };
+  } catch {
+    return null;
+  }
+}
+
+export const dataSource: CampaignDataSource = {
+  async listPatients(ctx, orgId, clinicIds, cursor, limit) {
+    if (useDemoDataSource() && (await demoAvailable(ctx))) {
+      return listDemoPatients(ctx, orgId, clinicIds, cursor, limit);
+    }
+    return listCorePatients(ctx, orgId, clinicIds, cursor, limit);
+  },
+  async getPatientContext(ctx, orgId, clinicId, patientId) {
+    if (useDemoDataSource() && (await demoAvailable(ctx))) {
+      return getDemoContext(ctx, orgId, clinicId, patientId);
+    }
+    return getCoreContext(ctx, orgId, clinicId, patientId);
+  },
+  async getSamplePatients(ctx, orgId, clinicIds, limit) {
+    const firstPage = await this.listPatients(ctx, orgId, clinicIds, null, limit);
+    return firstPage.page;
+  },
+};