fix(web): route chat expense writes through the server endpoint (ws-10) (#3516)

Author: Skords-01

apps/web/src/core/lib/chatActions/serverActions.test.ts

@@ -22,10 +22,17 @@ import type { ChatAction } from "./types";
  *   - empty query → не дзвонимо мережу.
  */
 
-const apiUrlMock = vi.fn((p: string) => `https://srv.test${p}`);
-vi.mock("../../../shared/lib/api/apiUrl", () => ({
-  apiUrl: (p: string) => apiUrlMock(p),
-}));
+// `vi.hoisted` — бо `serverActions.ts` тепер тягне `shared/api`, який кличе
+// `apiUrl("")` ще на module-init (до тіла цього файлу); звичайний const
+// упирався б у TDZ всередині hoisted-фабрики vi.mock.
+const apiUrlMock = vi.hoisted(() =>
+  vi.fn((p: string) => `https://srv.test${p}`),
+);
+vi.mock("../../../shared/lib/api/apiUrl", async (importOriginal) => {
+  const actual =
+    await importOriginal<typeof import("../../../shared/lib/api/apiUrl")>();
+  return { ...actual, apiUrl: (p: string) => apiUrlMock(p) };
+});
 
 const fetchMock = vi.fn();
 

apps/web/src/core/lib/chatActions/serverActions.ts

@@ -17,11 +17,26 @@
  */
 
 import { apiUrl } from "../../../shared/lib/api/apiUrl";
+import { apiClient } from "../../../shared/api";
+import { resolveExpenseCategoryMeta } from "../../../modules/finyk/utils";
+import {
+  flushPendingWrites,
+  getCategories,
+  getTransactions,
+  saveTransactions,
+} from "../../../modules/finyk/lib/finykStorage";
+import { createTransaction as createTransactionLocal } from "./finykActions/transactions";
+import type { Transaction } from "@sergeant/finyk-domain/domain/types";
 import type {
   RecallMemoryRequest,
   RecallMemoryResponse,
 } from "@sergeant/shared";
-import type { ChatAction, ChatActionResult, RecallMemoryAction } from "./types";
+import type {
+  ChatAction,
+  ChatActionResult,
+  CreateTransactionAction,
+  RecallMemoryAction,
+} from "./types";
 
 /**
  * Кількість мс, яку клієнт чекає на відповідь recall перш ніж скасувати
@@ -133,19 +148,93 @@ async function handleRecallMemory(action: RecallMemoryAction): Promise<string> {
   return formatRecallResults(trimmedQuery, out.memories);
 }
 
+/**
+ * `create_transaction` — витрати йдуть через `POST /api/finyk/manual-expenses`
+ * (server-of-record + локальне LS-дзеркало для миттєвого UI), доходи та
+ * offline-fallback лишаються на legacy LS-обробнику.
+ *
+ * Server-шлях не дає undo: DELETE-ендпоінта для manual-expenses ще немає,
+ * тож «скасувати» означало б розсинхрон LS ↔ DB. Fallback-шлях зберігає
+ * undo від `createTransactionLocal`.
+ */
+async function handleCreateTransaction(
+  action: CreateTransactionAction,
+): Promise<ChatActionResult> {
+  const { type, amount, category, description, date } = action.input;
+  const amt = Number(amount);
+  if (!Number.isFinite(amt) || amt <= 0) {
+    return "Некоректна сума транзакції.";
+  }
+  // Income сервер не приймає (manual-expenses — лише витрати) — пишемо локально.
+  if (type === "income") {
+    return createTransactionLocal(action);
+  }
+  try {
+    const { expense } = await apiClient.finyk.createManualExpense({
+      // LS та tool-input історично у гривнях; API — у копійках (Hard Rule #1).
+      amount: Math.round(Math.abs(amt) * 100),
+      category: category?.trim() || "other",
+      ...(description?.trim() ? { note: description.trim() } : {}),
+      ...(date && /^\d{4}-\d{2}-\d{2}$/.test(date) ? { date } : {}),
+    });
+    // LS-дзеркало через канонічний finykStorage-wrapper: списки/статистика
+    // читають blob синхронно, без рефетчу. `amount` — у ГРИВНЯХ і legacy-поле
+    // `category` поруч із канонічним `categoryId`: blob історично тримає
+    // shape із `finykActions/transactions.ts#createTransaction`, і його
+    // читачі очікують саме його.
+    const isoDate = new Date(`${expense.date}T12:00:00`).toISOString();
+    const entry: Transaction & { category: string } = {
+      id: expense.id,
+      amount: Math.abs(amt),
+      date: isoDate,
+      categoryId: category?.trim() || "",
+      category: category?.trim() || "",
+      type: "expense",
+      source: "ai",
+      time: Math.floor(Date.parse(isoDate) / 1000),
+      description: description?.trim() || "",
+      mcc: 0,
+      accountId: null,
+      manual: true,
+      _source: "ai",
+      _accountId: null,
+      _manual: true,
+    };
+    const manualExpenses = getTransactions();
+    manualExpenses.unshift(entry);
+    saveTransactions(manualExpenses);
+    // saveTransactions — debounced; flush одразу, щоб запис не загубився
+    // при швидкому закритті вкладки після відповіді чату.
+    flushPendingWrites();
+    const meta = category?.trim()
+      ? resolveExpenseCategoryMeta(category.trim(), getCategories())
+      : undefined;
+    const label = meta?.label || category?.trim() || "";
+    return `Витрату ${amt} грн${description?.trim() ? ` "${description.trim()}"` : ""}${label ? ` (${label})` : ""} записано на сервері (id:${expense.id})`;
+  } catch {
+    // Мережа/401/5xx — не губимо запис: пишемо локально зі старим undo-шляхом.
+    const local = createTransactionLocal(action);
+    const suffix = " (сервер недоступний — записано лише локально)";
+    if (typeof local === "string") return local + suffix;
+    return { ...local, result: local.result + suffix };
+  }
+}
+
 /**
  * Async dispatcher — повертає результат, якщо action — "server-side" tool,
  * інакше `undefined` (sync-flow обробить решту).
  *
- * Зберігаємо строкову форму `ChatActionResult` (без undo): recall — read-only,
- * undo не потрібен.
+ * `recall_memory` — read-only, undo не потрібен. `create_transaction` —
+ * server-write (undo лише у offline-fallback-а).
  */
 export async function handleAsyncChatAction(
   action: ChatAction,
 ): Promise<ChatActionResult | undefined> {
   switch (action.name) {
     case "recall_memory":
       return handleRecallMemory(action as RecallMemoryAction);
+    case "create_transaction":
+      return handleCreateTransaction(action as CreateTransactionAction);
     default:
       return undefined;
   }
@@ -157,4 +246,5 @@ export async function handleAsyncChatAction(
  */
 export const ASYNC_CHAT_ACTION_NAMES: ReadonlySet<string> = new Set([
   "recall_memory",
+  "create_transaction",
 ]);

apps/web/src/core/lib/hubChatActions.test.ts

@@ -25,6 +25,7 @@ afterEach(() => {
   clearSqliteCompletionsCache();
   clearSqliteRoutineStateCache();
   vi.useRealTimers();
+  vi.unstubAllGlobals();
 });
 
 function readLS<T>(key: string, fallback: T): T {
@@ -74,34 +75,109 @@ describe("create_habit", () => {
   });
 });
 
+// ws-10: create_transaction — async/server tool (`ASYNC_CHAT_ACTION_NAMES`).
+// Витрати йдуть через `POST /api/finyk/manual-expenses`; offline-fallback та
+// доходи лишаються на legacy LS-шляху. Тому всі тести — через `executeActions`.
 describe("create_transaction", () => {
-  it("записує витрату в finyk_manual_expenses_v1", () => {
-    const msg = executeAction({
-      name: "create_transaction",
-      input: { amount: 150, category: "food", description: "кава" },
-    });
-    expect(msg).toContain("Витрату");
-    expect(msg).toContain("150");
+  function stubFetchReject(): void {
+    vi.stubGlobal(
+      "fetch",
+      vi.fn(async () => {
+        throw new TypeError("Failed to fetch");
+      }),
+    );
+  }
+
+  afterEach(() => {
+    vi.unstubAllGlobals();
+  });
+
+  it("пише витрату через сервер і дзеркалить у finyk_manual_expenses_v1", async () => {
+    const serverExpense = {
+      id: "0b7e6c3a-7e0f-4b59-9b39-2f4f7f6f9d11",
+      amountKopiykas: 15000,
+      category: "food",
+      date: "2024-06-15",
+      note: "кава",
+      createdAt: "2024-06-15T12:00:00.000Z",
+      updatedAt: "2024-06-15T12:00:00.000Z",
+    };
+    vi.stubGlobal(
+      "fetch",
+      vi.fn(
+        async () =>
+          new Response(JSON.stringify({ ok: true, expense: serverExpense }), {
+            status: 201,
+            headers: { "content-type": "application/json" },
+          }),
+      ),
+    );
+
+    const [out] = await executeActions([
+      {
+        name: "create_transaction",
+        input: { amount: 150, category: "food", description: "кава" },
+      },
+    ]);
+    expect(out!.result).toContain("Витрату");
+    expect(out!.result).toContain("150");
+    expect(out!.result).toContain("записано на сервері");
+    expect(out!.result).toContain(serverExpense.id);
+    // Server-шлях не дає undo — DELETE-ендпоінта немає.
+    expect(out!.undo).toBeUndefined();
+
     const arr = readLS<
       Array<{
+        id: string;
         amount: number;
         category: string;
         description: string;
         type: string;
       }>
     >("finyk_manual_expenses_v1", []);
     expect(arr).toHaveLength(1);
+    // LS-дзеркало: id серверний (UUID), amount у гривнях (legacy LS-shape).
+    expect(arr[0]!.id).toBe(serverExpense.id);
     expect(arr[0]!.amount).toBe(150);
     expect(arr[0]!.category).toBe("food");
     expect(arr[0]!.type).toBe("expense");
   });
 
-  it("записує дохід коли type='income'", () => {
-    const msg = executeAction({
-      name: "create_transaction",
-      input: { type: "income", amount: 5000 },
-    });
-    expect(msg).toContain("Дохід");
+  it("fallback: пише локально з undo, коли сервер недоступний", async () => {
+    stubFetchReject();
+    const [out] = await executeActions([
+      {
+        name: "create_transaction",
+        input: { amount: 150, category: "food", description: "кава" },
+      },
+    ]);
+    expect(out!.result).toContain("Витрату");
+    expect(out!.result).toContain("150");
+    expect(out!.result).toContain("записано лише локально");
+    expect(typeof out!.undo).toBe("function");
+
+    const arr = readLS<Array<{ id: string; amount: number; type: string }>>(
+      "finyk_manual_expenses_v1",
+      [],
+    );
+    expect(arr).toHaveLength(1);
+    expect(arr[0]!.id).toMatch(/^m_/);
+    expect(arr[0]!.amount).toBe(150);
+    expect(arr[0]!.type).toBe("expense");
+  });
+
+  it("записує дохід локально коли type='income' (сервер приймає лише витрати)", async () => {
+    stubFetchReject();
+    const fetchMock = globalThis.fetch as ReturnType<typeof vi.fn>;
+    const [out] = await executeActions([
+      {
+        name: "create_transaction",
+        input: { type: "income", amount: 5000 },
+      },
+    ]);
+    expect(out!.result).toContain("Дохід");
+    // Income не має бити в API взагалі.
+    expect(fetchMock).not.toHaveBeenCalled();
     const arr = readLS<Array<{ type: string; amount: number }>>(
       "finyk_manual_expenses_v1",
       [],
@@ -110,21 +186,26 @@ describe("create_transaction", () => {
     expect(arr[0]!.amount).toBe(5000);
   });
 
-  it("відмовляє на 0 або від'ємну суму", () => {
-    expect(
-      executeAction({
-        name: "create_transaction",
-        input: { amount: 0 },
-      }),
-    ).toContain("Некоректна");
-    expect(
-      executeAction({
-        name: "create_transaction",
-        input: { amount: -5 },
-      }),
-    ).toContain("Некоректна");
+  it("відмовляє на 0 або від'ємну суму без серверного виклику", async () => {
+    stubFetchReject();
+    const fetchMock = globalThis.fetch as ReturnType<typeof vi.fn>;
+    const results = await executeActions([
+      { name: "create_transaction", input: { amount: 0 } },
+      { name: "create_transaction", input: { amount: -5 } },
+    ]);
+    expect(results[0]!.result).toContain("Некоректна");
+    expect(results[1]!.result).toContain("Некоректна");
+    expect(fetchMock).not.toHaveBeenCalled();
     expect(localStorage.getItem("finyk_manual_expenses_v1")).toBeNull();
   });
+
+  it("sync executeAction відмовляє з інструкцією про async-шлях", () => {
+    const msg = executeAction({
+      name: "create_transaction",
+      input: { amount: 150 },
+    });
+    expect(msg).toContain("вимагає async");
+  });
 });
 
 describe("log_set", () => {
@@ -231,6 +312,14 @@ describe("log_water", () => {
 
 describe("executeActions — паралельне виконання", () => {
   it("повертає результати у тому ж порядку, що й input", async () => {
+    // create_transaction — async/server tool: глушимо fetch, щоб тест
+    // детерміновано пішов offline-fallback-шляхом без реальної мережі.
+    vi.stubGlobal(
+      "fetch",
+      vi.fn(async () => {
+        throw new TypeError("Failed to fetch");
+      }),
+    );
     const results = await executeActions([
       { name: "create_habit", input: { name: "Пити воду" } },
       {

packages/api-client/src/createApiClient.ts

@@ -39,6 +39,7 @@ import {
   createBillingEndpoints,
   type BillingEndpoints,
 } from "./endpoints/billing";
+import { createFinykEndpoints, type FinykEndpoints } from "./endpoints/finyk";
 import {
   createWeeklyDigestEndpoints,
   type WeeklyDigestEndpoints,
@@ -78,6 +79,7 @@ export interface ApiClient {
   privat: PrivatEndpoints;
   waitlist: WaitlistEndpoints;
   billing: BillingEndpoints;
+  finyk: FinykEndpoints;
   weeklyDigest: WeeklyDigestEndpoints;
   transcribe: TranscribeEndpoints;
   webVitals: WebVitalsEndpoints;
@@ -99,6 +101,7 @@ export function createApiClient(config: ApiClientConfig = {}): ApiClient {
     privat: createPrivatEndpoints(http),
     waitlist: createWaitlistEndpoints(http),
     billing: createBillingEndpoints(http),
+    finyk: createFinykEndpoints(http),
     weeklyDigest: createWeeklyDigestEndpoints(http),
     transcribe: createTranscribeEndpoints(http),
     webVitals: createWebVitalsEndpoints(http),