Refactor buildVoteMessageContent to use escalation object

Simplify function signatures by passing the escalation object instead
of individual fields. This makes the code cleaner and allows direct
use of scheduled_for for Discord timestamps instead of recalculating.

- buildVoteMessageContent now takes (modRoleId, escalation, tally, votingStrategy)
- buildConfirmedMessageContent now takes (escalation, resolution, tally)
- Update all call sites in handlers.ts
- Update tests with mock escalation helper

🤖 Generated with [Claude Code](https://claude.com/claude-code)

Co-Authored-By: Claude Opus 4.5 <[email protected]>

Author: vcarl

app/commands/escalate/handlers.ts

@@ -28,6 +28,7 @@ import {
   resolveEscalation,
   updateEscalationStrategy,
   updateScheduledFor,
+  type Escalation,
 } from "#~/models/escalationVotes.server";
 import {
   DEFAULT_QUORUM,
@@ -342,11 +343,6 @@ ${buildVotesListContent(tally)}`,
       const quorum = flags.quorum;
       const votingStrategy =
         escalation.voting_strategy as VotingStrategy | null;
-      const earlyResolution = shouldTriggerEarlyResolution(
-        tally,
-        quorum,
-        votingStrategy,
-      );
 
       // Update scheduled_for based on new vote count
       const newScheduledFor = calculateScheduledFor(
@@ -355,14 +351,25 @@ ${buildVotesListContent(tally)}`,
       );
       await updateScheduledFor(escalationId, newScheduledFor);
 
+      // Create updated escalation object with new scheduled_for
+      const updatedEscalation: Escalation = {
+        ...escalation,
+        scheduled_for: newScheduledFor,
+      };
+
+      const earlyResolution = shouldTriggerEarlyResolution(
+        tally,
+        quorum,
+        votingStrategy,
+      );
+
       // Check if early resolution triggered with clear winner - show confirmed state
       if (earlyResolution && !tally.isTied && tally.leader) {
         await interaction.update({
           content: buildConfirmedMessageContent(
-            escalation.reported_user_id,
+            updatedEscalation,
             tally.leader,
             tally,
-            escalation.created_at,
           ),
           components: [
             new ActionRowBuilder<ButtonBuilder>().addComponents(
@@ -380,11 +387,8 @@ ${buildVotesListContent(tally)}`,
       await interaction.update({
         content: buildVoteMessageContent(
           modRoleId,
-          escalation.initiator_id,
-          escalation.reported_user_id,
+          updatedEscalation,
           tally,
-          quorum,
-          escalation.created_at,
           votingStrategy,
         ),
         components: buildVoteButtons(
@@ -440,14 +444,29 @@ ${buildVotesListContent(tally)}`,
       };
 
       const createdAt = new Date().toISOString();
+      const scheduledFor = calculateScheduledFor(createdAt, 0);
+
+      // Create a temporary escalation-like object for initial message
+      const tempEscalation: Escalation = {
+        id: escalationId,
+        guild_id: guildId,
+        thread_id: threadId,
+        vote_message_id: "", // Will be set after message is sent
+        reported_user_id: reportedUserId,
+        initiator_id: interaction.user.id,
+        flags: JSON.stringify({ quorum }),
+        created_at: createdAt,
+        resolved_at: null,
+        resolution: null,
+        voting_strategy: votingStrategy,
+        scheduled_for: scheduledFor,
+      };
+
       const content = {
         content: buildVoteMessageContent(
           modRoleId,
-          interaction.user.id,
-          reportedUserId,
+          tempEscalation,
           emptyTally,
-          quorum,
-          createdAt,
           votingStrategy,
         ),
         components: buildVoteButtons(
@@ -472,16 +491,7 @@ ${buildVotesListContent(tally)}`,
         }
         voteMessage = await channel.send(content);
         // Now create escalation record with the correct message ID
-        await createEscalation({
-          id: escalationId as `${string}-${string}-${string}-${string}-${string}`,
-          guildId,
-          threadId,
-          voteMessageId: voteMessage.id,
-          reportedUserId,
-          initiatorId: interaction.user.id,
-          quorum,
-          votingStrategy,
-        });
+        await createEscalation(tempEscalation);
 
         // Send notification
         await interaction.editReply("Escalation started");
@@ -508,15 +518,25 @@ ${buildVotesListContent(tally)}`,
         const votes = await getVotesForEscalation(escalationId);
         const tally = tallyVotes(votes);
 
+        // Recalculate scheduled_for based on current vote count
+        const newScheduledFor = calculateScheduledFor(
+          escalation.created_at,
+          tally.totalVotes,
+        );
+
+        // Create updated escalation object
+        const updatedEscalation: Escalation = {
+          ...escalation,
+          voting_strategy: votingStrategy,
+          scheduled_for: newScheduledFor,
+        };
+
         // Update content with current votes and new strategy
         const updatedContent = {
           content: buildVoteMessageContent(
             modRoleId,
-            escalation.initiator_id,
-            reportedUserId,
+            updatedEscalation,
             tally,
-            quorum,
-            escalation.created_at,
             votingStrategy,
           ),
           components: buildVoteButtons(
@@ -536,11 +556,6 @@ ${buildVotesListContent(tally)}`,
           await updateEscalationStrategy(escalationId, votingStrategy);
         }
 
-        // Recalculate scheduled_for based on current vote count
-        const newScheduledFor = calculateScheduledFor(
-          escalation.created_at,
-          tally.totalVotes,
-        );
         await updateScheduledFor(escalationId, newScheduledFor);
 
         // Send notification

app/commands/escalate/strings.test.ts

@@ -1,5 +1,6 @@
 import { tallyVotes, type VoteTally } from "#~/commands/escalate/voting";
 import { resolutions } from "#~/helpers/modResponse";
+import type { Escalation } from "#~/models/escalationVotes.server";
 
 import {
   buildConfirmedMessageContent,
@@ -9,6 +10,27 @@ import {
 
 const emptyTally: VoteTally = tallyVotes([]);
 
+// Helper to create mock escalation objects for testing
+function createMockEscalation(overrides: Partial<Escalation> = {}): Escalation {
+  const createdAt = new Date("2024-01-01T12:00:00Z").toISOString();
+  const scheduledFor = new Date("2024-01-02T12:00:00Z").toISOString(); // 24h later
+  return {
+    id: "test-escalation-id",
+    guild_id: "test-guild",
+    thread_id: "test-thread",
+    vote_message_id: "test-message",
+    reported_user_id: "123456789",
+    initiator_id: "987654321",
+    flags: JSON.stringify({ quorum: 3 }),
+    created_at: createdAt,
+    resolved_at: null,
+    resolution: null,
+    voting_strategy: null,
+    scheduled_for: scheduledFor,
+    ...overrides,
+  };
+}
+
 describe("buildVotesListContent", () => {
   it("returns empty string for no votes", () => {
     const result = buildVotesListContent(emptyTally);
@@ -47,60 +69,38 @@ describe("buildVotesListContent", () => {
 });
 
 describe("buildVoteMessageContent", () => {
-  const reportedUserId = "123456789";
-  const initiatorId = "987654321";
   const modRoleId = "564738291";
-  const createdAt = new Date("2024-01-01T12:00:00Z").toISOString();
 
   it("shows vote count toward quorum", () => {
-    const result = buildVoteMessageContent(
-      modRoleId,
-
-      initiatorId,
-      reportedUserId,
-      emptyTally,
-      3,
-      createdAt,
-    );
+    const escalation = createMockEscalation();
+    const result = buildVoteMessageContent(modRoleId, escalation, emptyTally);
 
     expect(result).toMatch(/0 vote.*quorum at 3/);
     expect(result).not.toMatch("null");
   });
 
   it("mentions the reported user", () => {
-    const result = buildVoteMessageContent(
-      modRoleId,
-
-      initiatorId,
-      reportedUserId,
-      emptyTally,
-      3,
-      createdAt,
-    );
+    const escalation = createMockEscalation();
+    const result = buildVoteMessageContent(modRoleId, escalation, emptyTally);
 
-    expect(result).toContain(`<@${reportedUserId}>`);
+    expect(result).toContain(`<@${escalation.reported_user_id}>`);
   });
 
   it("shows quorum reached status when votes >= quorum", () => {
+    const escalation = createMockEscalation();
     const tally = tallyVotes([
       { vote: resolutions.ban, voter_id: "u1" },
       { vote: resolutions.ban, voter_id: "u2" },
       { vote: resolutions.ban, voter_id: "u3" },
     ]);
-    const result = buildVoteMessageContent(
-      modRoleId,
-      initiatorId,
-      reportedUserId,
-      tally,
-      3,
-      createdAt,
-    );
+    const result = buildVoteMessageContent(modRoleId, escalation, tally);
 
     expect(result).toContain("Quorum reached");
     expect(result).toContain("Ban");
   });
 
   it("shows tied status when quorum reached but tied", () => {
+    const escalation = createMockEscalation();
     // Need 3+ votes for each option to reach quorum while tied
     const tally = tallyVotes([
       { vote: resolutions.ban, voter_id: "u1" },
@@ -110,99 +110,82 @@ describe("buildVoteMessageContent", () => {
       { vote: resolutions.kick, voter_id: "u5" },
       { vote: resolutions.kick, voter_id: "u6" },
     ]);
-    const result = buildVoteMessageContent(
-      modRoleId,
-      initiatorId,
-      reportedUserId,
-      tally,
-      3,
-      createdAt,
-    );
+    const result = buildVoteMessageContent(modRoleId, escalation, tally);
 
     expect(result).toContain("Tied between");
     expect(result).toContain("tiebreaker");
   });
 
   it("includes Discord timestamp", () => {
-    const result = buildVoteMessageContent(
-      modRoleId,
-
-      initiatorId,
-      reportedUserId,
-      emptyTally,
-      3,
-      createdAt,
-    );
+    const escalation = createMockEscalation();
+    const result = buildVoteMessageContent(modRoleId, escalation, emptyTally);
 
     expect(result).toMatch(/<t:\d+:R>/);
   });
 });
 
 describe("buildConfirmedMessageContent", () => {
-  const reportedUserId = "123456789";
-  const createdAt = new Date("2024-01-01T12:00:00Z").toISOString();
-
   it("shows the confirmed resolution", () => {
+    const escalation = createMockEscalation();
     const tally = tallyVotes([
       { vote: resolutions.ban, voter_id: "u1" },
       { vote: resolutions.ban, voter_id: "u2" },
       { vote: resolutions.ban, voter_id: "u3" },
     ]);
     const result = buildConfirmedMessageContent(
-      reportedUserId,
+      escalation,
       resolutions.ban,
       tally,
-      createdAt,
     );
 
     expect(result).toContain("Ban");
     expect(result).toContain("✅");
   });
 
   it("mentions the reported user", () => {
+    const escalation = createMockEscalation();
     const tally = tallyVotes([
       { vote: resolutions.kick, voter_id: "u1" },
       { vote: resolutions.kick, voter_id: "u2" },
       { vote: resolutions.kick, voter_id: "u3" },
     ]);
     const result = buildConfirmedMessageContent(
-      reportedUserId,
+      escalation,
       resolutions.kick,
       tally,
-      createdAt,
     );
 
-    expect(result).toContain(`<@${reportedUserId}>`);
+    expect(result).toContain(`<@${escalation.reported_user_id}>`);
   });
 
   it("shows execution timestamp", () => {
+    const escalation = createMockEscalation();
     const tally = tallyVotes([
       { vote: resolutions.track, voter_id: "u1" },
       { vote: resolutions.track, voter_id: "u2" },
       { vote: resolutions.track, voter_id: "u3" },
     ]);
     const result = buildConfirmedMessageContent(
-      reportedUserId,
+      escalation,
       resolutions.track,
       tally,
-      createdAt,
     );
 
     expect(result).toContain("Executes");
     expect(result).toMatch(/<t:\d+:R>/);
   });
 
   it("includes vote record", () => {
+    const escalation = createMockEscalation();
     const tally = tallyVotes([
       { vote: resolutions.restrict, voter_id: "mod1" },
       { vote: resolutions.restrict, voter_id: "mod2" },
       { vote: resolutions.kick, voter_id: "mod3" },
     ]);
     const result = buildConfirmedMessageContent(
-      reportedUserId,
+      escalation,
       resolutions.restrict,
       tally,
-      createdAt,
     );
 
     expect(result).toContain("<@mod1>");