@talkpilot/core-db 1.3.52 → 1.3.53

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

@@ -1,226 +0,0 @@
-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/results.constants.ts

@@ -1,11 +0,0 @@
-/** 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.statistics.getters.ts

@@ -1,329 +0,0 @@
-import { getResultsCollection } from "./results.getter";
-import {
-  formatYmdInTz,
-  startOfCalendarDayInTz,
-  endOfCalendarDayInTz,
-} from "../../utils/date.utils";
-import {
-  ACTIVE_STATUSES,
-  ACTIVE_CALLS_WINDOW_MS,
-  SESSION_STATS_LIMIT,
-  INCOMING_SESSION_ID,
-} from "./results.constants";
-import type {
-  StatsDateRangeParams,
-  ActiveCallsSummary,
-  TodayCallsSummary,
-  ClientCallStats,
-  SessionCallStats,
-} from "./results.statistics.types";
-
-const dateRangeFilter = (
-  dateFrom: string | undefined,
-  dateTo: string | undefined,
-  timezone: string,
-): { start: Date; end: Date } => {
-  const today = formatYmdInTz(new Date(), timezone);
-  return {
-    start: startOfCalendarDayInTz(dateFrom ?? today, timezone),
-    end: endOfCalendarDayInTz(dateTo ?? today, timezone),
-  };
-};
-
-const buildDateRangeMatch = (
-  start: Date,
-  end: Date,
-  clientId: string | undefined,
-) => {
-  const clientFilter = clientId ? { clientId } : {};
-  return { ...clientFilter, "calls.date": { $gte: start, $lte: end } };
-};
-
-// Filters on `clientId` (a document-level field) before `$unwind` explodes `calls[]`,
-// so Mongo never has to unwind documents belonging to other clients.
-const clientPreMatchStage = (clientId?: string) =>
-  clientId ? [{ $match: { clientId } }] : [];
-
-// Converts a duration string like "120 seconds" into a number (120) that can be summed inside an aggregation.
-const durationExpr = {
-  $convert: {
-    input: {
-      $arrayElemAt: [
-        { $split: [{ $ifNull: ["$calls.callLength", "0 seconds"] }, " "] },
-        0,
-      ],
-    },
-    to: "double",
-    onError: 0,
-    onNull: 0,
-  },
-};
-
-const statusFields = {
-  totalCalls: { $sum: 1 },
-  completed: {
-    $sum: { $cond: [{ $eq: ["$calls.status", "completed"] }, 1, 0] },
-  },
-  failed: { $sum: { $cond: [{ $eq: ["$calls.status", "failed"] }, 1, 0] } },
-  noAnswer: {
-    $sum: { $cond: [{ $eq: ["$calls.status", "no-answer"] }, 1, 0] },
-  },
-  busy: { $sum: { $cond: [{ $eq: ["$calls.status", "busy"] }, 1, 0] } },
-  inProgress: {
-    $sum: { $cond: [{ $eq: ["$calls.status", "in-progress"] }, 1, 0] },
-  },
-};
-
-export const aggregateActiveCallsSummary = async (
-  clientId?: string,
-): Promise<ActiveCallsSummary> => {
-  const coll = getResultsCollection();
-  const twoHoursAgo = new Date(Date.now() - ACTIVE_CALLS_WINDOW_MS);
-
-  const activeMatch = {
-    "calls.status": { $in: ACTIVE_STATUSES },
-    "calls.date": { $gte: twoHoursAgo },
-  };
-
-  const facetResult = await coll
-    .aggregate<{
-      counts: { total: number; incoming: number; outgoing: number }[];
-      activeClients: { _id: string }[];
-    }>([
-      ...clientPreMatchStage(clientId),
-      { $match: { "calls.date": { $gte: twoHoursAgo } } },
-      { $unwind: "$calls" },
-      { $match: activeMatch },
-      {
-        $facet: {
-          counts: [
-            {
-              $group: {
-                _id: null,
-                total: { $addToSet: "$calls.callSid" },
-                incoming: {
-                  $addToSet: {
-                    $cond: [
-                      { $eq: ["$sessionId", INCOMING_SESSION_ID] },
-                      "$calls.callSid",
-                      null,
-                    ],
-                  },
-                },
-                outgoing: {
-                  $addToSet: {
-                    $cond: [
-                      { $ne: ["$sessionId", INCOMING_SESSION_ID] },
-                      "$calls.callSid",
-                      null,
-                    ],
-                  },
-                },
-              },
-            },
-            {
-              $project: {
-                _id: 0,
-                total: { $size: "$total" },
-                incoming: {
-                  $size: { $setDifference: ["$incoming", [null]] },
-                },
-                outgoing: {
-                  $size: { $setDifference: ["$outgoing", [null]] },
-                },
-              },
-            },
-          ],
-          activeClients: [{ $group: { _id: "$clientId" } }],
-        },
-      },
-    ])
-    .next();
-
-  const counts = facetResult?.counts?.[0];
-
-  return {
-    total: counts?.total ?? 0,
-    incoming: counts?.incoming ?? 0,
-    outgoing: counts?.outgoing ?? 0,
-    activeClientIds: (facetResult?.activeClients ?? []).map(
-      (d) => d._id || "Unknown",
-    ),
-  };
-};
-
-export const aggregateTodayCallsSummary = async ({
-  dateFrom,
-  dateTo,
-  clientId,
-  timezone = "UTC",
-}: StatsDateRangeParams): Promise<TodayCallsSummary> => {
-  const coll = getResultsCollection();
-  const { start, end } = dateRangeFilter(dateFrom, dateTo, timezone);
-  const match = buildDateRangeMatch(start, end, clientId);
-
-  const facetResult = await coll
-    .aggregate<{
-      byStatus: { _id: string; count: number }[];
-      byType: { _id: string; count: number }[];
-      total: { count: number }[];
-      totalSeconds: { seconds: number }[];
-    }>([
-      ...clientPreMatchStage(clientId),
-      { $match: { "calls.date": { $gte: start, $lte: end } } },
-      { $unwind: "$calls" },
-      { $match: match },
-      {
-        $facet: {
-          byStatus: [{ $group: { _id: "$calls.status", count: { $sum: 1 } } }],
-          byType: [
-            {
-              $group: {
-                _id: {
-                  $cond: [
-                    { $eq: ["$sessionId", INCOMING_SESSION_ID] },
-                    "incoming",
-                    "outgoing",
-                  ],
-                },
-                count: { $sum: 1 },
-              },
-            },
-          ],
-          total: [{ $group: { _id: null, count: { $sum: 1 } } }],
-          totalSeconds: [
-            { $group: { _id: null, seconds: { $sum: durationExpr } } },
-          ],
-        },
-      },
-    ])
-    .next();
-
-  const byStatus: Record<string, number> = {};
-  (facetResult?.byStatus ?? []).forEach((s) => {
-    byStatus[s._id] = s.count;
-  });
-  const byType: Record<string, number> = {};
-  (facetResult?.byType ?? []).forEach((t) => {
-    byType[t._id] = t.count;
-  });
-
-  const totalSeconds = facetResult?.totalSeconds?.[0]?.seconds ?? 0;
-
-  return {
-    total: facetResult?.total?.[0]?.count ?? 0,
-    incoming: byType.incoming ?? 0,
-    outgoing: byType.outgoing ?? 0,
-    completed: byStatus.completed ?? 0,
-    failed: byStatus.failed ?? 0,
-    busy: byStatus.busy ?? 0,
-    noAnswer: byStatus["no-answer"] ?? 0,
-    totalMinutes: Math.ceil(totalSeconds / 60),
-  };
-};
-
-export const aggregateClientCallStats = async ({
-  dateFrom,
-  dateTo,
-  clientId,
-  timezone = "UTC",
-}: StatsDateRangeParams): Promise<ClientCallStats[]> => {
-  const coll = getResultsCollection();
-  const { start, end } = dateRangeFilter(dateFrom, dateTo, timezone);
-  const match = buildDateRangeMatch(start, end, clientId);
-
-  const rows = await coll
-    .aggregate<{
-      _id: string;
-      totalCalls: number;
-      completed: number;
-      failed: number;
-      noAnswer: number;
-      busy: number;
-      inProgress: number;
-      totalSeconds: number;
-    }>([
-      ...clientPreMatchStage(clientId),
-      { $match: { "calls.date": { $gte: start, $lte: end } } },
-      { $unwind: "$calls" },
-      { $match: match },
-      {
-        $group: {
-          _id: "$clientId",
-          ...statusFields,
-          totalSeconds: { $sum: durationExpr },
-        },
-      },
-      { $sort: { totalCalls: -1 } },
-    ])
-    .toArray();
-
-  return rows.map((r) => ({
-    clientId: r._id || "Unknown",
-    totalCalls: r.totalCalls,
-    completed: r.completed,
-    failed: r.failed,
-    noAnswer: r.noAnswer,
-    busy: r.busy,
-    inProgress: r.inProgress,
-    totalMinutes: Math.ceil((r.totalSeconds || 0) / 60),
-  }));
-};
-
-export const aggregateSessionCallStats = async ({
-  dateFrom,
-  dateTo,
-  clientId,
-  timezone = "UTC",
-}: StatsDateRangeParams): Promise<SessionCallStats[]> => {
-  const coll = getResultsCollection();
-  const { start, end } = dateRangeFilter(dateFrom, dateTo, timezone);
-  const match = buildDateRangeMatch(start, end, clientId);
-
-  const rows = await coll
-    .aggregate<{
-      _id: string;
-      totalCalls: number;
-      completed: number;
-      failed: number;
-      noAnswer: number;
-      busy: number;
-      inProgress: number;
-    }>([
-      ...clientPreMatchStage(clientId),
-      { $match: { "calls.date": { $gte: start, $lte: end } } },
-      { $unwind: "$calls" },
-      { $match: match },
-      { $group: { _id: "$sessionName", ...statusFields } },
-      { $sort: { totalCalls: -1 } },
-      { $limit: SESSION_STATS_LIMIT },
-    ])
-    .toArray();
-
-  return rows.map((r) => ({
-    sessionName: r._id || "Unknown",
-    totalCalls: r.totalCalls,
-    completed: r.completed,
-    failed: r.failed,
-    noAnswer: r.noAnswer,
-    busy: r.busy,
-    inProgress: r.inProgress,
-  }));
-};
-
-export const findClientIdsByCallSids = async (
-  callSids: string[],
-): Promise<Map<string, string>> => {
-  if (callSids.length === 0) return new Map();
-
-  const docs = await getResultsCollection()
-    .aggregate<{ clientId: string; callSid: string }>([
-      { $match: { "calls.callSid": { $in: callSids } } },
-      { $unwind: "$calls" },
-      { $match: { "calls.callSid": { $in: callSids } } },
-      { $project: { _id: 0, clientId: 1, callSid: "$calls.callSid" } },
-    ])
-    .toArray();
-
-  return new Map(docs.map((d) => [d.callSid, d.clientId]));
-};

package/src/talkpilot/results/results.statistics.types.ts

@@ -1,45 +0,0 @@
-export type StatsDateRangeParams = {
-  dateFrom?: string;
-  dateTo?: string;
-  clientId?: string;
-  timezone?: string;
-};
-
-export type ActiveCallsSummary = {
-  total: number;
-  incoming: number;
-  outgoing: number;
-  activeClientIds: string[];
-};
-
-export type TodayCallsSummary = {
-  total: number;
-  incoming: number;
-  outgoing: number;
-  completed: number;
-  failed: number;
-  busy: number;
-  noAnswer: number;
-  totalMinutes: number;
-};
-
-export type ClientCallStats = {
-  clientId: string;
-  totalCalls: number;
-  completed: number;
-  failed: number;
-  noAnswer: number;
-  busy: number;
-  inProgress: number;
-  totalMinutes: number;
-};
-
-export type SessionCallStats = {
-  sessionName: string;
-  totalCalls: number;
-  completed: number;
-  failed: number;
-  noAnswer: number;
-  busy: number;
-  inProgress: number;
-};

package/src/test-utils/factories/talkpilot/clients.ts

@@ -1,21 +0,0 @@
-import { Factory } from "fishery";
-import { ObjectId } from "mongodb";
-import { faker } from "@faker-js/faker";
-import type { Client } from "../../../talkpilot";
-
-export const clientFactory = Factory.define<Client & { _id?: ObjectId }>(
-  () => ({
-    _id: new ObjectId(),
-    clientId: faker.string.uuid(),
-    isActive: true,
-    credits: faker.number.int({ min: 0, max: 1000 }),
-    createdAt: new Date(),
-    updatedAt: new Date(),
-  }),
-);
-
-export function createClient(
-  overrides?: Partial<Client>,
-): Client & { _id?: ObjectId } {
-  return clientFactory.build(overrides);
-}

package/src/test-utils/factories/talkpilot/results.ts

@@ -1,43 +0,0 @@
-import { Factory } from "fishery";
-import { ObjectId } from "mongodb";
-import { faker } from "@faker-js/faker";
-import type { Result, CallResult } from "../../../talkpilot";
-
-export const callResultFactory = Factory.define<CallResult>(() => ({
-  callSid: `CA${faker.string.alphanumeric(32)}`,
-  status: "completed",
-  date: new Date(),
-  statuses: ["completed"],
-  userAnswer: null,
-  color: null,
-  name: null,
-  callLength: "60 seconds",
-  answeredBy: null,
-  to: faker.phone.number(),
-  from: faker.phone.number(),
-  transcription: [],
-  flowId: new ObjectId().toString(),
-  recordingUrl: null,
-}));
-
-export function createCallResult(overrides?: Partial<CallResult>): CallResult {
-  return callResultFactory.build(overrides);
-}
-
-export const resultFactory = Factory.define<Result & { _id?: ObjectId }>(
-  () => ({
-    _id: new ObjectId(),
-    calls: [],
-    clientId: faker.string.uuid(),
-    date: new Date(),
-    runId: `run_${new ObjectId().toString()}`,
-    sessionId: "incomingCall",
-    sessionName: "incomingCall",
-  }),
-);
-
-export function createResult(
-  overrides?: Partial<Result>,
-): Result & { _id?: ObjectId } {
-  return resultFactory.build(overrides);
-}