@talkpilot/core-db 1.3.51 → 1.3.52

package/src/talkpilot/phone_numbers/__tests__/phone_numbers.spec.ts

@@ -7,6 +7,11 @@ import {
   createPhoneNumberEntity,
   createPurchasedPhoneNumber,
   getPrimaryPhoneFlowId,
+  getClientPhones,
+  getAllClientPhoneMappings,
+  getDistinctClientPhonePairs,
+  findClientsByPhoneNumbers,
+  deletePhoneNumberRecords,
 } from "../phone_numbers.getter";
 import { getFlowsCollection } from "../../flows/flows.getter";
 import { createFlow, createPhoneNumber } from "../../../test-utils/factories";
@@ -14,7 +19,7 @@ import { ObjectId } from "mongodb";
 
 describe("db.phoneNumbers", () => {
   describe("getPhoneDataByPhoneNumber", () => {
-    it("return phone number data with flow", async () => {
+    it("should return phone number data with flow", async () => {
       const flow = createFlow({
         clientId: "test-client-id",
         conversationSettings: {
@@ -62,7 +67,7 @@ describe("db.phoneNumbers", () => {
   });
 
   describe("getClientPhoneNumber", () => {
-    it("return phone number by client id", async () => {
+    it("should return phone number by client id", async () => {
       const flow = createFlow();
       const phoneData = createPhoneNumber({
         flow_id: flow._id,
@@ -78,7 +83,7 @@ describe("db.phoneNumbers", () => {
   });
 
   describe("getClientPhoneData", () => {
-    it("returns primary phone data by default", async () => {
+    it("should return primary phone data by default", async () => {
       const clientId = "multiPhoneClient";
       const phone1 = createPhoneNumber({
         client_id: clientId,
@@ -100,7 +105,7 @@ describe("db.phoneNumbers", () => {
       expect(result?.phone_number).toBe("2");
     });
 
-    it("returns most recent non-primary phone data if isPrimary is false", async () => {
+    it("should return most recent non-primary phone data if isPrimary is false", async () => {
       const clientId = "multiPhoneClient2";
       const phone1 = createPhoneNumber({
         client_id: clientId,
@@ -131,7 +136,7 @@ describe("db.phoneNumbers", () => {
   });
 
   describe("getPhoneNumbersForFlows", () => {
-    it("returns all phone numbers for the client with flow ObjectIds, newest first", async () => {
+    it("should return all phone numbers for the client with flow ObjectIds, newest first", async () => {
       const clientId = "flowsClient";
       const flow1 = createFlow({ clientId });
       const flow2 = createFlow({ clientId });
@@ -169,12 +174,12 @@ describe("db.phoneNumbers", () => {
       });
     });
 
-    it("returns an empty array when the client has no phone numbers", async () => {
+    it("should return an empty array when the client has no phone numbers", async () => {
       const result = await getPhoneNumbersForFlows("noSuchClient");
       expect(result).toEqual([]);
     });
 
-    it("does not include phone numbers for other clients", async () => {
+    it("should not include phone numbers for other clients", async () => {
       const clientA = "clientA";
       const clientB = "clientB";
       const flow = createFlow();
@@ -191,7 +196,7 @@ describe("db.phoneNumbers", () => {
   });
 
   describe("createPhoneNumberEntity", () => {
-    it("creates first phone number as primary", async () => {
+    it("should create first phone number as primary", async () => {
       const clientId = "newClient";
       const flowId = new ObjectId().toHexString();
       const phoneNumber = "+123456789";
@@ -205,7 +210,7 @@ describe("db.phoneNumbers", () => {
       expect(result.is_primary).toBe(true);
     });
 
-    it("creates subsequent phone number as non-primary", async () => {
+    it("should create subsequent phone number as non-primary", async () => {
       const clientId = "existingClient";
       const flowId = new ObjectId().toHexString();
 
@@ -220,7 +225,7 @@ describe("db.phoneNumbers", () => {
   });
 
   describe("createPurchasedPhoneNumber", () => {
-    it("persists a phone_numbers document with provider payload and flow", async () => {
+    it("should persist a phone_numbers document with provider payload and flow", async () => {
       const clientId = "purchasedClientDb";
       const flowId = new ObjectId().toHexString();
       const phoneNumber = "+15551234567";
@@ -252,7 +257,7 @@ describe("db.phoneNumbers", () => {
   });
 
   describe("getPrimaryPhoneFlowId", () => {
-    it("returns flow_id from primary phone as string", async () => {
+    it("should return flow_id from primary phone as string", async () => {
       const clientId = "primaryFlowClient";
       const flowId = new ObjectId();
       await getPhoneNumbersCollection().insertOne(
@@ -266,11 +271,11 @@ describe("db.phoneNumbers", () => {
       expect(await getPrimaryPhoneFlowId(clientId)).toBe(flowId.toHexString());
     });
 
-    it("returns null when client has no primary phone", async () => {
+    it("should return null when client has no primary phone", async () => {
       expect(await getPrimaryPhoneFlowId("no-phone-client")).toBeNull();
     });
 
-    it("returns null when primary phone has no flow_id", async () => {
+    it("should return null when primary phone has no flow_id", async () => {
       const clientId = "phoneNoFlow";
       const phone = createPhoneNumber({ client_id: clientId, is_primary: true });
       delete phone.flow_id;
@@ -279,4 +284,213 @@ describe("db.phoneNumbers", () => {
       expect(await getPrimaryPhoneFlowId(clientId)).toBeNull();
     });
   });
+
+  describe("getClientPhones", () => {
+    it("should return all phone numbers for the given client, projected to phoneNumber only", async () => {
+      const clientId = "phonesClientA";
+      await getPhoneNumbersCollection().insertMany([
+        createPhoneNumber({ client_id: clientId, phone_number: "+100" }),
+        createPhoneNumber({ client_id: clientId, phone_number: "+200" }),
+      ]);
+
+      const result = await getClientPhones(clientId);
+
+      expect(result).toHaveLength(2);
+      expect(result).toEqual(
+        expect.arrayContaining([
+          { phoneNumber: "+100" },
+          { phoneNumber: "+200" },
+        ]),
+      );
+    });
+
+    it("should not include phone numbers belonging to other clients", async () => {
+      await getPhoneNumbersCollection().insertOne(
+        createPhoneNumber({ client_id: "someOtherClient" }),
+      );
+
+      const result = await getClientPhones("phonesClientB");
+      expect(result).toEqual([]);
+    });
+
+    it("should remove exact duplicate phone records for the same client", async () => {
+      const clientId = "phonesClientDup";
+      await getPhoneNumbersCollection().insertMany([
+        createPhoneNumber({ client_id: clientId, phone_number: "+300" }),
+        createPhoneNumber({ client_id: clientId, phone_number: "+300" }),
+        createPhoneNumber({ client_id: clientId, phone_number: "+400" }),
+      ]);
+
+      const result = await getClientPhones(clientId);
+
+      expect(result).toHaveLength(2);
+      expect(result).toEqual(
+        expect.arrayContaining([
+          { phoneNumber: "+300" },
+          { phoneNumber: "+400" },
+        ]),
+      );
+    });
+  });
+
+  describe("getAllClientPhoneMappings", () => {
+    it("should return a Map of clientId to phone number across all clients", async () => {
+      await getPhoneNumbersCollection().insertMany([
+        createPhoneNumber({ client_id: "mapClientA", phone_number: "+111" }),
+        createPhoneNumber({ client_id: "mapClientB", phone_number: "+222" }),
+      ]);
+
+      const result = await getAllClientPhoneMappings();
+
+      expect(result).toBeInstanceOf(Map);
+      expect(result.get("mapClientA")).toBe("+111");
+      expect(result.get("mapClientB")).toBe("+222");
+    });
+
+    it("should return an empty Map when there are no phone numbers", async () => {
+      const result = await getAllClientPhoneMappings();
+      expect(result.size).toBe(0);
+    });
+
+    it("should return the most recently updated phone number when a client has several", async () => {
+      const clientId = "mapClientRecent";
+      await getPhoneNumbersCollection().insertMany([
+        createPhoneNumber({
+          client_id: clientId,
+          phone_number: "+old",
+          updatedAt: new Date("2023-01-01"),
+        }),
+        createPhoneNumber({
+          client_id: clientId,
+          phone_number: "+new",
+          updatedAt: new Date("2023-06-01"),
+        }),
+      ]);
+
+      const result = await getAllClientPhoneMappings();
+
+      expect(result.get(clientId)).toBe("+new");
+    });
+
+    it("should prefer the is_primary number over a more recently updated non-primary one", async () => {
+      const clientId = "mapClientPrimary";
+      await getPhoneNumbersCollection().insertMany([
+        createPhoneNumber({
+          client_id: clientId,
+          phone_number: "+primary",
+          is_primary: true,
+          updatedAt: new Date("2023-01-01"),
+        }),
+        createPhoneNumber({
+          client_id: clientId,
+          phone_number: "+secondary",
+          is_primary: false,
+          updatedAt: new Date("2023-06-01"),
+        }),
+      ]);
+
+      const result = await getAllClientPhoneMappings();
+
+      expect(result.get(clientId)).toBe("+primary");
+    });
+  });
+
+  describe("getDistinctClientPhonePairs", () => {
+    it("should return unique client+phone pairs, collapsing exact duplicates", async () => {
+      await getPhoneNumbersCollection().insertMany([
+        createPhoneNumber({ client_id: "pairClientA", phone_number: "+500" }),
+        createPhoneNumber({ client_id: "pairClientA", phone_number: "+500" }),
+        createPhoneNumber({ client_id: "pairClientB", phone_number: "+600" }),
+      ]);
+
+      const result = await getDistinctClientPhonePairs();
+
+      expect(result).toEqual(
+        expect.arrayContaining([
+          { clientId: "pairClientA", phoneNumber: "+500" },
+          { clientId: "pairClientB", phoneNumber: "+600" },
+        ]),
+      );
+      expect(
+        result.filter(
+          (p) => p.clientId === "pairClientA" && p.phoneNumber === "+500",
+        ),
+      ).toHaveLength(1);
+    });
+
+    it("should keep separate pairs when the same number is shared by different clients", async () => {
+      await getPhoneNumbersCollection().insertMany([
+        createPhoneNumber({ client_id: "sharedClientA", phone_number: "+700" }),
+        createPhoneNumber({ client_id: "sharedClientB", phone_number: "+700" }),
+      ]);
+
+      const result = await getDistinctClientPhonePairs();
+
+      expect(result).toEqual(
+        expect.arrayContaining([
+          { clientId: "sharedClientA", phoneNumber: "+700" },
+          { clientId: "sharedClientB", phoneNumber: "+700" },
+        ]),
+      );
+    });
+  });
+
+  describe("findClientsByPhoneNumbers", () => {
+    it("should return other clients sharing each phone number, excluding the given client", async () => {
+      await getPhoneNumbersCollection().insertMany([
+        createPhoneNumber({ client_id: "excludeMe", phone_number: "+800" }),
+        createPhoneNumber({ client_id: "otherClient1", phone_number: "+800" }),
+        createPhoneNumber({ client_id: "otherClient2", phone_number: "+800" }),
+      ]);
+
+      const result = await findClientsByPhoneNumbers(["+800"], "excludeMe");
+
+      expect(result.get("+800")).toEqual(
+        expect.arrayContaining(["otherClient1", "otherClient2"]),
+      );
+      expect(result.get("+800")).not.toContain("excludeMe");
+    });
+
+    it("should return an empty array for a phone number with no other clients", async () => {
+      await getPhoneNumbersCollection().insertOne(
+        createPhoneNumber({ client_id: "soleOwner", phone_number: "+900" }),
+      );
+
+      const result = await findClientsByPhoneNumbers(["+900"], "soleOwner");
+
+      expect(result.get("+900")).toEqual([]);
+    });
+
+    it("should return an empty map immediately when given no phone numbers", async () => {
+      const result = await findClientsByPhoneNumbers([]);
+      expect(result.size).toBe(0);
+    });
+  });
+
+  describe("deletePhoneNumberRecords", () => {
+    it("should delete every record for the given phone number across all clients", async () => {
+      await getPhoneNumbersCollection().insertMany([
+        createPhoneNumber({ client_id: "delClientA", phone_number: "+1000" }),
+        createPhoneNumber({ client_id: "delClientB", phone_number: "+1000" }),
+        createPhoneNumber({ client_id: "delClientC", phone_number: "+2000" }),
+      ]);
+
+      const deletedCount = await deletePhoneNumberRecords("+1000");
+
+      expect(deletedCount).toBe(2);
+      const remaining = await getPhoneNumbersCollection()
+        .find({ phone_number: "+1000" })
+        .toArray();
+      expect(remaining).toHaveLength(0);
+      const untouched = await getPhoneNumbersCollection().findOne({
+        phone_number: "+2000",
+      });
+      expect(untouched?.client_id).toBe("delClientC");
+    });
+
+    it("should return 0 when no records match the phone number", async () => {
+      const deletedCount = await deletePhoneNumberRecords("+9999999");
+      expect(deletedCount).toBe(0);
+    });
+  });
 });

package/src/talkpilot/phone_numbers/phone_numbers.getter.ts

@@ -157,7 +157,9 @@ export const findClientByPhoneNumber = async (
   return client;
 };
 
-export const getPrimaryPhoneFlowId = async (clientId: string): Promise<string | null> => {
+export const getPrimaryPhoneFlowId = async (
+  clientId: string,
+): Promise<string | null> => {
   const phone = await getClientPhoneData(clientId);
   return phone?.flow_id ? String(phone.flow_id) : null;
 };
@@ -174,3 +176,76 @@ export const bindClientPhoneToFlow = async (
     throw new Error(`No primary phone number found for client: ${clientId}`);
   }
 };
+
+export const getClientPhones = async (
+  clientId: string,
+): Promise<{ phoneNumber: string }[]> => {
+  const docs = await getPhoneNumbersCollection()
+    .aggregate<{ _id: string }>([
+      { $match: { client_id: clientId } },
+      { $group: { _id: "$phone_number" } },
+    ])
+    .toArray();
+  return docs.map((d) => ({ phoneNumber: d._id }));
+};
+
+export const getAllClientPhoneMappings = async (): Promise<
+  Map<string, string>
+> => {
+  const docs = await getPhoneNumbersCollection()
+    .aggregate<{ _id: string; phone_number: string }>([
+      { $sort: { is_primary: -1, updatedAt: -1 } },
+      { $group: { _id: "$client_id", phone_number: { $first: "$phone_number" } } },
+    ])
+    .toArray();
+  return new Map(docs.map((d) => [d._id, d.phone_number]));
+};
+
+export const getDistinctClientPhonePairs = async (): Promise<
+  { clientId: string; phoneNumber: string }[]
+> => {
+  const docs = await getPhoneNumbersCollection()
+    .aggregate<{ _id: { client_id: string; phone_number: string } }>([
+      { $group: { _id: { client_id: "$client_id", phone_number: "$phone_number" } } },
+    ])
+    .toArray();
+  return docs.map((d) => ({
+    clientId: d._id.client_id,
+    phoneNumber: d._id.phone_number,
+  }));
+};
+
+export const findClientsByPhoneNumbers = async (
+  phoneNumbers: string[],
+  excludeClientId?: string,
+): Promise<Map<string, string[]>> => {
+  const result = new Map<string, string[]>(
+    phoneNumbers.map((p) => [p, [] as string[]]),
+  );
+  if (phoneNumbers.length === 0) return result;
+
+  const docs = await getPhoneNumbersCollection()
+    .aggregate<{ _id: string; clientIds: string[] }>([
+      {
+        $match: {
+          phone_number: { $in: phoneNumbers },
+          ...(excludeClientId ? { client_id: { $ne: excludeClientId } } : {}),
+        },
+      },
+      { $group: { _id: "$phone_number", clientIds: { $addToSet: "$client_id" } } },
+    ])
+    .toArray();
+
+  docs.forEach((d) => result.set(d._id, d.clientIds));
+  return result;
+};
+
+/** Deletes this number's record for every client that references it. Check `findClientsByPhoneNumbers` first to see who's affected. */
+export const deletePhoneNumberRecords = async (
+  phoneNumber: string,
+): Promise<number> => {
+  const result = await getPhoneNumbersCollection().deleteMany({
+    phone_number: phoneNumber,
+  });
+  return result.deletedCount;
+};

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,3 +1,4 @@
+export * from "./results.constants";
 export {
   getResultsCollection,
   initializeResultDocument,
@@ -5,3 +6,11 @@ export {
   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,5 +1,6 @@
 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> =>
@@ -17,8 +18,8 @@ export const initializeResultDocument = async (
     runId: createRunId(),
     date: new Date(),
     calls: [],
-    sessionId: session ? session._id!.toString() : "incomingCall",
-    sessionName: session ? session.session_name : "incomingCall",
+    sessionId: session ? session._id!.toString() : INCOMING_SESSION_ID,
+    sessionName: session ? session.session_name : INCOMING_SESSION_ID,
     clientId,
   });
   const result = await getResultsCollection().findOne({ _id: insertedId });