Provide context to resolve fraud comments

When fraud reports are resolved without banning the partner, and optional notes are provided, they're added as a comment to the partner comments. But without context, it's not clear what the note is pertaining to.

This addition provides context for any fraud notes left, but only for ones added after this feature is added.

Because old comments are stored `text only` it'll be difficult and not accurate to back fill previous resolution comments to show like this.

Author: marcusljf

apps/web/lib/actions/fraud/bulk-resolve-fraud-groups.ts

@@ -38,6 +38,7 @@ export const bulkResolveFraudGroupsAction = authActionClient
         id: true,
         programId: true,
         partnerId: true,
+        type: true,
       },
     });
 
@@ -66,18 +67,19 @@ export const bulkResolveFraudGroupsAction = authActionClient
       ...(resolutionReason && { resolutionReason }),
     });
 
-    // Add the resolution reason as a comment to each unique partner
+    // Add the resolution reason as a comment for each resolved fraud group
     if (resolutionReason && count > 0) {
-      const uniquePartnerIds = Array.from(
-        new Set(fraudGroups.map((group) => group.partnerId)),
-      );
-
       await prisma.partnerComment.createMany({
-        data: uniquePartnerIds.map((partnerId) => ({
+        data: fraudGroups.map((group) => ({
           programId,
-          partnerId,
+          partnerId: group.partnerId,
           userId: user.id,
           text: resolutionReason,
+          metadata: {
+            source: "fraudResolution",
+            groupId: group.id,
+            type: group.type,
+          },
         })),
       });
     }

apps/web/lib/actions/fraud/resolve-fraud-group.ts

@@ -35,6 +35,7 @@ export const resolveFraudGroupAction = authActionClient
         id: true,
         programId: true,
         partnerId: true,
+        type: true,
       },
     });
 
@@ -60,6 +61,11 @@ export const resolveFraudGroupAction = authActionClient
           partnerId: fraudGroup.partnerId,
           userId: user.id,
           text: resolutionReason,
+          metadata: {
+            source: "fraudResolution",
+            groupId: fraudGroup.id,
+            type: fraudGroup.type,
+          },
         },
       });
     }

apps/web/lib/actions/partners/update-partner-comment.ts

@@ -1,5 +1,8 @@
 "use server";
 
+import {
+  parseFraudResolutionComment,
+} from "@/lib/fraud-resolution-comment";
 import { getDefaultProgramIdOrThrow } from "@/lib/api/programs/get-default-program-id-or-throw";
 import { prisma } from "@dub/prisma";
 import {
@@ -23,6 +26,23 @@ export const updatePartnerCommentAction = authActionClient
 
     const programId = getDefaultProgramIdOrThrow(workspace);
 
+    // Preserve fraud resolution metadata from the existing comment
+    const existing = await prisma.partnerComment.findUniqueOrThrow({
+      where: { id, programId, userId: user.id },
+      select: { text: true, metadata: true },
+    });
+
+    const parsedLegacy = parseFraudResolutionComment(existing.text);
+    const metadata =
+      existing.metadata ??
+      (parsedLegacy.metadata
+        ? {
+            source: "fraudResolution",
+            groupId: parsedLegacy.metadata.groupId,
+            type: parsedLegacy.metadata.type,
+          }
+        : null);
+
     const comment = await prisma.partnerComment.update({
       where: {
         id,
@@ -31,6 +51,7 @@ export const updatePartnerCommentAction = authActionClient
       },
       data: {
         text,
+        metadata,
       },
       include: {
         user: true,

apps/web/lib/fraud-resolution-comment.ts

@@ -0,0 +1,73 @@
+import type { FraudRuleType } from "@dub/prisma/client";
+
+const FRAUD_RESOLUTION_COMMENT_PREFIX = "[[dub-fraud-resolution:";
+const FRAUD_RESOLUTION_COMMENT_SUFFIX = "]]";
+
+export interface FraudResolutionCommentMetadata {
+  groupId: string;
+  type: FraudRuleType;
+}
+
+export function serializeFraudResolutionComment({
+  metadata,
+  note,
+}: {
+  metadata: FraudResolutionCommentMetadata;
+  note: string;
+}) {
+  return `${FRAUD_RESOLUTION_COMMENT_PREFIX}${JSON.stringify(metadata)}${FRAUD_RESOLUTION_COMMENT_SUFFIX}\n${note}`;
+}
+
+export function parseFraudResolutionComment(text: string): {
+  metadata: FraudResolutionCommentMetadata | null;
+  note: string;
+} {
+  if (!text.startsWith(FRAUD_RESOLUTION_COMMENT_PREFIX)) {
+    return {
+      metadata: null,
+      note: text,
+    };
+  }
+
+  const suffixIndex = text.indexOf(FRAUD_RESOLUTION_COMMENT_SUFFIX);
+
+  if (suffixIndex === -1) {
+    return {
+      metadata: null,
+      note: text,
+    };
+  }
+
+  const metadataString = text.slice(
+    FRAUD_RESOLUTION_COMMENT_PREFIX.length,
+    suffixIndex,
+  );
+
+  try {
+    const metadata = JSON.parse(metadataString) as FraudResolutionCommentMetadata;
+
+    if (
+      !metadata ||
+      typeof metadata.groupId !== "string" ||
+      typeof metadata.type !== "string"
+    ) {
+      return {
+        metadata: null,
+        note: text,
+      };
+    }
+
+    const contentStart = suffixIndex + FRAUD_RESOLUTION_COMMENT_SUFFIX.length;
+    const hasNewLine = text.charAt(contentStart) === "\n";
+
+    return {
+      metadata,
+      note: text.slice(hasNewLine ? contentStart + 1 : contentStart),
+    };
+  } catch {
+    return {
+      metadata: null,
+      note: text,
+    };
+  }
+}

apps/web/lib/zod/schemas/programs.ts

@@ -9,6 +9,7 @@ import {
 import {
   Category,
   EventType,
+  FraudRuleType,
   PartnerBannedReason,
   ProgramEnrollmentStatus,
   ProgramPayoutMode,
@@ -188,6 +189,12 @@ export const createProgramApplicationSchema = z.object({
   formData: programApplicationFormDataWithValuesSchema,
 });
 
+export const fraudResolutionCommentMetadataSchema = z.object({
+  source: z.literal("fraudResolution"),
+  groupId: z.string(),
+  type: z.enum(FraudRuleType),
+});
+
 export const PartnerCommentSchema = z.object({
   id: z.string(),
   programId: z.string(),
@@ -199,6 +206,7 @@ export const PartnerCommentSchema = z.object({
     image: true,
   }),
   text: z.string(),
+  metadata: z.unknown().nullable().default(null),
   createdAt: z.date(),
   updatedAt: z.date(),
 });

apps/web/scripts/migrations/backfill-fraud-resolution-comment-metadata.ts

@@ -0,0 +1,107 @@
+import { parseFraudResolutionComment } from "@/lib/fraud-resolution-comment";
+import { prisma } from "@dub/prisma";
+import "dotenv-flow/config";
+
+async function main() {
+  const dryRun = process.argv.includes("--dry-run");
+
+  const comments = await prisma.partnerComment.findMany({
+    where: {
+      metadata: null,
+    },
+    select: {
+      id: true,
+      programId: true,
+      partnerId: true,
+      userId: true,
+      text: true,
+      createdAt: true,
+    },
+    orderBy: {
+      createdAt: "asc",
+    },
+  });
+
+  let upgradedFromLegacyEncoded = 0;
+  let upgradedFromResolvedGroupMatch = 0;
+  let ambiguous = 0;
+  let unmatched = 0;
+
+  for (const comment of comments) {
+    const legacy = parseFraudResolutionComment(comment.text);
+
+    if (legacy.metadata) {
+      if (!dryRun) {
+        await prisma.partnerComment.update({
+          where: { id: comment.id },
+          data: {
+            text: legacy.note,
+            metadata: {
+              source: "fraudResolution",
+              groupId: legacy.metadata.groupId,
+              type: legacy.metadata.type,
+            },
+          },
+        });
+      }
+
+      upgradedFromLegacyEncoded++;
+      continue;
+    }
+
+    const matchingGroups = await prisma.fraudEventGroup.findMany({
+      where: {
+        programId: comment.programId,
+        partnerId: comment.partnerId,
+        userId: comment.userId,
+        status: "resolved",
+        resolutionReason: comment.text,
+      },
+      select: {
+        id: true,
+        type: true,
+        resolvedAt: true,
+      },
+    });
+
+    if (matchingGroups.length === 0) {
+      unmatched++;
+      continue;
+    }
+
+    if (matchingGroups.length > 1) {
+      ambiguous++;
+      continue;
+    }
+
+    const [group] = matchingGroups;
+
+    if (!dryRun) {
+      await prisma.partnerComment.update({
+        where: { id: comment.id },
+        data: {
+          metadata: {
+            source: "fraudResolution",
+            groupId: group.id,
+            type: group.type,
+          },
+        },
+      });
+    }
+
+    upgradedFromResolvedGroupMatch++;
+  }
+
+  console.log(
+    [
+      `Scanned ${comments.length} comments with null metadata`,
+      `Upgraded from legacy encoded comments: ${upgradedFromLegacyEncoded}`,
+      `Upgraded from fraud group match: ${upgradedFromResolvedGroupMatch}`,
+      `Ambiguous matches skipped: ${ambiguous}`,
+      `No matches found: ${unmatched}`,
+      `Mode: ${dryRun ? "dry-run" : "write"}`,
+    ].join("\n"),
+  );
+}
+
+main();