@learncard/network-brain-service 4.1.2 → 5.0.0

package/src/routes/campaigns.ts

@@ -1,7 +1,11 @@
+import { CampaignAudienceResultValidator, type CampaignAudienceResult } from '@learncard/types';
 import { TRPCError } from '@trpc/server';
 import { z } from 'zod';
 import {
+    AnnouncementPreferencesValidator,
     CampaignAudienceInputValidator,
+    CampaignDispatchPreviewValidator,
+    CampaignDispatchOptionsValidator,
     CampaignEventValidator,
     CampaignIdValidator,
     CampaignStatsValidator,
@@ -21,7 +25,7 @@ import {
     type PaginatedCampaigns,
 } from '@learncard/types';
 
-import { t, profileRouteWithoutInputCapture } from '@routes';
+import { t, openRouteWithoutInputCapture, profileRouteWithoutInputCapture } from '@routes';
 import { isCampaignAdmin } from 'src/constants/campaigns';
 import { enforceRateLimits } from '@helpers/rateLimit.helpers';
 import { trace } from '@tracing';
@@ -32,6 +36,7 @@ import {
     getLiveCampaignsForProfile,
     getCampaignStats,
 } from '@accesslayer/campaign/read';
+import { getCampaignDispatchPreview } from '@accesslayer/campaign/dispatch';
 import { updateCampaign } from '@accesslayer/campaign/update';
 import { deleteCampaign } from '@accesslayer/campaign/delete';
 import {
@@ -40,6 +45,15 @@ import {
     pageCampaignAudience,
 } from '@accesslayer/campaign/audience';
 import { enrollInCampaign, recordCampaignEvent } from '@accesslayer/campaign/state';
+import { dispatchCampaign } from '@helpers/campaign-queue.helpers';
+import { sendCampaignTestToMe } from '@helpers/campaign-notifications.helpers';
+import { getCampaignTests, acknowledgeCampaignTest } from '@accesslayer/campaign/test';
+
+import {
+    getAnnouncementPreferences,
+    updateAnnouncementPreferences,
+} from '@accesslayer/campaign/preferences';
+import { unsubscribeFromCampaignEmails } from '@helpers/campaign-unsubscribe.helpers';
 
 const campaignAdminRoute = profileRouteWithoutInputCapture
     .meta({ requiredScope: 'campaigns:admin' })
@@ -68,6 +82,46 @@ const idInput = z.object({ campaignId: CampaignIdValidator }).strict();
 const noInput = z.object({}).strict().default({});
 
 export const campaignsRouter = t.router({
+    getAnnouncementPreferences: campaignUserRoute
+        .meta({ requiredScope: 'campaigns:read' })
+        .input(noInput)
+        .output(AnnouncementPreferencesValidator)
+        .query(({ ctx }) => getAnnouncementPreferences(ctx.user.profile.profileId)),
+    updateAnnouncementPreferences: campaignUserRoute
+        .meta({ requiredScope: 'campaigns:write' })
+        .input(AnnouncementPreferencesValidator.partial())
+        .output(AnnouncementPreferencesValidator)
+        .mutation(({ ctx, input }) =>
+            updateAnnouncementPreferences(ctx.user.profile.profileId, input)
+        ),
+    unsubscribe: openRouteWithoutInputCapture
+        .input(z.object({ token: z.string().min(1).max(2048) }).strict())
+        .output(z.boolean())
+        .mutation(({ input }) => unsubscribeFromCampaignEmails(input.token)),
+    sendTestToMe: campaignAdminRoute
+        .input(idInput)
+        .output(z.boolean())
+        .mutation(async ({ ctx, input }): Promise<boolean> =>
+            trace('route', 'campaigns:sendTestToMe', () =>
+                sendCampaignTestToMe(input.campaignId, ctx.user.profile)
+            )
+        ),
+    previewDispatch: campaignAdminRoute
+        .input(idInput)
+        .output(CampaignDispatchPreviewValidator)
+        .query(async ({ input }) =>
+            trace('route', 'campaigns:previewDispatch', () =>
+                getCampaignDispatchPreview(input.campaignId)
+            )
+        ),
+    dispatch: campaignAdminRoute
+        .input(idInput.extend(CampaignDispatchOptionsValidator.shape))
+        .output(z.object({ dispatchId: z.uuid() }))
+        .mutation(async ({ input }): Promise<{ dispatchId: string }> =>
+            trace('route', 'campaigns:dispatch', () =>
+                dispatchCampaign(input.campaignId, input.expectedPreviewToken)
+            )
+        ),
     isAdmin: campaignUserRoute
         .meta({ requiredScope: 'campaigns:read' })
         .input(noInput)
@@ -82,7 +136,7 @@ export const campaignsRouter = t.router({
         .output(CampaignValidator)
         .mutation(async ({ ctx, input }): Promise<Campaign> =>
             trace('route', 'campaigns:create', () =>
-                createCampaign(input, ctx.user.profile.profileId)
+                createCampaign(input, ctx.user.profile.profileId, ctx.tenant?.id)
             )
         ),
     update: campaignAdminRoute
@@ -119,19 +173,19 @@ export const campaignsRouter = t.router({
         ),
     previewAudience: campaignAdminRoute
         .input(CampaignAudienceInputValidator)
-        .output(z.object({ count: z.number() }))
-        .query(async ({ input, ctx }): Promise<{ count: number }> =>
-            trace('route', 'campaigns:previewAudience', async () => ({
-                count: await previewCampaignAudience(input.campaignId, input.source, ctx.domain),
-            }))
+        .output(CampaignAudienceResultValidator)
+        .query(async ({ input, ctx }): Promise<CampaignAudienceResult> =>
+            trace('route', 'campaigns:previewAudience', () =>
+                previewCampaignAudience(input.campaignId, input.source, ctx.domain)
+            )
         ),
     addAudience: campaignAdminRoute
         .input(CampaignAudienceInputValidator)
-        .output(z.object({ count: z.number() }))
-        .mutation(async ({ input, ctx }): Promise<{ count: number }> =>
-            trace('route', 'campaigns:addAudience', async () => ({
-                count: await addCampaignAudience(input.campaignId, input.source, ctx.domain),
-            }))
+        .output(CampaignAudienceResultValidator)
+        .mutation(async ({ input, ctx }): Promise<CampaignAudienceResult> =>
+            trace('route', 'campaigns:addAudience', () =>
+                addCampaignAudience(input.campaignId, input.source, ctx.domain)
+            )
         ),
     pageAudience: campaignAdminRoute
         .input(PageCampaignAudienceInputValidator)
@@ -152,18 +206,43 @@ export const campaignsRouter = t.router({
         .input(noInput)
         .output(z.array(MyCampaignValidator))
         .query(async ({ ctx }): Promise<MyCampaign[]> =>
-            trace('route', 'campaigns:getMyCampaigns', () =>
-                getLiveCampaignsForProfile(ctx.user.profile.profileId)
-            )
+            trace('route', 'campaigns:getMyCampaigns', async () => {
+                const profileId = ctx.user.profile.profileId;
+                const tests = isCampaignAdmin(profileId) ? await getCampaignTests(profileId) : [];
+                const campaigns = await getLiveCampaignsForProfile(profileId);
+                return [
+                    ...tests.map(test => ({
+                        campaign: { id: test.campaignId, message: test.message, selfEnroll: false },
+                        state: { shownCount: 0 },
+                        testId: test.id,
+                    })),
+                    ...campaigns,
+                ];
+            })
         ),
     recordEvent: campaignUserRoute
         .meta({ requiredScope: 'campaigns:write' })
-        .input(idInput.extend({ event: CampaignEventValidator }))
+        .input(idInput.extend({ event: CampaignEventValidator, testId: z.uuid().optional() }))
         .output(z.boolean())
         .mutation(async ({ input, ctx }): Promise<boolean> =>
-            trace('route', 'campaigns:recordEvent', () =>
-                recordCampaignEvent(ctx.user.profile.profileId, input.campaignId, input.event)
-            )
+            trace('route', 'campaigns:recordEvent', async () => {
+                if (input.testId) {
+                    if (!isCampaignAdmin(ctx.user.profile.profileId)) return false;
+                    // Private tests never write campaign engagement or audience state.
+                    return input.event === 'shown'
+                        ? acknowledgeCampaignTest(
+                              ctx.user.profile.profileId,
+                              input.campaignId,
+                              input.testId
+                          )
+                        : true;
+                }
+                return recordCampaignEvent(
+                    ctx.user.profile.profileId,
+                    input.campaignId,
+                    input.event
+                );
+            })
         ),
     enroll: campaignUserRoute
         .meta({ requiredScope: 'campaigns:write' })