@talkpilot/core-db 1.3.50 → 1.3.52

package/src/talkpilot/results/__tests__/results.statistics.spec.ts

@@ -0,0 +1,226 @@
+import {
+  aggregateActiveCallsSummary,
+  aggregateTodayCallsSummary,
+  aggregateClientCallStats,
+  aggregateSessionCallStats,
+  findClientIdsByCallSids,
+} from "../results.statistics.getters";
+import { getResultsCollection } from "../results.getter";
+import { createResult, createCallResult } from "../../../test-utils/factories";
+
+describe("results statistics getters", () => {
+  describe("aggregateActiveCallsSummary", () => {
+    it("should count distinct active calls within the last 2 hours, split incoming/outgoing", async () => {
+      const now = new Date();
+      await getResultsCollection().insertMany([
+        createResult({
+          clientId: "clientA",
+          sessionId: "incomingCall",
+          calls: [createCallResult({ status: "in-progress", date: now })],
+        }),
+        createResult({
+          clientId: "clientB",
+          sessionId: "someSessionId",
+          calls: [createCallResult({ status: "in-progress", date: now })],
+        }),
+        createResult({
+          clientId: "clientC",
+          sessionId: "incomingCall",
+          calls: [createCallResult({ status: "completed", date: 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 getResultsCollection().insertMany([
+        createResult({
+          clientId: "onlyThisClient",
+          calls: [createCallResult({ status: "in-progress", date: now })],
+        }),
+        createResult({
+          clientId: "otherClient",
+          calls: [createCallResult({ status: "in-progress", date: now })],
+        }),
+      ]);
+
+      const summary = await aggregateActiveCallsSummary("onlyThisClient");
+      expect(summary.total).toBe(1);
+      expect(summary.activeClientIds).toEqual(["onlyThisClient"]);
+    });
+
+    it("should exclude calls older than 2 hours", async () => {
+      const threeHoursAgo = new Date(Date.now() - 3 * 60 * 60 * 1000);
+      await getResultsCollection().insertOne(
+        createResult({
+          calls: [
+            createCallResult({ status: "in-progress", date: threeHoursAgo }),
+          ],
+        }),
+      );
+
+      const summary = await aggregateActiveCallsSummary();
+      expect(summary.total).toBe(0);
+    });
+  });
+
+  describe("aggregateTodayCallsSummary", () => {
+    it("should aggregate status/type counts and total minutes within the date range", async () => {
+      const today = new Date().toISOString().slice(0, 10);
+      await getResultsCollection().insertMany([
+        createResult({
+          sessionId: "incomingCall",
+          calls: [
+            createCallResult({
+              status: "completed",
+              callLength: "120 seconds",
+              date: new Date(),
+            }),
+          ],
+        }),
+        createResult({
+          sessionId: "someSession",
+          calls: [
+            createCallResult({
+              status: "failed",
+              callLength: "30 seconds",
+              date: 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 the default (today) range", 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 getResultsCollection().insertOne(
+        createResult({
+          calls: [createCallResult({ status: "completed", date: 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);
+    });
+  });
+
+  describe("aggregateClientCallStats", () => {
+    it("should group call counts and minutes by clientId", async () => {
+      const today = new Date().toISOString().slice(0, 10);
+      await getResultsCollection().insertOne(
+        createResult({
+          clientId: "clientX",
+          calls: [
+            createCallResult({
+              status: "completed",
+              callLength: "60 seconds",
+              date: new Date(),
+            }),
+            createCallResult({
+              status: "failed",
+              callLength: "60 seconds",
+              date: new Date(),
+            }),
+          ],
+        }),
+      );
+
+      const rows = await aggregateClientCallStats({ dateFrom: today, dateTo: today });
+      const row = rows.find((r) => r.clientId === "clientX");
+
+      expect(row).toMatchObject({ totalCalls: 2, 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 getResultsCollection().insertMany([
+        createResult({
+          clientId: "wantedClient",
+          calls: [createCallResult({ status: "completed", date: new Date() })],
+        }),
+        createResult({
+          clientId: "unwantedClient",
+          calls: [createCallResult({ status: "completed", date: new Date() })],
+        }),
+      ]);
+
+      const rows = await aggregateClientCallStats({
+        dateFrom: today,
+        dateTo: today,
+        clientId: "wantedClient",
+      });
+
+      expect(rows).toHaveLength(1);
+      expect(rows[0].clientId).toBe("wantedClient");
+    });
+  });
+
+  describe("aggregateSessionCallStats", () => {
+    it("should group call counts by sessionName", async () => {
+      const today = new Date().toISOString().slice(0, 10);
+      await getResultsCollection().insertOne(
+        createResult({
+          sessionName: "My Session",
+          calls: [createCallResult({ status: "completed", date: new Date() })],
+        }),
+      );
+
+      const rows = await aggregateSessionCallStats({ dateFrom: today, dateTo: today });
+      expect(rows.find((r) => r.sessionName === "My Session")).toMatchObject({
+        totalCalls: 1,
+        completed: 1,
+      });
+    });
+  });
+
+  describe("findClientIdsByCallSids", () => {
+    it("should map each callSid to the clientId that owns it", async () => {
+      const callA = createCallResult({ callSid: "CAaaa" });
+      const callB = createCallResult({ callSid: "CAbbb" });
+      await getResultsCollection().insertMany([
+        createResult({ clientId: "clientA", calls: [callA] }),
+        createResult({ clientId: "clientB", calls: [callB] }),
+      ]);
+
+      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);
+    });
+  });
+});

package/src/talkpilot/results/index.ts

@@ -1,7 +1,16 @@
-export {
-  getResultsCollection,
-  initializeResultDocument,
-  findResultById,
-  findResultByCallSid,
-} from "./results.getter";
-export type * from "./results.types";
+export * from "./results.constants";
+export {
+  getResultsCollection,
+  initializeResultDocument,
+  findResultById,
+  findResultByCallSid,
+} from "./results.getter";
+export type * from "./results.types";
+export {
+  aggregateActiveCallsSummary,
+  aggregateTodayCallsSummary,
+  aggregateClientCallStats,
+  aggregateSessionCallStats,
+  findClientIdsByCallSids,
+} from "./results.statistics.getters";
+export type * from "./results.statistics.types";

package/src/talkpilot/results/results.constants.ts

@@ -0,0 +1,11 @@
+/** sessionId used for calls that arrived without an existing session (incoming calls). */
+export const INCOMING_SESSION_ID = "incomingCall";
+
+/** Twilio call statuses considered "currently active" for the live calls summary. */
+export const ACTIVE_STATUSES = ["in-progress"];
+
+/** Lookback window for the "active calls right now" summary. */
+export const ACTIVE_CALLS_WINDOW_MS = 2 * 60 * 60 * 1000;
+
+/** Max rows returned by the per-session call stats breakdown. */
+export const SESSION_STATS_LIMIT = 20;

package/src/talkpilot/results/results.getter.ts

@@ -1,39 +1,40 @@
-import { Collection, ObjectId } from "mongodb";
-import { getDb, Session } from "../index";
-import type { Result } from "./results.types";
-
-export const getResultsCollection = (): Collection<Result> =>
-  getDb().collection<Result>("results");
-
-export const createRunId = (): string => {
-  return `run_${new ObjectId().toString()}`;
-};
-
-export const initializeResultDocument = async (
-  clientId: string,
-  session?: Session,
-): Promise<Result> => {
-  const { insertedId } = await getResultsCollection().insertOne({
-    runId: createRunId(),
-    date: new Date(),
-    calls: [],
-    sessionId: session ? session._id!.toString() : "incomingCall",
-    sessionName: session ? session.session_name : "incomingCall",
-    clientId,
-  });
-  const result = await getResultsCollection().findOne({ _id: insertedId });
-  if (!result) throw new Error("Failed to initialized result");
-  return result;
-};
-
-export const findResultById = async (
-  resultId: string | ObjectId,
-): Promise<Result | null> => {
-  return getResultsCollection().findOne({ _id: new ObjectId(resultId) });
-};
-
-export const findResultByCallSid = async (
-  callSid: string,
-): Promise<Result | null> => {
-  return getResultsCollection().findOne({ "calls.callSid": callSid });
-};
+import { Collection, ObjectId } from "mongodb";
+import { getDb, Session } from "../index";
+import { INCOMING_SESSION_ID } from "./results.constants";
+import type { Result } from "./results.types";
+
+export const getResultsCollection = (): Collection<Result> =>
+  getDb().collection<Result>("results");
+
+export const createRunId = (): string => {
+  return `run_${new ObjectId().toString()}`;
+};
+
+export const initializeResultDocument = async (
+  clientId: string,
+  session?: Session,
+): Promise<Result> => {
+  const { insertedId } = await getResultsCollection().insertOne({
+    runId: createRunId(),
+    date: new Date(),
+    calls: [],
+    sessionId: session ? session._id!.toString() : INCOMING_SESSION_ID,
+    sessionName: session ? session.session_name : INCOMING_SESSION_ID,
+    clientId,
+  });
+  const result = await getResultsCollection().findOne({ _id: insertedId });
+  if (!result) throw new Error("Failed to initialized result");
+  return result;
+};
+
+export const findResultById = async (
+  resultId: string | ObjectId,
+): Promise<Result | null> => {
+  return getResultsCollection().findOne({ _id: new ObjectId(resultId) });
+};
+
+export const findResultByCallSid = async (
+  callSid: string,
+): Promise<Result | null> => {
+  return getResultsCollection().findOne({ "calls.callSid": callSid });
+};

package/src/talkpilot/results/results.schema.ts

@@ -1,25 +1,25 @@
-export const resultMongoSchema = {
-  bsonType: "object",
-  required: [
-    "_id",
-    "sessionId",
-    "status",
-    "callLength",
-    "date",
-    "userAnswer",
-    "systemSessionId",
-    "clientId",
-  ],
-  properties: {
-    _id: { bsonType: "objectId" },
-    sessionId: { bsonType: "string" },
-    status: { bsonType: "string" },
-    callLength: { bsonType: "string" },
-    date: { bsonType: "date" },
-    userAnswer: { bsonType: "string" },
-    recordingUrl: { bsonType: ["string", "null"] },
-    systemSessionId: { bsonType: "string" },
-    clientId: { bsonType: "string" },
-  },
-  additionalProperties: false,
-} as const;
+export const resultMongoSchema = {
+  bsonType: "object",
+  required: [
+    "_id",
+    "sessionId",
+    "status",
+    "callLength",
+    "date",
+    "userAnswer",
+    "systemSessionId",
+    "clientId",
+  ],
+  properties: {
+    _id: { bsonType: "objectId" },
+    sessionId: { bsonType: "string" },
+    status: { bsonType: "string" },
+    callLength: { bsonType: "string" },
+    date: { bsonType: "date" },
+    userAnswer: { bsonType: "string" },
+    recordingUrl: { bsonType: ["string", "null"] },
+    systemSessionId: { bsonType: "string" },
+    clientId: { bsonType: "string" },
+  },
+  additionalProperties: false,
+} as const;