@talkpilot/core-db 1.3.65 → 1.3.66

package/src/talkpilot/calls/__tests__/calls.statistics.getters.spec.ts

@@ -0,0 +1,374 @@
+import { ObjectId } from "mongodb";
+import {
+  aggregateActiveCallsSummary,
+  aggregateTodayCallsSummary,
+  aggregateClientCallStats,
+  aggregateSessionCallStats,
+  getAllClientsLastCallDate,
+  findClientIdsByCallSids,
+  getCallsCollection,
+} from "../calls.getters";
+import { getSessionsCollection } from "../../sessions/sessions.getter";
+import type { Call } from "../calls.types";
+import {
+  createOutGoingCallDoc,
+  createIncomingCallDoc,
+  createSession,
+} from "../../../test-utils/factories";
+
+const insertCall = (call: Call) =>
+  getCallsCollection().insertOne({ ...call, env: call.env ?? "test" });
+
+describe("calls.getters statistics", () => {
+  describe("aggregateActiveCallsSummary", () => {
+    it("should count distinct active calls within the last 2 hours, split incoming/outgoing", async () => {
+      const now = new Date();
+      await Promise.all([
+        insertCall(createIncomingCallDoc({ clientId: "clientA", status: "in-progress", updatedAt: now })),
+        insertCall(createOutGoingCallDoc({ clientId: "clientB", status: "in-progress", updatedAt: now })),
+        insertCall(createIncomingCallDoc({ clientId: "clientC", status: "completed", updatedAt: now })),
+      ]);
+
+      const summary = await aggregateActiveCallsSummary();
+
+      expect(summary.total).toBe(2);
+      expect(summary.incoming).toBe(1);
+      expect(summary.outgoing).toBe(1);
+      expect(summary.activeClientIds.sort()).toEqual(["clientA", "clientB"]);
+    });
+
+    it("should filter by clientId when provided", async () => {
+      const now = new Date();
+      await Promise.all([
+        insertCall(createOutGoingCallDoc({ clientId: "onlyThisClient", status: "in-progress", updatedAt: now })),
+        insertCall(createOutGoingCallDoc({ clientId: "otherClient", status: "in-progress", updatedAt: now })),
+      ]);
+
+      const summary = await aggregateActiveCallsSummary("onlyThisClient");
+      expect(summary.total).toBe(1);
+      expect(summary.activeClientIds).toEqual(["onlyThisClient"]);
+    });
+
+    it("should exclude calls whose updatedAt is older than 2 hours", async () => {
+      const threeHoursAgo = new Date(Date.now() - 3 * 60 * 60 * 1000);
+      await insertCall(createOutGoingCallDoc({ status: "in-progress", updatedAt: threeHoursAgo }));
+
+      const summary = await aggregateActiveCallsSummary();
+      expect(summary.total).toBe(0);
+    });
+  });
+
+  describe("aggregateTodayCallsSummary", () => {
+    it("should aggregate status/type counts and total minutes within the given date range", async () => {
+      const today = new Date().toISOString().slice(0, 10);
+      await Promise.all([
+        insertCall(createIncomingCallDoc({ status: "completed", callLength: 120, createdAt: new Date() })),
+        insertCall(createOutGoingCallDoc({ status: "failed", callLength: 30, createdAt: new Date() })),
+      ]);
+
+      const summary = await aggregateTodayCallsSummary({ dateFrom: today, dateTo: today });
+
+      expect(summary.total).toBe(2);
+      expect(summary.incoming).toBe(1);
+      expect(summary.outgoing).toBe(1);
+      expect(summary.completed).toBe(1);
+      expect(summary.failed).toBe(1);
+      expect(summary.totalMinutes).toBe(3); // ceil(150/60)
+    });
+
+    it("should respect the given timezone when resolving an explicit date", async () => {
+      // 23:30 UTC on 2026-01-01 is already 2026-01-02 in Asia/Jerusalem (+2).
+      const lateUtc = new Date("2026-01-01T23:30:00.000Z");
+      await insertCall(createOutGoingCallDoc({ status: "completed", createdAt: lateUtc }));
+
+      const summaryUtc = await aggregateTodayCallsSummary({
+        dateFrom: "2026-01-01",
+        dateTo: "2026-01-01",
+        timezone: "UTC",
+      });
+      expect(summaryUtc.total).toBe(1);
+
+      const summaryJerusalem = await aggregateTodayCallsSummary({
+        dateFrom: "2026-01-01",
+        dateTo: "2026-01-01",
+        timezone: "Asia/Jerusalem",
+      });
+      expect(summaryJerusalem.total).toBe(0);
+    });
+
+    it("should include a call's full history (not just today) when no date range is given", async () => {
+      const sixMonthsAgo = new Date(Date.now() - 180 * 24 * 60 * 60 * 1000);
+      await insertCall(createOutGoingCallDoc({ status: "completed", createdAt: sixMonthsAgo }));
+
+      const summary = await aggregateTodayCallsSummary({});
+      expect(summary.total).toBe(1);
+    });
+  });
+
+  describe("aggregateClientCallStats", () => {
+    it("should group call counts and minutes by clientId", async () => {
+      const today = new Date().toISOString().slice(0, 10);
+      await Promise.all([
+        insertCall(
+          createOutGoingCallDoc({ clientId: "clientX", status: "completed", callLength: 60, createdAt: new Date() }),
+        ),
+        insertCall(
+          createOutGoingCallDoc({ clientId: "clientX", status: "failed", callLength: 60, createdAt: new Date() }),
+        ),
+      ]);
+
+      const rows = await aggregateClientCallStats({ dateFrom: today, dateTo: today });
+      const row = rows.find((r) => r.clientId === "clientX");
+
+      expect(row?.totalCalls).toBe(2);
+      expect(row?.statusCounts).toMatchObject({ completed: 1, failed: 1 });
+      expect(row?.totalMinutes).toBe(2);
+    });
+
+    it("should not include other clients when filtered by clientId", async () => {
+      const today = new Date().toISOString().slice(0, 10);
+      await Promise.all([
+        insertCall(createOutGoingCallDoc({ clientId: "wantedClient", status: "completed", createdAt: new Date() })),
+        insertCall(createOutGoingCallDoc({ clientId: "unwantedClient", status: "completed", createdAt: new Date() })),
+      ]);
+
+      const rows = await aggregateClientCallStats({
+        dateFrom: today,
+        dateTo: today,
+        clientId: "wantedClient",
+      });
+
+      expect(rows).toHaveLength(1);
+      expect(rows[0].clientId).toBe("wantedClient");
+    });
+
+    it("should include a client's full history when no date range is given", async () => {
+      const sixMonthsAgo = new Date(Date.now() - 180 * 24 * 60 * 60 * 1000);
+      await Promise.all([
+        insertCall(createOutGoingCallDoc({ clientId: "longHistoryClient", status: "completed", createdAt: sixMonthsAgo })),
+        insertCall(createOutGoingCallDoc({ clientId: "longHistoryClient", status: "completed", createdAt: new Date() })),
+      ]);
+
+      const rows = await aggregateClientCallStats({});
+      const row = rows.find((r) => r.clientId === "longHistoryClient");
+
+      expect(row?.totalCalls).toBe(2);
+    });
+
+    it("should set lastCallDate to the most recent call", async () => {
+      const earlierCall = new Date("2026-01-01T00:00:00.000Z");
+      const laterCall = new Date("2026-03-10T00:00:00.000Z");
+      await Promise.all([
+        insertCall(createOutGoingCallDoc({ clientId: "lastCallDateClient", status: "completed", createdAt: earlierCall })),
+        insertCall(createOutGoingCallDoc({ clientId: "lastCallDateClient", status: "completed", createdAt: laterCall })),
+      ]);
+
+      const rows = await aggregateClientCallStats({});
+      const row = rows.find((r) => r.clientId === "lastCallDateClient");
+
+      expect(row?.lastCallDate).toEqual(laterCall);
+    });
+
+    it("should filter by clientId alone when no date range is given", async () => {
+      await Promise.all([
+        insertCall(createOutGoingCallDoc({ clientId: "onlyThisClientNoRange", status: "completed", createdAt: new Date() })),
+        insertCall(createOutGoingCallDoc({ clientId: "otherClientNoRange", status: "completed", createdAt: new Date() })),
+      ]);
+
+      const rows = await aggregateClientCallStats({ clientId: "onlyThisClientNoRange" });
+
+      expect(rows).toHaveLength(1);
+      expect(rows[0].clientId).toBe("onlyThisClientNoRange");
+    });
+
+    it("should count every real status separately, including queued; a missing status only inflates totalCalls", async () => {
+      const today = new Date().toISOString().slice(0, 10);
+      await Promise.all([
+        insertCall(createOutGoingCallDoc({ clientId: "statusBucketClient", status: "completed", createdAt: new Date() })),
+        insertCall(createOutGoingCallDoc({ clientId: "statusBucketClient", status: "canceled", createdAt: new Date() })),
+        insertCall(createOutGoingCallDoc({ clientId: "statusBucketClient", status: "queued" as any, createdAt: new Date() })),
+        insertCall(createOutGoingCallDoc({ clientId: "statusBucketClient", status: "ringing", createdAt: new Date() })),
+        insertCall(createOutGoingCallDoc({ clientId: "statusBucketClient", status: "initiated", createdAt: new Date() })),
+        insertCall(createOutGoingCallDoc({ clientId: "statusBucketClient", status: "answered", createdAt: new Date() })),
+        insertCall(createOutGoingCallDoc({ clientId: "statusBucketClient", status: undefined, createdAt: new Date() })),
+      ]);
+
+      const rows = await aggregateClientCallStats({ dateFrom: today, dateTo: today });
+      const row = rows.find((r) => r.clientId === "statusBucketClient");
+
+      expect(row?.totalCalls).toBe(7);
+      expect(row?.statusCounts).toMatchObject({
+        completed: 1,
+        canceled: 1,
+        queued: 1,
+        ringing: 1,
+        initiated: 1,
+        answered: 1,
+      });
+    });
+  });
+
+  describe("aggregateSessionCallStats", () => {
+    it("should group by sessionId and resolve the session's current name via the sessions collection", async () => {
+      const today = new Date().toISOString().slice(0, 10);
+      const sessionId = new ObjectId();
+      await getSessionsCollection().insertOne(createSession({ _id: sessionId, session_name: "My Session" }));
+      await insertCall(
+        createOutGoingCallDoc({ sessionId, status: "completed", createdAt: new Date() }),
+      );
+
+      const rows = await aggregateSessionCallStats({ dateFrom: today, dateTo: today });
+      const row = rows.find((r) => r.sessionId === sessionId.toString());
+
+      expect(row).toMatchObject({ sessionName: "My Session", totalCalls: 1 });
+      expect(row?.statusCounts).toMatchObject({ completed: 1 });
+    });
+
+    it("should always show the session's current name, even if it was renamed after some calls happened", async () => {
+      const today = new Date().toISOString().slice(0, 10);
+      const sessionId = new ObjectId();
+      const earlierCall = new Date(Date.now() - 60 * 60 * 1000);
+      const laterCall = new Date();
+
+      await getSessionsCollection().insertOne(createSession({ _id: sessionId, session_name: "New Name" }));
+      await Promise.all([
+        insertCall(createOutGoingCallDoc({ sessionId, status: "completed", createdAt: earlierCall })),
+        insertCall(createOutGoingCallDoc({ sessionId, status: "completed", createdAt: laterCall })),
+      ]);
+
+      const rows = await aggregateSessionCallStats({ dateFrom: today, dateTo: today });
+      const merged = rows.find((r) => r.sessionId === sessionId.toString());
+
+      expect(merged).toMatchObject({ sessionName: "New Name", totalCalls: 2 });
+      expect(merged?.statusCounts).toMatchObject({ completed: 2 });
+    });
+
+    it("should show 'Unknown' when the session no longer exists in the sessions collection", async () => {
+      const today = new Date().toISOString().slice(0, 10);
+      const orphanedSessionId = new ObjectId();
+      await insertCall(createOutGoingCallDoc({ sessionId: orphanedSessionId, status: "completed", createdAt: new Date() }));
+
+      const rows = await aggregateSessionCallStats({ dateFrom: today, dateTo: today });
+      const row = rows.find((r) => r.sessionId === orphanedSessionId.toString());
+
+      expect(row?.sessionName).toBe("Unknown");
+    });
+
+    it("should label a null sessionId as 'Incoming Call', not 'Unknown' — a call with no session is expected, not broken data", async () => {
+      const today = new Date().toISOString().slice(0, 10);
+      await Promise.all([
+        insertCall(createIncomingCallDoc({ status: "completed", createdAt: new Date() })),
+        insertCall(createIncomingCallDoc({ status: "failed", createdAt: new Date() })),
+      ]);
+
+      const rows = await aggregateSessionCallStats({ dateFrom: today, dateTo: today });
+      const row = rows.find((r) => r.sessionName === "Incoming Call");
+
+      expect(row).toBeDefined();
+      expect(row?.totalCalls).toBe(2);
+      expect(row?.statusCounts).toMatchObject({ completed: 1, failed: 1 });
+      expect(row?.sessionName).not.toBe("Unknown");
+    });
+
+    it("should only include the given client's sessions when clientId is provided", async () => {
+      const today = new Date().toISOString().slice(0, 10);
+      const sessionA = new ObjectId();
+      const sessionB = new ObjectId();
+      await getSessionsCollection().insertMany([
+        createSession({ _id: sessionA, session_name: "Session A" }),
+        createSession({ _id: sessionB, session_name: "Session B" }),
+      ]);
+      await Promise.all([
+        insertCall(createOutGoingCallDoc({ clientId: "clientA", sessionId: sessionA, status: "completed", createdAt: new Date() })),
+        insertCall(createOutGoingCallDoc({ clientId: "clientB", sessionId: sessionB, status: "completed", createdAt: new Date() })),
+      ]);
+
+      const rows = await aggregateSessionCallStats({
+        dateFrom: today,
+        dateTo: today,
+        clientId: "clientA",
+      });
+
+      expect(rows).toHaveLength(1);
+      expect(rows[0]).toMatchObject({ sessionId: sessionA.toString(), sessionName: "Session A" });
+    });
+
+    it("should exclude a session with no calls in the given date range", async () => {
+      const today = new Date().toISOString().slice(0, 10);
+      const longAgo = new Date(Date.now() - 30 * 24 * 60 * 60 * 1000);
+      const oldSessionId = new ObjectId();
+      await getSessionsCollection().insertOne(createSession({ _id: oldSessionId, session_name: "Old Session" }));
+      await insertCall(createOutGoingCallDoc({ sessionId: oldSessionId, status: "completed", createdAt: longAgo }));
+
+      const rows = await aggregateSessionCallStats({ dateFrom: today, dateTo: today });
+
+      expect(rows.find((r) => r.sessionId === oldSessionId.toString())).toBeUndefined();
+    });
+
+    it("should include a session's full history when no date range is given", async () => {
+      const longAgo = new Date(Date.now() - 30 * 24 * 60 * 60 * 1000);
+      const sessionId = new ObjectId();
+      await getSessionsCollection().insertOne(createSession({ _id: sessionId, session_name: "All Time Session" }));
+      await insertCall(createOutGoingCallDoc({ sessionId, status: "completed", createdAt: longAgo }));
+
+      const rows = await aggregateSessionCallStats({});
+      const row = rows.find((r) => r.sessionId === sessionId.toString());
+
+      expect(row?.totalCalls).toBe(1);
+    });
+
+    it("should count each real status separately, including queued", async () => {
+      const today = new Date().toISOString().slice(0, 10);
+      const sessionId = new ObjectId();
+      await getSessionsCollection().insertOne(createSession({ _id: sessionId, session_name: "Bucket Session" }));
+      await Promise.all([
+        insertCall(createOutGoingCallDoc({ sessionId, status: "completed", createdAt: new Date() })),
+        insertCall(createOutGoingCallDoc({ sessionId, status: "canceled", createdAt: new Date() })),
+        insertCall(createOutGoingCallDoc({ sessionId, status: "queued" as any, createdAt: new Date() })),
+      ]);
+
+      const rows = await aggregateSessionCallStats({ dateFrom: today, dateTo: today });
+      const row = rows.find((r) => r.sessionId === sessionId.toString());
+
+      expect(row?.totalCalls).toBe(3);
+      expect(row?.statusCounts).toMatchObject({ completed: 1, canceled: 1, queued: 1 });
+    });
+  });
+
+  describe("getAllClientsLastCallDate", () => {
+    it("should map each clientId to its most recent call, ignoring any date range", async () => {
+      const earlierCall = new Date("2026-01-01T00:00:00.000Z");
+      const laterCall = new Date("2026-03-10T00:00:00.000Z");
+      await Promise.all([
+        insertCall(createOutGoingCallDoc({ clientId: "lastCallMapClientA", status: "completed", createdAt: earlierCall })),
+        insertCall(createOutGoingCallDoc({ clientId: "lastCallMapClientA", status: "completed", createdAt: laterCall })),
+        insertCall(createOutGoingCallDoc({ clientId: "lastCallMapClientB", status: "completed", createdAt: earlierCall })),
+      ]);
+
+      const map = await getAllClientsLastCallDate();
+
+      expect(map.get("lastCallMapClientA")).toEqual(laterCall);
+      expect(map.get("lastCallMapClientB")).toEqual(earlierCall);
+    });
+  });
+
+  describe("findClientIdsByCallSids", () => {
+    it("should map each callSid to the clientId that owns it", async () => {
+      await Promise.all([
+        insertCall(createOutGoingCallDoc({ clientId: "clientA", callSid: "CAaaa" })),
+        insertCall(createOutGoingCallDoc({ clientId: "clientB", callSid: "CAbbb" })),
+      ]);
+
+      const map = await findClientIdsByCallSids(["CAaaa", "CAbbb", "CAunknown"]);
+
+      expect(map.get("CAaaa")).toBe("clientA");
+      expect(map.get("CAbbb")).toBe("clientB");
+      expect(map.has("CAunknown")).toBe(false);
+    });
+
+    it("should return an empty map when given no callSids", async () => {
+      const map = await findClientIdsByCallSids([]);
+      expect(map.size).toBe(0);
+    });
+  });
+});