feat(chat): unlock paid messages before payment

src/stores/chat/__tests__/chat-machine.transitions.test.ts

@@ -3,6 +3,7 @@ import { createActor, fromCallback, fromPromise, waitFor } from "xstate";
 
 import {
   ChatSendResponse,
+  UnlockPrivateResponse,
   type UiMessage,
 } from "@/data/dto/chat";
 import { chatMachine } from "@/stores/chat/chat-machine";
@@ -37,6 +38,11 @@ interface UnlockHistoryOutput {
   newOffset: number;
 }
 
+interface UnlockMessageOutput {
+  messageId: string;
+  response: UnlockPrivateResponse;
+}
+
 function makeChatSendResponse(): ChatSendResponse {
   return ChatSendResponse.from({
     reply: "",
@@ -56,10 +62,34 @@ function makeChatSendResponse(): ChatSendResponse {
   });
 }
 
+function makeUnlockPrivateResponse(
+  overrides: Partial<Parameters<typeof UnlockPrivateResponse.from>[0]> = {},
+): UnlockPrivateResponse {
+  return UnlockPrivateResponse.from({
+    unlocked: true,
+    content: "unlocked content",
+    reason: "ok",
+    creditBalance: 90,
+    creditsCharged: 10,
+    requiredCredits: 10,
+    shortfallCredits: 0,
+    lockDetail: {
+      locked: false,
+      showContent: true,
+      showUpgrade: false,
+      reason: null,
+      hint: null,
+      detail: null,
+    },
+    ...overrides,
+  });
+}
+
 function createTestChatMachine(
   options: {
     historyMessages?: UiMessage[];
     unlockHistoryOutput?: UnlockHistoryOutput;
+    unlockMessageOutput?: UnlockMessageOutput;
   } = {},
 ) {
   return chatMachine.provide({
@@ -109,6 +139,13 @@ function createTestChatMachine(
         newOffset: 0,
         ...options.unlockHistoryOutput,
       })),
+      unlockMessage: fromPromise<UnlockMessageOutput, { messageId: string }>(
+        async ({ input }) =>
+          options.unlockMessageOutput ?? {
+            messageId: input.messageId,
+            response: makeUnlockPrivateResponse(),
+          },
+      ),
     },
   });
 }
@@ -437,6 +474,128 @@ describe("chatMachine transitions", () => {
     actor.stop();
   });
 
+  it("unlocks a single private message without navigating to payment", async () => {
+    const actor = createActor(
+      createTestChatMachine({
+        historyMessages: [
+          {
+            id: "msg-private-locked",
+            content: "",
+            isFromAI: true,
+            date: "2026-06-29",
+            locked: true,
+            lockReason: "private_message",
+            lockedPrivate: true,
+            privateMessageHint: "A private message is waiting.",
+          },
+        ],
+        unlockMessageOutput: {
+          messageId: "msg-private-locked",
+          response: makeUnlockPrivateResponse({
+            content: "This is the unlocked private message.",
+          }),
+        },
+      }),
+    ).start();
+
+    actor.send({ type: "ChatUserLogin", token: "token" });
+    await waitFor(actor, (snapshot) =>
+      snapshot.matches({ userSession: "ready" }),
+    );
+
+    actor.send({
+      type: "ChatUnlockMessageRequested",
+      messageId: "msg-private-locked",
+      kind: "private",
+    });
+
+    await waitFor(actor, (snapshot) =>
+      snapshot.matches({ userSession: "ready" }),
+    );
+
+    expect(actor.getSnapshot().context.unlockPaywallRequest).toBeNull();
+    expect(actor.getSnapshot().context.isUnlockingMessage).toBe(false);
+    expect(actor.getSnapshot().context.messages).toMatchObject([
+      {
+        id: "msg-private-locked",
+        content: "This is the unlocked private message.",
+        locked: false,
+        lockReason: null,
+        lockedPrivate: false,
+        privateMessageHint: null,
+      },
+    ]);
+
+    actor.stop();
+  });
+
+  it("requests payment when single message unlock lacks credits", async () => {
+    const actor = createActor(
+      createTestChatMachine({
+        historyMessages: [
+          {
+            id: "msg-voice-locked",
+            content: "",
+            isFromAI: true,
+            date: "2026-06-29",
+            audioUrl: "https://example.com/voice.mp3",
+            locked: true,
+            lockReason: "voice_message",
+            privateMessageHint: "A voice message is waiting.",
+          },
+        ],
+        unlockMessageOutput: {
+          messageId: "msg-voice-locked",
+          response: makeUnlockPrivateResponse({
+            unlocked: false,
+            content: "",
+            reason: "insufficient_balance",
+            creditBalance: 3,
+            creditsCharged: 0,
+            requiredCredits: 10,
+            shortfallCredits: 7,
+            lockDetail: {
+              locked: true,
+              showContent: false,
+              showUpgrade: true,
+              reason: "insufficient_balance",
+              hint: "Insufficient credits.",
+              detail: { messageId: "msg-voice-locked" },
+            },
+          }),
+        },
+      }),
+    ).start();
+
+    actor.send({ type: "ChatUserLogin", token: "token" });
+    await waitFor(actor, (snapshot) =>
+      snapshot.matches({ userSession: "ready" }),
+    );
+
+    actor.send({
+      type: "ChatUnlockMessageRequested",
+      messageId: "msg-voice-locked",
+      kind: "voice",
+    });
+
+    await waitFor(
+      actor,
+      (snapshot) => snapshot.context.unlockPaywallRequest !== null,
+    );
+
+    expect(actor.getSnapshot().context.unlockPaywallRequest).toEqual({
+      messageId: "msg-voice-locked",
+      kind: "voice",
+      reason: "insufficient_balance",
+      creditBalance: 3,
+      requiredCredits: 10,
+      shortfallCredits: 7,
+    });
+    expect(actor.getSnapshot().context.isUnlockingMessage).toBe(false);
+
+    actor.stop();
+  });
+
   it("clears the weekly limit prompt after payment succeeds", async () => {
     const actor = createActor(createTestChatMachine()).start();