@primocaredentgroup/convex-campaigns-component 0.1.3 → 0.3.0

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

@@ -0,0 +1,248 @@
+/**
+ * Public API host-facing: surface stabile per PrimoUpCore e componente Richiami.
+ * Usare queste API per integrazione in produzione.
+ */
+import { v } from "convex/values";
+import { mutation, query } from "../../../_generated/server";
+import { assertCanManageCampaigns } from "../permissions";
+import { getFieldRegistryPublic } from "../v2/fieldRegistry";
+import { getDefaultCallPolicy } from "../v2/callPolicy";
+import { normalizeClinicId, normalizeClinicIds } from "../lib/helpers";
+import type { Id } from "../../../_generated/dataModel";
+
+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 safeCampaignsByOrgPriority(ctx: any, orgId: string) {
+  try {
+    return await ctx.db
+      .query("campaigns")
+      .withIndex("by_org_priority", (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 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 listActiveCampaignsForOrg = query({
+  args: {
+    orgId: v.string(),
+    clinicId: v.optional(v.string()),
+  },
+  handler: async (ctx, args) => {
+    await assertCanManageCampaigns(ctx);
+    const campaigns = await safeCampaignsByOrgStatus(ctx, args.orgId, "ready");
+    const clinicIdNorm = args.clinicId ? normalizeClinicId(args.clinicId) : null;
+
+    const filtered =
+      clinicIdNorm === null
+        ? campaigns
+        : campaigns.filter((c: any) => {
+            const scopeIds = (c.scope?.clinicIds ?? c.scopeClinicIds ?? []).map(String);
+            return scopeIds.length === 0 || scopeIds.includes(clinicIdNorm);
+          });
+
+    const result: Array<{
+      campaignId: Id<"campaigns">;
+      name: string;
+      priority: number;
+      status: string;
+      scopeClinicIds: string[];
+      latestPublishedVersionId?: Id<"campaignVersions">;
+      latestPublishedVersionNumber?: number;
+      callPolicy: any;
+    }> = [];
+
+    for (const camp of filtered) {
+      const versions = await ctx.db
+        .query("campaignVersions")
+        .withIndex("by_campaign", (q: any) => q.eq("campaignId", camp._id))
+        .collect();
+      const latest = versions.sort((a: any, b: any) => b.version - a.version)[0];
+      const scopeClinicIds = (camp.scope?.clinicIds ?? camp.scopeClinicIds ?? []).map(String);
+      result.push({
+        campaignId: camp._id,
+        name: camp.name,
+        priority: Math.max(1, camp.priority ?? 100),
+        status: camp.status,
+        scopeClinicIds,
+        latestPublishedVersionId: latest?._id,
+        latestPublishedVersionNumber: latest?.version,
+        callPolicy: camp.callPolicy ?? getDefaultCallPolicy(),
+      });
+    }
+
+    return result.sort((a, b) => a.priority - b.priority);
+  },
+});
+
+export const getLatestPublishedVersion = query({
+  args: { campaignId: v.id("campaigns") },
+  handler: async (ctx, args) => {
+    await assertCanManageCampaigns(ctx);
+    const versions = await ctx.db
+      .query("campaignVersions")
+      .withIndex("by_campaign", (q: any) => q.eq("campaignId", args.campaignId))
+      .collect();
+    const latest = versions.sort((a: any, b: any) => b.version - a.version)[0];
+    if (!latest) return null;
+    return {
+      versionId: latest._id,
+      versionNumber: latest.version,
+      publishedAt: latest.publishedAt,
+      callPolicySnapshot: latest.callPolicySnapshot ?? getDefaultCallPolicy(),
+      rulesSnapshot: latest.rulesSnapshot,
+      scopeSnapshot: latest.scopeSnapshot,
+    };
+  },
+});
+
+export const getPatientCampaignMemberships = query({
+  args: { orgId: v.string(), patientId: v.string() },
+  handler: async (ctx, args) => {
+    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))];
+    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; 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, 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: Math.max(1, 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);
+  },
+});
+
+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));
+    const clinicIdNorm = args.clinicId ? normalizeClinicId(args.clinicId) : undefined;
+
+    if (clinicIdNorm) {
+      const page = await ctx.db
+        .query("audienceMembers")
+        .withIndex("by_version_clinic_createdAt", (q: any) =>
+          q.eq("versionId", args.versionId).eq("clinicId", clinicIdNorm),
+        )
+        .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_createdAt", (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 clinicIdNorm = normalizeClinicId(args.clinicId);
+    const id = await ctx.db.insert("contactLog", {
+      ...args,
+      clinicId: clinicIdNorm,
+      createdAt: Date.now(),
+    });
+    return { id };
+  },
+});
+
+export const getFieldRegistry = query({
+  args: {},
+  handler: async () => getFieldRegistryPublic(),
+});

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

@@ -3,76 +3,150 @@ import { query } from "../../../_generated/server";
 import { assertAuthorized } from "../permissions";
 import { campaignStatusValidator, scopeTypeValidator } from "../domain/types";
 
+const clinicIdFilterValidator = v.union(v.id("clinics"), v.string());
+
+function isRecoverableQueryError(error: unknown): boolean {
+  const message = error instanceof Error ? error.message : String(error);
+  return (
+    message.includes("CAMPAIGNS_UNAUTHORIZED") ||
+    message.includes("CAMPAIGNS_AUTH_") ||
+    (message.includes("Index") && message.includes("not found"))
+  );
+}
+
+async function safeCollectCampaignsByStatus(ctx: any, status: any) {
+  try {
+    return await ctx.db
+      .query("campaigns")
+      .withIndex("by_status", (q: any) => q.eq("status", status))
+      .collect();
+  } catch {
+    return await ctx.db
+      .query("campaigns")
+      .filter((q: any) => q.eq(q.field("status"), status))
+      .collect();
+  }
+}
+
+async function safeCollectStepsByCampaign(ctx: any, campaignId: string) {
+  try {
+    return await ctx.db
+      .query("campaign_steps")
+      .withIndex("by_campaign", (q: any) => q.eq("campaignId", campaignId))
+      .collect();
+  } catch {
+    return await ctx.db
+      .query("campaign_steps")
+      .filter((q: any) => q.eq(q.field("campaignId"), campaignId))
+      .collect();
+  }
+}
+
+async function safeCollectSnapshotsByCampaign(ctx: any, campaignId: string) {
+  try {
+    return await ctx.db
+      .query("audience_snapshots")
+      .withIndex("by_campaign_createdAt", (q: any) => q.eq("campaignId", campaignId))
+      .collect();
+  } catch {
+    return await ctx.db
+      .query("audience_snapshots")
+      .filter((q: any) => q.eq(q.field("campaignId"), campaignId))
+      .collect();
+  }
+}
+
+async function safeCollectMembersBySnapshot(ctx: any, snapshotId: string) {
+  try {
+    return await ctx.db
+      .query("audience_members")
+      .withIndex("by_snapshot", (q: any) => q.eq("snapshotId", snapshotId))
+      .collect();
+  } catch {
+    return await ctx.db
+      .query("audience_members")
+      .filter((q: any) => q.eq(q.field("snapshotId"), snapshotId))
+      .collect();
+  }
+}
+
 export const listCampaigns = query({
   args: {
     filters: v.optional(
       v.object({
         status: v.optional(campaignStatusValidator),
         scopeType: v.optional(scopeTypeValidator),
-        clinicId: v.optional(v.id("clinics")),
+        clinicId: v.optional(clinicIdFilterValidator),
       }),
     ),
   },
   handler: async (ctx, args) => {
-    await assertAuthorized(ctx, ["Admin", "Marketing"]);
-    let campaigns = args.filters?.status
-      ? await ctx.db
-          .query("campaigns")
-          .withIndex("by_status", (q) => q.eq("status", args.filters!.status!))
-          .collect()
-      : await ctx.db.query("campaigns").collect();
-
-    if (args.filters?.scopeType) {
-      campaigns = campaigns.filter((c) => c.scopeType === args.filters?.scopeType);
-    }
-    if (args.filters?.clinicId) {
-      campaigns = campaigns.filter((c) => c.scopeClinicIds.includes(args.filters!.clinicId!));
+    try {
+      await assertAuthorized(ctx, ["Admin", "Marketing"]);
+      let campaigns = args.filters?.status
+        ? await safeCollectCampaignsByStatus(ctx, args.filters.status)
+        : await ctx.db.query("campaigns").collect();
+
+      if (args.filters?.scopeType) {
+        campaigns = campaigns.filter((c: any) => c.scopeType === args.filters?.scopeType);
+      }
+      if (args.filters?.clinicId) {
+        campaigns = campaigns.filter((c: any) =>
+          c.scopeClinicIds.map((id: any) => String(id)).includes(String(args.filters!.clinicId!)),
+        );
+      }
+      return campaigns.sort((a: any, b: any) => b.updatedAt - a.updatedAt);
+    } catch (error) {
+      if (!isRecoverableQueryError(error)) throw error;
+      console.error("[campaigns.listCampaigns] recoverable error:", error);
+      return [];
     }
-    return campaigns.sort((a, b) => b.updatedAt - a.updatedAt);
   },
 });
 
 export const getCampaign = query({
   args: { campaignId: v.id("campaigns") },
   handler: async (ctx, args) => {
-    await assertAuthorized(ctx, ["Admin", "Marketing"]);
-    const campaign = await ctx.db.get(args.campaignId);
-    if (!campaign) return null;
+    try {
+      await assertAuthorized(ctx, ["Admin", "Marketing"]);
+      const campaign = await ctx.db.get(args.campaignId);
+      if (!campaign) return null;
 
-    const steps = await ctx.db
-      .query("campaign_steps")
-      .withIndex("by_campaign", (q) => q.eq("campaignId", args.campaignId))
-      .collect();
-
-    const snapshots = await ctx.db
-      .query("audience_snapshots")
-      .withIndex("by_campaign_createdAt", (q) => q.eq("campaignId", args.campaignId))
-      .collect();
+      const steps = await safeCollectStepsByCampaign(ctx, args.campaignId);
+      const snapshots = await safeCollectSnapshotsByCampaign(ctx, args.campaignId);
 
-    return {
-      campaign,
-      steps: steps.sort((a, b) => a.order - b.order),
-      snapshots: snapshots.sort((a, b) => b.createdAt - a.createdAt),
-    };
+      return {
+        campaign,
+        steps: steps.sort((a: any, b: any) => a.order - b.order),
+        snapshots: snapshots.sort((a: any, b: any) => b.createdAt - a.createdAt),
+      };
+    } catch (error) {
+      if (!isRecoverableQueryError(error)) throw error;
+      console.error("[campaigns.getCampaign] recoverable error:", error);
+      return null;
+    }
   },
 });
 
 export const getSnapshot = query({
   args: { snapshotId: v.id("audience_snapshots") },
   handler: async (ctx, args) => {
-    await assertAuthorized(ctx, ["Admin", "Marketing"]);
-    const snapshot = await ctx.db.get(args.snapshotId);
-    if (!snapshot) return null;
+    try {
+      await assertAuthorized(ctx, ["Admin", "Marketing"]);
+      const snapshot = await ctx.db.get(args.snapshotId);
+      if (!snapshot) return null;
 
-    const members = await ctx.db
-      .query("audience_members")
-      .withIndex("by_snapshot", (q) => q.eq("snapshotId", args.snapshotId))
-      .collect();
+      const members = await safeCollectMembersBySnapshot(ctx, args.snapshotId);
 
-    return {
-      snapshot,
-      membersCount: members.length,
-    };
+      return {
+        snapshot,
+        membersCount: members.length,
+      };
+    } catch (error) {
+      if (!isRecoverableQueryError(error)) throw error;
+      console.error("[campaigns.getSnapshot] recoverable error:", error);
+      return null;
+    }
   },
 });
 
@@ -85,47 +159,67 @@ export const getCampaignReport = query({
     }),
   },
   handler: async (ctx, args) => {
-    await assertAuthorized(ctx, ["Admin", "Marketing"]);
-    const snapshots = await ctx.db
-      .query("audience_snapshots")
-      .withIndex("by_campaign_createdAt", (q) => q.eq("campaignId", args.campaignId))
-      .collect();
-
-    const inRange = snapshots.filter(
-      (s) => s.createdAt >= args.range.from && s.createdAt <= args.range.to,
-    );
-    const counters = {
-      totalCandidates: 0,
-      eligible: 0,
-      queued: 0,
-      sent: 0,
-      taskCreated: 0,
-      completed: 0,
-      converted: 0,
-      failed: 0,
-      suppressedByReason: {} as Record<string, number>,
+    const emptyReport = {
+      campaignId: args.campaignId,
+      range: args.range,
+      snapshotsCount: 0,
+      counters: {
+        totalCandidates: 0,
+        eligible: 0,
+        queued: 0,
+        sent: 0,
+        taskCreated: 0,
+        completed: 0,
+        converted: 0,
+        failed: 0,
+        suppressedByReason: {} as Record<string, number>,
+      },
     };
 
-    for (const snapshot of inRange) {
-      counters.totalCandidates += snapshot.stats.totalCandidates;
-      counters.eligible += snapshot.stats.eligible;
-      counters.queued += snapshot.stats.queued;
-      counters.sent += snapshot.stats.sent;
-      counters.taskCreated += snapshot.stats.taskCreated;
-      counters.completed += snapshot.stats.completed;
-      counters.converted += snapshot.stats.converted;
-      counters.failed += snapshot.stats.failed;
-      for (const [reason, count] of Object.entries(snapshot.stats.suppressedByReason)) {
-        counters.suppressedByReason[reason] =
-          (counters.suppressedByReason[reason] ?? 0) + count;
+    try {
+      await assertAuthorized(ctx, ["Admin", "Marketing"]);
+      const snapshots = await safeCollectSnapshotsByCampaign(ctx, args.campaignId);
+
+      const inRange = snapshots.filter(
+        (s: any) => s.createdAt >= args.range.from && s.createdAt <= args.range.to,
+      );
+      const counters = {
+        totalCandidates: 0,
+        eligible: 0,
+        queued: 0,
+        sent: 0,
+        taskCreated: 0,
+        completed: 0,
+        converted: 0,
+        failed: 0,
+        suppressedByReason: {} as Record<string, number>,
+      };
+
+      for (const snapshot of inRange) {
+        counters.totalCandidates += snapshot.stats.totalCandidates;
+        counters.eligible += snapshot.stats.eligible;
+        counters.queued += snapshot.stats.queued;
+        counters.sent += snapshot.stats.sent;
+        counters.taskCreated += snapshot.stats.taskCreated;
+        counters.completed += snapshot.stats.completed;
+        counters.converted += snapshot.stats.converted;
+        counters.failed += snapshot.stats.failed;
+        for (const [reason, count] of Object.entries(snapshot.stats.suppressedByReason)) {
+          counters.suppressedByReason[reason] =
+            (counters.suppressedByReason[reason] ?? 0) + Number(count);
+        }
       }
-    }
 
-    return {
-      campaignId: args.campaignId,
-      range: args.range,
-      snapshotsCount: inRange.length,
-      counters,
-    };
+      return {
+        campaignId: args.campaignId,
+        range: args.range,
+        snapshotsCount: inRange.length,
+        counters,
+      };
+    } catch (error) {
+      if (!isRecoverableQueryError(error)) throw error;
+      console.error("[campaigns.getCampaignReport] recoverable error:", error);
+      return emptyReport;
+    }
   },
 });

package/convex/components/campaigns/index.ts

@@ -2,3 +2,7 @@ export * as campaignsQueries from "./functions/queries";
 export * as campaignsMutations from "./functions/mutations";
 export * as campaignsActions from "./functions/actions";
 export * as campaignsInternal from "./functions/internal";
+export * as campaignsPublic from "./functions/public";
+export * as campaignsPlayground from "./functions/playground";
+
+export type { CampaignCallPolicy, CampaignOutcome, RuleGroup, RuleCondition } from "./v2/types";

package/convex/components/campaigns/lib/helpers.ts

@@ -0,0 +1,9 @@
+/** Normalizza clinicId al boundary: accetta string o Convex id, ritorna string. */
+export function normalizeClinicId(id: string | unknown): string {
+  return String(id ?? "").trim();
+}
+
+/** Normalizza array di clinicIds. */
+export function normalizeClinicIds(ids?: (string | unknown)[]): string[] {
+  return [...new Set((ids ?? []).map((id) => normalizeClinicId(id)).filter(Boolean))];
+}